Imports
/- Copyright (c) 2026 Terence Rokop. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Terence Rokop -/ module public import Geb.Mathlib.Data.PFunctor.Presheaf.Basic public import Geb.Mathlib.Data.PFunctor.Slice.W public import Mathlib.CategoryTheory.Category.Preorder public import Mathlib.Order.Fin.Basic meta import GebMeta -- shake: keep; supplies the cite docstring role
set_option doc.verso true

Prototype: the walking arrow over an index type

Throwaway exploration, not upstream-eligible content. Every declaration here is Classical.­choice-free.

A presheaf polynomial endofunctor on the walking arrow acts on Fam(Type), where the base of a family is data, and its directions can name an element of the base only through a function from a fixed set, so a slice polynomial functor transcribed to it is recovered only up to a section and its W-type is not recovered at all. On the discrete category of an index type X, presheaves are Type/X, a direction names its index exactly, and the presheaf polynomial functors are the slice polynomials with their W-types. This module takes the product of the two: the category Idx X, the pairs (i, x) of a level and an index ordered by i ≤ i' and x = x', whose presheaves are X-indexed families of arrows, the objects (U : X → Type, T : Π x, U x → Type) of indexed induction-recursion. A direction at (j, x) names its index x by its object, and only an element of U x through a function.

elemEquiv computes the value of any presheaf polynomial endofunctor on Idx X: a shape, a base assignment at each index, and an assignment of level-1 directions in the fibres over it, the naturality along the one non-identity morphism at each index being the fibre condition, isNatural_iff. prodPsh transcribes a slice polynomial functor P : Type/X → Type/Y: level-0 shapes Y with no directions, so that the base is constantly a point, and level-1 shapes the shapes of P, each direction b of P giving a level-1 direction at (1, r b) with its restriction at (0, r b). ofSliceX embeds Type/X as the presheaves with a point at every level 0, and levelOneEquiv identifies the level-1 value of the transcription at ofSliceX p over (1, y) with the value of P at p over y, on the nose; map_cmp extends this to morphisms over X. For an endofunctor, wFixed then exhibits the slice W-type SlicePFunctor.­W as a fixed point of the transcription: the iteration of the transcription on the initial object of Type/X, which stays over the constant point, is the iteration of P.

Main definitions

  • Idx — the walking arrow over an index type, as a preorder.

  • Elem, elemEquiv — the value of a presheaf polynomial endofunctor on Idx X in dependent-type terms.

  • prodPsh — the transcription of a slice polynomial functor.

  • ofSliceX, ofSliceXHomType/X as presheaves on Idx X.

  • levelOneEquiv, cmp — the level-1 value at an object of Type/X is the slice functor's value, and the comparison map.

  • wFixed — the slice W-type is a fixed point of the transcription.

Main statements

  • isNatural_iff — naturality over Idx X is the fibre condition at each index.

  • levelZeroEquiv — the transcription's base is a point at every index.

  • map_cmp — the comparison map is natural in the object of Type/X.

References

  • [DybjerSetzer2003]Peter Dybjer, Anton Setzer (2003). “Induction--recursion and initial algebras”. Annals of Pure and Applied Logic 124(1--3), pp. 1–47. https://doi.org/10.1016/S0168-0072(02)00096-9.

  • [HancockMcBrideGhaniMalatestaAltenkirch2013]Peter Hancock, Conor McBride, Neil Ghani, Lorenzo Malatesta, Thorsten Altenkirch (2013). “Small Induction Recursion”. Typed Lambda Calculi and Applications (TLCA 2013) 7941, pp. 156–172. https://doi.org/10.1007/978-3-642-38946-7_13. This repository cites the TLCA 2013 proceedings numbering (Definition 8, Theorems 2/3/4, Corollary 2). The extended 2012 preprint at https://personal.cis.strath.ac.uk/conor.mcbride/pub/SmallIR/SmallIR.pdf renumbers two of these: its Theorem 15 is the proceedings' Theorem 2, and its Theorem 21 is the proceedings' Theorem 4..

Tags

prototype, presheaf, walking arrow, indexed inductive-recursive, slice polynomial functor, W-type

@[expose] public sectionopen CategoryTheorynamespace GebProto.LargeIR.Product

The index category

The walking arrow over an index type: pairs of a level and an index.

def Idx (X : Type) : Type := Fin 2 × X

The order: levels increase and indices are fixed, so the category has one non-identity morphism (0, x) ⟶ (1, x) at each index.

instance (X : Type) : Preorder (Idx X) where le p q := p.1 q.1 p.2 = q.2 le_refl _ := le_refl _, rfl le_trans _ _ _ h h' := le_trans h.1 h'.1, h.2.trans h'.2

An object of Idx X from its level and index.

def mkIdx {X : Type} (i : Fin 2) (x : X) : Idx X := (i, x)

The non-identity morphism at an index.

def waHomAt {X : Type} (x : X) : mkIdx 0 x mkIdx 1 x := homOfLE Fin.zero_le _, rfl

Morphisms of Idx X are unique.

theorem hom_ext {X : Type} {o o' : Idx X} (f g : o' o) : f = g := Subsingleton.elim f g

A morphism of Idx X is an identity or the non-identity morphism at its index.

theorem le_cases {X : Type} {o o' : Idx X} (h : o' o) : o' = o x, o' = mkIdx 0 x o = mkIdx 1 x := X:Typeo:Idx Xo':Idx Xh:o' oo' = o x, o' = mkIdx 0 x o = mkIdx 1 x X:Typeo':Idx Xi:Fin 2x:Xh:o' (i, x)o' = (i, x) x_1, o' = mkIdx 0 x_1 (i, x) = mkIdx 1 x_1 X:Typei:Fin 2x:Xi':Fin 2x':Xh:(i', x') (i, x)(i', x') = (i, x) x_1, (i', x') = mkIdx 0 x_1 (i, x) = mkIdx 1 x_1 X:Typei:Fin 2i':Fin 2x':Xh1:(i', x').1 (i, (i', x').2).1(i', x') = (i, (i', x').2) x, (i', x') = mkIdx 0 x (i, (i', x').2) = mkIdx 1 x match i, i' with X:Typei:Fin 2i':Fin 2x':Xh1:(0, x').1 (0, (0, x').2).1(0, x') = (0, (0, x').2) x, (0, x') = mkIdx 0 x (0, (0, x').2) = mkIdx 1 x All goals completed! 🐙 X:Typei:Fin 2i':Fin 2x':Xh1:(1, x').1 (1, (1, x').2).1(1, x') = (1, (1, x').2) x, (1, x') = mkIdx 0 x (1, (1, x').2) = mkIdx 1 x All goals completed! 🐙 X:Typei:Fin 2i':Fin 2x':Xh1:(0, x').1 (1, (0, x').2).1(0, x') = (1, (0, x').2) x, (0, x') = mkIdx 0 x (1, (0, x').2) = mkIdx 1 x All goals completed! 🐙 X:Typei:Fin 2i':Fin 2x':Xh1:(1, x').1 (0, (1, x').2).1(1, x') = (0, (1, x').2) x, (1, x') = mkIdx 0 x (0, (1, x').2) = mkIdx 1 x exact absurd h1 (X:Typei:Fin 2i':Fin 2x':Xh1:(1, x').1 (0, (1, x').2).1¬(1, x').1 (0, (1, x').2).1 X:Typei:Fin 2i':Fin 2x':Xh1:(1, x').1 (0, (1, x').2).1¬1 0; All goals completed! 🐙)

The value of an endofunctor

variable {X : Type} (Z : (Idx X)ᵒᵖ Type)

The fibre of the restriction at an index over a base element.

def fibre (x : X) (u : Z.obj mkIdx 0 x) : Type := { z : Z.obj mkIdx 1 x // Z.map (waHomAt x).op z = u }

A dependent pair reassembled from its components after a cast of the second along an equation of the first is the original pair.

private theorem sigma_mk_cast {o o' : Idx X} (z : Z.obj o) (e : o = o') : (o', cast (congrArg (fun k : Idx X Z.obj k) e) z : Σ k : Idx X, Z.obj k) = o, z := X:TypeZ:(Idx X)ᵒᵖ Typeo:Idx Xo':Idx Xz:Z.obj (Opposite.op o)e:o = o'o', cast z = o, z X:TypeZ:(Idx X)ᵒᵖ Typeo:Idx Xz:Z.obj (Opposite.op o)o, cast z = o, z All goals completed! 🐙

The value an element assigns to a direction, paired with the direction's object, is the element's raw assignment.

theorem sigma_value (F : PresheafDomPFunctorData.{0, 0, 0, 0} (Idx X)) (x : F.toSliceDomPFunctor.Obj (PresheafDomPFunctorData.elemProj Z)) o : Idx X (b : F.Direction x.1.1 o) : (o, F.value x b : Σ k : Idx X, Z.obj k) = x.1.2 b.1 := X:TypeZ:(Idx X)ᵒᵖ TypeF:PresheafDomPFunctorData (Idx X)x:F.Obj (PresheafDomPFunctorData.elemProj Z)o:Idx Xb:F.Direction (↑x).fst oo, F.value x b = (↑x).snd b X:TypeZ:(Idx X)ᵒᵖ TypeF:PresheafDomPFunctorData (Idx X)o:Idx Xa:F.Av:F.B a (i : Idx X) × Z.obj (Opposite.op i)hc:F.Compatible (PresheafDomPFunctorData.elemProj Z) a, v.fst a, v.sndb:F.Direction (↑a, v, hc).fst oo, F.value a, v, hc b = (↑a, v, hc).snd b X:TypeZ:(Idx X)ᵒᵖ TypeF:PresheafDomPFunctorData (Idx X)o:Idx Xa:F.Av:F.B a (i : Idx X) × Z.obj (Opposite.op i)hc:F.Compatible (PresheafDomPFunctorData.elemProj Z) a, v.fst a, v.sndb:F.B (↑a, v, hc).fsthb:F.DirectionOver (↑a, v, hc).fst o bo, F.value a, v, hc b, hb = (↑a, v, hc).snd b, hb All goals completed! 🐙

Over Idx X, a direction assignment is natural exactly when it satisfies the fibre equation along the non-identity morphism at each index, given that direction restriction along identities is the identity.

theorem isNatural_iff (F : PresheafDomPFunctorData.{0, 0, 0, 0} (Idx X)) (hid : F.DirectionRestrId) (x : F.toSliceDomPFunctor.Obj (PresheafDomPFunctorData.elemProj Z)) : F.IsNatural x (x' : X) (d : F.Direction x.1.1 (mkIdx 1 x')), F.value x (F.directionRestr x.1.1 (waHomAt x') d) = Z.map (waHomAt x').op (F.value x d) := X:TypeZ:(Idx X)ᵒᵖ TypeF:PresheafDomPFunctorData (Idx X)hid:F.DirectionRestrIdx:F.Obj (PresheafDomPFunctorData.elemProj Z)F.IsNatural x (x' : X) (d : F.Direction (↑x).fst (mkIdx 1 x')), F.value x (F.directionRestr (↑x).fst (waHomAt x') d) = (ConcreteCategory.hom (Z.map (waHomAt x').op)) (F.value x d) X:TypeZ:(Idx X)ᵒᵖ TypeF:PresheafDomPFunctorData (Idx X)hid:F.DirectionRestrIdx:F.Obj (PresheafDomPFunctorData.elemProj Z)h: (x' : X) (d : F.Direction (↑x).fst (mkIdx 1 x')), F.value x (F.directionRestr (↑x).fst (waHomAt x') d) = (ConcreteCategory.hom (Z.map (waHomAt x').op)) (F.value x d)o:Idx Xo':Idx Xf:o' od:F.Direction (↑x).fst oF.value x (F.directionRestr (↑x).fst f d) = (ConcreteCategory.hom (Z.map f.op)) (F.value x d) X:TypeZ:(Idx X)ᵒᵖ TypeF:PresheafDomPFunctorData (Idx X)hid:F.DirectionRestrIdx:F.Obj (PresheafDomPFunctorData.elemProj Z)h: (x' : X) (d : F.Direction (↑x).fst (mkIdx 1 x')), F.value x (F.directionRestr (↑x).fst (waHomAt x') d) = (ConcreteCategory.hom (Z.map (waHomAt x').op)) (F.value x d)o':Idx Xf:o' o'd:F.Direction (↑x).fst o'F.value x (F.directionRestr (↑x).fst f d) = (ConcreteCategory.hom (Z.map f.op)) (F.value x d)X:TypeZ:(Idx X)ᵒᵖ TypeF:PresheafDomPFunctorData (Idx X)hid:F.DirectionRestrIdx:F.Obj (PresheafDomPFunctorData.elemProj Z)h: (x' : X) (d : F.Direction (↑x).fst (mkIdx 1 x')), F.value x (F.directionRestr (↑x).fst (waHomAt x') d) = (ConcreteCategory.hom (Z.map (waHomAt x').op)) (F.value x d)x':Xd:F.Direction (↑x).fst (mkIdx 1 x')f:mkIdx 0 x' mkIdx 1 x'F.value x (F.directionRestr (↑x).fst f d) = (ConcreteCategory.hom (Z.map f.op)) (F.value x d) X:TypeZ:(Idx X)ᵒᵖ TypeF:PresheafDomPFunctorData (Idx X)hid:F.DirectionRestrIdx:F.Obj (PresheafDomPFunctorData.elemProj Z)h: (x' : X) (d : F.Direction (↑x).fst (mkIdx 1 x')), F.value x (F.directionRestr (↑x).fst (waHomAt x') d) = (ConcreteCategory.hom (Z.map (waHomAt x').op)) (F.value x d)o':Idx Xf:o' o'd:F.Direction (↑x).fst o'F.value x (F.directionRestr (↑x).fst f d) = (ConcreteCategory.hom (Z.map f.op)) (F.value x d) X:TypeZ:(Idx X)ᵒᵖ TypeF:PresheafDomPFunctorData (Idx X)hid:F.DirectionRestrIdx:F.Obj (PresheafDomPFunctorData.elemProj Z)h: (x' : X) (d : F.Direction (↑x).fst (mkIdx 1 x')), F.value x (F.directionRestr (↑x).fst (waHomAt x') d) = (ConcreteCategory.hom (Z.map (waHomAt x').op)) (F.value x d)o':Idx Xf:o' o'd:F.Direction (↑x).fst o'F.value x (id d) = (ConcreteCategory.hom (𝟙 (Z.obj (Opposite.op o')))) (F.value x d) All goals completed! 🐙 X:TypeZ:(Idx X)ᵒᵖ TypeF:PresheafDomPFunctorData (Idx X)hid:F.DirectionRestrIdx:F.Obj (PresheafDomPFunctorData.elemProj Z)h: (x' : X) (d : F.Direction (↑x).fst (mkIdx 1 x')), F.value x (F.directionRestr (↑x).fst (waHomAt x') d) = (ConcreteCategory.hom (Z.map (waHomAt x').op)) (F.value x d)x':Xd:F.Direction (↑x).fst (mkIdx 1 x')f:mkIdx 0 x' mkIdx 1 x'F.value x (F.directionRestr (↑x).fst f d) = (ConcreteCategory.hom (Z.map f.op)) (F.value x d) X:TypeZ:(Idx X)ᵒᵖ TypeF:PresheafDomPFunctorData (Idx X)hid:F.DirectionRestrIdx:F.Obj (PresheafDomPFunctorData.elemProj Z)h: (x' : X) (d : F.Direction (↑x).fst (mkIdx 1 x')), F.value x (F.directionRestr (↑x).fst (waHomAt x') d) = (ConcreteCategory.hom (Z.map (waHomAt x').op)) (F.value x d)x':Xd:F.Direction (↑x).fst (mkIdx 1 x')f:mkIdx 0 x' mkIdx 1 x'F.value x (F.directionRestr (↑x).fst (waHomAt x') d) = (ConcreteCategory.hom (Z.map (waHomAt x').op)) (F.value x d) All goals completed! 🐙
variable {Y : Type} (F : PresheafPFunctor.{0, 0, 0, 0, 0, 0} (Idx X) (Idx Y))

The restriction of a shape's directions at an index from level 1 to level 0.

abbrev dirRestr (a : F.A) (x : X) : F.Direction a (mkIdx 1 x) F.Direction a (mkIdx 0 x) := F.directionRestr a (waHomAt x)

The value of F at Z in dependent-type terms: a shape, a base assignment at each index, and an assignment of the level-1 directions at each index in the fibres over the base assignment at their restrictions.

def Elem : Type := Σ a : F.A, Σ g : x, F.Direction a (mkIdx 0 x) Z.obj mkIdx 0 x, x (d : F.Direction a (mkIdx 1 x)), fibre Z x (g x (dirRestr F a x d))

The raw assignment of an element built from a base assignment and a level-1 assignment, at a direction whose object is known.

def assignAux {a : F.A} (g : x, F.Direction a (mkIdx 0 x) Z.obj mkIdx 0 x) (w : x (d : F.Direction a (mkIdx 1 x)), fibre Z x (g x (dirRestr F a x d))) (b : F.B a) : (o : Idx X) F.r a, b = o Σ o : Idx X, Z.obj o | (0, x), h => (0, x), g x b, h | (1, x), h => (1, x), (w x b, h).1

The raw assignment lies over the direction's object.

theorem assignAux_fst {a : F.A} (g : x, F.Direction a (mkIdx 0 x) Z.obj mkIdx 0 x) (w : x (d : F.Direction a (mkIdx 1 x)), fibre Z x (g x (dirRestr F a x d))) (b : F.B a) : (o : Idx X) (h : F.r a, b = o), (assignAux Z F g w b o h).1 = o | (0, _), _ => rfl | (1, _), _ => rfl

The raw assignment at the direction-input object is the raw assignment at any object it equals.

theorem assignAux_congr {a : F.A} (g : x, F.Direction a (mkIdx 0 x) Z.obj mkIdx 0 x) (w : x (d : F.Direction a (mkIdx 1 x)), fibre Z x (g x (dirRestr F a x d))) (b : F.B a) {o : Idx X} (h : F.r a, b = o) : assignAux Z F g w b (F.r a, b) rfl = assignAux Z F g w b o h := X:TypeZ:(Idx X)ᵒᵖ TypeY:TypeF:PresheafPFunctor (Idx X) (Idx Y)a:F.Ag:(x : X) F.Direction a (mkIdx 0 x) Z.obj (Opposite.op (mkIdx 0 x))w:(x : X) (d : F.Direction a (mkIdx 1 x)) fibre Z x (g x (dirRestr F a x d))b:F.B ao:Idx Xh:F.r a, b = oassignAux Z F g w b (F.r a, b) = assignAux Z F g w b o h X:TypeZ:(Idx X)ᵒᵖ TypeY:TypeF:PresheafPFunctor (Idx X) (Idx Y)a:F.Ag:(x : X) F.Direction a (mkIdx 0 x) Z.obj (Opposite.op (mkIdx 0 x))w:(x : X) (d : F.Direction a (mkIdx 1 x)) fibre Z x (g x (dirRestr F a x d))b:F.B aassignAux Z F g w b (F.r a, b) = assignAux Z F g w b (F.r a, b) All goals completed! 🐙

The element built from a base assignment and a level-1 assignment, before its naturality.

def assignObj {a : F.A} (g : x, F.Direction a (mkIdx 0 x) Z.obj mkIdx 0 x) (w : x (d : F.Direction a (mkIdx 1 x)), fibre Z x (g x (dirRestr F a x d))) : F.toSliceDomPFunctor.Obj (PresheafDomPFunctorData.elemProj Z) := a, fun b assignAux Z F g w b (F.r a, b) rfl, funext fun b assignAux_fst Z F g w b _ rfl

The value the built element gives a level-0 direction is the base assignment.

theorem value_assignObj_zero {a : F.A} (g : x, F.Direction a (mkIdx 0 x) Z.obj mkIdx 0 x) (w : x (d : F.Direction a (mkIdx 1 x)), fibre Z x (g x (dirRestr F a x d))) (x : X) (d : F.Direction a (mkIdx 0 x)) : F.value (assignObj Z F g w) d = g x d := eq_of_heq (Sigma.mk.inj_iff.mp ((sigma_value Z F.toPresheafDomPFunctorData (assignObj Z F g w) d).trans (assignAux_congr Z F g w d.1 d.2))).2

The value the built element gives a level-1 direction is the level-1 assignment.

theorem value_assignObj_one {a : F.A} (g : x, F.Direction a (mkIdx 0 x) Z.obj mkIdx 0 x) (w : x (d : F.Direction a (mkIdx 1 x)), fibre Z x (g x (dirRestr F a x d))) (x : X) (d : F.Direction a (mkIdx 1 x)) : F.value (assignObj Z F g w) d = (w x d).1 := eq_of_heq (Sigma.mk.inj_iff.mp ((sigma_value Z F.toPresheafDomPFunctorData (assignObj Z F g w) d).trans (assignAux_congr Z F g w d.1 d.2))).2

Two elements of Elem with the same shape are equal when their base assignments agree and their level-1 assignments agree in the level-1 fibres of Z.

theorem gw_ext {a : F.A} {g g' : x, F.Direction a (mkIdx 0 x) Z.obj mkIdx 0 x} (hg : g' = g) {w : x (d : F.Direction a (mkIdx 1 x)), fibre Z x (g x (dirRestr F a x d))} {w' : x (d : F.Direction a (mkIdx 1 x)), fibre Z x (g' x (dirRestr F a x d))} (hw : x d, (w' x d).1 = (w x d).1) : (g', w' : Σ g : x, F.Direction a (mkIdx 0 x) Z.obj mkIdx 0 x, x (d : F.Direction a (mkIdx 1 x)), fibre Z x (g x (dirRestr F a x d))) = g, w := X:TypeZ:(Idx X)ᵒᵖ TypeY:TypeF:PresheafPFunctor (Idx X) (Idx Y)a:F.Ag:(x : X) F.Direction a (mkIdx 0 x) Z.obj (Opposite.op (mkIdx 0 x))g':(x : X) F.Direction a (mkIdx 0 x) Z.obj (Opposite.op (mkIdx 0 x))hg:g' = gw:(x : X) (d : F.Direction a (mkIdx 1 x)) fibre Z x (g x (dirRestr F a x d))w':(x : X) (d : F.Direction a (mkIdx 1 x)) fibre Z x (g' x (dirRestr F a x d))hw: (x : X) (d : F.Direction a (mkIdx 1 x)), (w' x d) = (w x d)g', w' = g, w X:TypeZ:(Idx X)ᵒᵖ TypeY:TypeF:PresheafPFunctor (Idx X) (Idx Y)a:F.Ag':(x : X) F.Direction a (mkIdx 0 x) Z.obj (Opposite.op (mkIdx 0 x))w':(x : X) (d : F.Direction a (mkIdx 1 x)) fibre Z x (g' x (dirRestr F a x d))w:(x : X) (d : F.Direction a (mkIdx 1 x)) fibre Z x (g' x (dirRestr F a x d))hw: (x : X) (d : F.Direction a (mkIdx 1 x)), (w' x d) = (w x d)g', w' = g', w All goals completed! 🐙

The value in dependent-type terms of an element.

def toElem (x : F.obj Z) : Elem Z F := x.shape, fun _ d F.value x.1 d, fun x' d F.value x.1 d, (x.2 (waHomAt x') d).symm

The raw assignment rebuilt from an element's values is the element's raw assignment.

theorem assignAux_value (x : F.obj Z) (b : F.B x.shape) : (o : Idx X) (h : F.r x.shape, b = o), assignAux Z F (fun _ (d : F.Direction x.shape (mkIdx 0 _)) F.value x.1 d) (fun x' (d : F.Direction x.shape (mkIdx 1 x')) F.value x.1 d, (x.2 (waHomAt x') d).symm) b o h = x.1.1.2 b | (0, _), h => sigma_value Z F.toPresheafDomPFunctorData x.1 b, h | (1, _), h => sigma_value Z F.toPresheafDomPFunctorData x.1 b, h

The value of F at Z is Elem Z F.

def elemEquiv : F.obj Z Elem Z F where toFun := toElem Z F invFun e := assignObj Z F e.2.1 e.2.2, (isNatural_iff Z F.toPresheafDomPFunctorData F.isFunctorial.directionRestr_id _).mpr fun x' d (value_assignObj_zero Z F _ _ _ _).trans ((e.2.2 x' d).2.symm.trans (congrArg _ (value_assignObj_one Z F _ _ x' d).symm)) left_inv x := Subtype.ext (Subtype.ext (Sigma.ext rfl (heq_of_eq (funext fun b assignAux_value Z F x b _ rfl)))) right_inv e := Sigma.ext rfl (heq_of_eq (gw_ext Z F (funext fun x funext fun d value_assignObj_zero Z F e.2.1 e.2.2 x d) fun x d value_assignObj_one Z F e.2.1 e.2.2 x d))

The transcription of a slice polynomial functor

variable (P : SlicePFunctor.{0, 0, 0, 0} X Y)

The directions of the transcription: none for a level-0 shape, and for a level-1 shape each direction of P twice, once at level 0 and once at level 1.

def pDir : Y P.A Type | .inl _ => PEmpty | .inr a => P.B a P.B a

The direction-input map: a direction of P lies at its own input index, at level 0 or 1 by its copy.

def pR : (Σ s : Y P.A, pDir P s) Idx X | .inl _, e => PEmpty.elim e | .inr a, .inl b => (0, P.r a, b) | .inr a, .inr b => (1, P.r a, b)

The shape-output map: a level-0 shape lies at its index, a level-1 shape at the output index of P.

def pQ : Y P.A Idx Y | .inl y => (0, y) | .inr a => (1, P.q a)

The slice polynomial functor on the objects of Idx X and Idx Y underlying the transcription.

def prodSlice : SlicePFunctor.{0, 0, 0, 0} (Idx X) (Idx Y) where toPFunctor := Y P.A, pDir P r := pR P q := pQ P

The direction restriction to a target level: the level-1 copy of a direction restricts to its level-0 copy.

def restrDir (s : Y P.A) (t : Fin 2) : pDir P s pDir P s := match s with | .inl _ => fun e e | .inr _ => fun d match d, t with | .inl b, _ => .inl b | .inr b, 0 => .inl b | .inr b, 1 => .inr b

The restricted direction lies over the target level at the same index.

theorem restrDir_over (s : Y P.A) (t : Fin 2) (d : pDir P s) {i : Fin 2} {x : X} (hd : pR P s, d = (i, x)) (ht : t i) : pR P s, restrDir P s t d = (t, x) := X:TypeY:TypeP:SlicePFunctor X Ys:Y P.At:Fin 2d:pDir P si:Fin 2x:Xhd:pR P s, d = (i, x)ht:t ipR P s, restrDir P s t d = (t, x) match s, d, t with X:TypeY:TypeP:SlicePFunctor X Ys:Y P.At:Fin 2d:pDir P si:Fin 2x:Xval✝:Ye:pDir P (Sum.inl val✝)x✝:Fin 2hd:pR P Sum.inl val✝, e = (i, x)ht:x✝ ipR P Sum.inl val✝, restrDir P (Sum.inl val✝) x✝ e = (x✝, x) All goals completed! 🐙 X:TypeY:TypeP:SlicePFunctor X Ys:Y P.At:Fin 2d:pDir P si:Fin 2x:Xa:P.Ab:P.B ahd:pR P Sum.inr a, Sum.inl b = (i, x)ht:0 ipR P Sum.inr a, restrDir P (Sum.inr a) 0 (Sum.inl b) = (0, x) All goals completed! 🐙 X:TypeY:TypeP:SlicePFunctor X Ys:Y P.At:Fin 2d:pDir P si:Fin 2x:Xval✝¹:P.Aval✝:P.B val✝¹hd:pR P Sum.inr val✝¹, Sum.inl val✝ = (i, x)ht:1 ipR P Sum.inr val✝¹, restrDir P (Sum.inr val✝¹) 1 (Sum.inl val✝) = (1, x) X:TypeY:TypeP:SlicePFunctor X Ys:Y P.At:Fin 2d:pDir P si:Fin 2x:Xval✝¹:P.Aval✝:P.B val✝¹hd:pR P Sum.inr val✝¹, Sum.inl val✝ = (i, x)ht:1 ih0:0 = ipR P Sum.inr val✝¹, restrDir P (Sum.inr val✝¹) 1 (Sum.inl val✝) = (1, x) X:TypeY:TypeP:SlicePFunctor X Ys:Y P.At:Fin 2d:pDir P sx:Xval✝¹:P.Aval✝:P.B val✝¹hd:pR P Sum.inr val✝¹, Sum.inl val✝ = (0, x)ht:1 0pR P Sum.inr val✝¹, restrDir P (Sum.inr val✝¹) 1 (Sum.inl val✝) = (1, x) exact absurd ht (X:TypeY:TypeP:SlicePFunctor X Ys:Y P.At:Fin 2d:pDir P sx:Xval✝¹:P.Aval✝:P.B val✝¹hd:pR P Sum.inr val✝¹, Sum.inl val✝ = (0, x)ht:1 0¬1 0 All goals completed! 🐙) X:TypeY:TypeP:SlicePFunctor X Ys:Y P.At:Fin 2d:pDir P si:Fin 2x:Xa:P.Ab:P.B ahd:pR P Sum.inr a, Sum.inr b = (i, x)ht:0 ipR P Sum.inr a, restrDir P (Sum.inr a) 0 (Sum.inr b) = (0, x) All goals completed! 🐙 X:TypeY:TypeP:SlicePFunctor X Ys:Y P.At:Fin 2d:pDir P si:Fin 2x:Xa:P.Ab:P.B ahd:pR P Sum.inr a, Sum.inr b = (i, x)ht:1 ipR P Sum.inr a, restrDir P (Sum.inr a) 1 (Sum.inr b) = (1, x) All goals completed! 🐙

The shape restriction to a target level: a level-1 shape restricts to the level-0 shape at its output index.

def restrShape (t : Fin 2) : Y P.A Y P.A | .inl y => .inl y | .inr a => match t with | 0 => .inl (P.q a) | 1 => .inr a

The restricted shape lies over the target level at the same index.

theorem restrShape_over (t : Fin 2) (s : Y P.A) {i : Fin 2} {y : Y} (hs : pQ P s = (i, y)) (ht : t i) : pQ P (restrShape P t s) = (t, y) := X:TypeY:TypeP:SlicePFunctor X Yt:Fin 2s:Y P.Ai:Fin 2y:Yhs:pQ P s = (i, y)ht:t ipQ P (restrShape P t s) = (t, y) match s, t with X:TypeY:TypeP:SlicePFunctor X Yt:Fin 2s:Y P.Ai:Fin 2y:Yy':Yhs:pQ P (Sum.inl y') = (i, y)ht:0 ipQ P (restrShape P 0 (Sum.inl y')) = (0, y) All goals completed! 🐙 X:TypeY:TypeP:SlicePFunctor X Yt:Fin 2s:Y P.Ai:Fin 2y:Yval✝:Yhs:pQ P (Sum.inl val✝) = (i, y)ht:1 ipQ P (restrShape P 1 (Sum.inl val✝)) = (1, y) X:TypeY:TypeP:SlicePFunctor X Yt:Fin 2s:Y P.Ai:Fin 2y:Yval✝:Yhs:pQ P (Sum.inl val✝) = (i, y)ht:1 ih0:0 = ipQ P (restrShape P 1 (Sum.inl val✝)) = (1, y) X:TypeY:TypeP:SlicePFunctor X Yt:Fin 2s:Y P.Ay:Yval✝:Yhs:pQ P (Sum.inl val✝) = (0, y)ht:1 0pQ P (restrShape P 1 (Sum.inl val✝)) = (1, y) exact absurd ht (X:TypeY:TypeP:SlicePFunctor X Yt:Fin 2s:Y P.Ay:Yval✝:Yhs:pQ P (Sum.inl val✝) = (0, y)ht:1 0¬1 0 All goals completed! 🐙) X:TypeY:TypeP:SlicePFunctor X Yt:Fin 2s:Y P.Ai:Fin 2y:Ya:P.Ahs:pQ P (Sum.inr a) = (i, y)ht:0 ipQ P (restrShape P 0 (Sum.inr a)) = (0, y) All goals completed! 🐙 X:TypeY:TypeP:SlicePFunctor X Yt:Fin 2s:Y P.Ai:Fin 2y:Ya:P.Ahs:pQ P (Sum.inr a) = (i, y)ht:1 ipQ P (restrShape P 1 (Sum.inr a)) = (1, y) All goals completed! 🐙

The reindexing of directions along a shape restriction: a level-0 shape has none, so it is the identity where defined.

def reindexDir (s : Y P.A) (t : Fin 2) : pDir P (restrShape P t s) pDir P s := match s, t with | .inl _, _ => fun e e | .inr _, 0 => fun e PEmpty.elim e | .inr _, 1 => fun d d

Reindexing preserves the direction-input object.

theorem reindexDir_over (s : Y P.A) (t : Fin 2) (d : pDir P (restrShape P t s)) : pR P s, reindexDir P s t d = pR P restrShape P t s, d := X:TypeY:TypeP:SlicePFunctor X Ys:Y P.At:Fin 2d:pDir P (restrShape P t s)pR P s, reindexDir P s t d = pR P restrShape P t s, d match s, t, d with X:TypeY:TypeP:SlicePFunctor X Ys:Y P.At:Fin 2d:pDir P (restrShape P t s)val✝:Yx✝:Fin 2e:pDir P (restrShape P x✝ (Sum.inl val✝))pR P Sum.inl val✝, reindexDir P (Sum.inl val✝) x✝ e = pR P restrShape P x✝ (Sum.inl val✝), e All goals completed! 🐙 X:TypeY:TypeP:SlicePFunctor X Ys:Y P.At:Fin 2d:pDir P (restrShape P t s)val✝:P.Ae:pDir P (restrShape P 0 (Sum.inr val✝))pR P Sum.inr val✝, reindexDir P (Sum.inr val✝) 0 e = pR P restrShape P 0 (Sum.inr val✝), e All goals completed! 🐙 X:TypeY:TypeP:SlicePFunctor X Ys:Y P.At:Fin 2d:pDir P (restrShape P t s)val✝:P.Ax✝:pDir P (restrShape P 1 (Sum.inr val✝))pR P Sum.inr val✝, reindexDir P (Sum.inr val✝) 1 x✝ = pR P restrShape P 1 (Sum.inr val✝), x✝ All goals completed! 🐙

The direction restriction along a morphism of Idx X.

def directionRestr (s : Y P.A) o o' : Idx X (f : o' o) (d : (prodSlice P).Direction s o) : (prodSlice P).Direction s o' := restrDir P s o'.1 d.1, X:TypeZ:(Idx X)ᵒᵖ TypeY:TypeF:PresheafPFunctor (Idx X) (Idx Y)P:SlicePFunctor X Ys:Y P.Ao:Idx Xo':Idx Xf:o' od:(prodSlice P).Direction s o(prodSlice P).DirectionOver s o' (restrDir P s o'.1 d) X:TypeZ:(Idx X)ᵒᵖ TypeY:TypeF:PresheafPFunctor (Idx X) (Idx Y)P:SlicePFunctor X Ys:Y P.Ao':Idx Xi:Fin 2x:Xf:o' (i, x)d:(prodSlice P).Direction s (i, x)(prodSlice P).DirectionOver s o' (restrDir P s o'.1 d) X:TypeZ:(Idx X)ᵒᵖ TypeY:TypeF:PresheafPFunctor (Idx X) (Idx Y)P:SlicePFunctor X Ys:Y P.Ai:Fin 2x:Xd:(prodSlice P).Direction s (i, x)i':Fin 2x':Xf:(i', x') (i, x)(prodSlice P).DirectionOver s (i', x') (restrDir P s (i', x').1 d) X:TypeZ:(Idx X)ᵒᵖ TypeY:TypeF:PresheafPFunctor (Idx X) (Idx Y)P:SlicePFunctor X Ys:Y P.Ai:Fin 2i':Fin 2x':Xd:(prodSlice P).Direction s (i, x')f:(i', x') (i, x')(prodSlice P).DirectionOver s (i', x') (restrDir P s (i', x').1 d) All goals completed! 🐙

The shape restriction along a morphism of Idx Y.

def shapeRestr o o' : Idx Y (g : o' o) (s : (prodSlice P).Shape o) : (prodSlice P).Shape o' := restrShape P o'.1 s.1, X:TypeZ:(Idx X)ᵒᵖ TypeY:TypeF:PresheafPFunctor (Idx X) (Idx Y)P:SlicePFunctor X Yo:Idx Yo':Idx Yg:o' os:(prodSlice P).Shape o(prodSlice P).ShapeOver o' (restrShape P o'.1 s) X:TypeZ:(Idx X)ᵒᵖ TypeY:TypeF:PresheafPFunctor (Idx X) (Idx Y)P:SlicePFunctor X Yo':Idx Yi:Fin 2y:Yg:o' (i, y)s:(prodSlice P).Shape (i, y)(prodSlice P).ShapeOver o' (restrShape P o'.1 s) X:TypeZ:(Idx X)ᵒᵖ TypeY:TypeF:PresheafPFunctor (Idx X) (Idx Y)P:SlicePFunctor X Yi:Fin 2y:Ys:(prodSlice P).Shape (i, y)i':Fin 2y':Yg:(i', y') (i, y)(prodSlice P).ShapeOver (i', y') (restrShape P (i', y').1 s) X:TypeZ:(Idx X)ᵒᵖ TypeY:TypeF:PresheafPFunctor (Idx X) (Idx Y)P:SlicePFunctor X Yi:Fin 2i':Fin 2y':Ys:(prodSlice P).Shape (i, y')g:(i', y') (i, y')(prodSlice P).ShapeOver (i', y') (restrShape P (i', y').1 s) All goals completed! 🐙

The reindexing of directions along a morphism of Idx Y.

def reindex o o' : Idx Y (g : o' o) (s : (prodSlice P).Shape o) p : Idx X (d : (prodSlice P).Direction (shapeRestr P g s).1 p) : (prodSlice P).Direction s.1 p := reindexDir P s.1 o'.1 d.1, (reindexDir_over P s.1 o'.1 d.1).trans d.2

The operations of the transcription.

def prodData : PresheafPFunctorData.{0, 0, 0, 0, 0, 0} (Idx X) (Idx Y) := { prodSlice P with directionRestr := directionRestr P shapeRestr := shapeRestr P reindex := reindex P }

Direction restriction along an identity is the identity.

theorem directionRestr_id : (prodData P).DirectionRestrId := X:TypeY:TypeP:SlicePFunctor X Y(prodData P).DirectionRestrId X:TypeY:TypeP:SlicePFunctor X Ys:(prodData P).Ao:Idx X(prodData P).directionRestr s (𝟙 o) = id X:TypeY:TypeP:SlicePFunctor X Ys:(prodData P).Ao:Idx Xd:(prodData P).Direction s o(prodData P).directionRestr s (𝟙 o) d = id d X:TypeY:TypeP:SlicePFunctor X Ys:(prodData P).Ao:Idx Xd:(prodData P).B shd:(prodData P).DirectionOver s o d(prodData P).directionRestr s (𝟙 o) d, hd = id d, hd X:TypeY:TypeP:SlicePFunctor X Ys:(prodData P).Ao:Idx Xd:(prodData P).B shd:(prodData P).DirectionOver s o d((prodData P).directionRestr s (𝟙 o) d, hd) = (id d, hd) match s, d with X:TypeY:TypeP:SlicePFunctor X Ys:(prodData P).Ao:Idx Xd:(prodData P).B sval✝:Ye:(prodData P).B (Sum.inl val✝)hd:(prodData P).DirectionOver (Sum.inl val✝) o e((prodData P).directionRestr (Sum.inl val✝) (𝟙 o) e, hd) = (id e, hd) All goals completed! 🐙 X:TypeY:TypeP:SlicePFunctor X Ys:(prodData P).Ao:Idx Xd:(prodData P).B sval✝¹:P.Aval✝:P.B val✝¹hd:(prodData P).DirectionOver (Sum.inr val✝¹) o (Sum.inl val✝)((prodData P).directionRestr (Sum.inr val✝¹) (𝟙 o) Sum.inl val✝, hd) = (id Sum.inl val✝, hd) All goals completed! 🐙 X:TypeY:TypeP:SlicePFunctor X Ys:(prodData P).Ao:Idx Xd:(prodData P).B sval✝¹:P.Aval✝:P.B val✝¹hd:(prodData P).DirectionOver (Sum.inr val✝¹) o (Sum.inr val✝)((prodData P).directionRestr (Sum.inr val✝¹) (𝟙 o) Sum.inr val✝, hd) = (id Sum.inr val✝, hd) X:TypeY:TypeP:SlicePFunctor X Ys:(prodData P).Ao:Idx Xd:(prodData P).B sval✝¹:P.Aval✝:P.B val✝¹hd:(prodData P).DirectionOver (Sum.inr val✝¹) o (Sum.inr val✝)h1:(1, P.r val✝¹, val✝) = o((prodData P).directionRestr (Sum.inr val✝¹) (𝟙 o) Sum.inr val✝, hd) = (id Sum.inr val✝, hd) X:TypeY:TypeP:SlicePFunctor X Ys:(prodData P).Ad:(prodData P).B sval✝¹:P.Aval✝:P.B val✝¹hd:(prodData P).DirectionOver (Sum.inr val✝¹) (1, P.r val✝¹, val✝) (Sum.inr val✝)((prodData P).directionRestr (Sum.inr val✝¹) (𝟙 (1, P.r val✝¹, val✝)) Sum.inr val✝, hd) = (id Sum.inr val✝, hd) All goals completed! 🐙

Direction restriction reverses composition.

theorem directionRestr_comp : (prodData P).DirectionRestrComp := X:TypeY:TypeP:SlicePFunctor X Y(prodData P).DirectionRestrComp X:TypeY:TypeP:SlicePFunctor X Ys:(prodData P).Ao:Idx Xo':Idx Xo'':Idx Xf:o' og:o'' o'(prodData P).directionRestr s (g f) = (prodData P).directionRestr s g (prodData P).directionRestr s f X:TypeY:TypeP:SlicePFunctor X Ys:(prodData P).Ao:Idx Xo':Idx Xo'':Idx Xf:o' og:o'' o'd:(prodData P).Direction s o(prodData P).directionRestr s (g f) d = ((prodData P).directionRestr s g (prodData P).directionRestr s f) d X:TypeY:TypeP:SlicePFunctor X Ys:(prodData P).Ao:Idx Xo':Idx Xo'':Idx Xf:o' og:o'' o'd:(prodData P).B shd:(prodData P).DirectionOver s o d(prodData P).directionRestr s (g f) d, hd = ((prodData P).directionRestr s g (prodData P).directionRestr s f) d, hd X:TypeY:TypeP:SlicePFunctor X Ys:(prodData P).Ao:Idx Xo':Idx Xo'':Idx Xf:o' og:o'' o'd:(prodData P).B shd:(prodData P).DirectionOver s o d((prodData P).directionRestr s (g f) d, hd) = (((prodData P).directionRestr s g (prodData P).directionRestr s f) d, hd) match s, d with X:TypeY:TypeP:SlicePFunctor X Ys:(prodData P).Ao:Idx Xo':Idx Xo'':Idx Xf:o' og:o'' o'd:(prodData P).B sval✝:Ye:(prodData P).B (Sum.inl val✝)hd:(prodData P).DirectionOver (Sum.inl val✝) o e((prodData P).directionRestr (Sum.inl val✝) (g f) e, hd) = (((prodData P).directionRestr (Sum.inl val✝) g (prodData P).directionRestr (Sum.inl val✝) f) e, hd) All goals completed! 🐙 X:TypeY:TypeP:SlicePFunctor X Ys:(prodData P).Ao:Idx Xo':Idx Xo'':Idx Xf:o' og:o'' o'd:(prodData P).B sval✝¹:P.Aval✝:P.B val✝¹hd:(prodData P).DirectionOver (Sum.inr val✝¹) o (Sum.inl val✝)((prodData P).directionRestr (Sum.inr val✝¹) (g f) Sum.inl val✝, hd) = (((prodData P).directionRestr (Sum.inr val✝¹) g (prodData P).directionRestr (Sum.inr val✝¹) f) Sum.inl val✝, hd) All goals completed! 🐙 X:TypeY:TypeP:SlicePFunctor X Ys:(prodData P).Ao:Idx Xo':Idx Xo'':Idx Xf:o' og:o'' o'd:(prodData P).B sval✝¹:P.Aval✝:P.B val✝¹hd:(prodData P).DirectionOver (Sum.inr val✝¹) o (Sum.inr val✝)((prodData P).directionRestr (Sum.inr val✝¹) (g f) Sum.inr val✝, hd) = (((prodData P).directionRestr (Sum.inr val✝¹) g (prodData P).directionRestr (Sum.inr val✝¹) f) Sum.inr val✝, hd) X:TypeY:TypeP:SlicePFunctor X Ys:(prodData P).Ao:Idx Xo':Idx Xo'':Idx Xf:o' og:o'' o'd:(prodData P).B sval✝¹:P.Aval✝:P.B val✝¹hd:(prodData P).DirectionOver (Sum.inr val✝¹) o (Sum.inr val✝)h1:(1, P.r val✝¹, val✝) = o((prodData P).directionRestr (Sum.inr val✝¹) (g f) Sum.inr val✝, hd) = (((prodData P).directionRestr (Sum.inr val✝¹) g (prodData P).directionRestr (Sum.inr val✝¹) f) Sum.inr val✝, hd) X:TypeY:TypeP:SlicePFunctor X Ys:(prodData P).Ao':Idx Xo'':Idx Xg:o'' o'd:(prodData P).B sval✝¹:P.Aval✝:P.B val✝¹f:o' (1, P.r val✝¹, val✝)hd:(prodData P).DirectionOver (Sum.inr val✝¹) (1, P.r val✝¹, val✝) (Sum.inr val✝)((prodData P).directionRestr (Sum.inr val✝¹) (g f) Sum.inr val✝, hd) = (((prodData P).directionRestr (Sum.inr val✝¹) g (prodData P).directionRestr (Sum.inr val✝¹) f) Sum.inr val✝, hd) X:TypeY:TypeP:SlicePFunctor X Ys:(prodData P).Ao'':Idx Xd:(prodData P).B sval✝¹:P.Aval✝:P.B val✝¹hd:(prodData P).DirectionOver (Sum.inr val✝¹) (1, P.r val✝¹, val✝) (Sum.inr val✝)i':Fin 2snd✝:Xg:o'' (i', snd✝)f:(i', snd✝) (1, P.r val✝¹, val✝)((prodData P).directionRestr (Sum.inr val✝¹) (g f) Sum.inr val✝, hd) = (((prodData P).directionRestr (Sum.inr val✝¹) g (prodData P).directionRestr (Sum.inr val✝¹) f) Sum.inr val✝, hd) X:TypeY:TypeP:SlicePFunctor X Ys:(prodData P).Ad:(prodData P).B sval✝¹:P.Aval✝:P.B val✝¹hd:(prodData P).DirectionOver (Sum.inr val✝¹) (1, P.r val✝¹, val✝) (Sum.inr val✝)i':Fin 2snd✝¹:Xf:(i', snd✝) (1, P.r val✝¹, val✝)i'':Fin 2snd✝:Xg:(i'', snd✝) (i', snd✝¹)((prodData P).directionRestr (Sum.inr val✝¹) (g f) Sum.inr val✝, hd) = (((prodData P).directionRestr (Sum.inr val✝¹) g (prodData P).directionRestr (Sum.inr val✝¹) f) Sum.inr val✝, hd) match i', i'' with X:TypeY:TypeP:SlicePFunctor X Ys:(prodData P).Ad:(prodData P).B sval✝¹:P.Aval✝:P.B val✝¹hd:(prodData P).DirectionOver (Sum.inr val✝¹) (1, P.r val✝¹, val✝) (Sum.inr val✝)i':Fin 2snd✝¹:Xi'':Fin 2snd✝:Xf:(0, snd✝¹) (1, P.r val✝¹, val✝)g:(0, snd✝) (0, snd✝¹)((prodData P).directionRestr (Sum.inr val✝¹) (g f) Sum.inr val✝, hd) = (((prodData P).directionRestr (Sum.inr val✝¹) g (prodData P).directionRestr (Sum.inr val✝¹) f) Sum.inr val✝, hd) All goals completed! 🐙 X:TypeY:TypeP:SlicePFunctor X Ys:(prodData P).Ad:(prodData P).B sval✝¹:P.Aval✝:P.B val✝¹hd:(prodData P).DirectionOver (Sum.inr val✝¹) (1, P.r val✝¹, val✝) (Sum.inr val✝)i':Fin 2snd✝¹:Xi'':Fin 2snd✝:Xf:(1, snd✝¹) (1, P.r val✝¹, val✝)g:(0, snd✝) (1, snd✝¹)((prodData P).directionRestr (Sum.inr val✝¹) (g f) Sum.inr val✝, hd) = (((prodData P).directionRestr (Sum.inr val✝¹) g (prodData P).directionRestr (Sum.inr val✝¹) f) Sum.inr val✝, hd) All goals completed! 🐙 X:TypeY:TypeP:SlicePFunctor X Ys:(prodData P).Ad:(prodData P).B sval✝¹:P.Aval✝:P.B val✝¹hd:(prodData P).DirectionOver (Sum.inr val✝¹) (1, P.r val✝¹, val✝) (Sum.inr val✝)i':Fin 2snd✝¹:Xi'':Fin 2snd✝:Xf:(1, snd✝¹) (1, P.r val✝¹, val✝)g:(1, snd✝) (1, snd✝¹)((prodData P).directionRestr (Sum.inr val✝¹) (g f) Sum.inr val✝, hd) = (((prodData P).directionRestr (Sum.inr val✝¹) g (prodData P).directionRestr (Sum.inr val✝¹) f) Sum.inr val✝, hd) All goals completed! 🐙 X:TypeY:TypeP:SlicePFunctor X Ys:(prodData P).Ad:(prodData P).B sval✝¹:P.Aval✝:P.B val✝¹hd:(prodData P).DirectionOver (Sum.inr val✝¹) (1, P.r val✝¹, val✝) (Sum.inr val✝)i':Fin 2snd✝¹:Xi'':Fin 2snd✝:Xf:(0, snd✝¹) (1, P.r val✝¹, val✝)g:(1, snd✝) (0, snd✝¹)((prodData P).directionRestr (Sum.inr val✝¹) (g f) Sum.inr val✝, hd) = (((prodData P).directionRestr (Sum.inr val✝¹) g (prodData P).directionRestr (Sum.inr val✝¹) f) Sum.inr val✝, hd) exact absurd (leOfHom g).1 (X:TypeY:TypeP:SlicePFunctor X Ys:(prodData P).Ad:(prodData P).B sval✝¹:P.Aval✝:P.B val✝¹hd:(prodData P).DirectionOver (Sum.inr val✝¹) (1, P.r val✝¹, val✝) (Sum.inr val✝)i':Fin 2snd✝¹:Xi'':Fin 2snd✝:Xf:(0, snd✝¹) (1, P.r val✝¹, val✝)g:(1, snd✝) (0, snd✝¹)¬(1, snd✝).1 (0, snd✝¹).1 X:TypeY:TypeP:SlicePFunctor X Ys:(prodData P).Ad:(prodData P).B sval✝¹:P.Aval✝:P.B val✝¹hd:(prodData P).DirectionOver (Sum.inr val✝¹) (1, P.r val✝¹, val✝) (Sum.inr val✝)i':Fin 2snd✝¹:Xi'':Fin 2snd✝:Xf:(0, snd✝¹) (1, P.r val✝¹, val✝)g:(1, snd✝) (0, snd✝¹)¬1 0; All goals completed! 🐙)

Shape restriction along an identity is the identity.

theorem shapeRestr_id : (prodData P).ShapeRestrId := X:TypeY:TypeP:SlicePFunctor X Y(prodData P).ShapeRestrId X:TypeY:TypeP:SlicePFunctor X Yo:Idx Y(prodData P).shapeRestr (𝟙 o) = id X:TypeY:TypeP:SlicePFunctor X Yo:Idx Ys:{ toSliceDomPFunctor := (prodData P).toSliceDomPFunctor, q := (prodData P).q }.Shape o(prodData P).shapeRestr (𝟙 o) s = id s X:TypeY:TypeP:SlicePFunctor X Yo:Idx Ys:{ toSliceDomPFunctor := (prodData P).toSliceDomPFunctor, q := (prodData P).q }.Ahs:{ toSliceDomPFunctor := (prodData P).toSliceDomPFunctor, q := (prodData P).q }.ShapeOver o s(prodData P).shapeRestr (𝟙 o) s, hs = id s, hs X:TypeY:TypeP:SlicePFunctor X Yo:Idx Ys:{ toSliceDomPFunctor := (prodData P).toSliceDomPFunctor, q := (prodData P).q }.Ahs:{ toSliceDomPFunctor := (prodData P).toSliceDomPFunctor, q := (prodData P).q }.ShapeOver o s((prodData P).shapeRestr (𝟙 o) s, hs) = (id s, hs) match s with X:TypeY:TypeP:SlicePFunctor X Yo:Idx Ys:{ toSliceDomPFunctor := (prodData P).toSliceDomPFunctor, q := (prodData P).q }.Aval✝:Yhs:{ toSliceDomPFunctor := (prodData P).toSliceDomPFunctor, q := (prodData P).q }.ShapeOver o (Sum.inl val✝)((prodData P).shapeRestr (𝟙 o) Sum.inl val✝, hs) = (id Sum.inl val✝, hs) All goals completed! 🐙 X:TypeY:TypeP:SlicePFunctor X Yo:Idx Ys:{ toSliceDomPFunctor := (prodData P).toSliceDomPFunctor, q := (prodData P).q }.Aval✝:P.Ahs:{ toSliceDomPFunctor := (prodData P).toSliceDomPFunctor, q := (prodData P).q }.ShapeOver o (Sum.inr val✝)((prodData P).shapeRestr (𝟙 o) Sum.inr val✝, hs) = (id Sum.inr val✝, hs) X:TypeY:TypeP:SlicePFunctor X Yo:Idx Ys:{ toSliceDomPFunctor := (prodData P).toSliceDomPFunctor, q := (prodData P).q }.Aval✝:P.Ahs:{ toSliceDomPFunctor := (prodData P).toSliceDomPFunctor, q := (prodData P).q }.ShapeOver o (Sum.inr val✝)h1:(1, P.q val✝) = o((prodData P).shapeRestr (𝟙 o) Sum.inr val✝, hs) = (id Sum.inr val✝, hs) X:TypeY:TypeP:SlicePFunctor X Ys:{ toSliceDomPFunctor := (prodData P).toSliceDomPFunctor, q := (prodData P).q }.Aval✝:P.Ahs:{ toSliceDomPFunctor := (prodData P).toSliceDomPFunctor, q := (prodData P).q }.ShapeOver (1, P.q val✝) (Sum.inr val✝)((prodData P).shapeRestr (𝟙 (1, P.q val✝)) Sum.inr val✝, hs) = (id Sum.inr val✝, hs) All goals completed! 🐙

Shape restriction reverses composition.

theorem shapeRestr_comp : (prodData P).ShapeRestrComp := X:TypeY:TypeP:SlicePFunctor X Y(prodData P).ShapeRestrComp X:TypeY:TypeP:SlicePFunctor X Yo:Idx Yo':Idx Yo'':Idx Yg:o' oh:o'' o'(prodData P).shapeRestr (h g) = (prodData P).shapeRestr h (prodData P).shapeRestr g X:TypeY:TypeP:SlicePFunctor X Yo:Idx Yo':Idx Yo'':Idx Yg:o' oh:o'' o's:{ toSliceDomPFunctor := (prodData P).toSliceDomPFunctor, q := (prodData P).q }.Shape o(prodData P).shapeRestr (h g) s = ((prodData P).shapeRestr h (prodData P).shapeRestr g) s X:TypeY:TypeP:SlicePFunctor X Yo:Idx Yo':Idx Yo'':Idx Yg:o' oh:o'' o's:{ toSliceDomPFunctor := (prodData P).toSliceDomPFunctor, q := (prodData P).q }.Ahs:{ toSliceDomPFunctor := (prodData P).toSliceDomPFunctor, q := (prodData P).q }.ShapeOver o s(prodData P).shapeRestr (h g) s, hs = ((prodData P).shapeRestr h (prodData P).shapeRestr g) s, hs X:TypeY:TypeP:SlicePFunctor X Yo:Idx Yo':Idx Yo'':Idx Yg:o' oh:o'' o's:{ toSliceDomPFunctor := (prodData P).toSliceDomPFunctor, q := (prodData P).q }.Ahs:{ toSliceDomPFunctor := (prodData P).toSliceDomPFunctor, q := (prodData P).q }.ShapeOver o s((prodData P).shapeRestr (h g) s, hs) = (((prodData P).shapeRestr h (prodData P).shapeRestr g) s, hs) match s with X:TypeY:TypeP:SlicePFunctor X Yo:Idx Yo':Idx Yo'':Idx Yg:o' oh:o'' o's:{ toSliceDomPFunctor := (prodData P).toSliceDomPFunctor, q := (prodData P).q }.Aval✝:Yhs:{ toSliceDomPFunctor := (prodData P).toSliceDomPFunctor, q := (prodData P).q }.ShapeOver o (Sum.inl val✝)((prodData P).shapeRestr (h g) Sum.inl val✝, hs) = (((prodData P).shapeRestr h (prodData P).shapeRestr g) Sum.inl val✝, hs) All goals completed! 🐙 X:TypeY:TypeP:SlicePFunctor X Yo:Idx Yo':Idx Yo'':Idx Yg:o' oh:o'' o's:{ toSliceDomPFunctor := (prodData P).toSliceDomPFunctor, q := (prodData P).q }.Aval✝:P.Ahs:{ toSliceDomPFunctor := (prodData P).toSliceDomPFunctor, q := (prodData P).q }.ShapeOver o (Sum.inr val✝)((prodData P).shapeRestr (h g) Sum.inr val✝, hs) = (((prodData P).shapeRestr h (prodData P).shapeRestr g) Sum.inr val✝, hs) X:TypeY:TypeP:SlicePFunctor X Yo:Idx Yo':Idx Yo'':Idx Yg:o' oh:o'' o's:{ toSliceDomPFunctor := (prodData P).toSliceDomPFunctor, q := (prodData P).q }.Aval✝:P.Ahs:{ toSliceDomPFunctor := (prodData P).toSliceDomPFunctor, q := (prodData P).q }.ShapeOver o (Sum.inr val✝)h1:(1, P.q val✝) = o((prodData P).shapeRestr (h g) Sum.inr val✝, hs) = (((prodData P).shapeRestr h (prodData P).shapeRestr g) Sum.inr val✝, hs) X:TypeY:TypeP:SlicePFunctor X Yo':Idx Yo'':Idx Yh:o'' o's:{ toSliceDomPFunctor := (prodData P).toSliceDomPFunctor, q := (prodData P).q }.Aval✝:P.Ag:o' (1, P.q val✝)hs:{ toSliceDomPFunctor := (prodData P).toSliceDomPFunctor, q := (prodData P).q }.ShapeOver (1, P.q val✝) (Sum.inr val✝)((prodData P).shapeRestr (h g) Sum.inr val✝, hs) = (((prodData P).shapeRestr h (prodData P).shapeRestr g) Sum.inr val✝, hs) X:TypeY:TypeP:SlicePFunctor X Yo'':Idx Ys:{ toSliceDomPFunctor := (prodData P).toSliceDomPFunctor, q := (prodData P).q }.Aval✝:P.Ahs:{ toSliceDomPFunctor := (prodData P).toSliceDomPFunctor, q := (prodData P).q }.ShapeOver (1, P.q val✝) (Sum.inr val✝)i':Fin 2snd✝:Yh:o'' (i', snd✝)g:(i', snd✝) (1, P.q val✝)((prodData P).shapeRestr (h g) Sum.inr val✝, hs) = (((prodData P).shapeRestr h (prodData P).shapeRestr g) Sum.inr val✝, hs) X:TypeY:TypeP:SlicePFunctor X Ys:{ toSliceDomPFunctor := (prodData P).toSliceDomPFunctor, q := (prodData P).q }.Aval✝:P.Ahs:{ toSliceDomPFunctor := (prodData P).toSliceDomPFunctor, q := (prodData P).q }.ShapeOver (1, P.q val✝) (Sum.inr val✝)i':Fin 2snd✝¹:Yg:(i', snd✝) (1, P.q val✝)i'':Fin 2snd✝:Yh:(i'', snd✝) (i', snd✝¹)((prodData P).shapeRestr (h g) Sum.inr val✝, hs) = (((prodData P).shapeRestr h (prodData P).shapeRestr g) Sum.inr val✝, hs) match i', i'' with X:TypeY:TypeP:SlicePFunctor X Ys:{ toSliceDomPFunctor := (prodData P).toSliceDomPFunctor, q := (prodData P).q }.Aval✝:P.Ahs:{ toSliceDomPFunctor := (prodData P).toSliceDomPFunctor, q := (prodData P).q }.ShapeOver (1, P.q val✝) (Sum.inr val✝)i':Fin 2snd✝¹:Yi'':Fin 2snd✝:Yg:(0, snd✝¹) (1, P.q val✝)h:(0, snd✝) (0, snd✝¹)((prodData P).shapeRestr (h g) Sum.inr val✝, hs) = (((prodData P).shapeRestr h (prodData P).shapeRestr g) Sum.inr val✝, hs) All goals completed! 🐙 X:TypeY:TypeP:SlicePFunctor X Ys:{ toSliceDomPFunctor := (prodData P).toSliceDomPFunctor, q := (prodData P).q }.Aval✝:P.Ahs:{ toSliceDomPFunctor := (prodData P).toSliceDomPFunctor, q := (prodData P).q }.ShapeOver (1, P.q val✝) (Sum.inr val✝)i':Fin 2snd✝¹:Yi'':Fin 2snd✝:Yg:(1, snd✝¹) (1, P.q val✝)h:(0, snd✝) (1, snd✝¹)((prodData P).shapeRestr (h g) Sum.inr val✝, hs) = (((prodData P).shapeRestr h (prodData P).shapeRestr g) Sum.inr val✝, hs) All goals completed! 🐙 X:TypeY:TypeP:SlicePFunctor X Ys:{ toSliceDomPFunctor := (prodData P).toSliceDomPFunctor, q := (prodData P).q }.Aval✝:P.Ahs:{ toSliceDomPFunctor := (prodData P).toSliceDomPFunctor, q := (prodData P).q }.ShapeOver (1, P.q val✝) (Sum.inr val✝)i':Fin 2snd✝¹:Yi'':Fin 2snd✝:Yg:(1, snd✝¹) (1, P.q val✝)h:(1, snd✝) (1, snd✝¹)((prodData P).shapeRestr (h g) Sum.inr val✝, hs) = (((prodData P).shapeRestr h (prodData P).shapeRestr g) Sum.inr val✝, hs) All goals completed! 🐙 X:TypeY:TypeP:SlicePFunctor X Ys:{ toSliceDomPFunctor := (prodData P).toSliceDomPFunctor, q := (prodData P).q }.Aval✝:P.Ahs:{ toSliceDomPFunctor := (prodData P).toSliceDomPFunctor, q := (prodData P).q }.ShapeOver (1, P.q val✝) (Sum.inr val✝)i':Fin 2snd✝¹:Yi'':Fin 2snd✝:Yg:(0, snd✝¹) (1, P.q val✝)h:(1, snd✝) (0, snd✝¹)((prodData P).shapeRestr (h g) Sum.inr val✝, hs) = (((prodData P).shapeRestr h (prodData P).shapeRestr g) Sum.inr val✝, hs) exact absurd (leOfHom h).1 (X:TypeY:TypeP:SlicePFunctor X Ys:{ toSliceDomPFunctor := (prodData P).toSliceDomPFunctor, q := (prodData P).q }.Aval✝:P.Ahs:{ toSliceDomPFunctor := (prodData P).toSliceDomPFunctor, q := (prodData P).q }.ShapeOver (1, P.q val✝) (Sum.inr val✝)i':Fin 2snd✝¹:Yi'':Fin 2snd✝:Yg:(0, snd✝¹) (1, P.q val✝)h:(1, snd✝) (0, snd✝¹)¬(1, snd✝).1 (0, snd✝¹).1 X:TypeY:TypeP:SlicePFunctor X Ys:{ toSliceDomPFunctor := (prodData P).toSliceDomPFunctor, q := (prodData P).q }.Aval✝:P.Ahs:{ toSliceDomPFunctor := (prodData P).toSliceDomPFunctor, q := (prodData P).q }.ShapeOver (1, P.q val✝) (Sum.inr val✝)i':Fin 2snd✝¹:Yi'':Fin 2snd✝:Yg:(0, snd✝¹) (1, P.q val✝)h:(1, snd✝) (0, snd✝¹)¬1 0; All goals completed! 🐙)

Reindexing commutes with direction restriction.

theorem reindex_naturality : (prodData P).ReindexNaturality := X:TypeY:TypeP:SlicePFunctor X Y(prodData P).ReindexNaturality X:TypeY:TypeP:SlicePFunctor X Yo:Idx Yo':Idx Yg:o' os:(prodData P).toSlicePFunctor.Shape op:Idx Xp':Idx Xf:p' p(prodData P).directionRestr (↑s) f (prodData P).reindex g s = (prodData P).reindex g s (prodData P).directionRestr (↑((prodData P).shapeRestr g s)) f X:TypeY:TypeP:SlicePFunctor X Yo:Idx Yo':Idx Yg:o' os:(prodData P).toSlicePFunctor.Shape op:Idx Xp':Idx Xf:p' pd:(prodData P).Direction (↑((prodData P).shapeRestr g s)) p((prodData P).directionRestr (↑s) f (prodData P).reindex g s) d = ((prodData P).reindex g s (prodData P).directionRestr (↑((prodData P).shapeRestr g s)) f) d X:TypeY:TypeP:SlicePFunctor X Yo:Idx Yo':Idx Yg:o' os:(prodData P).toSlicePFunctor.Shape op:Idx Xp':Idx Xf:p' pd:(prodData P).B ((prodData P).shapeRestr g s)hd:(prodData P).DirectionOver (↑((prodData P).shapeRestr g s)) p d((prodData P).directionRestr (↑s) f (prodData P).reindex g s) d, hd = ((prodData P).reindex g s (prodData P).directionRestr (↑((prodData P).shapeRestr g s)) f) d, hd X:TypeY:TypeP:SlicePFunctor X Yo:Idx Yo':Idx Yg:o' os:(prodData P).toSlicePFunctor.Shape op:Idx Xp':Idx Xf:p' pd:(prodData P).B ((prodData P).shapeRestr g s)hd:(prodData P).DirectionOver (↑((prodData P).shapeRestr g s)) p d(((prodData P).directionRestr (↑s) f (prodData P).reindex g s) d, hd) = (((prodData P).reindex g s (prodData P).directionRestr (↑((prodData P).shapeRestr g s)) f) d, hd) X:TypeY:TypeP:SlicePFunctor X Yo:Idx Yo':Idx Yg:o' op:Idx Xp':Idx Xf:p' ps:(prodData P).toSlicePFunctor.Ahs:(prodData P).toSlicePFunctor.ShapeOver o sd:(prodData P).B ((prodData P).shapeRestr g s, hs)hd:(prodData P).DirectionOver (↑((prodData P).shapeRestr g s, hs)) p d(((prodData P).directionRestr (↑s, hs) f (prodData P).reindex g s, hs) d, hd) = (((prodData P).reindex g s, hs (prodData P).directionRestr (↑((prodData P).shapeRestr g s, hs)) f) d, hd) cases s with X:TypeY:TypeP:SlicePFunctor X Yo:Idx Yo':Idx Yg:o' op:Idx Xp':Idx Xf:p' pval✝:Yhs:(prodData P).toSlicePFunctor.ShapeOver o (Sum.inl val✝)d:(prodData P).B ((prodData P).shapeRestr g Sum.inl val✝, hs)hd:(prodData P).DirectionOver (↑((prodData P).shapeRestr g Sum.inl val✝, hs)) p d(((prodData P).directionRestr (↑Sum.inl val✝, hs) f (prodData P).reindex g Sum.inl val✝, hs) d, hd) = (((prodData P).reindex g Sum.inl val✝, hs (prodData P).directionRestr (↑((prodData P).shapeRestr g Sum.inl val✝, hs)) f) d, hd) All goals completed! 🐙 X:TypeY:TypeP:SlicePFunctor X Yo:Idx Yo':Idx Yg:o' op:Idx Xp':Idx Xf:p' pval✝:P.Ahs:(prodData P).toSlicePFunctor.ShapeOver o (Sum.inr val✝)d:(prodData P).B ((prodData P).shapeRestr g Sum.inr val✝, hs)hd:(prodData P).DirectionOver (↑((prodData P).shapeRestr g Sum.inr val✝, hs)) p d(((prodData P).directionRestr (↑Sum.inr val✝, hs) f (prodData P).reindex g Sum.inr val✝, hs) d, hd) = (((prodData P).reindex g Sum.inr val✝, hs (prodData P).directionRestr (↑((prodData P).shapeRestr g Sum.inr val✝, hs)) f) d, hd) X:TypeY:TypeP:SlicePFunctor X Yo:Idx Yo':Idx Yg:o' op:Idx Xp':Idx Xf:p' pval✝:P.Ahs:(prodData P).toSlicePFunctor.ShapeOver o (Sum.inr val✝)d:(prodData P).B ((prodData P).shapeRestr g Sum.inr val✝, hs)hd:(prodData P).DirectionOver (↑((prodData P).shapeRestr g Sum.inr val✝, hs)) p dh1:(1, P.q val✝) = o(((prodData P).directionRestr (↑Sum.inr val✝, hs) f (prodData P).reindex g Sum.inr val✝, hs) d, hd) = (((prodData P).reindex g Sum.inr val✝, hs (prodData P).directionRestr (↑((prodData P).shapeRestr g Sum.inr val✝, hs)) f) d, hd) X:TypeY:TypeP:SlicePFunctor X Yo':Idx Yp:Idx Xp':Idx Xf:p' pval✝:P.Ag:o' (1, P.q val✝)hs:(prodData P).toSlicePFunctor.ShapeOver (1, P.q val✝) (Sum.inr val✝)d:(prodData P).B ((prodData P).shapeRestr g Sum.inr val✝, hs)hd:(prodData P).DirectionOver (↑((prodData P).shapeRestr g Sum.inr val✝, hs)) p d(((prodData P).directionRestr (↑Sum.inr val✝, hs) f (prodData P).reindex g Sum.inr val✝, hs) d, hd) = (((prodData P).reindex g Sum.inr val✝, hs (prodData P).directionRestr (↑((prodData P).shapeRestr g Sum.inr val✝, hs)) f) d, hd) X:TypeY:TypeP:SlicePFunctor X Yp:Idx Xp':Idx Xf:p' pval✝:P.Ahs:(prodData P).toSlicePFunctor.ShapeOver (1, P.q val✝) (Sum.inr val✝)i':Fin 2snd✝:Yg:(i', snd✝) (1, P.q val✝)d:(prodData P).B ((prodData P).shapeRestr g Sum.inr val✝, hs)hd:(prodData P).DirectionOver (↑((prodData P).shapeRestr g Sum.inr val✝, hs)) p d(((prodData P).directionRestr (↑Sum.inr val✝, hs) f (prodData P).reindex g Sum.inr val✝, hs) d, hd) = (((prodData P).reindex g Sum.inr val✝, hs (prodData P).directionRestr (↑((prodData P).shapeRestr g Sum.inr val✝, hs)) f) d, hd) match i' with X:TypeY:TypeP:SlicePFunctor X Yp:Idx Xp':Idx Xf:p' pval✝:P.Ahs:(prodData P).toSlicePFunctor.ShapeOver (1, P.q val✝) (Sum.inr val✝)i':Fin 2snd✝:Yg:(1, snd✝) (1, P.q val✝)d:(prodData P).B ((prodData P).shapeRestr g Sum.inr val✝, hs)hd:(prodData P).DirectionOver (↑((prodData P).shapeRestr g Sum.inr val✝, hs)) p d(((prodData P).directionRestr (↑Sum.inr val✝, hs) f (prodData P).reindex g Sum.inr val✝, hs) d, hd) = (((prodData P).reindex g Sum.inr val✝, hs (prodData P).directionRestr (↑((prodData P).shapeRestr g Sum.inr val✝, hs)) f) d, hd) All goals completed! 🐙 X:TypeY:TypeP:SlicePFunctor X Yp:Idx Xp':Idx Xf:p' pval✝:P.Ahs:(prodData P).toSlicePFunctor.ShapeOver (1, P.q val✝) (Sum.inr val✝)i':Fin 2snd✝:Yg:(0, snd✝) (1, P.q val✝)d:(prodData P).B ((prodData P).shapeRestr g Sum.inr val✝, hs)hd:(prodData P).DirectionOver (↑((prodData P).shapeRestr g Sum.inr val✝, hs)) p d(((prodData P).directionRestr (↑Sum.inr val✝, hs) f (prodData P).reindex g Sum.inr val✝, hs) d, hd) = (((prodData P).reindex g Sum.inr val✝, hs (prodData P).directionRestr (↑((prodData P).shapeRestr g Sum.inr val✝, hs)) f) d, hd) All goals completed! 🐙

Reindexing along an identity is the identity.

theorem reindex_id : (prodData P).ReindexId (shapeRestr_id P) := X:TypeY:TypeP:SlicePFunctor X Y(prodData P).ReindexId X:TypeY:TypeP:SlicePFunctor X Yo:Idx Ys:(prodData P).toSlicePFunctor.Shape op:Idx Xd:(prodData P).Direction (↑((prodData P).shapeRestr (𝟙 o) s)) p(prodData P).reindex (𝟙 o) s d = cast d X:TypeY:TypeP:SlicePFunctor X Yo:Idx Yp:Idx Xs:(prodData P).toSlicePFunctor.Ahs:(prodData P).toSlicePFunctor.ShapeOver o sd:(prodData P).Direction (↑((prodData P).shapeRestr (𝟙 o) s, hs)) p(prodData P).reindex (𝟙 o) s, hs d = cast d X:TypeY:TypeP:SlicePFunctor X Yo:Idx Yp:Idx Xs:(prodData P).toSlicePFunctor.Ahs:(prodData P).toSlicePFunctor.ShapeOver o sd:(prodData P).B ((prodData P).shapeRestr (𝟙 o) s, hs)hd:(prodData P).DirectionOver (↑((prodData P).shapeRestr (𝟙 o) s, hs)) p d(prodData P).reindex (𝟙 o) s, hs d, hd = cast d, hd match s with X:TypeY:TypeP:SlicePFunctor X Yo:Idx Yp:Idx Xs:(prodData P).toSlicePFunctor.Aval✝:Yhs:(prodData P).toSlicePFunctor.ShapeOver o (Sum.inl val✝)d:(prodData P).B ((prodData P).shapeRestr (𝟙 o) Sum.inl val✝, hs)hd:(prodData P).DirectionOver (↑((prodData P).shapeRestr (𝟙 o) Sum.inl val✝, hs)) p d(prodData P).reindex (𝟙 o) Sum.inl val✝, hs d, hd = cast d, hd X:TypeY:TypeP:SlicePFunctor X Yo:Idx Yp:Idx Xs:(prodData P).toSlicePFunctor.Aval✝:Yhs:(prodData P).toSlicePFunctor.ShapeOver o (Sum.inl val✝)d:(prodData P).B ((prodData P).shapeRestr (𝟙 o) Sum.inl val✝, hs)hd:(prodData P).DirectionOver (↑((prodData P).shapeRestr (𝟙 o) Sum.inl val✝, hs)) p d((prodData P).reindex (𝟙 o) Sum.inl val✝, hs d, hd) = (cast d, hd) All goals completed! 🐙 X:TypeY:TypeP:SlicePFunctor X Yo:Idx Yp:Idx Xs:(prodData P).toSlicePFunctor.Aval✝:P.Ahs:(prodData P).toSlicePFunctor.ShapeOver o (Sum.inr val✝)d:(prodData P).B ((prodData P).shapeRestr (𝟙 o) Sum.inr val✝, hs)hd:(prodData P).DirectionOver (↑((prodData P).shapeRestr (𝟙 o) Sum.inr val✝, hs)) p d(prodData P).reindex (𝟙 o) Sum.inr val✝, hs d, hd = cast d, hd X:TypeY:TypeP:SlicePFunctor X Yo:Idx Yp:Idx Xs:(prodData P).toSlicePFunctor.Aval✝:P.Ahs:(prodData P).toSlicePFunctor.ShapeOver o (Sum.inr val✝)d:(prodData P).B ((prodData P).shapeRestr (𝟙 o) Sum.inr val✝, hs)hd:(prodData P).DirectionOver (↑((prodData P).shapeRestr (𝟙 o) Sum.inr val✝, hs)) p dh1:(1, P.q val✝) = o(prodData P).reindex (𝟙 o) Sum.inr val✝, hs d, hd = cast d, hd X:TypeY:TypeP:SlicePFunctor X Yp:Idx Xs:(prodData P).toSlicePFunctor.Aval✝:P.Ahs:(prodData P).toSlicePFunctor.ShapeOver (1, P.q val✝) (Sum.inr val✝)d:(prodData P).B ((prodData P).shapeRestr (𝟙 (1, P.q val✝)) Sum.inr val✝, hs)hd:(prodData P).DirectionOver (↑((prodData P).shapeRestr (𝟙 (1, P.q val✝)) Sum.inr val✝, hs)) p d(prodData P).reindex (𝟙 (1, P.q val✝)) Sum.inr val✝, hs d, hd = cast d, hd X:TypeY:TypeP:SlicePFunctor X Yp:Idx Xs:(prodData P).toSlicePFunctor.Aval✝:P.Ahs:(prodData P).toSlicePFunctor.ShapeOver (1, P.q val✝) (Sum.inr val✝)d:(prodData P).B ((prodData P).shapeRestr (𝟙 (1, P.q val✝)) Sum.inr val✝, hs)hd:(prodData P).DirectionOver (↑((prodData P).shapeRestr (𝟙 (1, P.q val✝)) Sum.inr val✝, hs)) p d((prodData P).reindex (𝟙 (1, P.q val✝)) Sum.inr val✝, hs d, hd) = (cast d, hd) All goals completed! 🐙

Reindexing along a composite is the composite of the reindexings.

theorem reindex_comp : (prodData P).ReindexComp (shapeRestr_comp P) := X:TypeY:TypeP:SlicePFunctor X Y(prodData P).ReindexComp X:TypeY:TypeP:SlicePFunctor X Yo:Idx Yo':Idx Yo'':Idx Yg:o' oh:o'' o's:(prodData P).toSlicePFunctor.Shape op:Idx Xd:(prodData P).Direction (↑((prodData P).shapeRestr (h g) s)) p(prodData P).reindex (h g) s d = (prodData P).reindex g s ((prodData P).reindex h ((prodData P).shapeRestr g s) (cast d)) X:TypeY:TypeP:SlicePFunctor X Yo:Idx Yo':Idx Yo'':Idx Yg:o' oh:o'' o'p:Idx Xs:(prodData P).toSlicePFunctor.Ahs:(prodData P).toSlicePFunctor.ShapeOver o sd:(prodData P).Direction (↑((prodData P).shapeRestr (h g) s, hs)) p(prodData P).reindex (h g) s, hs d = (prodData P).reindex g s, hs ((prodData P).reindex h ((prodData P).shapeRestr g s, hs) (cast d)) X:TypeY:TypeP:SlicePFunctor X Yo:Idx Yo':Idx Yo'':Idx Yg:o' oh:o'' o'p:Idx Xs:(prodData P).toSlicePFunctor.Ahs:(prodData P).toSlicePFunctor.ShapeOver o sd:(prodData P).B ((prodData P).shapeRestr (h g) s, hs)hd:(prodData P).DirectionOver (↑((prodData P).shapeRestr (h g) s, hs)) p d(prodData P).reindex (h g) s, hs d, hd = (prodData P).reindex g s, hs ((prodData P).reindex h ((prodData P).shapeRestr g s, hs) (cast d, hd)) match s with X:TypeY:TypeP:SlicePFunctor X Yo:Idx Yo':Idx Yo'':Idx Yg:o' oh:o'' o'p:Idx Xs:(prodData P).toSlicePFunctor.Aval✝:Yhs:(prodData P).toSlicePFunctor.ShapeOver o (Sum.inl val✝)d:(prodData P).B ((prodData P).shapeRestr (h g) Sum.inl val✝, hs)hd:(prodData P).DirectionOver (↑((prodData P).shapeRestr (h g) Sum.inl val✝, hs)) p d(prodData P).reindex (h g) Sum.inl val✝, hs d, hd = (prodData P).reindex g Sum.inl val✝, hs ((prodData P).reindex h ((prodData P).shapeRestr g Sum.inl val✝, hs) (cast d, hd)) X:TypeY:TypeP:SlicePFunctor X Yo:Idx Yo':Idx Yo'':Idx Yg:o' oh:o'' o'p:Idx Xs:(prodData P).toSlicePFunctor.Aval✝:Yhs:(prodData P).toSlicePFunctor.ShapeOver o (Sum.inl val✝)d:(prodData P).B ((prodData P).shapeRestr (h g) Sum.inl val✝, hs)hd:(prodData P).DirectionOver (↑((prodData P).shapeRestr (h g) Sum.inl val✝, hs)) p d((prodData P).reindex (h g) Sum.inl val✝, hs d, hd) = ((prodData P).reindex g Sum.inl val✝, hs ((prodData P).reindex h ((prodData P).shapeRestr g Sum.inl val✝, hs) (cast d, hd))) All goals completed! 🐙 X:TypeY:TypeP:SlicePFunctor X Yo:Idx Yo':Idx Yo'':Idx Yg:o' oh:o'' o'p:Idx Xs:(prodData P).toSlicePFunctor.Aval✝:P.Ahs:(prodData P).toSlicePFunctor.ShapeOver o (Sum.inr val✝)d:(prodData P).B ((prodData P).shapeRestr (h g) Sum.inr val✝, hs)hd:(prodData P).DirectionOver (↑((prodData P).shapeRestr (h g) Sum.inr val✝, hs)) p d(prodData P).reindex (h g) Sum.inr val✝, hs d, hd = (prodData P).reindex g Sum.inr val✝, hs ((prodData P).reindex h ((prodData P).shapeRestr g Sum.inr val✝, hs) (cast d, hd)) X:TypeY:TypeP:SlicePFunctor X Yo:Idx Yo':Idx Yo'':Idx Yg:o' oh:o'' o'p:Idx Xs:(prodData P).toSlicePFunctor.Aval✝:P.Ahs:(prodData P).toSlicePFunctor.ShapeOver o (Sum.inr val✝)d:(prodData P).B ((prodData P).shapeRestr (h g) Sum.inr val✝, hs)hd:(prodData P).DirectionOver (↑((prodData P).shapeRestr (h g) Sum.inr val✝, hs)) p dh1:(1, P.q val✝) = o(prodData P).reindex (h g) Sum.inr val✝, hs d, hd = (prodData P).reindex g Sum.inr val✝, hs ((prodData P).reindex h ((prodData P).shapeRestr g Sum.inr val✝, hs) (cast d, hd)) X:TypeY:TypeP:SlicePFunctor X Yo':Idx Yo'':Idx Yh:o'' o'p:Idx Xs:(prodData P).toSlicePFunctor.Aval✝:P.Ag:o' (1, P.q val✝)hs:(prodData P).toSlicePFunctor.ShapeOver (1, P.q val✝) (Sum.inr val✝)d:(prodData P).B ((prodData P).shapeRestr (h g) Sum.inr val✝, hs)hd:(prodData P).DirectionOver (↑((prodData P).shapeRestr (h g) Sum.inr val✝, hs)) p d(prodData P).reindex (h g) Sum.inr val✝, hs d, hd = (prodData P).reindex g Sum.inr val✝, hs ((prodData P).reindex h ((prodData P).shapeRestr g Sum.inr val✝, hs) (cast d, hd)) X:TypeY:TypeP:SlicePFunctor X Yo':Idx Yo'':Idx Yh:o'' o'p:Idx Xs:(prodData P).toSlicePFunctor.Aval✝:P.Ag:o' (1, P.q val✝)hs:(prodData P).toSlicePFunctor.ShapeOver (1, P.q val✝) (Sum.inr val✝)d:(prodData P).B ((prodData P).shapeRestr (h g) Sum.inr val✝, hs)hd:(prodData P).DirectionOver (↑((prodData P).shapeRestr (h g) Sum.inr val✝, hs)) p d((prodData P).reindex (h g) Sum.inr val✝, hs d, hd) = ((prodData P).reindex g Sum.inr val✝, hs ((prodData P).reindex h ((prodData P).shapeRestr g Sum.inr val✝, hs) (cast d, hd))) X:TypeY:TypeP:SlicePFunctor X Yo'':Idx Yp:Idx Xs:(prodData P).toSlicePFunctor.Aval✝:P.Ahs:(prodData P).toSlicePFunctor.ShapeOver (1, P.q val✝) (Sum.inr val✝)i':Fin 2snd✝:Yh:o'' (i', snd✝)g:(i', snd✝) (1, P.q val✝)d:(prodData P).B ((prodData P).shapeRestr (h g) Sum.inr val✝, hs)hd:(prodData P).DirectionOver (↑((prodData P).shapeRestr (h g) Sum.inr val✝, hs)) p d((prodData P).reindex (h g) Sum.inr val✝, hs d, hd) = ((prodData P).reindex g Sum.inr val✝, hs ((prodData P).reindex h ((prodData P).shapeRestr g Sum.inr val✝, hs) (cast d, hd))) X:TypeY:TypeP:SlicePFunctor X Yp:Idx Xs:(prodData P).toSlicePFunctor.Aval✝:P.Ahs:(prodData P).toSlicePFunctor.ShapeOver (1, P.q val✝) (Sum.inr val✝)i':Fin 2snd✝¹:Yg:(i', snd✝) (1, P.q val✝)i'':Fin 2snd✝:Yh:(i'', snd✝) (i', snd✝¹)d:(prodData P).B ((prodData P).shapeRestr (h g) Sum.inr val✝, hs)hd:(prodData P).DirectionOver (↑((prodData P).shapeRestr (h g) Sum.inr val✝, hs)) p d((prodData P).reindex (h g) Sum.inr val✝, hs d, hd) = ((prodData P).reindex g Sum.inr val✝, hs ((prodData P).reindex h ((prodData P).shapeRestr g Sum.inr val✝, hs) (cast d, hd))) match i', i'' with X:TypeY:TypeP:SlicePFunctor X Yp:Idx Xs:(prodData P).toSlicePFunctor.Aval✝:P.Ahs:(prodData P).toSlicePFunctor.ShapeOver (1, P.q val✝) (Sum.inr val✝)i':Fin 2snd✝¹:Yi'':Fin 2snd✝:Yg:(0, snd✝¹) (1, P.q val✝)h:(0, snd✝) (0, snd✝¹)d:(prodData P).B ((prodData P).shapeRestr (h g) Sum.inr val✝, hs)hd:(prodData P).DirectionOver (↑((prodData P).shapeRestr (h g) Sum.inr val✝, hs)) p d((prodData P).reindex (h g) Sum.inr val✝, hs d, hd) = ((prodData P).reindex g Sum.inr val✝, hs ((prodData P).reindex h ((prodData P).shapeRestr g Sum.inr val✝, hs) (cast d, hd))) All goals completed! 🐙 X:TypeY:TypeP:SlicePFunctor X Yp:Idx Xs:(prodData P).toSlicePFunctor.Aval✝:P.Ahs:(prodData P).toSlicePFunctor.ShapeOver (1, P.q val✝) (Sum.inr val✝)i':Fin 2snd✝¹:Yi'':Fin 2snd✝:Yg:(1, snd✝¹) (1, P.q val✝)h:(0, snd✝) (1, snd✝¹)d:(prodData P).B ((prodData P).shapeRestr (h g) Sum.inr val✝, hs)hd:(prodData P).DirectionOver (↑((prodData P).shapeRestr (h g) Sum.inr val✝, hs)) p d((prodData P).reindex (h g) Sum.inr val✝, hs d, hd) = ((prodData P).reindex g Sum.inr val✝, hs ((prodData P).reindex h ((prodData P).shapeRestr g Sum.inr val✝, hs) (cast d, hd))) All goals completed! 🐙 X:TypeY:TypeP:SlicePFunctor X Yp:Idx Xs:(prodData P).toSlicePFunctor.Aval✝:P.Ahs:(prodData P).toSlicePFunctor.ShapeOver (1, P.q val✝) (Sum.inr val✝)i':Fin 2snd✝¹:Yi'':Fin 2snd✝:Yg:(1, snd✝¹) (1, P.q val✝)h:(1, snd✝) (1, snd✝¹)d:(prodData P).B ((prodData P).shapeRestr (h g) Sum.inr val✝, hs)hd:(prodData P).DirectionOver (↑((prodData P).shapeRestr (h g) Sum.inr val✝, hs)) p d((prodData P).reindex (h g) Sum.inr val✝, hs d, hd) = ((prodData P).reindex g Sum.inr val✝, hs ((prodData P).reindex h ((prodData P).shapeRestr g Sum.inr val✝, hs) (cast d, hd))) All goals completed! 🐙 X:TypeY:TypeP:SlicePFunctor X Yp:Idx Xs:(prodData P).toSlicePFunctor.Aval✝:P.Ahs:(prodData P).toSlicePFunctor.ShapeOver (1, P.q val✝) (Sum.inr val✝)i':Fin 2snd✝¹:Yi'':Fin 2snd✝:Yg:(0, snd✝¹) (1, P.q val✝)h:(1, snd✝) (0, snd✝¹)d:(prodData P).B ((prodData P).shapeRestr (h g) Sum.inr val✝, hs)hd:(prodData P).DirectionOver (↑((prodData P).shapeRestr (h g) Sum.inr val✝, hs)) p d((prodData P).reindex (h g) Sum.inr val✝, hs d, hd) = ((prodData P).reindex g Sum.inr val✝, hs ((prodData P).reindex h ((prodData P).shapeRestr g Sum.inr val✝, hs) (cast d, hd))) exact absurd (leOfHom h).1 (X:TypeY:TypeP:SlicePFunctor X Yp:Idx Xs:(prodData P).toSlicePFunctor.Aval✝:P.Ahs:(prodData P).toSlicePFunctor.ShapeOver (1, P.q val✝) (Sum.inr val✝)i':Fin 2snd✝¹:Yi'':Fin 2snd✝:Yg:(0, snd✝¹) (1, P.q val✝)h:(1, snd✝) (0, snd✝¹)d:(prodData P).B ((prodData P).shapeRestr (h g) Sum.inr val✝, hs)hd:(prodData P).DirectionOver (↑((prodData P).shapeRestr (h g) Sum.inr val✝, hs)) p d¬(1, snd✝).1 (0, snd✝¹).1 X:TypeY:TypeP:SlicePFunctor X Yp:Idx Xs:(prodData P).toSlicePFunctor.Aval✝:P.Ahs:(prodData P).toSlicePFunctor.ShapeOver (1, P.q val✝) (Sum.inr val✝)i':Fin 2snd✝¹:Yi'':Fin 2snd✝:Yg:(0, snd✝¹) (1, P.q val✝)h:(1, snd✝) (0, snd✝¹)d:(prodData P).B ((prodData P).shapeRestr (h g) Sum.inr val✝, hs)hd:(prodData P).DirectionOver (↑((prodData P).shapeRestr (h g) Sum.inr val✝, hs)) p d¬1 0; All goals completed! 🐙)

The transcription's operations satisfy the functor laws.

The transcription of a slice polynomial functor Type/X → Type/Y to a presheaf polynomial functor from presheaves on Idx X to presheaves on Idx Y.

def prodPsh : PresheafPFunctor.{0, 0, 0, 0, 0, 0} (Idx X) (Idx Y) := { prodData P with isFunctorial := prodData_isFunctorial P }

Objects of the slice as presheaves

The fibres of the presheaf of an object p : E → X of Type/X: a point at every level 0, the fibre of p at level 1.

def sliceObj {E : Type} (p : E X) : Idx X Type | (0, _) => Unit | (1, x) => { e : E // p e = x }

The restriction maps of that presheaf.

def sliceMap {E : Type} (p : E X) : (o o' : Idx X), (o' o) sliceObj p o sliceObj p o' | (0, _), (0, _), _ => fun u u | (1, _), (1, _), f => fun e e.1, e.2.trans (leOfHom f).2.symm | (1, _), (0, _), _ => fun _ () | (0, _), (1, _), f => absurd (leOfHom f).1 (X:TypeZ:(Idx X)ᵒᵖ TypeY:TypeF:PresheafPFunctor (Idx X) (Idx Y)P:SlicePFunctor X YE:Typep:E Xsnd✝¹:Xsnd✝:Xf:(1, snd✝) (0, snd✝¹)¬(1, snd✝).1 (0, snd✝¹).1 X:TypeZ:(Idx X)ᵒᵖ TypeY:TypeF:PresheafPFunctor (Idx X) (Idx Y)P:SlicePFunctor X YE:Typep:E Xsnd✝¹:Xsnd✝:Xf:(1, snd✝) (0, snd✝¹)¬1 0; All goals completed! 🐙)

An object p : E → X of Type/X as a presheaf on Idx X.

def ofSliceX {E : Type} (p : E X) : (Idx X)ᵒᵖ Type where obj o := sliceObj p o.unop map f := sliceMap p _ _ f.unop map_id o := match o with | (0, _) => rfl | (1, _) => rfl map_comp {o o' o''} f g := match o, o', o'', f, g with | (0, _), (0, _), (0, _), _, _ => rfl | (1, _), (1, _), (1, _), _, _ => rfl | (1, _), (0, _), (0, _), _, _ => rfl | (1, _), (1, _), (0, _), _, _ => rfl | (1, _), (0, _), (1, _), _, g => absurd (leOfHom g.unop).1 (X:TypeZ:(Idx X)ᵒᵖ TypeY:TypeF:PresheafPFunctor (Idx X) (Idx Y)P:SlicePFunctor X YE:Typep:E Xo:(Idx X)ᵒᵖo':(Idx X)ᵒᵖo'':(Idx X)ᵒᵖf:o o'g✝:o' o''snd✝²:Xsnd✝¹:Xsnd✝:Xx✝:Opposite.op (1, snd✝²) Opposite.op (0, snd✝¹)g:Opposite.op (0, snd✝¹) Opposite.op (1, snd✝)¬(Opposite.unop (Opposite.op (1, snd✝))).1 (Opposite.unop (Opposite.op (0, snd✝¹))).1 X:TypeZ:(Idx X)ᵒᵖ TypeY:TypeF:PresheafPFunctor (Idx X) (Idx Y)P:SlicePFunctor X YE:Typep:E Xo:(Idx X)ᵒᵖo':(Idx X)ᵒᵖo'':(Idx X)ᵒᵖf:o o'g✝:o' o''snd✝²:Xsnd✝¹:Xsnd✝:Xx✝:Opposite.op (1, snd✝²) Opposite.op (0, snd✝¹)g:Opposite.op (0, snd✝¹) Opposite.op (1, snd✝)¬1 0; All goals completed! 🐙) | (0, _), (1, _), _, f, _ => absurd (leOfHom f.unop).1 (X:TypeZ:(Idx X)ᵒᵖ TypeY:TypeF:PresheafPFunctor (Idx X) (Idx Y)P:SlicePFunctor X YE:Typep:E Xo:(Idx X)ᵒᵖo':(Idx X)ᵒᵖo'':(Idx X)ᵒᵖf✝:o o'g:o' o''snd✝¹:Xsnd✝:Xx✝¹:(Idx X)ᵒᵖf:Opposite.op (0, snd✝¹) Opposite.op (1, snd✝)x✝:Opposite.op (1, snd✝) x✝¹¬(Opposite.unop (Opposite.op (1, snd✝))).1 (Opposite.unop (Opposite.op (0, snd✝¹))).1 X:TypeZ:(Idx X)ᵒᵖ TypeY:TypeF:PresheafPFunctor (Idx X) (Idx Y)P:SlicePFunctor X YE:Typep:E Xo:(Idx X)ᵒᵖo':(Idx X)ᵒᵖo'':(Idx X)ᵒᵖf✝:o o'g:o' o''snd✝¹:Xsnd✝:Xx✝¹:(Idx X)ᵒᵖf:Opposite.op (0, snd✝¹) Opposite.op (1, snd✝)x✝:Opposite.op (1, snd✝) x✝¹¬1 0; All goals completed! 🐙) | (0, _), (0, _), (1, _), _, g => absurd (leOfHom g.unop).1 (X:TypeZ:(Idx X)ᵒᵖ TypeY:TypeF:PresheafPFunctor (Idx X) (Idx Y)P:SlicePFunctor X YE:Typep:E Xo:(Idx X)ᵒᵖo':(Idx X)ᵒᵖo'':(Idx X)ᵒᵖf:o o'g✝:o' o''snd✝²:Xsnd✝¹:Xsnd✝:Xx✝:Opposite.op (0, snd✝²) Opposite.op (0, snd✝¹)g:Opposite.op (0, snd✝¹) Opposite.op (1, snd✝)¬(Opposite.unop (Opposite.op (1, snd✝))).1 (Opposite.unop (Opposite.op (0, snd✝¹))).1 X:TypeZ:(Idx X)ᵒᵖ TypeY:TypeF:PresheafPFunctor (Idx X) (Idx Y)P:SlicePFunctor X YE:Typep:E Xo:(Idx X)ᵒᵖo':(Idx X)ᵒᵖo'':(Idx X)ᵒᵖf:o o'g✝:o' o''snd✝²:Xsnd✝¹:Xsnd✝:Xx✝:Opposite.op (0, snd✝²) Opposite.op (0, snd✝¹)g:Opposite.op (0, snd✝¹) Opposite.op (1, snd✝)¬1 0; All goals completed! 🐙)

The components of a morphism over X as a natural transformation: the identity at level 0, the morphism on fibres at level 1.

def sliceHomApp {E E' : Type} {p : E X} {p' : E' X} (h : E E') (hh : p' h = p) : o : Idx X, sliceObj p o sliceObj p' o | (0, _) => fun u u | (1, _) => fun e h e.1, (congrFun hh e.1).trans e.2

A morphism h over X, p' ∘ h = p, as a natural transformation ofSliceX p ⟶ ofSliceX p'.

def ofSliceXHom {E E' : Type} {p : E X} {p' : E' X} (h : E E') (hh : p' h = p) : NatTrans (ofSliceX p) (ofSliceX p') where app o := sliceHomApp h hh o.unop naturality {o o'} f := match o, o', f with | (0, _), (0, _), _ => rfl | (1, _), (1, _), _ => rfl | (1, _), (0, _), _ => rfl | (0, _), (1, _), f => absurd (leOfHom f.unop).1 (X:TypeZ:(Idx X)ᵒᵖ TypeY:TypeF:PresheafPFunctor (Idx X) (Idx Y)P:SlicePFunctor X YE:TypeE':Typep:E Xp':E' Xh:E E'hh:p' h = po:(Idx X)ᵒᵖo':(Idx X)ᵒᵖf✝:o o'snd✝¹:Xsnd✝:Xf:Opposite.op (0, snd✝¹) Opposite.op (1, snd✝)¬(Opposite.unop (Opposite.op (1, snd✝))).1 (Opposite.unop (Opposite.op (0, snd✝¹))).1 X:TypeZ:(Idx X)ᵒᵖ TypeY:TypeF:PresheafPFunctor (Idx X) (Idx Y)P:SlicePFunctor X YE:TypeE':Typep:E Xp':E' Xh:E E'hh:p' h = po:(Idx X)ᵒᵖo':(Idx X)ᵒᵖf✝:o o'snd✝¹:Xsnd✝:Xf:Opposite.op (0, snd✝¹) Opposite.op (1, snd✝)¬1 0; All goals completed! 🐙)

The value at an object of the slice

The level-1 elements of the transcription's value at ofSliceX p over (1, y), in dependent-type terms.

abbrev ElemOver {E : Type} (p : E X) (y : Y) : Type := { e : Elem (ofSliceX p) (prodPsh P) // pQ P e.1 = mkIdx 1 y }

From an element over (1, y) to the slice functor's value over y: the level-1 assignment at each direction's own input index.

def toSliceObj {E : Type} (p : E X) (y : Y) (e : ElemOver P p y) : { o : P.toSliceDomPFunctor.Obj p // P.obj p o = y } := match e with | .inl _, _, _, h => absurd (congrArg Prod.fst h) Fin.zero_ne_one | .inr a, _, w, h => a, fun b (w (P.r a, b) .inr b, rfl).1.1, funext fun b (w (P.r a, b) .inr b, rfl).1.2, congrArg Prod.snd h

The level-1 assignment of the element built from a value of the slice functor: at the level-1 copy of a direction, its assigned element of the fibre.

def ofSliceObjW {E : Type} (p : E X) (o : P.toSliceDomPFunctor.Obj p) (x : X) (d : (prodSlice P).Direction (.inr o.1.1) (mkIdx 1 x)) : fibre (ofSliceX p) x () := match d with | .inl _, hd => absurd (congrArg Prod.fst hd) Fin.zero_ne_one | .inr b, hd => o.1.2 b, (congrFun o.2 b).trans (congrArg Prod.snd hd), rfl

From the slice functor's value over y to an element over (1, y).

def ofSliceObj {E : Type} (p : E X) (y : Y) (o : { o : P.toSliceDomPFunctor.Obj p // P.obj p o = y }) : ElemOver P p y := .inr o.1.1.1, fun _ _ (), fun x d ofSliceObjW P p o.1 x d, Prod.ext rfl o.2

The level-1 value of the transcription at ofSliceX p over (1, y), in dependent-type terms, is the slice functor's value at p over y.

def elemOverEquiv {E : Type} (p : E X) (y : Y) : ElemOver P p y { o : P.toSliceDomPFunctor.Obj p // P.obj p o = y } where toFun := toSliceObj P p y invFun := ofSliceObj P p y left_inv e := X:TypeZ:(Idx X)ᵒᵖ TypeY:TypeF:PresheafPFunctor (Idx X) (Idx Y)P:SlicePFunctor X YE:Typep:E Xy:Ye:ElemOver P p yofSliceObj P p y (toSliceObj P p y e) = e X:TypeZ:(Idx X)ᵒᵖ TypeY:TypeF:PresheafPFunctor (Idx X) (Idx Y)P:SlicePFunctor X YE:Typep:E Xy:Ys:(prodPsh P).Ag:(x : X) (prodPsh P).Direction s (mkIdx 0 x) (ofSliceX p).obj (Opposite.op (mkIdx 0 x))w:(x : X) (d : (prodPsh P).Direction s (mkIdx 1 x)) fibre (ofSliceX p) x (g x (dirRestr (prodPsh P) s x d))h:pQ P s, g, w.fst = mkIdx 1 yofSliceObj P p y (toSliceObj P p y s, g, w, h) = s, g, w, h match s with X:TypeZ:(Idx X)ᵒᵖ TypeY:TypeF:PresheafPFunctor (Idx X) (Idx Y)P:SlicePFunctor X YE:Typep:E Xy:Ys:(prodPsh P).Aval✝:Yg:(x : X) (prodPsh P).Direction (Sum.inl val✝) (mkIdx 0 x) (ofSliceX p).obj (Opposite.op (mkIdx 0 x))w:(x : X) (d : (prodPsh P).Direction (Sum.inl val✝) (mkIdx 1 x)) fibre (ofSliceX p) x (g x (dirRestr (prodPsh P) (Sum.inl val✝) x d))h:pQ P Sum.inl val✝, g, w.fst = mkIdx 1 yofSliceObj P p y (toSliceObj P p y Sum.inl val✝, g, w, h) = Sum.inl val✝, g, w, h All goals completed! 🐙 X:TypeZ:(Idx X)ᵒᵖ TypeY:TypeF:PresheafPFunctor (Idx X) (Idx Y)P:SlicePFunctor X YE:Typep:E Xy:Ys:(prodPsh P).Aa:P.Ag:(x : X) (prodPsh P).Direction (Sum.inr a) (mkIdx 0 x) (ofSliceX p).obj (Opposite.op (mkIdx 0 x))w:(x : X) (d : (prodPsh P).Direction (Sum.inr a) (mkIdx 1 x)) fibre (ofSliceX p) x (g x (dirRestr (prodPsh P) (Sum.inr a) x d))h:pQ P Sum.inr a, g, w.fst = mkIdx 1 yofSliceObj P p y (toSliceObj P p y Sum.inr a, g, w, h) = Sum.inr a, g, w, h X:TypeZ:(Idx X)ᵒᵖ TypeY:TypeF:PresheafPFunctor (Idx X) (Idx Y)P:SlicePFunctor X YE:Typep:E Xy:Ys:(prodPsh P).Aa:P.Ag:(x : X) (prodPsh P).Direction (Sum.inr a) (mkIdx 0 x) (ofSliceX p).obj (Opposite.op (mkIdx 0 x))w:(x : X) (d : (prodPsh P).Direction (Sum.inr a) (mkIdx 1 x)) fibre (ofSliceX p) x (g x (dirRestr (prodPsh P) (Sum.inr a) x d))h:pQ P Sum.inr a, g, w.fst = mkIdx 1 yx:Xd:(prodPsh P).Direction (Sum.inr (↑(toSliceObj P p y Sum.inr a, g, w, h)).fst) (mkIdx 1 x)(ofSliceObjW P p (↑(toSliceObj P p y Sum.inr a, g, w, h)) x d) = (w x d) X:TypeZ:(Idx X)ᵒᵖ TypeY:TypeF:PresheafPFunctor (Idx X) (Idx Y)P:SlicePFunctor X YE:Typep:E Xy:Ys:(prodPsh P).Aa:P.Ag:(x : X) (prodPsh P).Direction (Sum.inr a) (mkIdx 0 x) (ofSliceX p).obj (Opposite.op (mkIdx 0 x))w:(x : X) (d : (prodPsh P).Direction (Sum.inr a) (mkIdx 1 x)) fibre (ofSliceX p) x (g x (dirRestr (prodPsh P) (Sum.inr a) x d))h:pQ P Sum.inr a, g, w.fst = mkIdx 1 yx:Xd:(prodPsh P).B (Sum.inr (↑(toSliceObj P p y Sum.inr a, g, w, h)).fst)hd:(prodPsh P).DirectionOver (Sum.inr (↑(toSliceObj P p y Sum.inr a, g, w, h)).fst) (mkIdx 1 x) d(ofSliceObjW P p (↑(toSliceObj P p y Sum.inr a, g, w, h)) x d, hd) = (w x d, hd) match d with X:TypeZ:(Idx X)ᵒᵖ TypeY:TypeF:PresheafPFunctor (Idx X) (Idx Y)P:SlicePFunctor X YE:Typep:E Xy:Ys:(prodPsh P).Aa:P.Ag:(x : X) (prodPsh P).Direction (Sum.inr a) (mkIdx 0 x) (ofSliceX p).obj (Opposite.op (mkIdx 0 x))w:(x : X) (d : (prodPsh P).Direction (Sum.inr a) (mkIdx 1 x)) fibre (ofSliceX p) x (g x (dirRestr (prodPsh P) (Sum.inr a) x d))h:pQ P Sum.inr a, g, w.fst = mkIdx 1 yx:Xd:(prodPsh P).B (Sum.inr (↑(toSliceObj P p y Sum.inr a, g, w, h)).fst)val✝:P.B (↑(toSliceObj P p y Sum.inr a, g, w, h)).fsthd:(prodPsh P).DirectionOver (Sum.inr (↑(toSliceObj P p y Sum.inr a, g, w, h)).fst) (mkIdx 1 x) (Sum.inl val✝)(ofSliceObjW P p (↑(toSliceObj P p y Sum.inr a, g, w, h)) x Sum.inl val✝, hd) = (w x Sum.inl val✝, hd) All goals completed! 🐙 X:TypeZ:(Idx X)ᵒᵖ TypeY:TypeF:PresheafPFunctor (Idx X) (Idx Y)P:SlicePFunctor X YE:Typep:E Xy:Ys:(prodPsh P).Aa:P.Ag:(x : X) (prodPsh P).Direction (Sum.inr a) (mkIdx 0 x) (ofSliceX p).obj (Opposite.op (mkIdx 0 x))w:(x : X) (d : (prodPsh P).Direction (Sum.inr a) (mkIdx 1 x)) fibre (ofSliceX p) x (g x (dirRestr (prodPsh P) (Sum.inr a) x d))h:pQ P Sum.inr a, g, w.fst = mkIdx 1 yx:Xd:(prodPsh P).B (Sum.inr (↑(toSliceObj P p y Sum.inr a, g, w, h)).fst)b:P.B (↑(toSliceObj P p y Sum.inr a, g, w, h)).fsthd:(prodPsh P).DirectionOver (Sum.inr (↑(toSliceObj P p y Sum.inr a, g, w, h)).fst) (mkIdx 1 x) (Sum.inr b)(ofSliceObjW P p (↑(toSliceObj P p y Sum.inr a, g, w, h)) x Sum.inr b, hd) = (w x Sum.inr b, hd) X:TypeZ:(Idx X)ᵒᵖ TypeY:TypeF:PresheafPFunctor (Idx X) (Idx Y)P:SlicePFunctor X YE:Typep:E Xy:Ys:(prodPsh P).Aa:P.Ag:(x : X) (prodPsh P).Direction (Sum.inr a) (mkIdx 0 x) (ofSliceX p).obj (Opposite.op (mkIdx 0 x))w:(x : X) (d : (prodPsh P).Direction (Sum.inr a) (mkIdx 1 x)) fibre (ofSliceX p) x (g x (dirRestr (prodPsh P) (Sum.inr a) x d))h:pQ P Sum.inr a, g, w.fst = mkIdx 1 yx:Xd:(prodPsh P).B (Sum.inr (↑(toSliceObj P p y Sum.inr a, g, w, h)).fst)b:P.B (↑(toSliceObj P p y Sum.inr a, g, w, h)).fsthd:(prodPsh P).DirectionOver (Sum.inr (↑(toSliceObj P p y Sum.inr a, g, w, h)).fst) (mkIdx 1 x) (Sum.inr b)hx:P.r a, b = x(ofSliceObjW P p (↑(toSliceObj P p y Sum.inr a, g, w, h)) x Sum.inr b, hd) = (w x Sum.inr b, hd) X:TypeZ:(Idx X)ᵒᵖ TypeY:TypeF:PresheafPFunctor (Idx X) (Idx Y)P:SlicePFunctor X YE:Typep:E Xy:Ys:(prodPsh P).Aa:P.Ag:(x : X) (prodPsh P).Direction (Sum.inr a) (mkIdx 0 x) (ofSliceX p).obj (Opposite.op (mkIdx 0 x))w:(x : X) (d : (prodPsh P).Direction (Sum.inr a) (mkIdx 1 x)) fibre (ofSliceX p) x (g x (dirRestr (prodPsh P) (Sum.inr a) x d))h:pQ P Sum.inr a, g, w.fst = mkIdx 1 yd:(prodPsh P).B (Sum.inr (↑(toSliceObj P p y Sum.inr a, g, w, h)).fst)b:P.B (↑(toSliceObj P p y Sum.inr a, g, w, h)).fsthd:(prodPsh P).DirectionOver (Sum.inr (↑(toSliceObj P p y Sum.inr a, g, w, h)).fst) (mkIdx 1 (P.r a, b)) (Sum.inr b)(ofSliceObjW P p (↑(toSliceObj P p y Sum.inr a, g, w, h)) (P.r a, b) Sum.inr b, hd) = (w (P.r a, b) Sum.inr b, hd) All goals completed! 🐙 right_inv o := Subtype.ext (Subtype.ext rfl)

The elements of the transcription's value over (1, y) are the elements of Elem over it.

def objLevelOne {E : Type} (p : E X) (y : Y) : { t : (prodPsh P).obj (ofSliceX p) // (prodPsh P).q t.shape = mkIdx 1 y } ElemOver P p y where toFun t := toElem (ofSliceX p) (prodPsh P) t.1, t.2 invFun e := (elemEquiv (ofSliceX p) (prodPsh P)).symm e.1, e.2 left_inv t := Subtype.ext ((elemEquiv (ofSliceX p) (prodPsh P)).left_inv t.1) right_inv e := Subtype.ext ((elemEquiv (ofSliceX p) (prodPsh P)).right_inv e.1)

The level-1 value of the transcription at ofSliceX p over (1, y) is the slice functor's value at p over y.

def levelOneEquiv {E : Type} (p : E X) (y : Y) : { t : (prodPsh P).obj (ofSliceX p) // (prodPsh P).q t.shape = mkIdx 1 y } { o : P.toSliceDomPFunctor.Obj p // P.obj p o = y } := (objLevelOne P p y).trans (elemOverEquiv P p y)

An element of Elem over (0, y) is the level-0 shape at y with its empty assignments.

theorem elem_zero_ext {E : Type} (p : E X) (y : Y) (e : Elem (ofSliceX p) (prodPsh P)) (h : pQ P e.1 = mkIdx 0 y) : e = (Sum.inl y : Y P.A), fun x (d : (prodPsh P).Direction (Sum.inl y : Y P.A) (mkIdx 0 x)) PEmpty.elim d.1, fun x (d : (prodPsh P).Direction (Sum.inl y : Y P.A) (mkIdx 1 x)) PEmpty.elim d.1 := X:TypeY:TypeP:SlicePFunctor X YE:Typep:E Xy:Ye:Elem (ofSliceX p) (prodPsh P)h:pQ P e.fst = mkIdx 0 ye = Sum.inl y, fun x d PEmpty.elim d, fun x d PEmpty.elim d X:TypeY:TypeP:SlicePFunctor X YE:Typep:E Xy:Ys:(prodPsh P).Ag:(x : X) (prodPsh P).Direction s (mkIdx 0 x) (ofSliceX p).obj (Opposite.op (mkIdx 0 x))w:(x : X) (d : (prodPsh P).Direction s (mkIdx 1 x)) fibre (ofSliceX p) x (g x (dirRestr (prodPsh P) s x d))h:pQ P s, g, w.fst = mkIdx 0 ys, g, w = Sum.inl y, fun x d PEmpty.elim d, fun x d PEmpty.elim d cases s with X:TypeY:TypeP:SlicePFunctor X YE:Typep:E Xy:Yy':Yg:(x : X) (prodPsh P).Direction (Sum.inl y') (mkIdx 0 x) (ofSliceX p).obj (Opposite.op (mkIdx 0 x))w:(x : X) (d : (prodPsh P).Direction (Sum.inl y') (mkIdx 1 x)) fibre (ofSliceX p) x (g x (dirRestr (prodPsh P) (Sum.inl y') x d))h:pQ P Sum.inl y', g, w.fst = mkIdx 0 ySum.inl y', g, w = Sum.inl y, fun x d PEmpty.elim d, fun x d PEmpty.elim d X:TypeY:TypeP:SlicePFunctor X YE:Typep:E Xy:Yy':Yg:(x : X) (prodPsh P).Direction (Sum.inl y') (mkIdx 0 x) (ofSliceX p).obj (Opposite.op (mkIdx 0 x))w:(x : X) (d : (prodPsh P).Direction (Sum.inl y') (mkIdx 1 x)) fibre (ofSliceX p) x (g x (dirRestr (prodPsh P) (Sum.inl y') x d))h:pQ P Sum.inl y', g, w.fst = mkIdx 0 yhy:y' = ySum.inl y', g, w = Sum.inl y, fun x d PEmpty.elim d, fun x d PEmpty.elim d X:TypeY:TypeP:SlicePFunctor X YE:Typep:E Xy':Yg:(x : X) (prodPsh P).Direction (Sum.inl y') (mkIdx 0 x) (ofSliceX p).obj (Opposite.op (mkIdx 0 x))w:(x : X) (d : (prodPsh P).Direction (Sum.inl y') (mkIdx 1 x)) fibre (ofSliceX p) x (g x (dirRestr (prodPsh P) (Sum.inl y') x d))h:pQ P Sum.inl y', g, w.fst = mkIdx 0 y'Sum.inl y', g, w = Sum.inl y', fun x d PEmpty.elim d, fun x d PEmpty.elim d All goals completed! 🐙 X:TypeY:TypeP:SlicePFunctor X YE:Typep:E Xy:Yval✝:P.Ag:(x : X) (prodPsh P).Direction (Sum.inr val✝) (mkIdx 0 x) (ofSliceX p).obj (Opposite.op (mkIdx 0 x))w:(x : X) (d : (prodPsh P).Direction (Sum.inr val✝) (mkIdx 1 x)) fibre (ofSliceX p) x (g x (dirRestr (prodPsh P) (Sum.inr val✝) x d))h:pQ P Sum.inr val✝, g, w.fst = mkIdx 0 ySum.inr val✝, g, w = Sum.inl y, fun x d PEmpty.elim d, fun x d PEmpty.elim d All goals completed! 🐙

The transcription's base at ofSliceX p is a point at every index: the level-0 shape at the index with its empty assignments.

def levelZeroEquiv {E : Type} (p : E X) (y : Y) : { t : (prodPsh P).obj (ofSliceX p) // (prodPsh P).q t.shape = mkIdx 0 y } Unit where toFun _ := () invFun _ := (elemEquiv (ofSliceX p) (prodPsh P)).symm (Sum.inl y : Y P.A), fun x (d : (prodPsh P).Direction (Sum.inl y : Y P.A) (mkIdx 0 x)) PEmpty.elim d.1, fun x (d : (prodPsh P).Direction (Sum.inl y : Y P.A) (mkIdx 1 x)) PEmpty.elim d.1, rfl left_inv t := Subtype.ext ((elemEquiv (ofSliceX p) (prodPsh P)).injective ((elem_zero_ext P p y (toElem (ofSliceX p) (prodPsh P) t.1) t.2).trans ((elemEquiv (ofSliceX p) (prodPsh P)).apply_symm_apply _).symm).symm) right_inv _ := rfl

The comparison map from the slice functor's value to the transcription's value: the level-1 element with the given assignments.

def cmp {E : Type} (p : E X) (o : P.toSliceDomPFunctor.Obj p) : (prodPsh P).obj (ofSliceX p) := ((levelOneEquiv P p (P.obj p o)).symm o, rfl).1

The comparison map is natural in the object of Type/X.

theorem map_cmp {E E' : Type} {p : E X} {p' : E' X} (h : E E') (hh : p' h = p) (o : P.toSliceDomPFunctor.Obj p) : (prodPsh P).map (ofSliceXHom h hh) (cmp P p o) = cmp P p' (P.map h hh o) := X:TypeY:TypeP:SlicePFunctor X YE:TypeE':Typep:E Xp':E' Xh:E E'hh:p' h = po:P.Obj p(prodPsh P).map (ofSliceXHom h hh) (cmp P p o) = cmp P p' (P.map h hh o) X:TypeY:TypeP:SlicePFunctor X YE:TypeE':Typep:E Xp':E' Xh:E E'hh:p' h = pa:P.Av:P.B a Ehv:P.Compatible p a, v.fst a, v.snd(prodPsh P).map (ofSliceXHom h hh) (cmp P p a, v, hv) = cmp P p' (P.map h hh a, v, hv) X:TypeY:TypeP:SlicePFunctor X YE:TypeE':Typep:E Xp':E' Xh:E E'hh:p' h = pa:P.Av:P.B a Ehv:P.Compatible p a, v.fst a, v.sndd:(prodPsh P).B (↑((prodPsh P).map (ofSliceXHom h hh) (cmp P p a, v, hv))).fst(↑((prodPsh P).map (ofSliceXHom h hh) (cmp P p a, v, hv))).snd d = (↑(cmp P p' (P.map h hh a, v, hv))).snd d match d with X:TypeY:TypeP:SlicePFunctor X YE:TypeE':Typep:E Xp':E' Xh:E E'hh:p' h = pa:P.Av:P.B a Ehv:P.Compatible p a, v.fst a, v.sndd:(prodPsh P).B (↑((prodPsh P).map (ofSliceXHom h hh) (cmp P p a, v, hv))).fstval✝:P.B (↑a, v, hv, ).fst(↑((prodPsh P).map (ofSliceXHom h hh) (cmp P p a, v, hv))).snd (Sum.inl val✝) = (↑(cmp P p' (P.map h hh a, v, hv))).snd (Sum.inl val✝) All goals completed! 🐙 X:TypeY:TypeP:SlicePFunctor X YE:TypeE':Typep:E Xp':E' Xh:E E'hh:p' h = pa:P.Av:P.B a Ehv:P.Compatible p a, v.fst a, v.sndd:(prodPsh P).B (↑((prodPsh P).map (ofSliceXHom h hh) (cmp P p a, v, hv))).fstval✝:P.B (↑a, v, hv, ).fst(↑((prodPsh P).map (ofSliceXHom h hh) (cmp P p a, v, hv))).snd (Sum.inr val✝) = (↑(cmp P p' (P.map h hh a, v, hv))).snd (Sum.inr val✝) All goals completed! 🐙

The slice W-type is a fixed point

variable (Q : SlicePFunctor.{0, 0, 0, 0} X X)

The slice W-type as a presheaf on Idx X.

abbrev wPsh : (Idx X)ᵒᵖ Type := ofSliceX Q.wIndex

The slice functor's value at its W-type over x is the W-type's fibre over x: the constructor and destructor of SlicePFunctor.­W.

def wObjEquiv (x : X) : { o : Q.toSliceDomPFunctor.Obj Q.wIndex // Q.obj Q.wIndex o = x } { z : Q.W // Q.wIndex z = x } where toFun o := SlicePFunctor.W.mk o.1, (SlicePFunctor.W.wIndex_mk o.1).trans o.2 invFun z := SlicePFunctor.W.dest z.1, ((SlicePFunctor.W.wIndex_mk _).symm.trans (congrArg Q.wIndex (SlicePFunctor.W.mk_dest z.1))).trans z.2 left_inv o := Subtype.ext (SlicePFunctor.W.dest_mk o.1) right_inv z := Subtype.ext (SlicePFunctor.W.mk_dest z.1)

The slice W-type is a fixed point of the transcription: the transcription's level-1 value at the W-type's presheaf over (1, x) is the W-type's fibre over x, which is that presheaf's own value at (1, x), and its level 0 is a point, as is the presheaf's.

def wFixed (x : X) : { t : (prodPsh Q).obj (wPsh Q) // (prodPsh Q).q t.shape = mkIdx 1 x } (wPsh Q).obj mkIdx 1 x := (levelOneEquiv Q Q.wIndex x).trans (wObjEquiv Q x)
end GebProto.LargeIR.Product