| import OAI.Computability.WLIdentification.BinaryAddresses |
|
|
| namespace OAI |
|
|
| namespace WLIdentification |
|
|
| namespace BinaryAddress |
|
|
| def carryMap {d : ℕ} (h : Fin d) : ProductMap d where |
| domain i := if i < h then {true} else if i = h then {false} else Finset.univ |
| nonempty i := by split <;> first | exact Finset.singleton_nonempty _ | split <;> simp |
| mapping i b := if i ≤ h then !b else b |
| injective i _ _ _ _ he := by |
| by_cases hi : i ≤ h |
| · simpa only [hi, ite_true, Bool.not_not] using congrArg (fun b => !b) he |
| · simpa only [hi, ite_false] using he |
|
|
| @[simp] theorem carryMap_rel {d : ℕ} (h : Fin d) (x y : Bits d) : |
| (carryMap h).Rel x y ↔ Carry h true x ∧ y = flipPrefix h x := by |
| change ((∀ i, x i ∈ if i < h then {true} else if i = h then {false} else Finset.univ) ∧ |
| (∀ i, (if i ≤ h then !(x i) else x i) = y i)) ↔ _ |
| have he : (∀ i, (if i ≤ h then !(x i) else x i) = y i) ↔ y = flipPrefix h x := by |
| rw [← funext_iff, eq_comm]; rfl |
| rw [he] |
| apply and_congr_left |
| intro _ |
| constructor |
| · intro hv |
| refine ⟨fun i hi => ?_, ?_⟩ |
| · simpa only [hi, ite_true, Finset.mem_singleton] using hv i |
| · simpa using hv h |
| · rintro ⟨hv, hh⟩ i |
| by_cases hi : i < h |
| · simp [hi, hv i hi] |
| · by_cases he : i = h |
| · subst i; simpa using hh |
| · simp [hi, he] |
|
|
| theorem carryMap_sound {d : ℕ} (h : Fin d) {x y : Bits d} |
| (hxy : (carryMap h).Rel x y) : value y = value x + 1 := by |
| obtain ⟨hx, rfl⟩ := (carryMap_rel _ _ _).mp hxy |
| rw [← advance_carry h x hx] |
| exact value_advance x (carry_not_last hx) |
|
|
| theorem carryMap_complete {d : ℕ} (x y : Bits d) (hxy : value y = value x + 1) : |
| ∃ h : Fin d, (carryMap h).Rel x y := by |
| have hn : x ≠ fun _ => true := by |
| intro he |
| have h := value_lt y |
| rw [hxy, he, value_one] at h |
| omega |
| obtain ⟨h, hh⟩ := carry_exists x hn |
| refine ⟨h, (carryMap_rel _ _ _).mpr ⟨hh, ?_⟩⟩ |
| apply value_injective d |
| rw [← advance_carry h x hh, value_advance x (carry_not_last hh), hxy] |
|
|
| /-- An additional all-ones case supplies the cyclic seam for positions only. -/ |
| def cycleMap (d : ℕ) : Option (Fin d) → ProductMap d |
| | none => ProductMap.singleton (fun _ => true) (fun _ => false) |
| | some h => carryMap h |
|
|
| theorem cycleMap_sound {d : ℕ} (h : Option (Fin d)) {x y : Bits d} |
| (hxy : (cycleMap d h).Rel x y) : y = advance x := by |
| cases h with |
| | none => |
| obtain ⟨rfl, rfl⟩ := (ProductMap.singleton_rel _ _ _ _).mp hxy |
| exact (advance_one d).symm |
| | some h => |
| obtain ⟨hh, rfl⟩ := (carryMap_rel _ _ _).mp hxy |
| exact (advance_carry h x hh).symm |
|
|
| theorem cycleMap_complete {d : ℕ} (x : Bits d) : |
| ∃ h, (cycleMap d h).Rel x (advance x) := by |
| by_cases he : x = fun _ => true |
| · exact ⟨none, (ProductMap.singleton_rel _ _ _ _).mpr ⟨he, he ▸ advance_one d⟩⟩ |
| · obtain ⟨h, hh⟩ := carry_exists x he |
| exact ⟨some h, (carryMap_rel _ _ _).mpr ⟨hh, advance_carry h x hh⟩⟩ |
|
|
| noncomputable def rotation (d : ℕ) : Bits d ≃ Bits d := |
| (equiv d).trans ((finRotate (2 ^ d)).trans (equiv d).symm) |
|
|
| theorem rotation_advance {d : ℕ} (x : Bits d) : rotation d x = advance x := by |
| apply value_injective d |
| have h : value (rotation d x) = ((value x + 1) % (2 ^ d)) := by |
| change ((equiv d) (rotation d x)).val = _ |
| simp only [rotation, Equiv.trans_apply, Equiv.apply_symm_apply] |
| rw [finRotate_apply] |
| simp only [Fin.val_add, Fin.val_one', Nat.add_mod_mod] |
| rfl |
| exact h.trans (advance_mod x).symm |
|
|
| end BinaryAddress |
|
|
| namespace BinaryAddress |
|
|
| /-- The largest differing bit determines strict numeric order. -/ |
| theorem value_lt_iff {d : ℕ} (x y : Bits d) : value x < value y ↔ |
| ∃ h : Fin d, x h = false ∧ y h = true ∧ ∀ i, h < i → x i = y i := by |
| induction d with |
| | zero => simp [value] |
| | succ d ih => |
| let xt : Bits d := fun i => x i.succ |
| let yt : Bits d := fun i => y i.succ |
| constructor |
| · intro h |
| by_cases ht : value xt < value yt |
| · obtain ⟨i, hi, hj, hh⟩ := (ih xt yt).mp ht |
| refine ⟨i.succ, hi, hj, ?_⟩ |
| intro j hji |
| cases j using Fin.cases with |
| | zero => exact (Fin.not_lt_zero _ hji).elim |
| | succ j => exact hh j (by simpa using hji) |
| · have he : value xt = value yt := by |
| change (if x 0 then 1 else 0) + 2 * value xt < (if y 0 then 1 else 0) + 2 * value yt at h |
| split_ifs at h <;> omega |
| have hev := value_injective d he |
| refine ⟨0, ?_, ?_, ?_⟩ |
| · change (if x 0 then 1 else 0) + 2 * value xt < (if y 0 then 1 else 0) + 2 * value yt at h |
| cases hx0 : x 0 <;> cases hy0 : y 0 <;> simp_all |
| · change (if x 0 then 1 else 0) + 2 * value xt < (if y 0 then 1 else 0) + 2 * value yt at h |
| cases hx0 : x 0 <;> cases hy0 : y 0 <;> simp_all |
| · intro i hi |
| cases i using Fin.cases with |
| | zero => exact (lt_irrefl _ hi).elim |
| | succ i => exact congrFun hev i |
| · rintro ⟨h, hx, hy, hhigh⟩ |
| cases h using Fin.cases with |
| | zero => |
| have hev : xt = yt := by |
| funext i |
| exact hhigh i.succ (by simp) |
| change (if x 0 then 1 else 0) + 2 * value xt < (if y 0 then 1 else 0) + 2 * value yt |
| rw [hx, hy, hev] |
| simp |
| | succ h => |
| have ht : value xt < value yt := (ih xt yt).mpr |
| ⟨h, hx, hy, fun i hi => hhigh i.succ (by simpa using hi)⟩ |
| change (if x 0 then 1 else 0) + 2 * value xt < (if y 0 then 1 else 0) + 2 * value yt |
| split_ifs <;> omega |
|
|
| /-- A threshold request fixes its high prefix and first strictly-larger bit. -/ |
| def aboveMap {d : ℕ} (x : Bits d) (h : Fin d) : ProductMap d where |
| domain i := if h < i then {x i} else if i = h then {true} else Finset.univ |
| nonempty i := by split <;> first | exact Finset.singleton_nonempty _ | split <;> simp |
| mapping _ b := b |
| injective _ _ _ _ _ he := he |
|
|
| @[simp] theorem aboveMap_rel {d : ℕ} (x : Bits d) (h : Fin d) (y z : Bits d) : |
| (aboveMap x h).Rel y z ↔ y = z ∧ y h = true ∧ ∀ i, h < i → y i = x i := by |
| change ((∀ i, y i ∈ if h < i then {x i} else if i = h then {true} else Finset.univ) ∧ |
| ∀ i, y i = z i) ↔ _ |
| rw [← funext_iff] |
| constructor |
| · rintro ⟨hy, rfl⟩ |
| exact ⟨rfl, by simpa using hy h, fun i hi => by simpa [hi] using hy i⟩ |
| · rintro ⟨rfl, hh, hhi⟩ |
| refine ⟨fun i => ?_, rfl⟩ |
| by_cases hi : h < i |
| · simp [hi, hhi i hi] |
| · by_cases he : i = h |
| · subst i; simp [hh] |
| · simp [hi, he] |
|
|
| abbrev ThresholdCase {d : ℕ} (x : Bits d) := Option {h : Fin d // x h = false} |
|
|
| def thresholdMap {d : ℕ} (x : Bits d) : ThresholdCase x → ProductMap d |
| | none => ProductMap.singleton x x |
| | some h => aboveMap x h.val |
|
|
| theorem threshold_sound {d : ℕ} (x : Bits d) (h : ThresholdCase x) {y z : Bits d} |
| (hy : (thresholdMap x h).Rel y z) : value x ≤ value y ∧ y = z := by |
| cases h with |
| | none => |
| obtain ⟨rfl, rfl⟩ := (ProductMap.singleton_rel _ _ _ _).mp hy |
| exact ⟨le_rfl, rfl⟩ |
| | some h => |
| obtain ⟨he, hh, hhi⟩ := (aboveMap_rel _ _ _ _).mp hy |
| exact ⟨le_of_lt ((value_lt_iff x y).mpr |
| ⟨h.val, h.property, hh, fun i hi => (hhi i hi).symm⟩), he⟩ |
|
|
| theorem threshold_complete {d : ℕ} (x y : Bits d) (hxy : value x ≤ value y) : |
| ∃ h : ThresholdCase x, (thresholdMap x h).Rel y y := by |
| rcases lt_or_eq_of_le hxy with hlt | he |
| · obtain ⟨h, hx, hy, hhi⟩ := (value_lt_iff x y).mp hlt |
| exact ⟨some ⟨h, hx⟩, (aboveMap_rel _ _ _ _).mpr ⟨rfl, hy, fun i hi => (hhi i hi).symm⟩⟩ |
| · have he' := value_injective d he |
| exact ⟨none, (ProductMap.singleton_rel _ _ _ _).mpr ⟨he'.symm, he'.symm⟩⟩ |
|
|
| end BinaryAddress |
|
|
| namespace ProductCircuit |
| variable {r : ℕ} {P E Z T : Type} (C : ProductCircuit r P E Z T) |
|
|
| theorem edge_rel (e : E) {x y : Fin r → Bool} (h : (C.edgeMap e).Rel x y) |
| (hx : C.True (C.source e) x) : C.PortTrue (C.target e) y (C.port e) := by |
| obtain ⟨a, rfl, rfl⟩ := (ProductMap.rel_iff _ _ _).mp h |
| exact PortTrue.edge e a hx |
|
|
| theorem seed_rel (z : Z) {x y : Fin r → Bool} (h : (C.seedMap z).Rel x y) : |
| C.True (C.seedType z) x := by |
| obtain ⟨a, rfl, rfl⟩ := (ProductMap.rel_iff _ _ _).mp h |
| exact fun j => PortTrue.seed z a j |
|
|
| end ProductCircuit |
|
|
| end WLIdentification |
|
|
| end OAI |
|
|
