| import OAI.Computability.SpaceSimulation.Register.Arithmetic |
|
|
| namespace OAI |
|
|
| /-! Finite-case reasoning in the indexed complexity calculus. -/ |
| namespace Fifths |
| namespace Comp |
| variable {X I Y : Type} {x : I → List X} {S a b : I → ℕ} |
|
|
| theorem divideCases [Fintype Y] (code : Y → ℕ) (inj : Function.Injective code) |
| {w : I → Y} (r : Comp x S a (fun i => code (w i))) |
| (h : ∀ y, Comp (fun i : {i // w i = y} => x i) (fun i => S i) (fun i => a i) |
| (fun i => b i)) : Comp x S a b := by |
| classical |
| suffices g : ∀ l : Finset Y, |
| Comp (fun i : {i // w i ∈ l} => x i) (fun i => S i) (fun i => a i) (fun i => b i) from |
| (g Finset.univ).pull (fun i => ⟨i,Finset.mem_univ (w i)⟩) |
| intro l |
| induction l using Finset.induction_on with |
| | empty => |
| let f := fun i : {i // w i ∈ (∅ : Finset Y)} => i.val |
| exact (Comp.constant (r.pull f).source 0).congr (fun i => by have a := i.property; simp at a) |
| | @insert y l m ih => |
| let f := fun i : {i // w i ∈ insert y l} => i.val |
| have p := r.pull f |
| let B (i : {i |
| refine (casesB (B := B) (p.eq (Comp.constant p.source (code y))) ?_ ?_) |
| · exact (h y).pull (fun i : {i // B i = true} => ⟨f i.val,inj (of_decide_eq_true i.property)⟩) |
| · exact ih.pull (fun i : {i // B i = false} => ⟨f i.val,by |
| have g := Finset.mem_insert.mp i.val.property |
| rcases g with g|g |
| · have a := i.property |
| simp [B,f,g] at a |
| · exact g⟩) |
|
|
| theorem chooseCase [Fintype Y] (code : Y → ℕ) (inj : Function.Injective code) {w : I → Y} |
| (p : I → Y → ℕ) (r : Comp x S a (fun i => code (w i))) |
| (h : ∀ y, Comp x S a (fun i => p i y)) : |
| Comp x S a (fun i => p i (w i)) := by |
| refine divideCases code inj r ?_ |
| intro y |
| exact ((h y).pull _).congr (fun i => congrArg (p i) i.property.symm) |
|
|
| end Comp |
| end Fifths |
|
|
| end OAI |
|
|
