| import OAI.Computability.WLIdentification.ScalarExtension |
|
|
| namespace OAI |
|
|
| namespace WLIdentification |
|
|
| namespace ComparisonSchemas |
| variable {r : ℕ} {P E : Type} (S : ComparisonSchemas r P E) |
|
|
| /-- Cut an unused middle link on each private wire. End links need never be |
| removed: the private interior alone is longer than any small support. -/ |
| def Avoids (n : ℕ) (U : Finset (S.layout n).Block) (cut : E → Fin n) : Prop := |
| ∀ e, Sum.inr (Sum.inl (e, cut e)) ∉ (S.layout n).usedLinks U |
|
|
| theorem exists_cuts (n : ℕ) (U : Finset (S.layout n).Block) (hu : U.card < n) : |
| ∃ cut : E → Fin n, S.Avoids n U cut := by |
| classical |
| have hex (e : E) : ∃ i : Fin n, Sum.inr (Sum.inl (e, i)) ∉ (S.layout n).usedLinks U := by |
| by_contra h |
| have hall : ∀ i : Fin n, Sum.inr (Sum.inl (e, i)) ∈ (S.layout n).usedLinks U := by |
| simpa only [not_exists, not_not] using h |
| have hs : Finset.univ.image (fun i : Fin n => (Sum.inr (Sum.inl (e, i)) : S.Link n)) ⊆ |
| (S.layout n).usedLinks U := by |
| intro l hl |
| obtain ⟨i, _, rfl⟩ := Finset.mem_image.mp hl |
| exact hall i |
| have hinj : Function.Injective (fun i : Fin n => (Sum.inr (Sum.inl (e, i)) : S.Link n)) := by |
| intro i j hij |
| exact (Prod.mk.inj (Sum.inl.inj (Sum.inr.inj hij))).2 |
| have hc := Finset.card_le_card hs |
| rw [Finset.card_image_of_injective _ hinj, Finset.card_univ, Fintype.card_fin] at hc |
| have hb := (S.layout n).usedLinks_card U |
| omega |
| choose cut hc using hex |
| exact ⟨cut, hc⟩ |
|
|
| def root (n : ℕ) (cut : E → Fin n) : S.InternalType n → P |
| | .inl p => p |
| | .inr (e, i) => if i.val ≤ (cut e).val then S.source e else S.target e |
|
|
| def onLeft (_S : ComparisonSchemas r P E) (n : ℕ) (cut : E → Fin n) (e : E) (i : Fin (n + 1)) : Prop := |
| i.val ≤ (cut e).val |
|
|
| instance (n : ℕ) (cut : E → Fin n) (e : E) (i : Fin (n + 1)) : |
| Decidable (S.onLeft n cut e i) := inferInstanceAs (Decidable (i.val ≤ (cut e).val)) |
|
|
| theorem cut_middle {n : ℕ} {cut : E → Fin n} {e : E} {i : Fin n} (hi : i ≠ cut e) : |
| S.onLeft n cut e i.castSucc ↔ S.onLeft n cut e i.succ := by |
| have hne : i.val ≠ (cut e).val := fun h => hi (Fin.ext h) |
| dsimp only [onLeft, Fin.val_castSucc, Fin.val_succ] |
| omega |
|
|
| theorem root_link {n : ℕ} {U : Finset (S.layout n).Block} {cut : E → Fin n} |
| (hc : S.Avoids n U cut) {l : S.Link n} (hl : l ∈ (S.layout n).usedLinks U) : |
| S.root n cut (S.first n l) = S.root n cut (S.second n l) := by |
| cases l with |
| | inl e => simp [root, first, second] |
| | inr l => cases l with |
| | inl ei => |
| obtain ⟨e, i⟩ := ei |
| have hi : i ≠ cut e := fun hi => hc e (hi ▸ hl) |
| dsimp only [root, first, second] |
| have hm := S.cut_middle hi |
| dsimp only [onLeft] at hm |
| simp only [hm] |
| | inr e => |
| have hn := (cut e).isLt |
| simp [root, first, second, show ¬n ≤ (cut e).val by omega] |
|
|
| /-- Every injective partial binary coordinate map extends to a permutation. |
| This lemma preserves singleton domains rather than silently enlarging them. -/ |
| theorem binary_extension (A : Finset Bool) (hA : A.Nonempty) |
| (f : {a // a ∈ A} → Bool) (hf : Function.Injective f) : |
| ∃ p : Equiv.Perm Bool, ∀ a, p a.val = f a := by |
| classical |
| obtain ⟨x, hx⟩ := hA |
| let a0 : {a // a ∈ A} := ⟨x, hx⟩ |
| let flip : Equiv.Perm Bool := ⟨Bool.not, Bool.not, Bool.not_not, Bool.not_not⟩ |
| by_cases he : f a0 = x |
| · refine ⟨Equiv.refl Bool, ?_⟩ |
| intro a |
| change a.val = f a |
| by_cases ha : a = a0 |
| · subst a; exact he.symm |
| · have hav : a.val ≠ x := fun h => ha (Subtype.ext h) |
| have hfa : f a ≠ f a0 := fun h => ha (hf h) |
| rw [he] at hfa |
| cases hval : a.val <;> cases hfx : f a <;> cases x <;> simp_all |
| · refine ⟨flip, ?_⟩ |
| intro a |
| change (!a.val) = f a |
| by_cases ha : a = a0 |
| · subst a |
| dsimp only [a0] |
| cases hfx : f ⟨x, hx⟩ <;> cases x <;> simp_all [a0] |
| · have hav : a.val ≠ x := fun h => ha (Subtype.ext h) |
| have hfa : f a ≠ f a0 := fun h => ha (hf h) |
| cases hval : a.val <;> cases hfx : f a <;> cases hf0 : f a0 <;> cases x <;> simp_all |
| |
| noncomputable def permutation (e : E) (i : Fin r) : Equiv.Perm Bool := |
| (binary_extension (S.domain e i) (S.domain_nonempty e i) |
| (S.mapping e i) (S.mapping_injective e i)).choose |
|
|
| theorem permutation_apply (e : E) (i : Fin r) (a : {a // a ∈ S.domain e i}) : |
| S.permutation e i a.val = S.mapping e i a := |
| (binary_extension (S.domain e i) (S.domain_nonempty e i) |
| (S.mapping e i) (S.mapping_injective e i)).choose_spec a |
|
|
| noncomputable def align (n : ℕ) (cut : E → Fin n) : (S.layout n).Corner → Bool |
| | ⟨.inl _, _, a⟩ => a.val |
| | ⟨.inr (e, j), i, a⟩ => if S.onLeft n cut e j then a.val else S.permutation e i a.val |
|
|
| theorem align_link {n : ℕ} {U : Finset (S.layout n).Block} {cut : E → Fin n} |
| (hc : S.Avoids n U cut) {l : S.Link n} (hl : l ∈ (S.layout n).usedLinks U) |
| (i : Fin r) (a : (S.layout n).Match l i) : |
| S.align n cut ((S.layout n).nameFirst (.inr ⟨l, i, a⟩)) = |
| S.align n cut ((S.layout n).nameSecond (.inr ⟨l, i, a⟩)) := by |
| cases l with |
| | inl e => |
| change a.val = (if 0 ≤ (cut e).val then a.val else S.permutation e i a.val) |
| rw [ite_eq_left (Nat.zero_le _)] |
| | inr l => cases l with |
| | inl ei => |
| obtain ⟨e, j⟩ := ei |
| have hj : j ≠ cut e := fun he => hc e (he ▸ hl) |
| change (if S.onLeft n cut e j.castSucc then a.val else S.permutation e i a.val) = |
| (if S.onLeft n cut e j.succ then a.val else S.permutation e i a.val) |
| simp only [S.cut_middle hj] |
| | inr e => |
| change (if n ≤ (cut e).val then a.val else S.permutation e i a.val) = S.mapping e i a |
| rw [ite_eq_right (Nat.not_le.mpr (cut e).isLt)] |
| exact S.permutation_apply e i a |
|
|
| end ComparisonSchemas |
|
|
| namespace RingLayout |
| variable {r : ℕ} {T L : Type} (R : RingLayout r T L) |
|
|
| theorem vertical_usedLink {U : Finset R.Block} {v : R.VName} |
| (hv : Sum.inr v ∈ R.names U) : v.1 ∈ R.usedLinks U := by |
| classical |
| obtain ⟨b, hb, hn⟩ := Finset.mem_biUnion.mp hv |
| cases b with |
| | inl b => simp [blockNames] at hn |
| | inr b => |
| simp only [blockNames, Finset.mem_insert, Finset.mem_singleton, Sum.inr_ne_inl, |
| Sum.inr.injEq, false_or] at hn |
| rcases hn with rfl | rfl <;> exact R.mem_usedLinks.mpr ⟨b, hb, rfl⟩ |
| |
| abbrev Shift := (t : T) → Fin (R.dimension t) → Bit |
| abbrev Potential := (c : R.Corner) → Fin (R.dimension c.1) → Bit |
|
|
| def potentialHorizontal (h : R.Shift) (M : R.Potential) : R.Horizontal := |
| fun x => M ⟨x.1, x.2.1, x.2.2.1⟩ + M ⟨x.1, finRotate r x.2.1, x.2.2.2⟩ + Marker.delta x.2.1 • h x.1 |
|
|
| def potentialVertical (M : R.Potential) : R.Vertical := |
| fun x => R.firstForm x.1 (M (R.nameFirst (.inr x))) + |
| R.secondForm x.1 (M (R.nameSecond (.inr x))) |
|
|
| def translation (h : R.Shift) (M : R.Potential) : R.Coordinate → Bit := |
| R.pack (R.potentialHorizontal h M) (R.potentialVertical M) |
|
|
| /-- The potential terms cancel on every square, leaving only its row marker |
| multiplied by the affine link-shift equation. -/ |
| theorem translation_square (h : R.Shift) (M : R.Potential) (b : R.Square) : |
| R.firstForm b.1 (R.horizontal (R.translation h M) (R.leftH b)) + |
| R.secondForm b.1 (R.horizontal (R.translation h M) (R.rightH b)) + |
| R.vertical (R.translation h M) (R.topV b) + |
| R.vertical (R.translation h M) (R.bottomV b) = |
| Marker.delta b.2.1 * (R.firstForm b.1 (h (R.first b.1)) + |
| R.secondForm b.1 (h (R.second b.1))) := by |
| have hh : R.horizontal (R.translation h M) = R.potentialHorizontal h M := rfl |
| have hv : R.vertical (R.translation h M) = R.potentialVertical M := rfl |
| rw [hh, hv] |
| dsimp only [potentialHorizontal, potentialVertical, leftH, rightH, topV, |
| bottomV, nameFirst, nameSecond] |
| simp only [map_add, map_smul, smul_eq_mul] |
| ring_nf |
| simp only [show (2 : Bit) = 0 by decide, mul_zero, zero_add, add_zero] |
|
|
| end RingLayout |
|
|
| namespace ComparisonSchemas |
| variable {r : ℕ} {P E : Type} (S : ComparisonSchemas r P E) |
|
|
| theorem align_aligned {n : ℕ} {U : Finset (S.layout n).Block} {cut : E → Fin n} |
| (hc : S.Avoids n U cut) : (S.layout n).Aligned U (S.align n cut) := by |
| intro v hv |
| exact S.align_link hc ((S.layout n).vertical_usedLink hv) v.2.1 v.2.2 |
|
|
| theorem root_edge {n : ℕ} {U : Finset (S.layout n).Block} {cut : E → Fin n} |
| (hc : S.Avoids n U cut) (hr : 2 ≤ r) {u v : (S.layout n).Corner} |
| (huv : ((S.layout n).cornerGraph hr U).Adj u v) : |
| S.root n cut u.1 = S.root n cut v.1 := by |
| obtain ⟨x, hx, hh⟩ := huv |
| cases x with |
| | inl x => rcases hh with ⟨rfl, rfl⟩ | ⟨rfl, rfl⟩ <;> rfl |
| | inr x => |
| have he := S.root_link hc ((S.layout n).vertical_usedLink hx) |
| rcases hh with ⟨rfl, rfl⟩ | ⟨rfl, rfl⟩ |
| · exact he |
| · exact he.symm |
|
|
| theorem root_reachable {n : ℕ} {U : Finset (S.layout n).Block} {cut : E → Fin n} |
| (hc : S.Avoids n U cut) (hr : 2 ≤ r) {u v : (S.layout n).Corner} |
| (huv : ((S.layout n).cornerGraph hr U).Reachable u v) : |
| S.root n cut u.1 = S.root n cut v.1 := by |
| obtain ⟨p⟩ := huv |
| induction p with |
| | nil => rfl |
| | cons h p ih => exact (S.root_edge hc hr h).trans ih |
|
|
| abbrev RealShift := (p : P) → Fin (S.dimension p) → Bit |
|
|
| def linkConstant (n : ℕ) (b : E → Bit) : S.Link n → Bit |
| | .inl _ => 0 |
| | .inr (.inl _) => 0 |
| | .inr (.inr e) => b e |
|
|
| def specialTwist (n : ℕ) (b : E → Bit) : (S.layout n).Block → Bit |
| | .inl _ => 0 |
| | .inr q => Marker.delta q.2.1 * S.linkConstant n b q.1 |
|
|
| /-- Completing the cut layout to rooted stars gives a uniform affine shift. |
| The real vectors may be arbitrary; internal values are constant on each arm. -/ |
| def starShift (n : ℕ) (cut : E → Fin n) (b : E → Bit) (q : S.RealShift) : (S.layout n).Shift |
| | .inl p => q p |
| | .inr (e, i) => fun _ => if S.onLeft n cut e i then S.left e (q (S.source e)) |
| else b e + S.right e (q (S.target e)) |
|
|
| theorem starShift_link {n : ℕ} {U : Finset (S.layout n).Block} {cut : E → Fin n} |
| (hc : S.Avoids n U cut) (b : E → Bit) (q : S.RealShift) |
| {l : S.Link n} (hl : l ∈ (S.layout n).usedLinks U) : |
| (S.layout n).firstForm l (S.starShift n cut b q ((S.layout n).first l)) + |
| (S.layout n).secondForm l (S.starShift n cut b q ((S.layout n).second l)) = |
| S.linkConstant n b l := by |
| cases l with |
| | inl e => |
| change S.left e (q (S.source e)) + |
| (if 0 ≤ (cut e).val then S.left e (q (S.source e)) else b e + S.right e (q (S.target e))) = 0 |
| rw [ite_eq_left (Nat.zero_le _), CharTwo.add_self_eq_zero] |
| | inr l => cases l with |
| | inl ei => |
| obtain ⟨e, i⟩ := ei |
| have hi : i ≠ cut e := fun he => hc e (he ▸ hl) |
| change (if S.onLeft n cut e i.castSucc then S.left e (q (S.source e)) else b e + S.right e (q (S.target e))) + |
| (if S.onLeft n cut e i.succ then S.left e (q (S.source e)) else b e + S.right e (q (S.target e))) = 0 |
| simp only [S.cut_middle hi, CharTwo.add_self_eq_zero] |
| | inr e => |
| change (if n ≤ (cut e).val then S.left e (q (S.source e)) else b e + S.right e (q (S.target e))) + |
| S.right e (q (S.target e)) = b e |
| rw [ite_eq_right (Nat.not_le.mpr (cut e).isLt), add_assoc, CharTwo.add_self_eq_zero, add_zero] |
|
|
| variable [Fintype P] [Fintype E] |
|
|
| theorem translation_legal {n : ℕ} {U : Finset (S.layout n).Block} {cut : E → Fin n} |
| (hc : S.Avoids n U cut) (hr : 2 ≤ r) (b : E → Bit) (q : S.RealShift) |
| (M : (S.layout n).Potential) {a : (S.layout n).Block} (ha : a ∈ U) : |
| ((S.layout n).affine hr).Legal (S.specialTwist n b) a |
| (((S.layout n).affine hr).restrict a ((S.layout n).translation (S.starShift n cut b q) M)) := by |
| cases a with |
| | inl a => intro hh; cases hh |
| | inr a => |
| intro _ |
| change (S.layout n).squareForm a (fun c => (S.layout n).translation (S.starShift n cut b q) M c.val) = _ |
| rw [RingLayout.squareForm_apply] |
| change (S.layout n).firstForm a.1 |
| ((S.layout n).horizontal ((S.layout n).translation (S.starShift n cut b q) M) ((S.layout n).leftH a)) + |
| (S.layout n).secondForm a.1 |
| ((S.layout n).horizontal ((S.layout n).translation (S.starShift n cut b q) M) ((S.layout n).rightH a)) + |
| (S.layout n).vertical ((S.layout n).translation (S.starShift n cut b q) M) ((S.layout n).topV a) + |
| (S.layout n).vertical ((S.layout n).translation (S.starShift n cut b q) M) ((S.layout n).bottomV a) = _ |
| rw [RingLayout.translation_square, S.starShift_link hc b q ((S.layout n).mem_usedLinks.mpr ⟨a, ha, rfl⟩)] |
| rfl |
| |
| end ComparisonSchemas |
| |
| namespace RingLayout |
| variable {r : ℕ} {T L : Type} (R : RingLayout r T L) |
|
|
| def coordinateName : R.Coordinate → R.Name |
| | .inl h => .inl h.1 |
| | .inr v => .inr v |
|
|
| theorem coordinate_name_mem {b : R.Block} {c : R.Coordinate} |
| (hc : c ∈ R.coordinates b) : R.coordinateName c ∈ R.blockNames b := by |
| classical |
| cases b with |
| | inl h => |
| obtain ⟨j, _, rfl⟩ := Finset.mem_image.mp hc |
| exact Finset.mem_singleton_self _ |
| | inr b => |
| simp only [coordinates, Finset.mem_union, Finset.mem_insert, Finset.mem_singleton] at hc |
| rcases hc with (hh | hh) | hh | hh |
| · obtain ⟨j, _, rfl⟩ := Finset.mem_image.mp hh |
| simp [coordinateName, blockNames] |
| · obtain ⟨j, _, rfl⟩ := Finset.mem_image.mp hh |
| simp [coordinateName, blockNames] |
| · subst c |
| simp [coordinateName, blockNames] |
| · subst c |
| simp [coordinateName, blockNames] |
|
|
| theorem cornerMarker_symm (hr : 3 ≤ r) {U : Finset R.Block} {u v : R.Corner} |
| (h : (R.cornerGraph (by omega) U).Adj u v) : R.cornerMarker u v = R.cornerMarker v u := by |
| obtain ⟨n, _, h⟩ := h |
| cases n with |
| | inl n => |
| obtain ⟨h1, h2⟩ := R.cornerMarker_horizontal hr n |
| rcases h with ⟨rfl, rfl⟩ | ⟨rfl, rfl⟩ |
| · exact h1.trans h2.symm |
| · exact h2.trans h1.symm |
| | inr n => |
| obtain ⟨h1, h2⟩ := R.cornerMarker_vertical n |
| rcases h with ⟨rfl, rfl⟩ | ⟨rfl, rfl⟩ |
| · exact h1.trans h2.symm |
| · exact h2.trans h1.symm |
|
|
| theorem nonwrapping_exact (hr : 3 ≤ r) {U : Finset R.Block} |
| (hw : ¬R.Wrapping (by omega) U) : |
| ∃ s : R.Corner → Bit, ∀ n ∈ R.names U, |
| R.cornerMarker (R.nameFirst n) (R.nameSecond n) = s (R.nameFirst n) + s (R.nameSecond n) := by |
| have hc : ∀ u (p : (R.cornerGraph (by omega) U).Walk u u), Marker.walkSum R.cornerMarker p = 0 := by |
| intro u p |
| have hb : ∀ x : Bit, x = 0 ∨ x = 1 := by intro x; fin_cases x <;> (first | exact Or.inl rfl | exact Or.inr rfl) |
| rcases hb (Marker.walkSum R.cornerMarker p) with h | h |
| · exact h |
| · exact (hw ⟨u, p, h⟩).elim |
| obtain ⟨s, hs⟩ := Marker.exact_of_closed_zero R.cornerMarker |
| (fun _ _ h => R.cornerMarker_symm hr h) hc |
| exact ⟨s, fun n hn => hs _ _ ⟨n, hn, Or.inl ⟨rfl, rfl⟩⟩⟩ |
|
|
| /-- On a nonwrapping support any two shifts with the same affine link equations |
| induce the same offset family after a potential adjustment. -/ |
| theorem adjust_potential (hr : 3 ≤ r) {U : Finset R.Block} |
| (hw : ¬R.Wrapping (by omega) U) (old new : R.Shift) (M : R.Potential) |
| (he : ∀ l ∈ R.usedLinks U, |
| R.firstForm l (old (R.first l)) + R.secondForm l (old (R.second l)) = |
| R.firstForm l (new (R.first l)) + R.secondForm l (new (R.second l))) : |
| ∃ N : R.Potential, ∀ b ∈ U, ∀ c ∈ R.coordinates b, |
| R.translation new N c = R.translation old M c := by |
| classical |
| obtain ⟨s, hs⟩ := R.nonwrapping_exact hr hw |
| let N : R.Potential := fun c => M c + s c • (new c.1 + old c.1) |
| have hh {h : R.HName} (hh : Sum.inl h ∈ R.names U) : |
| R.potentialHorizontal new N h = R.potentialHorizontal old M h := by |
| have hm := (R.cornerMarker_horizontal hr h).1.symm.trans (hs (.inl h) hh) |
| exact Marker.horizontal_adjust (M (R.nameFirst (.inl h))) (M (R.nameSecond (.inl h))) |
| (old h.1) (new h.1) (s (R.nameFirst (.inl h))) (s (R.nameSecond (.inl h))) |
| (Marker.delta h.2.1) hm.symm |
| have hv {v : R.VName} (hv : Sum.inr v ∈ R.names U) : |
| R.potentialVertical N v = R.potentialVertical M v := by |
| have hm := (R.cornerMarker_vertical v).1.symm.trans (hs (.inr v) hv) |
| have hst : s (R.nameFirst (.inr v)) = s (R.nameSecond (.inr v)) := by |
| calc |
| _ = s (R.nameFirst (.inr v)) + (s (R.nameFirst (.inr v)) + s (R.nameSecond (.inr v))) := by rw [← hm, add_zero] |
| _ = _ := by rw [← add_assoc, CharTwo.add_self_eq_zero, zero_add] |
| have hl := he v.1 (R.vertical_usedLink hv) |
| have he' : R.firstForm v.1 (new (R.first v.1) + old (R.first v.1)) + |
| R.secondForm v.1 (new (R.second v.1) + old (R.second v.1)) = 0 := by |
| rw [map_add, map_add] |
| calc |
| _ = (R.firstForm v.1 (new (R.first v.1)) + R.secondForm v.1 (new (R.second v.1))) + |
| (R.firstForm v.1 (old (R.first v.1)) + R.secondForm v.1 (old (R.second v.1))) := by abel |
| _ = 0 := by rw [hl, CharTwo.add_self_eq_zero] |
| exact Marker.vertical_adjust (R.firstForm v.1) (R.secondForm v.1) |
| (M (R.nameFirst (.inr v))) (M (R.nameSecond (.inr v))) |
| (new (R.first v.1) + old (R.first v.1)) (new (R.second v.1) + old (R.second v.1)) |
| (s (R.nameFirst (.inr v))) (s (R.nameSecond (.inr v))) hst he' |
| refine ⟨N, ?_⟩ |
| intro b hb c hc |
| have hn := R.name_present hb (R.coordinate_name_mem hc) |
| cases c with |
| | inl h => exact congrFun (hh hn) h.2 |
| | inr v => exact hv hn |
|
|
| end RingLayout |
|
|
| namespace ComparisonSchemas |
| variable {r : ℕ} {P E : Type} (S : ComparisonSchemas r P E) |
|
|
| def GoodAddress (n : ℕ) (hr : 2 ≤ r) (U : Finset (S.layout n).Block) |
| (cut : E → Fin n) (a : Fin r → Bool) : Prop := |
| ∀ V ⊆ U, V.card ≤ r → (S.layout n).Wrapping hr V → |
| (S.layout n).IsWrappingAddress V (S.align n cut) a |
|
|
| theorem goodAddress_exists (n : ℕ) (hr : 3 ≤ r) {U : Finset (S.layout n).Block} |
| (hu : U.card ≤ r + 1) {cut : E → Fin n} (hc : S.Avoids n U cut) : |
| ∃ a, S.GoodAddress n (by omega) U cut a := by |
| classical |
| by_cases hw : ∃ V ⊆ U, V.card ≤ r ∧ (S.layout n).Wrapping (by omega) V |
| · obtain ⟨V, hV, hv, hwV⟩ := hw |
| obtain ⟨a, ha, _⟩ := (S.layout n).wrapping_address hr hwV hv |
| ((S.layout n).aligned_mono hV (S.align_aligned hc)) |
| refine ⟨a, ?_⟩ |
| intro W hW hw' hww |
| obtain ⟨a', ha', _⟩ := (S.layout n).wrapping_address hr hww hw' |
| ((S.layout n).aligned_mono hW (S.align_aligned hc)) |
| have he := (S.layout n).wrapping_addresses_agree hr hV hW hu hwV hww ha ha' |
| exact he ▸ ha' |
| · exact ⟨fun _ => false, fun V hV hv hwV => (hw ⟨V, hV, hv, hwV⟩).elim⟩ |
|
|
| theorem avoids_mono {n : ℕ} {V U : Finset (S.layout n).Block} (h : V ⊆ U) |
| {cut : E → Fin n} (hc : S.Avoids n U cut) : S.Avoids n V cut := by |
| intro e he |
| obtain ⟨b, hb, hb'⟩ := (S.layout n).mem_usedLinks.mp he |
| exact hc e ((S.layout n).mem_usedLinks.mpr ⟨b, h hb, hb'⟩) |
|
|
| theorem goodAddress_mono {n : ℕ} {hr : 2 ≤ r} {V U : Finset (S.layout n).Block} |
| (h : V ⊆ U) {cut : E → Fin n} {a : Fin r → Bool} |
| (ha : S.GoodAddress n hr U cut a) : S.GoodAddress n hr V cut a := |
| fun W hW => ha W (hW.trans h) |
|
|
| end ComparisonSchemas |
|
|
| end WLIdentification |
|
|
| end OAI |
|
|
