| import OAI.Computability.WLIdentification.CarryPresentation |
|
|
| namespace OAI |
|
|
| namespace WLIdentification |
| namespace FinitePresentation |
| open WordExpressions |
| attribute [local instance] Classical.propDecidable Classical.decEq |
| namespace CellularRealizer |
| open CellularCircuit |
| variable (A : Type) [Fintype A] (d : Word → ℕ) (dp : NatPoly (fun X : Fin 1 → Word => d (X 0))) |
| noncomputable abbrev pointP := Presented.fixed (Gate A) |
| noncomputable abbrev tripleP := Presented.fixed (A × A × A) |
| abbrev digitP := Presented.fin d dp |
| abbrev kindP := ((digitP d dp).prod (digitP d dp).option).sum ((digitP d dp).sum |
| (((digitP d dp).prod (digitP d dp).option).sum (Presented.unit.sum Presented.unit))) |
| noncomputable abbrev edgeBase := (kindP d dp).prod (tripleP A) |
| def edgeEquiv (w : Word) : Connection (d w) A ≃ |
| (((Fin (d w) × Option (Fin (d w))) ⊕ (Fin (d w) ⊕ ((Fin (d w) × Option (Fin (d w))) ⊕ (Unit ⊕ Unit)))) × (A × A × A)) := |
| Connection.equiv.trans (Equiv.prodComm _ _) |
| noncomputable def edgeP : Presented (fun w => Connection (d w) A) := (edgeBase A d dp).retype (edgeEquiv A d) |
|
|
| noncomputable def casesNumber {f : ∀ w,Connection (d w) A → ℕ} |
| (l : Number (((digitP d dp).prod (digitP d dp).option).prod (tripleP A)) |
| (fun w x => f w (.left x.2.1 x.2.2.1 x.2.2.2 x.1.1 x.1.2))) |
| (c : Number ((digitP d dp).prod (tripleP A)) |
| (fun w x => f w (.center x.2.1 x.2.2.1 x.2.2.2 x.1))) |
| (r : Number (((digitP d dp).prod (digitP d dp).option).prod (tripleP A)) |
| (fun w x => f w (.right x.2.1 x.2.2.1 x.2.2.2 x.1.1 x.1.2))) |
| (j : Number (Presented.unit.prod (tripleP A)) |
| (fun w x => f w (.join x.2.1 x.2.2.1 x.2.2.2))) |
| (o : Number (Presented.unit.prod (tripleP A)) |
| (fun w x => f w (.output x.2.1 x.2.2.1 x.2.2.2))) : Number (edgeP A d dp) f := |
| ((Number.sumFst l (Number.sumFst c (Number.sumFst r (Number.sumFst j o)))).retype (edgeEquiv A d)).congr |
| (by intro w x; cases x <;> rfl) |
|
|
| noncomputable def pointIndex : Number (pointP A) (fun _ p => gateIndex p) := Number.fixed _ gateIndex |
| noncomputable def dimension : Number (pointP A) (fun _ p => dimension p) := Number.fixed (Gate A) CellularCircuit.dimension |
|
|
| noncomputable def edgeIndex : Number (edgeP A d dp) (fun _ e => connectionIndex e) := |
| ((Number.pair ((Number.fixed (A × A × A) (fun a => Nat.pair (NaturalCode.fixed A a.1) |
| (Nat.pair (NaturalCode.fixed A a.2.1) (NaturalCode.fixed A a.2.2)))).comp (Map.snd _ _)) |
| (Number.code (kindP d dp) |>.comp (Map.fst _ _))).retype (edgeEquiv A d)).congr |
| (by intro w x; cases x <;> rfl) |
|
|
| noncomputable def source : Map (edgeP A d dp) (pointP A) (fun _ => CellularCircuit.source) := by |
| apply casesNumber |
| · exact (Number.fixed _ (fun a : A × A × A => NaturalCode.fixed (Gate A) (.scalar a.1))).comp (Map.snd _ _) |
| · exact (Number.fixed _ (fun a : A × A × A => NaturalCode.fixed (Gate A) (.scalar a.2.1))).comp (Map.snd _ _) |
| · exact (Number.fixed _ (fun a : A × A × A => NaturalCode.fixed (Gate A) (.scalar a.2.2))).comp (Map.snd _ _) |
| · exact (Number.fixed _ (fun a : A × A × A => NaturalCode.fixed (Gate A) (.first a.1 a.2.1 a.2.2))).comp (Map.snd _ _) |
| · exact (Number.fixed _ (fun a : A × A × A => NaturalCode.fixed (Gate A) (.second a.1 a.2.1 a.2.2))).comp (Map.snd _ _) |
|
|
| noncomputable def target (F : A → A → A → A) : Map (edgeP A d dp) (pointP A) (fun _ => CellularCircuit.target F) := by |
| apply casesNumber |
| · exact (Number.fixed _ (fun a : A × A × A => NaturalCode.fixed (Gate A) (.first a.1 a.2.1 a.2.2))).comp (Map.snd _ _) |
| · exact (Number.fixed _ (fun a : A × A × A => NaturalCode.fixed (Gate A) (.first a.1 a.2.1 a.2.2))).comp (Map.snd _ _) |
| · exact (Number.fixed _ (fun a : A × A × A => NaturalCode.fixed (Gate A) (.second a.1 a.2.1 a.2.2))).comp (Map.snd _ _) |
| · exact (Number.fixed _ (fun a : A × A × A => NaturalCode.fixed (Gate A) (.second a.1 a.2.1 a.2.2))).comp (Map.snd _ _) |
| · exact (Number.fixed _ (fun a : A × A × A => NaturalCode.fixed (Gate A) (.scalar (F a.1 a.2.1 a.2.2)))).comp (Map.snd _ _) |
|
|
| noncomputable def port (F : A → A → A → A) : Number (edgeP A d dp) (fun _ e => (CellularCircuit.port F e).val) := by |
| apply casesNumber |
| · exact Number.const _ 0 |
| · exact Number.const _ 1 |
| · exact Number.const _ 1 |
| · exact Number.const _ 0 |
| · exact Number.const _ 0 |
|
|
| noncomputable def edgeMap : ProductRealizer (edgeP A d dp) (fun w => d w+d w) (NatPoly.add dp dp) |
| (fun _ => CellularCircuit.edgeMap) := by |
| let C := ProductRealizer.carry d dp |
| let R := ProductRealizer.cycle d dp |
| let I := ProductRealizer.identity (digitP d dp) d dp |
| let L := (C.comp (Map.fst _ _)).concat (R.comp (Map.snd _ _)) |
| let H := C.concat I |
| let B := (C.comp (Map.fst _ _)).concat (R.inverse.comp (Map.snd _ _)) |
| let J := ProductRealizer.identity Presented.unit (fun w => d w+d w) (NatPoly.add dp dp) |
| exact (((L.sumCases (H.sumCases (B.sumCases (J.sumCases J)))).comp (Map.fst _ _)).comp |
| (Map.retype (edgeBase A d dp) (edgeEquiv A d))).congr (by intro w x; cases x <;> rfl) |
|
|
| end CellularRealizer |
| end FinitePresentation |
| end WLIdentification |
|
|
| end OAI |
|
|
