File size: 4,681 Bytes
3277efa | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 | import OAI.SetTheory.PartitionPrinciple.Geometry.TileTreeGluing
namespace OAI
section
namespace PartitionPilot.Compression.RecursiveMaps.RootedGluing.Scheme
universe u
variable {V : Type u} (d : Scheme V)
def Label := (v : V) × d.Space v
inductive Related : d.Label → d.Label → Prop
| parent (v : V) (h : d.depth v ≠ 0)
(x : {x : d.Space v // (d.order v).le x (d.childAnchor v h)}) :
Related ⟨v, x.val⟩ ⟨d.parent v, ((d.link v h).toFun x).val⟩
| refl (x) : Related x x
| symm {x y} : Related x y → Related y x
| trans {x y z} : Related x y → Related y z → Related x z
def labelSetoid : Setoid d.Label := ⟨d.Related, Related.refl, Related.symm, Related.trans⟩
def Generated := Quotient d.labelSetoid
def labelClass (v : V) (x : d.Space v) : d.Generated := Quotient.mk d.labelSetoid ⟨v, x⟩
theorem label_parent (v : V) (h : d.depth v ≠ 0)
(x : {x : d.Space v // (d.order v).le x (d.childAnchor v h)}) :
d.labelClass v x.val = d.labelClass (d.parent v) ((d.link v h).toFun x).val :=
Quotient.sound (Related.parent v h x)
noncomputable def stageClass : (n : Nat) → (d.stages n).Point → d.Generated
| 0, x => d.labelClass d.root x
| n + 1, .inl x => stageClass n x
| _ + 1, .inr x => d.labelClass x.1.val x.2.val
theorem stageClass_old (n : Nat) (x : (d.stages n).Point) :
d.stageClass (n + 1) ((d.stages n).batch.old.toFun x) = d.stageClass n x := rfl
theorem stageClass_vertex (n : Nat) (v : V) (hv : d.depth v ≤ n) (x : d.Space v) :
d.stageClass n (((d.stages n).vertex v hv).toFun x) = d.labelClass v x := by
classical
induction n generalizing v with
| zero =>
have eq := d.zero_eq_root v (Nat.eq_zero_of_le_zero hv)
subst v
rfl
| succ n ih =>
change d.stageClass (n + 1) (((d.stages n).successor.vertex v hv).toFun x) = _
by_cases older : d.depth v ≤ n
· rw [(d.stages n).successor_old v older x, d.stageClass_old]
exact ih v older x
· let s := d.stages n
let i : s.Layer := ⟨v, by omega⟩
rw [s.successor_new i x]
by_cases base : (d.order v).le x (d.childAnchor v (s.layer_nonzero i))
· have eq : (s.batch.tile i).toFun x =
s.batch.old.toFun ((s.vertex (d.parent v) (s.parent_present i)).toFun
((d.link v (s.layer_nonzero i)).toFun ⟨x, base⟩).val) :=
(s.batch.tile_old_overlap i x _).mpr ⟨base, rfl⟩
rw [eq, d.stageClass_old]
exact (ih (d.parent v) (s.parent_present i) _).trans
(d.label_parent v (s.layer_nonzero i) ⟨x, base⟩).symm
· have represented := (s.batch.glue i).represent_new x base
change d.stageClass (n + 1) (s.batch.componentMap i ((s.batch.glue i).represent x)) = _
rw [represented]
rfl
theorem stageClass_up {n m : Nat} (h : n ≤ m) (x : (d.stages n).Point) :
d.stageClass m (d.chain.up h x) = d.stageClass n x := by
induction h with
| refl => erw [d.chain.up_self]
| @step m h ih =>
erw [d.chain.up_succ h]
exact (d.stageClass_old m _).trans ih
noncomputable def toGenerated : d.Node → d.Generated :=
Quotient.lift (fun x => d.stageClass x.1 x.2) (by
rintro x y ⟨k, hx, hy, eq⟩
exact (d.stageClass_up hx x.2).symm.trans
((congrArg (d.stageClass k) eq).trans (d.stageClass_up hy y.2)))
theorem toGenerated_vertex (v : V) (x : d.Space v) :
d.toGenerated ((d.vertex v).toFun x) = d.labelClass v x :=
d.stageClass_vertex (d.depth v) v (le_refl _) x
theorem related_sound {x y : d.Label} (h : d.Related x y) :
(d.vertex x.1).toFun x.2 = (d.vertex y.1).toFun y.2 := by
induction h with
| parent v hv x => exact d.parent_identification v hv x
| refl => rfl
| symm h ih => exact ih.symm
| trans h1 h2 ih1 ih2 => exact ih1.trans ih2
theorem exact_identifications (v w : V) (x : d.Space v) (y : d.Space w) :
(d.vertex v).toFun x = (d.vertex w).toFun y ↔ d.Related ⟨v, x⟩ ⟨w, y⟩ := by
constructor
· intro eq
have classes := congrArg d.toGenerated eq
rw [d.toGenerated_vertex, d.toGenerated_vertex] at classes
exact Quotient.exact classes
· exact d.related_sound
noncomputable def fromGenerated : d.Generated → d.Node :=
Quotient.lift (fun x => (d.vertex x.1).toFun x.2) (fun _ _ h => d.related_sound h)
theorem from_to (x : d.Node) : d.fromGenerated (d.toGenerated x) = x := by
rcases d.cover x with ⟨v, a, rfl⟩
rw [d.toGenerated_vertex]
rfl
theorem to_from (x : d.Generated) : d.toGenerated (d.fromGenerated x) = x := by
induction x using Quotient.ind with
| _ x => exact d.toGenerated_vertex x.1 x.2
end PartitionPilot.Compression.RecursiveMaps.RootedGluing.Scheme
end
end OAI
|