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 roleset_option doc.verso truePrototype: 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 onIdx Xin dependent-type terms. -
prodPsh— the transcription of a slice polynomial functor. -
ofSliceX,ofSliceXHom—Type/Xas presheaves onIdx X. -
levelOneEquiv,cmp— the level-1value at an object ofType/Xis 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 overIdx Xis 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 ofType/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.ProductThe 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.
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' ≤ o⊢ o' = 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 o⊢ ⟨o, 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 o⊢ ⟨o, 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 b⊢ ⟨o, 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 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 (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) inl 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)
rfl All goals completed! 🐙
· inr 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) rw [hom_ext f (waHomAt x') inr 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)] inr 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)
exact h 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, _), _ => rflThe 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 := by 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⟩ = o⊢ assignAux Z F g w b (F.r ⟨a, b⟩) ⋯ = assignAux Z F g w b o h
subst 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 a⊢ assignAux Z F g w b (F.r ⟨a, b⟩) ⋯ = assignAux Z F g w b (F.r ⟨a, b⟩) ⋯
rfl 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⟩ := by 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⟩
subst hg 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⟩
exact Sigma.ext rfl (heq_of_eq (funext fun x ↦ funext fun d ↦ Subtype.ext (hw x d))) 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.
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 bThe 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) := by 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 ≤ i⊢ pR P ⟨s, restrDir P s t d⟩ = (t, x)
match s, d, t with
| .inl _, e, _ => 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✝ ≤ i⊢ pR P ⟨Sum.inl val✝, restrDir P (Sum.inl val✝) x✝ e⟩ = (x✝, x) exact PEmpty.elim e All goals completed! 🐙
| .inr a, .inl b, 0 => 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 ≤ i⊢ pR P ⟨Sum.inr a, restrDir P (Sum.inr a) 0 (Sum.inl b)⟩ = (0, x) exact Prod.ext rfl (congrArg Prod.snd hd : P.r ⟨a, b⟩ = x) All goals completed! 🐙
| .inr _, .inl _, 1 => 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 ≤ i⊢ pR P ⟨Sum.inr val✝¹, restrDir P (Sum.inr val✝¹) 1 (Sum.inl val✝)⟩ = (1, x)
have h0 : (0 : Fin 2) = i := congrArg Prod.fst hd 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 = i⊢ pR P ⟨Sum.inr val✝¹, restrDir P (Sum.inr val✝¹) 1 (Sum.inl val✝)⟩ = (1, x)
subst h0 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⊢ pR P ⟨Sum.inr val✝¹, restrDir P (Sum.inr val✝¹) 1 (Sum.inl val✝)⟩ = (1, x)
exact absurd ht (by 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 decide All goals completed! 🐙)
| .inr a, .inr b, 0 => 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 ≤ i⊢ pR P ⟨Sum.inr a, restrDir P (Sum.inr a) 0 (Sum.inr b)⟩ = (0, x) exact Prod.ext rfl (congrArg Prod.snd hd : P.r ⟨a, b⟩ = x) All goals completed! 🐙
| .inr a, .inr b, 1 => 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 ≤ i⊢ pR P ⟨Sum.inr a, restrDir P (Sum.inr a) 1 (Sum.inr b)⟩ = (1, x) exact Prod.ext rfl (congrArg Prod.snd hd : P.r ⟨a, b⟩ = 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 aThe 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) := by X:TypeY:TypeP:SlicePFunctor X Yt:Fin 2s:Y ⊕ P.Ai:Fin 2y:Yhs:pQ P s = (i, y)ht:t ≤ i⊢ pQ P (restrShape P t s) = (t, y)
match s, t with
| .inl y', 0 => X:TypeY:TypeP:SlicePFunctor X Yt:Fin 2s:Y ⊕ P.Ai:Fin 2y:Yy':Yhs:pQ P (Sum.inl y') = (i, y)ht:0 ≤ i⊢ pQ P (restrShape P 0 (Sum.inl y')) = (0, y) exact Prod.ext rfl (congrArg Prod.snd hs : y' = y) All goals completed! 🐙
| .inl _, 1 => X:TypeY:TypeP:SlicePFunctor X Yt:Fin 2s:Y ⊕ P.Ai:Fin 2y:Yval✝:Yhs:pQ P (Sum.inl val✝) = (i, y)ht:1 ≤ i⊢ pQ P (restrShape P 1 (Sum.inl val✝)) = (1, y)
have h0 : (0 : Fin 2) = i := congrArg Prod.fst hs 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 = i⊢ pQ P (restrShape P 1 (Sum.inl val✝)) = (1, y)
subst h0 X:TypeY:TypeP:SlicePFunctor X Yt:Fin 2s:Y ⊕ P.Ay:Yval✝:Yhs:pQ P (Sum.inl val✝) = (0, y)ht:1 ≤ 0⊢ pQ P (restrShape P 1 (Sum.inl val✝)) = (1, y)
exact absurd ht (by 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 decide All goals completed! 🐙)
| .inr a, 0 => 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 ≤ i⊢ pQ P (restrShape P 0 (Sum.inr a)) = (0, y) exact Prod.ext rfl (congrArg Prod.snd hs : P.q a = y) All goals completed! 🐙
| .inr a, 1 => 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 ≤ i⊢ pQ P (restrShape P 1 (Sum.inr a)) = (1, y) exact Prod.ext rfl (congrArg Prod.snd hs : P.q a = 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 ↦ dReindexing 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⟩ := by 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
| .inl _, _, e => 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⟩ exact PEmpty.elim e All goals completed! 🐙
| .inr _, 0, e => 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⟩ exact PEmpty.elim e All goals completed! 🐙
| .inr _, 1, _ => 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✝⟩ rfl 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, by 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)
obtain ⟨i, x⟩ := o 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)
obtain ⟨i', x'⟩ := o' 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)
obtain rfl : x' = x := (leOfHom f).2 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)
exact restrDir_over P s i' d.1 d.2 (leOfHom f).1 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, by 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)
obtain ⟨i, y⟩ := o 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)
obtain ⟨i', y'⟩ := o' 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)
obtain rfl : y' = y := (leOfHom g).2 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)
exact restrShape_over P i' s.1 s.2 (leOfHom g).1 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 := by X:TypeY:TypeP:SlicePFunctor X Y⊢ (prodData P).DirectionRestrId
intro s o X:TypeY:TypeP:SlicePFunctor X Ys:(prodData P).Ao:Idx X⊢ (prodData P).directionRestr s (𝟙 o) = id
funext d X:TypeY:TypeP:SlicePFunctor X Ys:(prodData P).Ao:Idx Xd:(prodData P).Direction s o⊢ (prodData P).directionRestr s (𝟙 o) d = id d
obtain ⟨d, hd⟩ := 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⟩
refine Subtype.ext ?_ 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
| .inl _, e => 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⟩) exact PEmpty.elim e All goals completed! 🐙
| .inr _, .inl _ => 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⟩) rfl All goals completed! 🐙
| .inr _, .inr _ => 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⟩)
have h1 : ((1 : Fin 2), _) = o := 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⟩)
subst h1 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⟩)
rfl All goals completed! 🐙Direction restriction reverses composition.
theorem directionRestr_comp : (prodData P).DirectionRestrComp := by X:TypeY:TypeP:SlicePFunctor X Y⊢ (prodData P).DirectionRestrComp
intro s o o' o'' f g 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
funext d 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
obtain ⟨d, hd⟩ := 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⟩
refine Subtype.ext ?_ 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
| .inl _, e => 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⟩) exact PEmpty.elim e All goals completed! 🐙
| .inr _, .inl _ => 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⟩) rfl All goals completed! 🐙
| .inr _, .inr _ => 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⟩)
have h1 : ((1 : Fin 2), _) = o := 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⟩)
subst h1 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⟩)
obtain ⟨i', _⟩ := o' 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⟩)
obtain ⟨i'', _⟩ := o'' 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
| 0, 0 => 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⟩) rfl All goals completed! 🐙
| 1, 0 => 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⟩) rfl All goals completed! 🐙
| 1, 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:(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⟩) rfl All goals completed! 🐙
| 0, 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✝¹)⊢ ↑((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 (by 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 change ¬ ((1 : Fin 2) ≤ 0) 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; decide All goals completed! 🐙)Shape restriction along an identity is the identity.
theorem shapeRestr_id : (prodData P).ShapeRestrId := by X:TypeY:TypeP:SlicePFunctor X Y⊢ (prodData P).ShapeRestrId
intro o X:TypeY:TypeP:SlicePFunctor X Yo:Idx Y⊢ (prodData P).shapeRestr (𝟙 o) = id
funext s 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
obtain ⟨s, hs⟩ := 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⟩
refine Subtype.ext ?_ 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
| .inl _ => 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⟩) rfl All goals completed! 🐙
| .inr _ => 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⟩)
have h1 : ((1 : Fin 2), _) = o := 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⟩)
subst h1 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⟩)
rfl All goals completed! 🐙Shape restriction reverses composition.
theorem shapeRestr_comp : (prodData P).ShapeRestrComp := by X:TypeY:TypeP:SlicePFunctor X Y⊢ (prodData P).ShapeRestrComp
intro o o' o'' g h 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
funext 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 }.Shape o⊢ (prodData P).shapeRestr (h ≫ g) s = ((prodData P).shapeRestr h ∘ (prodData P).shapeRestr g) s
obtain ⟨s, hs⟩ := 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⟩
refine Subtype.ext ?_ 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
| .inl _ => 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⟩) rfl All goals completed! 🐙
| .inr _ => 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⟩)
have h1 : ((1 : Fin 2), _) = o := 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⟩)
subst h1 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⟩)
obtain ⟨i', _⟩ := o' 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⟩)
obtain ⟨i'', _⟩ := o'' 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
| 0, 0 => 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⟩) rfl All goals completed! 🐙
| 1, 0 => 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⟩) rfl All goals completed! 🐙
| 1, 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:(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⟩) rfl All goals completed! 🐙
| 0, 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✝¹)⊢ ↑((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 (by 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 change ¬ ((1 : Fin 2) ≤ 0) 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; decide All goals completed! 🐙)Reindexing commutes with direction restriction.
theorem reindex_naturality : (prodData P).ReindexNaturality := by X:TypeY:TypeP:SlicePFunctor X Y⊢ (prodData P).ReindexNaturality
intro o o' g s p p' f 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
funext 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).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
obtain ⟨d, hd⟩ := 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⟩
refine Subtype.ext ?_ 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⟩)
obtain ⟨s, hs⟩ := s 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
| inl _ => inl 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⟩) exact PEmpty.elim d All goals completed! 🐙
| inr _ => inr 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⟩)
have h1 : ((1 : Fin 2), _) = o := hs inr 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⟩)
subst h1 inr 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⟩)
obtain ⟨i', _⟩ := o' inr 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
| 1 => 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⟩) rfl All goals completed! 🐙
| 0 => 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⟩) exact PEmpty.elim d All goals completed! 🐙Reindexing along an identity is the identity.
theorem reindex_id : (prodData P).ReindexId (shapeRestr_id P) := by X:TypeY:TypeP:SlicePFunctor X Y⊢ (prodData P).ReindexId ⋯
intro o s p d 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
obtain ⟨s, hs⟩ := s 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
obtain ⟨d, hd⟩ := 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
| .inl _ => 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⟩
refine Subtype.ext ?_ 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⟩)
exact PEmpty.elim d All goals completed! 🐙
| .inr _ => 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⟩
have h1 : ((1 : Fin 2), _) = o := hs 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⟩
subst h1 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⟩
refine Subtype.ext ?_ 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⟩)
rfl All goals completed! 🐙Reindexing along a composite is the composite of the reindexings.
theorem reindex_comp : (prodData P).ReindexComp (shapeRestr_comp P) := by X:TypeY:TypeP:SlicePFunctor X Y⊢ (prodData P).ReindexComp ⋯
intro o o' o'' g h s p d 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))
obtain ⟨s, hs⟩ := s 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))
obtain ⟨d, hd⟩ := 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
| .inl _ => 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⟩))
refine Subtype.ext ?_ 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⟩)))
exact PEmpty.elim d All goals completed! 🐙
| .inr _ => 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⟩))
have h1 : ((1 : Fin 2), _) = o := hs 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⟩))
subst h1 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⟩))
refine Subtype.ext ?_ 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⟩)))
obtain ⟨i', _⟩ := o' 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⟩)))
obtain ⟨i'', _⟩ := o'' 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
| 0, 0 => 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⟩))) exact PEmpty.elim d All goals completed! 🐙
| 1, 0 => 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⟩))) exact PEmpty.elim d All goals completed! 🐙
| 1, 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:(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⟩))) rfl All goals completed! 🐙
| 0, 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⊢ ↑((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 (by 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 change ¬ ((1 : Fin 2) ≤ 0) 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; decide All goals completed! 🐙)The transcription's operations satisfy the functor laws.
theorem prodData_isFunctorial : (prodData P).IsFunctorial where
directionRestr_id := directionRestr_id P
directionRestr_comp := directionRestr_comp P
shapeRestr_id := shapeRestr_id P
shapeRestr_comp := shapeRestr_comp P
reindex_naturality := reindex_naturality P
reindex_id := reindex_id P
reindex_comp := reindex_comp P
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 (by 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 change ¬ ((1 : Fin 2) ≤ 0) 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; decide 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 (by 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 change ¬ ((1 : Fin 2) ≤ 0) 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; decide All goals completed! 🐙)
| ⟨(0, _)⟩, ⟨(1, _)⟩, _, f, _ =>
absurd (leOfHom f.unop).1 (by 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 change ¬ ((1 : Fin 2) ≤ 0) 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; decide All goals completed! 🐙)
| ⟨(0, _)⟩, ⟨(0, _)⟩, ⟨(1, _)⟩, _, g =>
absurd (leOfHom g.unop).1 (by 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 change ¬ ((1 : Fin 2) ≤ 0) 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; decide 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 (by 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 change ¬ ((1 : Fin 2) ≤ 0) 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; decide 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 := by X:TypeZ:(Idx X)ᵒᵖ ⥤ TypeY:TypeF:PresheafPFunctor (Idx X) (Idx Y)P:SlicePFunctor X YE:Typep:E → Xy:Ye:ElemOver P p y⊢ ofSliceObj P p y (toSliceObj P p y e) = e
obtain ⟨⟨s, g, w⟩, h⟩ := 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 y⊢ ofSliceObj P p y (toSliceObj P p y ⟨⟨s, ⟨g, w⟩⟩, h⟩) = ⟨⟨s, ⟨g, w⟩⟩, h⟩
match s with
| .inl _ => 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 y⊢ ofSliceObj P p y (toSliceObj P p y ⟨⟨Sum.inl val✝, ⟨g, w⟩⟩, h⟩) = ⟨⟨Sum.inl val✝, ⟨g, w⟩⟩, h⟩ exact absurd (congrArg Prod.fst h) Fin.zero_ne_one All goals completed! 🐙
| .inr a => 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 y⊢ ofSliceObj P p y (toSliceObj P p y ⟨⟨Sum.inr a, ⟨g, w⟩⟩, h⟩) = ⟨⟨Sum.inr a, ⟨g, w⟩⟩, h⟩
refine Subtype.ext (Sigma.ext rfl (heq_of_eq (gw_ext (ofSliceX p) (prodPsh P)
(funext fun _ ↦ funext fun _ ↦ rfl) fun 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).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)
obtain ⟨d, hd⟩ := 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
| .inl _ => 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⟩) exact absurd (congrArg Prod.fst hd) Fin.zero_ne_one All goals completed! 🐙
| .inr b => 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⟩)
have hx : P.r ⟨a, b⟩ = x := congrArg Prod.snd 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⟩)
subst hx 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⟩)
rfl 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⟩ := by X:TypeY:TypeP:SlicePFunctor X YE:Typep:E → Xy:Ye:Elem (ofSliceX p) (prodPsh P)h:pQ P e.fst = mkIdx 0 y⊢ e = ⟨Sum.inl y, ⟨fun x d ↦ PEmpty.elim ↑d, fun x d ↦ PEmpty.elim ↑d⟩⟩
obtain ⟨s, g, w⟩ := e 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 y⊢ ⟨s, ⟨g, w⟩⟩ = ⟨Sum.inl y, ⟨fun x d ↦ PEmpty.elim ↑d, fun x d ↦ PEmpty.elim ↑d⟩⟩
cases s with
| inl y' => inl 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 y⊢ ⟨Sum.inl y', ⟨g, w⟩⟩ = ⟨Sum.inl y, ⟨fun x d ↦ PEmpty.elim ↑d, fun x d ↦ PEmpty.elim ↑d⟩⟩
have hy : y' = y := congrArg Prod.snd h inl 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' = y⊢ ⟨Sum.inl y', ⟨g, w⟩⟩ = ⟨Sum.inl y, ⟨fun x d ↦ PEmpty.elim ↑d, fun x d ↦ PEmpty.elim ↑d⟩⟩
subst hy inl 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⟩⟩
exact Sigma.ext rfl (heq_of_eq (gw_ext (ofSliceX p) (prodPsh P)
(funext fun x ↦ funext
fun (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)) All goals completed! 🐙
| inr _ => inr 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 y⊢ ⟨Sum.inr val✝, ⟨g, w⟩⟩ = ⟨Sum.inl y, ⟨fun x d ↦ PEmpty.elim ↑d, fun x d ↦ PEmpty.elim ↑d⟩⟩ exact absurd (congrArg Prod.fst h).symm Fin.zero_ne_one 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) := by 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)
obtain ⟨⟨a, v⟩, hv⟩ := 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⟩)
refine Subtype.ext (Subtype.ext (Sigma.ext rfl (heq_of_eq (funext fun d ↦ ?_)))) 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
| .inl _ => 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✝) rfl All goals completed! 🐙
| .inr _ => 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✝) rfl 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.
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