openAI-math-dataset / lean /OAI /LinearAlgebra /MatrixMultiplication /Entropy /BaseConditionalReaders.lean
| import OAI.LinearAlgebra.MatrixMultiplication.Tensor.BaseTensorBudgets | |
| import OAI.LinearAlgebra.MatrixMultiplication.Completion.Labels | |
| namespace OAI | |
| /-! Finite entropy, rate estimates and ordered asymptotic limits. -/ | |
| noncomputable section | |
| namespace MatrixMultiplication.BaseConditionalReaders | |
| open MatrixMultiplication.Foundation CompletionLabels CompletionLabels.TopologicalFlatten | |
| open scoped Classical | |
| universe u | |
| variable {X Y Z : Type u} | |
| def ConditionalLeaf (S : FlaggedTensor X Y Z) (c : Color) := | |
| {a : Leaf S // CompletionLabels.leafColor S a = c} | |
| def view (S : FlaggedTensor X Y Z) (c : Color) (k : Color) | |
| (a : ConditionalLeaf S c) : Coordinate X Y Z k := coordinate a.val.val k | |
| theorem conditional_flag (S : FlaggedTensor X Y Z) (c : Color) | |
| (a : ConditionalLeaf S c) : ownerFlag S c (coordinate a.val.val c) := | |
| (leafColor_eq_iff S a.val c).mp a.property | |
| def trivialSchedule (S : FlaggedTensor X Y Z) (c : Color) : | |
| TopologicalSchedule (ConditionalLeaf S c) (Coordinate X Y Z) 0 where | |
| arity := fun _ => 1 | |
| readerPair := fun _ => .xy | |
| active := fun _ _ => false | |
| branch := fun _ _ => 0 | |
| view := view S c | |
| activate := fun _ _ => false | |
| activate_correct := by intro n hn; omega | |
| localFirst := fun _ _ => 0 | |
| localSecond := fun _ _ => 0 | |
| localFirst_read := by intro n hn; omega | |
| localSecond_read := by intro n hn; omega | |
| theorem trivialSchedule_complete (S : FlaggedTensor X Y Z) (c : Color) | |
| (h : Subsingleton (ConditionalLeaf S c)) : | |
| (trivialSchedule S c).toNodeSchedule.Complete 0 := by | |
| intro a b _ | |
| exact h.allEq a b | |
| def binarySchedule {A : Type*} {Coord : Color → Type*} | |
| (v : (c : Color) → A → Coord c) (pair : ReaderPair) | |
| (choice : A → Fin 2) | |
| (first : Coord (firstSide pair) → Fin 2) | |
| (second : Coord (secondSide pair) → Fin 2) | |
| (hfirst : ∀ a, first (v (firstSide pair) a) = choice a) | |
| (hsecond : ∀ a, second (v (secondSide pair) a) = choice a) : | |
| TopologicalSchedule A Coord 1 where | |
| arity := fun | 0 => 2 | _ + 1 => 1 | |
| readerPair := fun _ => pair | |
| active := fun | 0, _ => true | _ + 1, _ => false | |
| branch := fun | 0, a => choice a | _ + 1, _ => 0 | |
| view := v | |
| activate := fun | 0, _ => true | _ + 1, _ => false | |
| activate_correct := by | |
| intro n hn a | |
| have hn0 : n = 0 := by omega | |
| subst n | |
| rfl | |
| localFirst := fun | 0, u => first u | _ + 1, _ => 0 | |
| localSecond := fun | 0, u => second u | _ + 1, _ => 0 | |
| localFirst_read := by | |
| intro n hn a _ | |
| have hn0 : n = 0 := by omega | |
| subst n | |
| exact hfirst a | |
| localSecond_read := by | |
| intro n hn a _ | |
| have hn0 : n = 0 := by omega | |
| subst n | |
| exact hsecond a | |
| theorem binarySchedule_complete {A : Type*} {Coord : Color → Type*} | |
| (v : (c : Color) → A → Coord c) (pair : ReaderPair) | |
| (choice : A → Fin 2) (first) (second) (hfirst) (hsecond) | |
| (hinj : Function.Injective choice) : | |
| (binarySchedule v pair choice first second hfirst hsecond).toNodeSchedule.Complete 1 := by | |
| intro a b h | |
| apply hinj | |
| exact (h 0 (by omega)).2 rfl | |
| theorem baseTwo_subsingleton (c : Color) : | |
| Subsingleton (ConditionalLeaf BaseTwo.flagged c) := by | |
| refine ⟨?_⟩ | |
| intro a b | |
| have ha := conditional_flag BaseTwo.flagged c a | |
| have hb := conditional_flag BaseTwo.flagged c b | |
| have hsa := a.val.property | |
| have hsb := b.val.property | |
| apply Subtype.ext | |
| apply Subtype.ext | |
| cases c with | |
| | B => | |
| obtain ⟨hax, hay, haz⟩ := (BaseTwo.conditionalB _ _ _).mp ⟨hsa, ha⟩ | |
| obtain ⟨hbx, hby, hbz⟩ := (BaseTwo.conditionalB _ _ _).mp ⟨hsb, hb⟩ | |
| exact Prod.ext (hax.trans hbx.symm) (Prod.ext (hay.trans hby.symm) (haz.trans hbz.symm)) | |
| | A => | |
| obtain ⟨hax, hay, haz⟩ := (BaseTwo.conditionalA _ _ _).mp ⟨hsa, ha⟩ | |
| obtain ⟨hbx, hby, hbz⟩ := (BaseTwo.conditionalA _ _ _).mp ⟨hsb, hb⟩ | |
| exact Prod.ext (hax.trans hbx.symm) (Prod.ext (hay.trans hby.symm) (haz.trans hbz.symm)) | |
| | C => | |
| obtain ⟨hax, hay, haz⟩ := (BaseTwo.conditionalC _ _ _).mp ⟨hsa, ha⟩ | |
| obtain ⟨hbx, hby, hbz⟩ := (BaseTwo.conditionalC _ _ _).mp ⟨hsb, hb⟩ | |
| exact Prod.ext (hax.trans hbx.symm) (Prod.ext (hay.trans hby.symm) (haz.trans hbz.symm)) | |
| def baseTwo (c : Color) : | |
| TopologicalSchedule (ConditionalLeaf BaseTwo.flagged c) | |
| (Coordinate (Fin 2) (Fin 2) (Fin 2)) 0 := trivialSchedule BaseTwo.flagged c | |
| theorem baseTwo_complete (c : Color) : (baseTwo c).toNodeSchedule.Complete 0 := | |
| trivialSchedule_complete BaseTwo.flagged c (baseTwo_subsingleton c) | |
| def aChoice (a : ConditionalLeaf BaseThree.flagged .A) : Fin 2 := | |
| if a.val.val.2.1 = 0 then 0 else 1 | |
| def bChoice (a : ConditionalLeaf BaseThree.flagged .B) : Fin 2 := | |
| if a.val.val.1 = 2 then 0 else 1 | |
| theorem aChoice_read (a : ConditionalLeaf BaseThree.flagged .A) : | |
| (if a.val.val.2.2 = 2 then (0 : Fin 2) else 1) = aChoice a := by | |
| have ha := conditional_flag BaseThree.flagged .A a | |
| have h := BaseThree.readableA _ _ _ a.val.property ha | |
| simp only [aChoice, ← h] | |
| theorem bChoice_read (a : ConditionalLeaf BaseThree.flagged .B) : | |
| (if a.val.val.2.1 = 0 then (0 : Fin 2) else 1) = bChoice a := by | |
| have hb := conditional_flag BaseThree.flagged .B a | |
| have h := BaseThree.readableB _ _ _ a.val.property hb | |
| simp only [bChoice, ← h] | |
| theorem aChoice_injective : Function.Injective aChoice := by | |
| intro a b h | |
| have ha := (BaseThree.conditionalA _ _ _).mp | |
| ⟨a.val.property, conditional_flag BaseThree.flagged .A a⟩ | |
| have hb := (BaseThree.conditionalA _ _ _).mp | |
| ⟨b.val.property, conditional_flag BaseThree.flagged .A b⟩ | |
| rcases ha with ⟨hax, ha | ha⟩ <;> rcases hb with ⟨hbx, hb | hb⟩ <;> | |
| rcases ha with ⟨hay, haz⟩ <;> rcases hb with ⟨hby, hbz⟩ | |
| all_goals | |
| first | |
| | apply Subtype.ext | |
| apply Subtype.ext | |
| exact Prod.ext (hax.trans hbx.symm) (Prod.ext (hay.trans hby.symm) (haz.trans hbz.symm)) | |
| | simp [aChoice, hay, hby] at h | |
| theorem bChoice_injective : Function.Injective bChoice := by | |
| intro a b h | |
| have ha := (BaseThree.conditionalB _ _ _).mp | |
| ⟨a.val.property, conditional_flag BaseThree.flagged .B a⟩ | |
| have hb := (BaseThree.conditionalB _ _ _).mp | |
| ⟨b.val.property, conditional_flag BaseThree.flagged .B b⟩ | |
| rcases ha with ⟨haz, ha | ha⟩ <;> rcases hb with ⟨hbz, hb | hb⟩ <;> | |
| rcases ha with ⟨hax, hay⟩ <;> rcases hb with ⟨hbx, hby⟩ | |
| all_goals | |
| first | |
| | apply Subtype.ext | |
| apply Subtype.ext | |
| exact Prod.ext (hax.trans hbx.symm) (Prod.ext (hay.trans hby.symm) (haz.trans hbz.symm)) | |
| | simp [bChoice, hax, hbx, Fin.ext_iff] at h | |
| def baseThreeA : | |
| TopologicalSchedule (ConditionalLeaf BaseThree.flagged .A) | |
| (Coordinate (Fin 3) (Fin 3) (Fin 3)) 1 := | |
| binarySchedule (view BaseThree.flagged .A) .yz aChoice | |
| (fun (y : Fin 3) => if y = 0 then 0 else 1) (fun (z : Fin 3) => if z = 2 then 0 else 1) | |
| (fun _ => rfl) aChoice_read | |
| def baseThreeB : | |
| TopologicalSchedule (ConditionalLeaf BaseThree.flagged .B) | |
| (Coordinate (Fin 3) (Fin 3) (Fin 3)) 1 := | |
| binarySchedule (view BaseThree.flagged .B) .xy bChoice | |
| (fun (x : Fin 3) => if x = 2 then 0 else 1) (fun (y : Fin 3) => if y = 0 then 0 else 1) | |
| (fun _ => rfl) bChoice_read | |
| theorem baseThreeA_complete : baseThreeA.toNodeSchedule.Complete 1 := by | |
| unfold baseThreeA | |
| exact binarySchedule_complete _ _ _ _ _ _ _ aChoice_injective | |
| theorem baseThreeB_complete : baseThreeB.toNodeSchedule.Complete 1 := by | |
| unfold baseThreeB | |
| exact binarySchedule_complete _ _ _ _ _ _ _ bChoice_injective | |
| theorem baseThreeC_subsingleton : Subsingleton (ConditionalLeaf BaseThree.flagged .C) := by | |
| refine ⟨?_⟩ | |
| intro a b | |
| obtain ⟨hax, hay, haz⟩ := (BaseThree.conditionalC _ _ _).mp | |
| ⟨a.val.property, conditional_flag BaseThree.flagged .C a⟩ | |
| obtain ⟨hbx, hby, hbz⟩ := (BaseThree.conditionalC _ _ _).mp | |
| ⟨b.val.property, conditional_flag BaseThree.flagged .C b⟩ | |
| apply Subtype.ext | |
| apply Subtype.ext | |
| exact Prod.ext (hax.trans hbx.symm) (Prod.ext (hay.trans hby.symm) (haz.trans hbz.symm)) | |
| def baseThreeC : | |
| TopologicalSchedule (ConditionalLeaf BaseThree.flagged .C) | |
| (Coordinate (Fin 3) (Fin 3) (Fin 3)) 0 := trivialSchedule BaseThree.flagged .C | |
| theorem baseThreeC_complete : baseThreeC.toNodeSchedule.Complete 0 := | |
| trivialSchedule_complete BaseThree.flagged .C baseThreeC_subsingleton | |
| def baseTwoProgram : | |
| Program (Leaf BaseTwo.flagged) (Coordinate (Fin 2) (Fin 2) (Fin 2)) | |
| Color (Fin 2) 0 where | |
| context := CompletionLabels.leafColor BaseTwo.flagged | |
| view := fun side a => coordinate a.val side | |
| pair := fun _ => .xy | |
| labels := fun _ _ => 0 | |
| read := fun _ _ _ _ _ => 0 | |
| readable := by intro n hn; omega | |
| theorem baseTwoProgram_complete : baseTwoProgram.Complete := by | |
| intro a b hc _ | |
| change CompletionLabels.leafColor BaseTwo.flagged a = | |
| CompletionLabels.leafColor BaseTwo.flagged b at hc | |
| let aa : ConditionalLeaf BaseTwo.flagged (CompletionLabels.leafColor BaseTwo.flagged a) := | |
| ⟨a, rfl⟩ | |
| let bb : ConditionalLeaf BaseTwo.flagged (CompletionLabels.leafColor BaseTwo.flagged a) := | |
| ⟨b, hc.symm⟩ | |
| exact congrArg Subtype.val ((baseTwo_subsingleton _).allEq aa bb) | |
| def aLabel (a : Leaf BaseThree.flagged) : Fin 2 := | |
| if CompletionLabels.leafColor BaseThree.flagged a = .A then | |
| if a.val.2.1 = 0 then 0 else 1 else 0 | |
| def bLabel (a : Leaf BaseThree.flagged) : Fin 2 := | |
| if CompletionLabels.leafColor BaseThree.flagged a = .B then | |
| if a.val.1 = 2 then 0 else 1 else 0 | |
| def aRead (side : Color) (ctx : Color) : Coordinate (Fin 3) (Fin 3) (Fin 3) side → Fin 2 := | |
| match side with | |
| | .B => fun _ => 0 | |
| | .A => fun (z : Fin 3) => if ctx = .A then (if z = 2 then 0 else 1) else 0 | |
| | .C => fun (y : Fin 3) => if ctx = .A then (if y = 0 then 0 else 1) else 0 | |
| def bRead (side : Color) (ctx : Color) : Coordinate (Fin 3) (Fin 3) (Fin 3) side → Fin 2 := | |
| match side with | |
| | .B => fun (x : Fin 3) => if ctx = .B then (if x = 2 then 0 else 1) else 0 | |
| | .A => fun _ => 0 | |
| | .C => fun (y : Fin 3) => if ctx = .B then (if y = 0 then 0 else 1) else 0 | |
| theorem aRead_correct (a : Leaf BaseThree.flagged) (side : Color) | |
| (hs : side = firstSide .yz ∨ side = secondSide .yz) : | |
| aRead side (CompletionLabels.leafColor BaseThree.flagged a) (coordinate a.val side) = | |
| aLabel a := by | |
| cases side with | |
| | B => rcases hs with h | h <;> cases h | |
| | A => | |
| by_cases ha : CompletionLabels.leafColor BaseThree.flagged a = .A | |
| · have hf := (leafColor_eq_iff BaseThree.flagged a .A).mp ha | |
| have h := BaseThree.readableA _ _ _ a.property hf | |
| simp only [aRead, aLabel, ha, ite_true, coordinate, ← h] | |
| · simp [aRead, aLabel, ha] | |
| | C => rfl | |
| theorem bRead_correct (a : Leaf BaseThree.flagged) (side : Color) | |
| (hs : side = firstSide .xy ∨ side = secondSide .xy) : | |
| bRead side (CompletionLabels.leafColor BaseThree.flagged a) (coordinate a.val side) = | |
| bLabel a := by | |
| cases side with | |
| | B => rfl | |
| | A => rcases hs with h | h <;> cases h | |
| | C => | |
| by_cases hb : CompletionLabels.leafColor BaseThree.flagged a = .B | |
| · have hf := (leafColor_eq_iff BaseThree.flagged a .B).mp hb | |
| have h := BaseThree.readableB _ _ _ a.property hf | |
| simp only [bRead, bLabel, hb, ite_true, coordinate, ← h] | |
| · simp [bRead, bLabel, hb] | |
| def baseThreeProgram : | |
| Program (Leaf BaseThree.flagged) (Coordinate (Fin 3) (Fin 3) (Fin 3)) | |
| Color (Fin 2) 2 where | |
| context := CompletionLabels.leafColor BaseThree.flagged | |
| view := fun side a => coordinate a.val side | |
| pair := fun | 0 => .yz | _ + 1 => .xy | |
| labels := fun | 0, a => aLabel a | 1, a => bLabel a | _ + 2, _ => 0 | |
| read := fun | |
| | 0, side, ctx, _, own => aRead side ctx own | |
| | 1, side, ctx, _, own => bRead side ctx own | |
| | _ + 2, _, _, _, _ => 0 | |
| readable := by | |
| intro n hn a side hs | |
| have hn2 : n = 0 ∨ n = 1 := by omega | |
| rcases hn2 with rfl | rfl | |
| · exact aRead_correct a side hs | |
| · exact bRead_correct a side hs | |
| theorem baseThreeProgram_complete : baseThreeProgram.Complete := by | |
| intro a b hc hl | |
| change CompletionLabels.leafColor BaseThree.flagged a = | |
| CompletionLabels.leafColor BaseThree.flagged b at hc | |
| cases ha : CompletionLabels.leafColor BaseThree.flagged a with | |
| | A => | |
| have hb : CompletionLabels.leafColor BaseThree.flagged b = .A := hc.symm.trans ha | |
| let aa : ConditionalLeaf BaseThree.flagged .A := ⟨a, ha⟩ | |
| let bb : ConditionalLeaf BaseThree.flagged .A := ⟨b, hb⟩ | |
| have hh := hl 0 (by omega) | |
| change aLabel a = aLabel b at hh | |
| have he : aChoice aa = aChoice bb := by | |
| simpa only [aLabel, ha, hb, ite_true, aChoice, aa, bb] using hh | |
| exact congrArg Subtype.val (aChoice_injective he) | |
| | B => | |
| have hb : CompletionLabels.leafColor BaseThree.flagged b = .B := hc.symm.trans ha | |
| let aa : ConditionalLeaf BaseThree.flagged .B := ⟨a, ha⟩ | |
| let bb : ConditionalLeaf BaseThree.flagged .B := ⟨b, hb⟩ | |
| have hh := hl 1 (by omega) | |
| change bLabel a = bLabel b at hh | |
| have he : bChoice aa = bChoice bb := by | |
| simpa only [bLabel, ha, hb, ite_true, bChoice, aa, bb] using hh | |
| exact congrArg Subtype.val (bChoice_injective he) | |
| | C => | |
| have hb : CompletionLabels.leafColor BaseThree.flagged b = .C := hc.symm.trans ha | |
| let aa : ConditionalLeaf BaseThree.flagged .C := ⟨a, ha⟩ | |
| let bb : ConditionalLeaf BaseThree.flagged .C := ⟨b, hb⟩ | |
| exact congrArg Subtype.val (baseThreeC_subsingleton.allEq aa bb) | |
| def baseTwoReadable : ReadableTensor BaseTwo.flagged where | |
| Code := Fin 2 | |
| depth := 0 | |
| program := baseTwoProgram | |
| context_eq _ := rfl | |
| view_eq _ _ := rfl | |
| complete := baseTwoProgram_complete | |
| def baseThreeReadable : ReadableTensor BaseThree.flagged where | |
| Code := Fin 2 | |
| depth := 2 | |
| program := baseThreeProgram | |
| context_eq _ := rfl | |
| view_eq _ _ := rfl | |
| complete := baseThreeProgram_complete | |
| end MatrixMultiplication.BaseConditionalReaders | |
| end | |
| end OAI | |