| import OAI.Combinatorics.Automata.Corners |
|
|
| namespace OAI |
|
|
| namespace OneWayLiveness |
|
|
| namespace BRel |
| variable {H : Type*} |
|
|
| @[simp] lemma restrictedId_holds (F : Set H) (x y : H) : |
| (restrictedId F).holds x y ↔ x = y ∧ x ∈ F := Iff.rfl |
| lemma restrictedId_idem (F : Set H) : restrictedId F * restrictedId F = restrictedId F := by |
| ext x z; simp |
| |
| lemma restrictedId_mul (F : Set H) (a : BRel H) (x y : H) : |
| (restrictedId F * a).holds x y ↔ x ∈ F ∧ a.holds x y := by simp |
| lemma mul_restrictedId (F : Set H) (a : BRel H) (x y : H) : |
| (a * restrictedId F).holds x y ↔ a.holds x y ∧ y ∈ F := by simp |
|
|
| lemma corner_supported {F : Set H} (z : Corner (restrictedId F) (restrictedId_idem F)) |
| {x y : H} (h : z.val.holds x y) : x ∈ F ∧ y ∈ F := by |
| constructor |
| · have h' : (restrictedId F * z.val).holds x y := by rw [z.left]; exact h |
| exact ((restrictedId_mul F _ x y).mp h').1 |
| · have h' : (z.val * restrictedId F).holds x y := by rw [z.right]; exact h |
| exact ((mul_restrictedId F _ x y).mp h').2 |
| |
| def restriction (F : Set H) : Corner (restrictedId F) (restrictedId_idem F) →* BRel F where |
| toFun z := ⟨fun x y => z.val.holds x.val y.val⟩ |
| map_one' := by ext x y; change (x.val = y.val ∧ x.val ∈ F) ↔ x = y; simp [Subtype.ext_iff] |
| map_mul' z w := by |
| ext x y |
| change (∃ k : H, z.val.holds x.val k ∧ w.val.holds k y.val) ↔ |
| ∃ k : F, z.val.holds x.val k.val ∧ w.val.holds k.val y.val |
| constructor |
| · rintro ⟨k, hz, hw⟩ |
| exact ⟨⟨k, (corner_supported z hz).2⟩, hz, hw⟩ |
| · rintro ⟨k, hz, hw⟩ |
| exact ⟨k.val, hz, hw⟩ |
|
|
| def extend (F : Set H) (a : BRel F) : BRel H := |
| ⟨fun x y => ∃ hx : x ∈ F, ∃ hy : y ∈ F, a.holds ⟨x, hx⟩ ⟨y, hy⟩⟩ |
|
|
| def extension (F : Set H) (a : BRel F) : Corner (restrictedId F) (restrictedId_idem F) := |
| ⟨extend F a, by ext x y; simp only [restrictedId_mul]; exact ⟨And.right, fun h => ⟨h.choose, h⟩⟩, |
| by ext x y; simp only [mul_restrictedId]; exact ⟨And.left, fun h => ⟨h, h.choose_spec.choose⟩⟩⟩ |
| |
| def restrictionEquiv (F : Set H) : Corner (restrictedId F) (restrictedId_idem F) ≃* BRel F := |
| { restriction F with |
| invFun := extension F |
| left_inv := by |
| intro z |
| apply Corner.ext |
| ext x y |
| change (∃ hx : x ∈ F, ∃ hy : y ∈ F, z.val.holds x y) ↔ z.val.holds x y |
| exact ⟨fun ⟨_, _, h⟩ => h, fun h => ⟨(corner_supported z h).1, (corner_supported z h).2, h⟩⟩ |
| right_inv := by |
| intro a |
| ext x y |
| change (∃ hx : x.val ∈ F, ∃ hy : y.val ∈ F, a.holds ⟨x.val, hx⟩ ⟨y.val, hy⟩) ↔ a.holds x y |
| simp } |
|
|
| /-- Restrict a relation corner with a split subidentity. -/ |
| lemma relation_corner {P : BRel H} (hP : P * P = P) (F : Set H) |
| (hF : restrictedId F * P * restrictedId F = restrictedId F) : |
| let Q := P * restrictedId F * P |
| ∃ hQ : Q * Q = Q, ∃ θ : Corner Q hQ ≃* BRel F, |
| (∀ z x y, (θ z).holds x y ↔ z.val.holds x.val y.val) ∧ P * Q = Q ∧ Q * P = Q := by |
| let E := restrictedId F |
| have hE : E * E = E := restrictedId_idem F |
| let u := P * E |
| let v := E * P |
| let Q := P * E * P |
| have huv : u * v = Q := by dsimp [u, v, Q]; rw [← mul_assoc, mul_assoc P E E, hE] |
| have hvu : v * u = E := by dsimp [u, v]; rw [mul_assoc E P, ← mul_assoc P P E, hP]; simpa only [E, mul_assoc] using hF |
| have hu : u * E = u := by dsimp [u]; rw [mul_assoc, hE] |
| have hv : E * v = v := by dsimp [v]; rw [← mul_assoc, hE] |
| have hQ : Q * Q = Q := by |
| rw [← huv, mul_assoc, ← mul_assoc v u, hvu, ← mul_assoc, hu] |
| have hpq : P * Q = Q := by dsimp [Q]; rw [← mul_assoc, ← mul_assoc, hP] |
| have hqp : Q * P = Q := by dsimp [Q]; rw [mul_assoc, hP] |
| let θ := (Corner.equivOfSplit (he := hQ) (hf := hE) u v huv hvu hu hv).trans (restrictionEquiv F) |
| refine ⟨hQ, θ, ?_, hpq, hqp⟩ |
| intro z x y |
| change (v * z.val * u).holds x.val y.val ↔ z.val.holds x.val y.val |
| have hpz : P * z.val = z.val := by |
| calc |
| _ = P * (Q * z.val) := by rw [z.left] |
| _ = z.val := by rw [← mul_assoc, hpq, z.left] |
| have hzp : z.val * P = z.val := by |
| calc |
| _ = (z.val * Q) * P := by rw [z.right] |
| _ = z.val := by rw [mul_assoc, hqp, z.right] |
| have heq : v * z.val * u = E * z.val * E := by |
| dsimp [u, v] |
| rw [mul_assoc E P, hpz, ← mul_assoc, mul_assoc E z.val P, hzp] |
| rw [heq, mul_restrictedId, restrictedId_mul] |
| simp |
| end BRel |
|
|
| namespace BRel |
| variable {H : Type*} |
| def permGraph (σ : Equiv.Perm H) : BRel H := ⟨fun x y => σ x = y⟩ |
| @[simp] lemma permGraph_holds (σ : Equiv.Perm H) (x y : H) : |
| (permGraph σ).holds x y ↔ σ x = y := Iff.rfl |
|
|
| def permUnit (σ : Equiv.Perm H) : (BRel H)ˣ where |
| val := permGraph σ |
| inv := permGraph σ.symm |
| val_inv := by ext x y; simp |
| inv_val := by ext x y; simp |
| |
| /-- The identity with one extra pair. -/ |
| def addEdge (x y : H) : BRel H := ⟨fun u v => u = v ∨ u = x ∧ v = y⟩ |
| @[simp] lemma addEdge_holds (x y u v : H) : |
| (addEdge x y).holds u v ↔ u = v ∨ u = x ∧ v = y := Iff.rfl |
| lemma addEdge_idem (x y : H) : addEdge x y * addEdge x y = addEdge x y := by |
| ext u v |
| simp only [mul_holds, addEdge_holds] |
| aesop |
| lemma addEdge_ne_one {x y : H} (hxy : x ≠ y) : addEdge x y ≠ 1 := by |
| intro he |
| have hh : (addEdge x y).holds x y := Or.inr ⟨rfl, rfl⟩ |
| rw [he] at hh |
| exact hxy hh |
|
|
| lemma conjugate_addEdge (σ : Equiv.Perm H) (x y : H) : |
| (↑(permUnit σ)⁻¹ : BRel H) * addEdge x y * ↑(permUnit σ) = addEdge (σ x) (σ y) := by |
| ext u v |
| change (∃ k, (∃ j, σ.symm u = j ∧ (j = k ∨ j = x ∧ k = y)) ∧ σ k = v) ↔ |
| u = v ∨ u = σ x ∧ v = σ y |
| constructor |
| · rintro ⟨k, ⟨j, hj, hk⟩, hv⟩ |
| subst j |
| rcases hk with hk | ⟨hx, rfl⟩ |
| · exact Or.inl (by rw [← hk, σ.apply_symm_apply] at hv; exact hv) |
| · exact Or.inr ⟨(σ.symm_apply_eq).mp hx, hv.symm⟩ |
| · rintro (rfl | ⟨rfl, rfl⟩) |
| · exact ⟨σ.symm u, ⟨σ.symm u, rfl, Or.inl rfl⟩, σ.apply_symm_apply u⟩ |
| · exact ⟨y, ⟨x, σ.symm_apply_apply x, Or.inr ⟨rfl, rfl⟩⟩, rfl⟩ |
| |
| lemma exists_perm_pair [Finite H] {x y u v : H} (hxy : x ≠ y) (huv : u ≠ v) : |
| ∃ σ : Equiv.Perm H, σ x = u ∧ σ y = v := by |
| let f : Bool → H := fun b => if b then y else x |
| let g : Bool → H := fun b => if b then v else u |
| have hf : Function.Injective f := by |
| intro b c h |
| cases b <;> cases c <;> simp_all [f, Ne.symm hxy] |
| have hg : Function.Injective g := by |
| intro b c h |
| cases b <;> cases c <;> simp_all [g, Ne.symm huv] |
| obtain ⟨σ, hσ⟩ := Equiv.Perm.exists_extending_pair f g hf hg |
| exact ⟨σ, hσ false, hσ true⟩ |
| end BRel |
|
|
| /-- Every target unit admits a unit lift (unitality included in the homomorphism). -/ |
| def HasUnitLifts {M N : Type*} [Monoid M] [Monoid N] (f : M →* N) : Prop := |
| ∀ u : Nˣ, ∃ v : Mˣ, f (↑v) = (↑u) |
|
|
| lemma unit_image_inv {M N : Type*} [Monoid M] [Monoid N] (f : M →* N) |
| (u : Mˣ) (v : Nˣ) (h : f (↑u) = (↑v)) : f (↑u⁻¹) = (↑v⁻¹) := by |
| have he : Units.map f u = v := Units.ext h |
| exact congrArg (fun w : Nˣ => (↑w⁻¹ : N)) he |
|
|
| lemma conjugate_lift {M H A : Type*} [Monoid M] [Finite H] [Fintype A] |
| (ρ : M →* Pairing (A ⊕ A)) (f : M →* BRel H) (hl : HasUnitLifts f) |
| (a : M) (ha : a * a = a) (x y : H) (hxy : x ≠ y) (hfa : f a = BRel.addEdge x y) |
| (u v : H) (huv : u ≠ v) : |
| ∃ b : M, b * b = b ∧ f b = BRel.addEdge u v ∧ Pairing.rank (ρ b) = Pairing.rank (ρ a) := by |
| obtain ⟨σ, hx, hy⟩ := BRel.exists_perm_pair hxy huv |
| obtain ⟨w, hw⟩ := hl (BRel.permUnit σ) |
| refine ⟨(↑w⁻¹ : M) * a * (↑w : M), ?_, ?_, ?_⟩ |
| · calc |
| _ = (↑w⁻¹ : M) * (a * ((↑w : M) * ↑w⁻¹) * a) * ↑w := by simp only [mul_assoc] |
| _ = (↑w⁻¹ : M) * a * ↑w := by rw [Units.mul_inv, mul_one, ha] |
| · rw [map_mul, map_mul, hw, unit_image_inv f w _ hw, hfa, BRel.conjugate_addEdge, hx, hy] |
| · rw [map_mul, map_mul] |
| change Pairing.rank (((Units.map ρ w⁻¹ : (Pairing (A ⊕ A))ˣ) : Pairing (A ⊕ A)) * ρ a * |
| ((Units.map ρ w : (Pairing (A ⊕ A))ˣ) : Pairing (A ⊕ A))) = _ |
| rw [Pairing.rank_mul_unit, Pairing.rank_unit_mul] |
|
|
| /-- Disjoint source/target points and a separate intermediate hub. -/ |
| structure RectangleFrame (H I J : Type*) where |
| left : I → H |
| right : J → H |
| hub : H |
| left_injective : Function.Injective left |
| right_injective : Function.Injective right |
| disjoint : ∀ i j, left i ≠ right j |
| left_ne_hub : ∀ i, left i ≠ hub |
| right_ne_hub : ∀ j, right j ≠ hub |
|
|
| namespace RectangleFrame |
| variable {H I J : Type*} (F : RectangleFrame H I J) |
| def base : BRel H := BRel.restrictedId {x | x ≠ F.hub} |
| def rel (E : Set (I × J)) : BRel H := |
| ⟨fun x y => (x = y ∧ x ≠ F.hub) ∨ ∃ p ∈ E, x = F.left p.1 ∧ y = F.right p.2⟩ |
|
|
| @[simp] lemma rel_holds (E : Set (I × J)) (x y : H) : |
| (F.rel E).holds x y ↔ (x = y ∧ x ≠ F.hub) ∨ ∃ p ∈ E, x = F.left p.1 ∧ y = F.right p.2 := Iff.rfl |
| lemma rel_empty : F.rel ∅ = F.base := by ext x y; simp [base] |
| |
| lemma rel_mul (E D : Set (I × J)) : F.rel E * F.rel D = F.rel (E ∪ D) := by |
| ext x y |
| constructor |
| · rintro ⟨k, (⟨hx, hn⟩ | ⟨p, hp, hx, hk⟩), hy⟩ |
| · subst k |
| rcases hy with ⟨hxy, _⟩ | ⟨p, hp, hp1, hp2⟩ |
| · exact Or.inl ⟨hxy, hn⟩ |
| · exact Or.inr ⟨p, Or.inr hp, hp1, hp2⟩ |
| · rcases hy with ⟨hky, _⟩ | ⟨q, _hq, hq1, _hq2⟩ |
| · exact Or.inr ⟨p, Or.inl hp, hx, hky.symm.trans hk⟩ |
| · exact (F.disjoint q.1 p.2 (hq1.symm.trans hk)).elim |
| · rintro (⟨rfl, hn⟩ | ⟨p, hp | hp, rfl, rfl⟩) |
| · exact ⟨x, Or.inl ⟨rfl, hn⟩, Or.inl ⟨rfl, hn⟩⟩ |
| · exact ⟨F.right p.2, Or.inr ⟨p, hp, rfl, rfl⟩, |
| Or.inl ⟨rfl, F.right_ne_hub p.2⟩⟩ |
| · exact ⟨F.left p.1, Or.inl ⟨rfl, F.left_ne_hub p.1⟩, |
| Or.inr ⟨p, hp, rfl, rfl⟩⟩ |
|
|
| lemma rel_idem (E : Set (I × J)) : F.rel E * F.rel E = F.rel E := by |
| rw [rel_mul, Set.union_self] |
| lemma rel_absorb {E D : Set (I × J)} (h : E ⊆ D) : |
| F.rel E * F.rel D = F.rel D ∧ F.rel D * F.rel E = F.rel D := by |
| rw [rel_mul, rel_mul, Set.union_eq_right.mpr h, Set.union_eq_left.mpr h] |
| exact ⟨rfl, rfl⟩ |
|
|
| lemma generator_image (i : I) (j : J) : |
| F.base * BRel.addEdge (F.left i) F.hub * BRel.addEdge F.hub (F.right j) * F.base = |
| F.rel {(i,j)} := by |
| have hl := F.left_ne_hub i |
| have hr := F.right_ne_hub j |
| have he : F.base * BRel.addEdge (F.left i) F.hub * BRel.addEdge F.hub (F.right j) * F.base = |
| F.base * (BRel.addEdge (F.left i) F.hub * BRel.addEdge F.hub (F.right j)) * F.base := by |
| simp only [mul_assoc] |
| rw [he] |
| ext x y |
| simp only [base, BRel.mul_holds, BRel.addEdge_holds, rel_holds, |
| Set.mem_singleton_iff, exists_eq_left] |
| aesop |
|
|
| lemma restricted_old (E : Set (I × J)) (K : Set H) |
| (hK : ∀ x ∈ K, x ≠ F.hub) |
| (hE : ∀ p ∈ E, F.left p.1 ∉ K ∨ F.right p.2 ∉ K) : |
| BRel.restrictedId K * F.rel E * BRel.restrictedId K = BRel.restrictedId K := by |
| ext x y |
| simp only [BRel.mul_restrictedId, BRel.restrictedId_mul, BRel.restrictedId_holds] |
| constructor |
| · rintro ⟨⟨hx, (⟨hxy, _⟩ | ⟨p, hp, rfl, rfl⟩)⟩, hy⟩ |
| · exact ⟨hxy, hx⟩ |
| · exact ((hE p hp).elim (fun h => h hx) (fun h => h hy)).elim |
| · rintro ⟨rfl, hx⟩ |
| exact ⟨⟨hx, Or.inl ⟨rfl, hK x hx⟩⟩, hx⟩ |
|
|
| lemma restricted_new (E : Set (I × J)) (K : Set H) |
| (hK : ∀ x ∈ K, x ≠ F.hub) |
| (hE : ∀ p ∈ E, F.left p.1 ∉ K ∨ F.right p.2 ∉ K) |
| (i : I) (j : J) (hi : F.left i ∈ K) (hj : F.right j ∈ K) : |
| let u : K := ⟨F.left i,hi⟩ |
| let v : K := ⟨F.right j,hj⟩ |
| ∀ x y : K, (F.rel (insert (i,j) E)).holds x.val y.val ↔ (BRel.addEdge u v).holds x y := by |
| intro u v x y |
| simp only [rel_holds, BRel.addEdge_holds] |
| constructor |
| · rintro (⟨hxy, _⟩ | ⟨p, hp, hx, hy⟩) |
| · exact Or.inl (Subtype.ext hxy) |
| · rcases hp with rfl | hp |
| · exact Or.inr ⟨Subtype.ext hx, Subtype.ext hy⟩ |
| · exact ((hE p hp).elim (fun h => h (hx ▸ x.property)) (fun h => h (hy ▸ y.property))).elim |
| · rintro (rfl | ⟨rfl, rfl⟩) |
| · exact Or.inl ⟨rfl, hK x.val x.property⟩ |
| · exact Or.inr ⟨(i,j), Or.inl rfl, rfl, rfl⟩ |
| end RectangleFrame |
|
|
| namespace Corner |
| variable {M : Type*} [Monoid M] {e : M} {he : e * e = e} |
|
|
| def flattenEquiv (q : Corner e he) (hq : q * q = q) : |
| Corner q hq ≃* Corner q.val (val_idempotent q hq) where |
| toFun z := ⟨z.val.val, congrArg Corner.val z.left, congrArg Corner.val z.right⟩ |
| invFun z := |
| ⟨⟨z.val, by |
| calc |
| e * z.val = e * (q.val * z.val) := by rw [z.left] |
| _ = z.val := by rw [← mul_assoc, q.left, z.left], by |
| calc |
| z.val * e = (z.val * q.val) * e := by rw [z.right] |
| _ = z.val := by rw [mul_assoc, q.right, z.right]⟩, |
| Corner.ext z.left, Corner.ext z.right⟩ |
| left_inv z := Corner.ext (Corner.ext rfl) |
| right_inv z := Corner.ext rfl |
| map_mul' _ _ := Corner.ext rfl |
| end Corner |
|
|
| lemma HasUnitLifts.comp_equiv {M N P : Type*} [Monoid M] [Monoid N] [Monoid P] |
| {f : M →* N} (hf : HasUnitLifts f) (e : N ≃* P) : HasUnitLifts (e.toMonoidHom.comp f) := by |
| intro u |
| obtain ⟨v, hv⟩ := hf (Units.map e.symm.toMonoidHom u) |
| refine ⟨v, ?_⟩ |
| change e (f (↑v)) = (↑u) |
| rw [hv] |
| exact e.apply_symm_apply _ |
|
|
| lemma min_rank_corner_unitLifts {M N A : Type*} [Monoid M] [Monoid N] [Finite M] [Fintype A] |
| (ρ : M →* Pairing (A ⊕ A)) (hρ : Function.Injective ρ) |
| (f : M →* N) (hs : Function.Surjective f) |
| (e : M) (he : e * e = e) (q : N) (hq : q * q = q) (hf : f e = q) |
| (hmin : ∀ z : M, z * z = z → f z = q → Pairing.rank (ρ e) ≤ Pairing.rank (ρ z)) : |
| HasUnitLifts (Corner.mapTo (he := he) (hq := hq) f hf) := by |
| intro u |
| obtain ⟨y, hy⟩ := Corner.mapTo_surjective (he := he) (hq := hq) f hf hs (↑u) |
| have hunit : IsUnit y := min_rank_corner_isUnit ρ hρ f e he q hq hf hmin y (hy ▸ u.isUnit) |
| obtain ⟨v, rfl⟩ := hunit |
| exact ⟨v, hy⟩ |
|
|
| namespace BRel |
| variable {H : Type*} |
| lemma restricted_sandwich {P N : BRel H} (F : Set H) |
| (hF : restrictedId F * P * restrictedId F = restrictedId F) |
| (hPN : P * N = N) (hNP : N * P = N) : |
| let Q := P * restrictedId F * P |
| restrictedId F * (Q * N * Q) * restrictedId F = restrictedId F * N * restrictedId F := by |
| let E := restrictedId F |
| have hl : E * (P * E * P) = E * P := by rw [← mul_assoc, ← mul_assoc, hF] |
| have hr : (P * E * P) * E = P * E := by rw [mul_assoc P E P, mul_assoc, hF] |
| change E * ((P * E * P) * N * (P * E * P)) * E = E * N * E |
| calc |
| _ = (E * (P * E * P)) * N * ((P * E * P) * E) := by simp only [mul_assoc] |
| _ = (E * P) * N * (P * E) := by rw [hl, hr] |
| _ = E * (P * N * P) * E := by simp only [mul_assoc] |
| _ = E * N * E := by rw [hPN, hNP] |
|
|
| lemma sandwich_holds_on {P N : BRel H} (F : Set H) |
| (hF : restrictedId F * P * restrictedId F = restrictedId F) |
| (hPN : P * N = N) (hNP : N * P = N) (x y : F) : |
| ((P * restrictedId F * P) * N * (P * restrictedId F * P)).holds x.val y.val ↔ |
| N.holds x.val y.val := by |
| have hh := congrArg (fun a : BRel H => a.holds x.val y.val) (restricted_sandwich F hF hPN hNP) |
| simpa only [mul_restrictedId, restrictedId_mul, x.property, y.property, |
| true_and, and_true, eq_iff_iff] using hh |
| end BRel |
|
|
| end OneWayLiveness |
|
|
| end OAI |
|
|
