| import OAI.Computability.WLIdentification.SchemaPresentation |
|
|
| namespace OAI |
|
|
| namespace WLIdentification |
| namespace FinitePresentation |
| open WordExpressions |
| attribute [local instance] Classical.propDecidable Classical.decEq |
|
|
| structure CircuitRealizer {P E Z T : Word → Type} (PP : Presented P) (EP : Presented E) |
| (ZP : Presented Z) (TP : Presented T) (r : Word → ℕ) |
| (rp : NatPoly (fun X : Fin 1 → Word => r (X 0))) |
| (C : ∀ w, ProductCircuit (r w) (P w) (E w) (Z w) (T w)) where |
| pointIndex : Number PP (fun w p => (C w).pointIndex p) |
| edgeIndex : Number EP (fun w e => (C w).edgeIndex e) |
| seedIndex : Number ZP (fun w z => (C w).seedIndex z) |
| testIndex : Number TP (fun w t => (C w).testIndex t) |
| dimension : Number PP (fun w p => (C w).dimension p) |
| source : Map EP PP (fun w => (C w).source) |
| target : Map EP PP (fun w => (C w).target) |
| port : Number EP (fun w e => ((C w).port e).val) |
| seedType : Map ZP PP (fun w => (C w).seedType) |
| testType : Map TP PP (fun w => (C w).testType) |
| edgeDomain : Test (EP.prod ((Presented.fin r rp).prod Presented.bool)) |
| (fun w x => decide (x.2.2∈((C w).edgeMap x.1).domain x.2.1)) |
| seedDomain : Test (ZP.prod ((Presented.fin r rp).prod Presented.bool)) |
| (fun w x => decide (x.2.2∈((C w).seedMap x.1).domain x.2.1)) |
| testDomain : Test (TP.prod ((Presented.fin r rp).prod Presented.bool)) |
| (fun w x => decide (x.2.2∈((C w).testMap x.1).domain x.2.1)) |
| edgeMapping : Map (EP.prod ((Presented.fin r rp).prod Presented.bool)) Presented.bool |
| (fun w x => ((C w).edgeMap x.1).mapping x.2.1 x.2.2) |
|
|
| namespace CircuitRealizer |
| variable {P E Z T : Word → Type} {PP : Presented P} {EP : Presented E} |
| {ZP : Presented Z} {TP : Presented T} {r : Word → ℕ} |
| {rp : NatPoly (fun X : Fin 1 → Word => r (X 0))} |
| {C : ∀ w, ProductCircuit (r w) (P w) (E w) (Z w) (T w)} |
| (F : CircuitRealizer PP EP ZP TP r rp C) |
|
|
| abbrev rowP (_F : CircuitRealizer PP EP ZP TP r rp C) := Presented.fin r rp |
| abbrev primaryP (_F : CircuitRealizer PP EP ZP TP r rp C) := PP.option |
| noncomputable def primaryDim : Number F.primaryP (fun w p => (C w).primaryDimension p) := |
| (F.dimension.optionCases (fun _ => 1) (NatPoly.const 1)).congr (by intro w p; cases p <;> rfl) |
| abbrev broadcastP := PP.finSigma F.dimension |
| noncomputable abbrev selfP := F.primaryP.finSigma F.primaryDim |
| noncomputable abbrev connectionBase := EP.sum (TP.sum (F.rowP.sum (F.broadcastP.sum (F.selfP.sum Presented.unit)))) |
|
|
| def connectionEquiv (w : Word) : (C w).Connection ≃ (E w ⊕ (T w ⊕ (Fin (r w) ⊕ |
| ((Σ p : P w,Fin ((C w).dimension p)) ⊕ ((Σ p : (C w).Primary,Fin ((C w).primaryDimension p)) ⊕ Unit))))) where |
| toFun |
| | .original e => .inl e |
| | .test t => .inr (.inl t) |
| | .flip i => .inr (.inr (.inl i)) |
| | .broadcast p j => .inr (.inr (.inr (.inl ⟨p,j⟩))) |
| | .self p j => .inr (.inr (.inr (.inr (.inl ⟨p,j⟩)))) |
| | .conflict => .inr (.inr (.inr (.inr (.inr ())))) |
| invFun |
| | .inl e => .original e |
| | .inr (.inl t) => .test t |
| | .inr (.inr (.inl i)) => .flip i |
| | .inr (.inr (.inr (.inl p))) => .broadcast p.1 p.2 |
| | .inr (.inr (.inr (.inr (.inl p)))) => .self p.1 p.2 |
| | .inr (.inr (.inr (.inr (.inr _)))) => .conflict |
| left_inv x := by cases x <;> rfl |
| right_inv x := by rcases x with e|t|i|p|p|u <;> rfl |
|
|
| noncomputable def connectionP : Presented (fun w => (C w).Connection) := F.connectionBase.retype (connectionEquiv (C := C)) |
|
|
| noncomputable def casesNumber {f : ∀ w,(C w).Connection → ℕ} |
| (o : Number EP (fun w e => f w (.original e))) |
| (t : Number TP (fun w t => f w (.test t))) |
| (i : Number F.rowP (fun w i => f w (.flip i))) |
| (b : Number F.broadcastP (fun w p => f w (.broadcast p.1 p.2))) |
| (s : Number F.selfP (fun w p => f w (.self p.1 p.2))) |
| (c : Number Presented.unit (fun w _ => f w .conflict)) : Number F.connectionP f := |
| ((Number.sumCases o (Number.sumCases t (Number.sumCases i (Number.sumCases b (Number.sumCases s c))))).retype |
| (connectionEquiv (C := C))).congr (by intro w x; cases x <;> rfl) |
|
|
| noncomputable def casesNumberFst {A : Word → Type} (AP : Presented A) {f : ∀ w,(C w).Connection × A w → ℕ} |
| (o : Number (EP.prod AP) (fun w x => f w (.original x.1,x.2))) |
| (t : Number (TP.prod AP) (fun w x => f w (.test x.1,x.2))) |
| (i : Number (F.rowP.prod AP) (fun w x => f w (.flip x.1,x.2))) |
| (b : Number (F.broadcastP.prod AP) (fun w x => f w (.broadcast x.1.1 x.1.2,x.2))) |
| (s : Number (F.selfP.prod AP) (fun w x => f w (.self x.1.1 x.1.2,x.2))) |
| (c : Number (Presented.unit.prod AP) (fun w x => f w (.conflict,x.2))) : Number (F.connectionP.prod AP) f := |
| ((Number.sumFst o (Number.sumFst t (Number.sumFst i (Number.sumFst b (Number.sumFst s c))))).retypeFst |
| (connectionEquiv (C := C))).congr (by intro w x; rcases x with ⟨x,y⟩; cases x <;> rfl) |
|
|
| noncomputable def casesTestFst {A : Word → Type} (AP : Presented A) {f : ∀ w,(C w).Connection × A w → Bool} |
| (o : Test (EP.prod AP) (fun w x => f w (.original x.1,x.2))) |
| (t : Test (TP.prod AP) (fun w x => f w (.test x.1,x.2))) |
| (i : Test (F.rowP.prod AP) (fun w x => f w (.flip x.1,x.2))) |
| (b : Test (F.broadcastP.prod AP) (fun w x => f w (.broadcast x.1.1 x.1.2,x.2))) |
| (s : Test (F.selfP.prod AP) (fun w x => f w (.self x.1.1 x.1.2,x.2))) |
| (c : Test (Presented.unit.prod AP) (fun w x => f w (.conflict,x.2))) : Test (F.connectionP.prod AP) f := |
| ((Test.sumFst o (Test.sumFst t (Test.sumFst i (Test.sumFst b (Test.sumFst s c))))).retypeFst |
| (connectionEquiv (C := C))).congr (by intro w x; rcases x with ⟨x,y⟩; cases x <;> rfl) |
|
|
| noncomputable def connectionSource : Map F.connectionP F.primaryP (fun w => (C w).connectionSource) := by |
| apply F.casesNumber |
| · exact (Map.some PP).comp F.source |
| · exact (Map.some PP).comp F.testType |
| · exact Map.none _ _ |
| · exact Map.none _ _ |
| · exact Map.sigmaFst _ _ |
| · exact Map.none _ _ |
| noncomputable def connectionTarget : Map F.connectionP F.primaryP (fun w => (C w).connectionTarget) := by |
| apply F.casesNumber |
| · exact (Map.some PP).comp F.target |
| · exact Map.none _ _ |
| · exact Map.none _ _ |
| · exact (Map.some PP).comp (Map.sigmaFst _ _) |
| · exact Map.sigmaFst _ _ |
| · exact Map.none _ _ |
|
|
| noncomputable abbrev realBase := F.primaryP.sum (F.connectionP.sum Presented.unit) |
| def realEquiv (w : Word) : (C w).RealType ≃ ((C w).Primary ⊕ ((C w).Connection ⊕ Unit)) where |
| toFun | .primary p => .inl p | .buffer l => .inr (.inl l) | .dummy => .inr (.inr ()) |
| invFun | .inl p => .primary p | .inr (.inl l) => .buffer l | .inr (.inr _) => .dummy |
| left_inv x := by cases x <;> rfl |
| right_inv x := by rcases x with p|l|u <;> rfl |
| noncomputable def realP : Presented (fun w => (C w).RealType) := F.realBase.retype (realEquiv (C := C)) |
|
|
| noncomputable abbrev comparisonBase := ZP.sum (F.connectionP.sum (F.connectionP.sum F.connectionP)) |
| def comparisonEquiv (w : Word) : (C w).Comparison ≃ (Z w ⊕ ((C w).Connection ⊕ ((C w).Connection ⊕ (C w).Connection))) where |
| toFun | .seed z => .inl z | .first l => .inr (.inl l) | .second l => .inr (.inr (.inl l)) | .third l => .inr (.inr (.inr l)) |
| invFun | .inl z => .seed z | .inr (.inl l) => .first l | .inr (.inr (.inl l)) => .second l | .inr (.inr (.inr l)) => .third l |
| left_inv x := by cases x <;> rfl |
| right_inv x := by rcases x with z|l|l|l <;> rfl |
| noncomputable def comparisonP : Presented (fun w => (C w).Comparison) := F.comparisonBase.retype (comparisonEquiv (C := C)) |
|
|
| noncomputable def comparisonCases {f : ∀ w,(C w).Comparison → ℕ} |
| (z : Number ZP (fun w z => f w (.seed z))) |
| (a : Number F.connectionP (fun w l => f w (.first l))) |
| (b : Number F.connectionP (fun w l => f w (.second l))) |
| (c : Number F.connectionP (fun w l => f w (.third l))) : Number F.comparisonP f := |
| ((Number.sumCases z (Number.sumCases a (Number.sumCases b c))).retype (comparisonEquiv (C := C))).congr |
| (by intro w x; cases x <;> rfl) |
|
|
| noncomputable def comparisonNumberFst {A : Word → Type} (AP : Presented A) {f : ∀ w,(C w).Comparison × A w → ℕ} |
| (z : Number (ZP.prod AP) (fun w x => f w (.seed x.1,x.2))) |
| (a : Number (F.connectionP.prod AP) (fun w x => f w (.first x.1,x.2))) |
| (b : Number (F.connectionP.prod AP) (fun w x => f w (.second x.1,x.2))) |
| (c : Number (F.connectionP.prod AP) (fun w x => f w (.third x.1,x.2))) : Number (F.comparisonP.prod AP) f := |
| ((Number.sumFst z (Number.sumFst a (Number.sumFst b c))).retypeFst (comparisonEquiv (C := C))).congr |
| (by intro w x; rcases x with ⟨x,y⟩; cases x <;> rfl) |
| noncomputable def comparisonTestFst {A : Word → Type} (AP : Presented A) {f : ∀ w,(C w).Comparison × A w → Bool} |
| (z : Test (ZP.prod AP) (fun w x => f w (.seed x.1,x.2))) |
| (a : Test (F.connectionP.prod AP) (fun w x => f w (.first x.1,x.2))) |
| (b : Test (F.connectionP.prod AP) (fun w x => f w (.second x.1,x.2))) |
| (c : Test (F.connectionP.prod AP) (fun w x => f w (.third x.1,x.2))) : Test (F.comparisonP.prod AP) f := |
| ((Test.sumFst z (Test.sumFst a (Test.sumFst b c))).retypeFst (comparisonEquiv (C := C))).congr |
| (by intro w x; rcases x with ⟨x,y⟩; cases x <;> rfl) |
|
|
| end CircuitRealizer |
| end FinitePresentation |
| end WLIdentification |
|
|
| end OAI |
|
|
