File size: 5,743 Bytes
2f887db
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
128
129
130
131
132
133
import OAI.Computability.PerfectCompleteness.Construction.NodeEmbedding
import OAI.Computability.PerfectCompleteness.Decoding.DecoderSourcePullback

namespace OAI

section

namespace PerfectCompleteness.ProjectedNodeEmbedding

noncomputable section

open RecursiveSpaces TreeSourceSpaces HierarchicalArrays
open ChildBlockProjection (nodeProjection squarePullback)

variable {branch : Nat → Nat} {n t : Nat}
  {slots projected : Slots branch n → Fin t → MixedSupport.Slot}
  (p : ∀ s k, MixedSupport.Projection (slots s k) (projected s k))
  (upper : Nodes branch n)

def nativePullback :
    NodeEmbedding.NodeH projected upper →ₗ[F2] NodeEmbedding.NodeH slots upper :=
  HPullback (nodeProjection p upper)

@[simp] theorem nativePullback_apply
    (f : NodeEmbedding.NodeH projected upper) (x : Domain (nodeSlots slots upper)) :
    (nativePullback p upper f).val x =
      f.val (sourceProjection (nodeProjection p upper) x) := rfl

theorem nativePullback_injective : Function.Injective (nativePullback p upper) :=
  HPullback_injective (nodeProjection p upper)

def intoOriginal :
    NodeEmbedding.NodeH projected upper →ₗ[F2] NodeEmbedding.RowSpace slots upper :=
  (NodeEmbedding.embed slots upper).comp (nativePullback p upper)

theorem intoOriginal_injective : Function.Injective (intoOriginal p upper) :=
  (NodeEmbedding.embed_injective slots upper).comp (nativePullback_injective p upper)

@[simp] theorem intoOriginal_apply
    (f : NodeEmbedding.NodeH projected upper) (x : NodeEmbedding.NumberedDomain slots) :
    (intoOriginal p upper f).val x =
      f.val (sourceProjection (nodeProjection p upper)
        (NodeEmbedding.numberedRestriction slots upper x)) := rfl

theorem numberedRestriction_projection (x : NodeEmbedding.NumberedDomain slots) :
    sourceProjection (nodeProjection p upper) (NodeEmbedding.numberedRestriction slots upper x) =
      NodeEmbedding.numberedRestriction projected upper
        (MixedSupport.projectionMap (TreeCanonical.numberedProjection p) x) := by
  change restrictNode projected upper
    (sourceProjection p ((TreeCanonical.assignmentEquiv slots).symm x)) = _
  exact congrArg (restrictNode projected upper)
    (TreeCanonical.assignmentEquiv_symm_projection p x)

theorem intoOriginal_apply_projected
    (f : NodeEmbedding.NodeH projected upper) (x : NodeEmbedding.NumberedDomain slots) :
    (intoOriginal p upper f).val x =
      (NodeEmbedding.embed projected upper f).val
        (MixedSupport.projectionMap (TreeCanonical.numberedProjection p) x) := by
  exact congrArg f.val (numberedRestriction_projection p upper x)

theorem intoOriginal_val (f : NodeEmbedding.NodeH projected upper) :
    (intoOriginal p upper f).val =
      PointwiseSpaces.pullback F2
        (MixedSupport.projectionMap (TreeCanonical.numberedProjection p))
        (NodeEmbedding.embed projected upper f).val := by
  funext x
  exact intoOriginal_apply_projected p upper f x

theorem intoOriginal_at_assignment
    (f : NodeEmbedding.NodeH projected upper) (x : Domain slots) :
    (intoOriginal p upper f).val (TreeCanonical.assignmentEquiv slots x) =
      f.val (restrictNode projected upper (sourceProjection p x)) := by
  change f.val (sourceProjection (nodeProjection p upper)
    (restrictNode slots upper ((TreeCanonical.assignmentEquiv slots).symm
      (TreeCanonical.assignmentEquiv slots x)))) = _
  rw [Equiv.symm_apply_apply]
  rfl

theorem dualMap_eq_upperTarget
    (q : Module.Dual F2 (NodeEmbedding.RowSpace slots upper)) :
    (intoOriginal p upper).dualMap q = DecoderSourcePullback.upperTarget p upper q := by
  apply LinearMap.ext
  intro f
  rfl

theorem evaluation_dualMap (x : NodeEmbedding.NumberedDomain slots) :
    (intoOriginal p upper).dualMap
        (EvaluationMatrix.evaluation (NodeEmbedding.RowSpace slots upper) x) =
      EvaluationMatrix.evaluation (NodeEmbedding.NodeH projected upper)
        (NodeEmbedding.numberedRestriction projected upper
          (MixedSupport.projectionMap (TreeCanonical.numberedProjection p) x)) := by
  apply LinearMap.ext
  intro f
  exact congrArg f.val (numberedRestriction_projection p upper x)

theorem intoOriginal_mul (f g : NodeEmbedding.NodeH projected upper) :
    (intoOriginal p upper f).val * (intoOriginal p upper g).val =
      PointwiseSpaces.pullback F2
        (sourceProjection (nodeProjection p upper) ∘ NodeEmbedding.numberedRestriction slots upper)
        (f.val * g.val) := rfl

def intoOriginalSquare :
    PointwiseSpaces.squareSpace (NodeEmbedding.NodeH projected upper) →ₗ[F2]
      PointwiseSpaces.squareSpace (NodeEmbedding.RowSpace slots upper) where
  toFun f := ⟨PointwiseSpaces.pullback F2 (NodeEmbedding.numberedRestriction slots upper)
    (squarePullback (nodeProjection p upper) f).val, by
      rw [NodeEmbedding.squareSpace_eq]
      exact Submodule.mem_map_of_mem (squarePullback (nodeProjection p upper) f).property⟩
  map_add' f g := by apply Subtype.ext; rfl
  map_smul' c f := by apply Subtype.ext; rfl

@[simp] theorem intoOriginalSquare_apply
    (f : PointwiseSpaces.squareSpace (NodeEmbedding.NodeH projected upper))
    (x : NodeEmbedding.NumberedDomain slots) :
    (intoOriginalSquare p upper f).val x =
      f.val (sourceProjection (nodeProjection p upper)
        (NodeEmbedding.numberedRestriction slots upper x)) := rfl

theorem intoOriginalSquare_product (f g : NodeEmbedding.NodeH projected upper) :
    intoOriginalSquare p upper
        (OddListExtraction.productElement (NodeEmbedding.NodeH projected upper) f g) =
      OddListExtraction.productElement (NodeEmbedding.RowSpace slots upper)
        (intoOriginal p upper f) (intoOriginal p upper g) := by
  apply Subtype.ext
  rfl

end
end PerfectCompleteness.ProjectedNodeEmbedding

end

end OAI