| 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 |
|
|
