File size: 4,930 Bytes
4a56cd6
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
import OAI.Computability.PerfectCompleteness.Construction.FactoredFunctionsLemmas
import OAI.Computability.PerfectCompleteness.Sampling.UniformChildSum

namespace OAI


namespace PerfectCompleteness.LocalReconstruction

open scoped BigOperators
open PointwiseSpaces RecursiveSpaces FactoredFunctions

noncomputable section

variable {π•œ : Type*} [Field π•œ] {branch : Nat β†’ Nat} {n : Nat}

abbrev Retained (A : Slots branch (n + 1) β†’ Type*)
    (clean : Fin (branch n) β†’ Prop) :=
  (j : {j : Fin (branch n) // Β¬ clean j}) β†’ Assignment (childFamily A j.1)

def retain (A : Slots branch (n + 1) β†’ Type*) (clean : Fin (branch n) β†’ Prop) :
    Assignment A β†’ Retained A clean :=
  fun x j => childRestriction A j.1 x

abbrev Summands (A : Slots branch (n + 1) β†’ Type*)
    (clean : Fin (branch n) β†’ Prop) :=
  (j : {j : Fin (branch n) // Β¬ clean j}) β†’
    squareSpace (space π•œ branch n (childFamily A j.1))

def retainedCut (A : Slots branch (n + 1) β†’ Type*)
    (clean : Fin (branch n) β†’ Prop) [DecidablePred clean]
    (u : Summands (π•œ := π•œ) A clean) : Retained A clean β†’ π•œ :=
  fun x => βˆ‘ j, (u j).val (x j)

def cutCall (A : Slots branch (n + 1) β†’ Type*)
    (clean : Fin (branch n) β†’ Prop) [DecidablePred clean]
    (u : Summands (π•œ := π•œ) A clean) : space π•œ branch (n + 1) A :=
  βŸ¨βˆ‘ j, pullback π•œ (childRestriction A j.1) (u j).val, by
    apply (space π•œ branch (n + 1) A).sum_mem
    intro j _
    exact child_square_le_space A j.1 (Submodule.mem_map_of_mem (u j).property)⟩

theorem cutCall_factors (A : Slots branch (n + 1) β†’ Type*)
    (clean : Fin (branch n) β†’ Prop) [DecidablePred clean]
    (u : Summands (π•œ := π•œ) A clean) :
    (cutCall A clean u).val = retainedCut A clean u ∘ retain A clean := by
  funext x
  simp only [cutCall, retainedCut, retain, Function.comp_apply,
    Finset.sum_apply, PointwiseSpaces.pullback_apply]

theorem cutCall_ignores_clean (A : Slots branch (n + 1) β†’ Type*)
    (clean : Fin (branch n) β†’ Prop) [DecidablePred clean]
    (u : Summands (π•œ := π•œ) A clean) :
    (cutCall A clean u).val ∈ factoringSpace (retain A clean) := by
  rw [mem_factoringSpace_iff_exists_factor]
  exact ⟨retainedCut A clean u, fun x => congrFun (cutCall_factors A clean u) x⟩

theorem actual_sum_eq_cutCall (A : Slots branch (n + 1) β†’ Type*)
    (clean : Fin (branch n) β†’ Prop) [DecidablePred clean]
    (u : (j : Fin (branch n)) β†’ squareSpace (space π•œ branch n (childFamily A j)))
    (zero : βˆ€ j, clean j β†’ u j = 0) :
    UniformChildSum.recursiveSum A u = cutCall A clean (fun j => u j.1) := by
  apply Subtype.ext
  change (βˆ‘ j : Fin (branch n), pullback π•œ (childRestriction A j) (u j).val) = _
  rw [← Fintype.sum_subtype_add_sum_subtype clean
    (fun j => pullback π•œ (childRestriction A j) (u j).val)]
  have hz : (βˆ‘ j : {j : Fin (branch n) // clean j},
      pullback π•œ (childRestriction A j.1) (u j.1).val) = 0 := by
    apply Finset.sum_eq_zero
    intro j _
    rw [zero j.1 j.2]
    exact map_zero _
  rw [hz, zero_add]
  rfl

theorem actual_sum_ignores_clean (A : Slots branch (n + 1) β†’ Type*)
    (clean : Fin (branch n) β†’ Prop) [DecidablePred clean]
    (u : (j : Fin (branch n)) β†’ squareSpace (space π•œ branch n (childFamily A j)))
    (zero : βˆ€ j, clean j β†’ u j = 0) :
    (UniformChildSum.recursiveSum A u).val ∈ factoringSpace (retain A clean) := by
  rw [actual_sum_eq_cutCall A clean u zero]
  exact cutCall_ignores_clean A clean _

inductive Recipe (π•œ Atom : Type*) where
  | constant : π•œ β†’ Recipe π•œ Atom
  | atom : Atom β†’ Recipe π•œ Atom
  | add : Recipe π•œ Atom β†’ Recipe π•œ Atom β†’ Recipe π•œ Atom
  | mul : Recipe π•œ Atom β†’ Recipe π•œ Atom β†’ Recipe π•œ Atom

namespace Recipe

variable {Atom X Z : Type*}

def evaluate (atoms : Atom β†’ X β†’ π•œ) : Recipe π•œ Atom β†’ X β†’ π•œ
  | .constant c => fun _ => c
  | .atom a => atoms a
  | .add f g => evaluate atoms f + evaluate atoms g
  | .mul f g => evaluate atoms f * evaluate atoms g

theorem evaluate_factors (other : X β†’ Z) (atoms : Atom β†’ X β†’ π•œ)
    (known : βˆ€ a, atoms a ∈ factoringSpace other) (r : Recipe π•œ Atom) :
    r.evaluate atoms ∈ factoringSpace other := by
  induction r with
  | constant c => exact const_mem_factoringSpace other c
  | atom a => exact known a
  | add f g hf hg => exact (factoringSpace other).add_mem hf hg
  | mul f g hf hg => exact mul_mem_factoringSpace other hf hg

theorem evaluate_pullback (other : X β†’ Z) (atoms : Atom β†’ Z β†’ π•œ)
    (r : Recipe π•œ Atom) :
    r.evaluate (fun a => atoms a ∘ other) = r.evaluate atoms ∘ other := by
  induction r with
  | constant c => rfl
  | atom a => rfl
  | add f g hf hg =>
      simp only [evaluate, hf, hg]
      rfl
  | mul f g hf hg =>
      simp only [evaluate, hf, hg]
      rfl

end Recipe

end
end PerfectCompleteness.LocalReconstruction

end OAI