| import OAI.Computability.WLIdentification.RowOffsets |
|
|
| namespace OAI |
|
|
| namespace WLIdentification |
|
|
| structure ComparisonSchemas (r : ℕ) (P E : Type) where |
| pointIndex : P ↪ ℕ |
| edgeIndex : E ↪ ℕ |
| dimension : P → ℕ |
| dimension_bound : ∀ p, dimension p = 1 ∨ dimension p = 2 |
| source : E → P |
| target : E → P |
| domain : E → Fin r → Finset Bool |
| domain_nonempty : ∀ e i, (domain e i).Nonempty |
| mapping : (e : E) → (i : Fin r) → {a // a ∈ domain e i} → Bool |
| mapping_injective : ∀ e i, Function.Injective (mapping e i) |
| left : (e : E) → (Fin (dimension (source e)) → Bit) →ₗ[Bit] Bit |
| right : (e : E) → (Fin (dimension (target e)) → Bit) →ₗ[Bit] Bit |
|
|
| namespace ComparisonSchemas |
| variable {r : ℕ} {P E : Type} (S : ComparisonSchemas r P E) |
|
|
| abbrev InternalType (_S : ComparisonSchemas r P E) (n : ℕ) := P ⊕ (E × Fin (n + 1)) |
| abbrev Link (_S : ComparisonSchemas r P E) (n : ℕ) := E ⊕ ((E × Fin n) ⊕ E) |
|
|
| def first (n : ℕ) : S.Link n → S.InternalType n |
| | .inl e => .inl (S.source e) |
| | .inr (.inl (e, i)) => .inr (e, i.castSucc) |
| | .inr (.inr e) => .inr (e, Fin.last n) |
|
|
| def second (n : ℕ) : S.Link n → S.InternalType n |
| | .inl e => .inr (e, 0) |
| | .inr (.inl (e, i)) => .inr (e, i.succ) |
| | .inr (.inr e) => .inl (S.target e) |
|
|
| def wire (n : ℕ) : S.Link n → E |
| | .inl e => e |
| | .inr (.inl (e, _)) => e |
| | .inr (.inr e) => e |
|
|
| def layoutDimension (n : ℕ) : S.InternalType n → ℕ |
| | .inl p => S.dimension p |
| | .inr _ => 1 |
|
|
| def layoutLabels (n : ℕ) : S.InternalType n → Fin r → Finset Bool |
| | .inl _, _ => Finset.univ |
| | .inr (e, _), i => S.domain e i |
|
|
| def firstLabel (n : ℕ) (l : S.Link n) (i : Fin r) : |
| {a // a ∈ S.domain (S.wire n l) i} → {a // a ∈ S.layoutLabels n (S.first n l) i} := by |
| cases l with |
| | inl e => exact fun a => ⟨a.val, Finset.mem_univ _⟩ |
| | inr l => cases l with |
| | inl p => exact id |
| | inr e => exact id |
|
|
| def secondLabel (n : ℕ) (l : S.Link n) (i : Fin r) : |
| {a // a ∈ S.domain (S.wire n l) i} → {a // a ∈ S.layoutLabels n (S.second n l) i} := by |
| cases l with |
| | inl e => exact id |
| | inr l => cases l with |
| | inl p => exact id |
| | inr e => exact fun a => ⟨S.mapping e i a, Finset.mem_univ _⟩ |
|
|
| def firstForm (n : ℕ) (l : S.Link n) : |
| (Fin (S.layoutDimension n (S.first n l)) → Bit) →ₗ[Bit] Bit := by |
| cases l with |
| | inl e => exact S.left e |
| | inr l => cases l with |
| | inl p => exact (LinearMap.proj (0 : Fin 1)) |
| | inr e => exact (LinearMap.proj (0 : Fin 1)) |
|
|
| def secondForm (n : ℕ) (l : S.Link n) : |
| (Fin (S.layoutDimension n (S.second n l)) → Bit) →ₗ[Bit] Bit := by |
| cases l with |
| | inl e => exact (LinearMap.proj (0 : Fin 1)) |
| | inr l => cases l with |
| | inl p => exact (LinearMap.proj (0 : Fin 1)) |
| | inr e => exact S.right e |
|
|
| def layout (n : ℕ) : RingLayout r (S.InternalType n) (S.Link n) where |
| typeIndex := NaturalCode.sum S.pointIndex (NaturalCode.prod S.edgeIndex (NaturalCode.fin _)) |
| linkIndex := NaturalCode.sum S.edgeIndex (NaturalCode.sum (NaturalCode.prod S.edgeIndex (NaturalCode.fin _)) S.edgeIndex) |
| dimension := S.layoutDimension n |
| dimension_bound t := by cases t with |
| | inl p => exact S.dimension_bound p |
| | inr p => exact Or.inl rfl |
| labels := S.layoutLabels n |
| labels_nonempty t i := by cases t with |
| | inl p => exact ⟨false, Finset.mem_univ _⟩ |
| | inr p => exact S.domain_nonempty p.1 i |
| first := S.first n |
| second := S.second n |
| endpoints_ne l := by |
| cases l with |
| | inl e => intro h; cases h |
| | inr l => cases l with |
| | inl p => |
| intro h |
| have hi := congrArg (fun t : S.InternalType n => |
| match t with | .inl _ => 0 | .inr p => p.2.val) h |
| change p.2.val = p.2.val + 1 at hi |
| omega |
| | inr e => intro h; cases h |
| internal_endpoint l := by |
| cases l with |
| | inl e => exact Or.inr rfl |
| | inr l => cases l <;> exact Or.inl rfl |
| matchLabels l i := S.domain (S.wire n l) i |
| matchLabels_nonempty l i := S.domain_nonempty (S.wire n l) i |
| firstLabel := S.firstLabel n |
| secondLabel := S.secondLabel n |
| firstLabel_injective l i := by |
| cases l with |
| | inl e => |
| intro a b h |
| apply Subtype.ext |
| exact congrArg (fun x : {a // a ∈ S.layoutLabels n (S.first n (.inl e)) i} => x.val) h |
| | inr l => cases l <;> exact Function.injective_id |
| secondLabel_injective l i := by |
| cases l with |
| | inl e => exact Function.injective_id |
| | inr l => cases l with |
| | inl p => exact Function.injective_id |
| | inr e => exact fun a b h => S.mapping_injective e i (congrArg Subtype.val h) |
| firstForm := S.firstForm n |
| secondForm := S.secondForm n |
|
|
| end ComparisonSchemas |
|
|
| namespace CycleRows.RowSum |
| variable {r : ℕ} {A : Fin r → Type} {V : Type} [AddCommMonoid V] |
|
|
| protected theorem sum {I : Type} (s : Finset I) |
| (h : I → ((i : Fin r) → A i) → V) (hh : ∀ j ∈ s, RowSum A V (h j)) : |
| RowSum A V (fun a => ∑ j ∈ s, h j a) := by |
| classical |
| induction s using Finset.induction_on with |
| | empty => simpa only [Finset.sum_empty] using (RowSum.zero (A := A) (V := V)) |
| | @insert j s hj ih => |
| simpa only [Finset.sum_insert hj] using |
| (hh j (Finset.mem_insert_self _ _)).add |
| (ih (fun i hi => hh i (Finset.mem_insert_of_mem hi))) |
|
|
| protected theorem pi {J : Type} {W : J → Type} [∀ j, AddCommMonoid (W j)] |
| (h : ((i : Fin r) → A i) → (j : J) → W j) |
| (hh : ∀ j, RowSum A (W j) (fun a => h a j)) : RowSum A ((j : J) → W j) h := by |
| choose f hf using hh |
| refine ⟨fun i u v j => f j i u v, ?_⟩ |
| intro a |
| funext j |
| simpa only [Finset.sum_apply] using hf j a |
|
|
| end CycleRows.RowSum |
|
|
| namespace WireAlgebra |
|
|
| def prefixSum {n : ℕ} (c : Fin n → Bit) (j : Fin (n + 1)) : Bit := |
| ∑ i : Fin n, if i.val < j.val then c i else 0 |
|
|
| @[simp] |
| theorem prefix_zero {n : ℕ} (c : Fin n → Bit) : prefixSum c 0 = 0 := by |
| simp [prefixSum] |
|
|
| @[simp] |
| theorem prefix_last {n : ℕ} (c : Fin n → Bit) : prefixSum c (Fin.last n) = ∑ i, c i := by |
| simp [prefixSum] |
|
|
| theorem prefix_succ {n : ℕ} (c : Fin n → Bit) (j : Fin n) : |
| prefixSum c j.succ = prefixSum c j.castSucc + c j := by |
| have hi (i : Fin n) : (if i.val < j.val + 1 then c i else 0) = |
| (if i.val < j.val then c i else 0) + (if i = j then c i else 0) := by |
| by_cases h : i.val < j.val |
| · have hne : i ≠ j := fun hh => by subst i; omega |
| simp [h, hne, show i.val < j.val + 1 by omega] |
| · by_cases he : i = j |
| · subst i; simp |
| · have hn : ¬i.val < j.val + 1 := by |
| intro hh |
| exact he (Fin.ext (by omega)) |
| simp [h, he, hn] |
| simp only [prefixSum, Fin.val_succ, Fin.val_castSucc, hi, Finset.sum_add_distrib] |
| simp |
|
|
| theorem sum_adjacent {n : ℕ} (h : Fin (n + 1) → Bit) : |
| ∑ i : Fin n, (h i.castSucc + h i.succ) = h 0 + h (Fin.last n) := by |
| have ha := Fin.sum_univ_castSucc h |
| have hb := Fin.sum_univ_succ h |
| have hab : (∑ i : Fin n, h i.castSucc) + h (Fin.last n) = |
| h 0 + ∑ i : Fin n, h i.succ := ha.symm.trans hb |
| rw [Finset.sum_add_distrib] |
| calc |
| _ = ((∑ i : Fin n, h i.castSucc) + (∑ i : Fin n, h i.succ)) + |
| (h (Fin.last n) + h (Fin.last n)) := by |
| rw [CharTwo.add_self_eq_zero, add_zero] |
| _ = ((∑ i : Fin n, h i.castSucc) + h (Fin.last n)) + |
| (∑ i : Fin n, h i.succ) + h (Fin.last n) := by abel |
| _ = _ := by |
| rw [hab] |
| simp only [add_assoc, CharTwo.add_self_eq_zero, zero_add] |
|
|
| /-- A wire's internal scalars cancel; the converse uses explicit prefixSum sums. -/ |
| theorem chain_lifting {n : ℕ} (left right first last : Bit) (middle : Fin n → Bit) : |
| (∃ h : Fin (n + 1) → Bit, |
| left + h 0 = first ∧ |
| (∀ i, h i.castSucc + h i.succ = middle i) ∧ |
| h (Fin.last n) + right = last) ↔ |
| left + right = first + (∑ i, middle i) + last := by |
| constructor |
| · rintro ⟨h, hfirst, hmiddle, hlast⟩ |
| rw [← hfirst, ← hlast, ← funext hmiddle, sum_adjacent] |
| symm |
| calc |
| _ = left + right + (h 0 + h 0) + (h (Fin.last n) + h (Fin.last n)) := by abel |
| _ = _ := by simp only [CharTwo.add_self_eq_zero, add_zero] |
| · intro he |
| refine ⟨fun j => left + first + prefixSum middle j, ?_, ?_, ?_⟩ |
| · simp only [prefix_zero, add_zero] |
| rw [← add_assoc, CharTwo.add_self_eq_zero, zero_add] |
| · intro i |
| dsimp only |
| rw [prefix_succ] |
| calc |
| _ = ((left + first + prefixSum middle i.castSucc) + |
| (left + first + prefixSum middle i.castSucc)) + middle i := by abel |
| _ = middle i := by rw [CharTwo.add_self_eq_zero, zero_add] |
| · dsimp only |
| rw [prefix_last] |
| calc |
| _ = (left + right) + first + (∑ i, middle i) := by abel |
| _ = last := by |
| rw [he] |
| calc |
| _ = (first + first) + ((∑ i, middle i) + (∑ i, middle i)) + last := by abel |
| _ = last := by simp only [CharTwo.add_self_eq_zero, zero_add] |
|
|
| end WireAlgebra |
|
|
| namespace WireAlgebra |
|
|
| theorem prefix_equations {n : ℕ} (left right first last : Bit) (middle : Fin n → Bit) |
| (he : left + right = first + (∑ i, middle i) + last) : |
| let h := fun j => left + first + prefixSum middle j |
| (left + h 0 = first) ∧ (∀ i, h i.castSucc + h i.succ = middle i) ∧ |
| (h (Fin.last n) + right = last) := by |
| dsimp only |
| constructor |
| · simp only [prefix_zero, add_zero] |
| rw [← add_assoc, CharTwo.add_self_eq_zero, zero_add] |
| constructor |
| · intro i |
| rw [prefix_succ] |
| calc |
| _ = ((left + first + prefixSum middle i.castSucc) + |
| (left + first + prefixSum middle i.castSucc)) + middle i := by abel |
| _ = middle i := by rw [CharTwo.add_self_eq_zero, zero_add] |
| · rw [prefix_last] |
| calc |
| _ = (left + right) + first + (∑ i, middle i) := by abel |
| _ = last := by |
| rw [he] |
| calc |
| _ = (first + first) + ((∑ i, middle i) + (∑ i, middle i)) + last := by abel |
| _ = last := by simp only [CharTwo.add_self_eq_zero, zero_add] |
|
|
| end WireAlgebra |
|
|
| namespace ComparisonSchemas |
| variable {r : ℕ} {P E : Type} (S : ComparisonSchemas r P E) |
|
|
| abbrev Address (_S : ComparisonSchemas r P E) := |
| Fin r → {a : Bool // a ∈ (Finset.univ : Finset Bool)} |
| abbrev DomainAddress (e : E) := (i : Fin r) → {a // a ∈ S.domain e i} |
|
|
| def sourceAddress (e : E) (a : S.DomainAddress e) : S.Address := |
| fun i => ⟨(a i).val, Finset.mem_univ _⟩ |
| def targetAddress (e : E) (a : S.DomainAddress e) : S.Address := |
| fun i => ⟨S.mapping e i (a i), Finset.mem_univ _⟩ |
|
|
| def firstShift (n : ℕ) (beta : (S.layout n).Block → Bit) (e : E) |
| (a : S.DomainAddress e) : Bit := (S.layout n).linkShift beta (.inl e) a |
|
|
| def middleShift (n : ℕ) (beta : (S.layout n).Block → Bit) (e : E) (j : Fin n) |
| (a : S.DomainAddress e) : Bit := (S.layout n).linkShift beta (.inr (.inl (e, j))) a |
|
|
| def lastShift (n : ℕ) (beta : (S.layout n).Block → Bit) (e : E) |
| (a : S.DomainAddress e) : Bit := (S.layout n).linkShift beta (.inr (.inr e)) a |
|
|
| def wireShift (n : ℕ) (beta : (S.layout n).Block → Bit) (e : E) |
| (a : S.DomainAddress e) : Bit := |
| S.firstShift n beta e a + (∑ j, S.middleShift n beta e j a) + S.lastShift n beta e a |
|
|
| theorem wireShift_rowSum (n : ℕ) (beta : (S.layout n).Block → Bit) (e : E) : |
| CycleRows.RowSum (fun i => {a // a ∈ S.domain e i}) Bit (S.wireShift n beta e) := by |
| exact ((S.layout n).linkShift_rowSum beta (.inl e)).add |
| (CycleRows.RowSum.sum Finset.univ (S.middleShift n beta e) |
| (fun j _ => (S.layout n).linkShift_rowSum beta (.inr (.inl (e, j))))) |>.add |
| ((S.layout n).linkShift_rowSum beta (.inr (.inr e))) |
|
|
| variable [Fintype P] [Fintype E] |
|
|
| theorem offsets_iff_real_rowSums (hr : 3 ≤ r) (n : ℕ) |
| (beta : (S.layout n).Block → Bit) : |
| (∃ z, ((S.layout n).affine (by omega)).Solves beta z) ↔ |
| ∃ h : (p : P) → S.Address → Fin (S.dimension p) → Bit, |
| (∀ p, CycleRows.RowSum (fun _ : Fin r => {a : Bool // a ∈ (Finset.univ : Finset Bool)}) |
| (Fin (S.dimension p) → Bit) (h p)) ∧ |
| ∀ e (a : S.DomainAddress e), |
| S.left e (h (S.source e) (S.sourceAddress e a)) + |
| S.right e (h (S.target e) (S.targetAddress e a)) = S.wireShift n beta e a := by |
| rw [(S.layout n).offsets_iff_rowSums hr beta] |
| constructor |
| · rintro ⟨h, hs, he⟩ |
| refine ⟨fun p => h (.inl p), fun p => hs (.inl p), ?_⟩ |
| intro e a |
| apply (WireAlgebra.chain_lifting _ _ _ _ _).mp |
| refine ⟨fun j => h (.inr (e, j)) a (0 : Fin 1), ?_, ?_, ?_⟩ |
| · exact he (.inl e) a |
| · intro j |
| exact he (.inr (.inl (e, j))) a |
| · exact he (.inr (.inr e)) a |
| · rintro ⟨h, hs, he⟩ |
| let g (e : E) (j : Fin (n + 1)) (a : S.DomainAddress e) : Bit := |
| S.left e (h (S.source e) (S.sourceAddress e a)) + S.firstShift n beta e a + |
| WireAlgebra.prefixSum (fun i => S.middleShift n beta e i a) j |
| let q : (t : S.InternalType n) → (S.layout n).Address t → |
| Fin ((S.layout n).dimension t) → Bit := fun t => match t with |
| | .inl p => h p |
| | .inr (e, j) => fun a _ => g e j a |
| have hg (e : E) (a : S.DomainAddress e) : |
| (S.left e (h (S.source e) (S.sourceAddress e a)) + g e 0 a = S.firstShift n beta e a) ∧ |
| (∀ j, g e j.castSucc a + g e j.succ a = S.middleShift n beta e j a) ∧ |
| (g e (Fin.last n) a + S.right e (h (S.target e) (S.targetAddress e a)) = S.lastShift n beta e a) := |
| WireAlgebra.prefix_equations _ _ _ _ _ (he e a) |
| refine ⟨q, ?_, ?_⟩ |
| · intro t |
| cases t with |
| | inl p => exact hs p |
| | inr p => |
| apply CycleRows.RowSum.pi |
| intro j |
| have hf := ((hs (S.source p.1)).map (S.left p.1).toAddMonoidHom).pullback |
| (fun i (a : {a // a ∈ S.domain p.1 i}) => (⟨a.val, Finset.mem_univ _⟩ : {b : Bool // b ∈ (Finset.univ : Finset Bool)})) |
| have hb := (S.layout n).linkShift_rowSum beta (.inl p.1) |
| have hc : CycleRows.RowSum (fun i => {a // a ∈ S.domain p.1 i}) Bit |
| (fun a => WireAlgebra.prefixSum (fun i => S.middleShift n beta p.1 i a) p.2) := by |
| apply CycleRows.RowSum.sum |
| intro i _ |
| by_cases hi : i.val < p.2.val |
| · simpa only [hi, ite_true, middleShift, RingLayout.Match, layout, wire] using |
| (S.layout n).linkShift_rowSum beta (.inr (.inl (p.1, i))) |
| · simpa only [hi, ite_false] using |
| (CycleRows.RowSum.zero (A := fun i => {a // a ∈ S.domain p.1 i}) (V := Bit)) |
| exact (hf.add hb).add hc |
| · intro l a |
| cases l with |
| | inl e => exact (hg e a).1 |
| | inr l => cases l with |
| | inl p => exact (hg p.1 a).2.1 p.2 |
| | inr e => exact (hg e a).2.2 |
|
|
| end ComparisonSchemas |
|
|
| end WLIdentification |
|
|
| end OAI |
|
|
