File size: 6,820 Bytes
e63eb7f | 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 | import OAI.Combinatorics.EditApproximation.Coarse.CoarseBinaryBox
import OAI.Combinatorics.EditApproximation.Coarse.CoarseScalarBounds
import OAI.Combinatorics.EditApproximation.Coarse.CoarseBinaryWeight
namespace OAI
namespace EditApproximation
namespace BinaryFraction
theorem coarseBinaryChildren_bounds {B d : ℕ} {α : Type*} (k q L N V D A : ℕ)
(two allowance : BinaryFraction)
(evaluate : CoarseSourceTree B α d → CoarseThresholdDraws B d → BinaryFraction → ℕ →
CoarseBinaryArray × ℕ)
(weight : CoarseSourceTree B α d → CoarseThresholdDraws B d → BinaryFraction → ℕ)
(children : List (CoarseSourceTree B α d × Fin B × CoarseThresholdDraws B d))
(hB : 0 < B) (hlen : children.length ≤ B) (htwo : two.value = 2) (htw : two.width ≤ A)
(ha : allowance.width ≤ A) (hBbits : Nat.size B + 2 ≤ A)
(hqbits : Nat.size q + 2 ≤ A) (hLbits : Nat.size L + 2 ≤ A)
(hNbits : Nat.size N ≤ A)
(ht : ∀ draw : Fin B, (coarseChildThresholdWithWork B q allowance draw).1.width ≤ A)
(hs : CoarseGridCell two (coarseChildAllowanceWithWork q allowance).1 k D A)
(hbound : Nat.size (B * (V + k) + 2) + 2 * D + 1 ≤ A)
(he : ∀ child draw below, (child, draw, below) ∈ children → ∀ s,
s + child.word.length ≤ N →
CoarseBinaryBox two (2 * k + 1) V D A
(evaluate child below (coarseChildAllowanceWithWork L
(coarseChildThresholdWithWork B q allowance draw).1).1 s).1 ∧
(evaluate child below (coarseChildAllowanceWithWork L
(coarseChildThresholdWithWork B q allowance draw).1).1 s).2 ≤
(100000000 * (A + 1) ^ 2) * weight child below
(coarseChildAllowanceWithWork L (coarseChildThresholdWithWork B q allowance draw).1).1)
(start : ℕ) (hstart : start + coarseChildrenSpan children ≤ N) :
CoarseBinaryBox two (2 * k + 1) (children.length * (V + k)) D A
(coarseBinaryChildren k q L two evaluate allowance children start).1 ∧
(coarseBinaryChildren k q L two evaluate allowance children start).2 + children.length ≤
(100000000 * (A + 1) ^ 2) *
(coarseBinaryChildrenWeight q L weight allowance children + (2 * k + 1) * children.length) := by
have hvsmall : V + 2 ≤ B * (V + k) + 2 := by nlinarith
have hvbound : Nat.size (V + 2) + 2 * D + 1 ≤ A :=
(Nat.add_le_add_right (Nat.add_le_add_right (Nat.size_le_size hvsmall) _) _).trans hbound
have hmapbound : Nat.size (V + k) + 2 * D + 1 ≤ A :=
(Nat.add_le_add_right (Nat.add_le_add_right (Nat.size_le_size (by nlinarith : V + k ≤ B * (V + k) + 2)) _) _).trans hbound
induction children generalizing start with
| nil =>
constructor
· exact coarseBinaryBox_none _ _ _ _ _
· simp only [coarseBinaryChildren, coarseBinaryChildrenWeight, List.length_nil, mul_zero, add_zero, le_refl]
| cons data rest ih =>
obtain ⟨child, draw, below⟩ := data
have hspan : start + (child.word.length + coarseChildrenSpan rest) ≤ N := hstart
have hchild := he child draw below List.mem_cons_self start (by omega)
have hrest := ih (by simp only [List.length_cons] at hlen; omega)
(fun child draw below hmem => he child draw below (List.mem_cons_of_mem _ hmem))
(start + child.word.length) (by omega)
let threshold := coarseChildThresholdWithWork B q allowance draw
let childAllowance := coarseChildAllowanceWithWork L threshold.1
let evaluated := evaluate child below childAllowance.1 start
let penalty := coarseBinaryPenaltyWithWork two evaluated.1
let scale := coarseChildAllowanceWithWork q allowance
let contribution := coarseBinaryMapWithWork (coarseContributionWithWork threshold.1 scale.1) penalty.1
let remainder := coarseBinaryChildren k q L two evaluate allowance rest (start + child.word.length)
have hpen : CoarseBinaryBox two (2 * k + 1) V D A penalty.1 :=
coarseBinaryPenaltyWithWork_box two _ V D A evaluated.1 hchild.1 htwo htw hvbound
have hcon : CoarseBinaryBox two (2 * k + 1) (V + k) D A contribution.1 :=
coarseBinaryMapWithWork_box two _ V (V + k) D A _ penalty.1 hpen
(fun a ha => coarseContributionWithWork_bounds two threshold.1 scale.1 a V k D A ha hs hmapbound)
have habound : Nat.size ((V + k) + rest.length * (V + k)) + 2 * D + 1 ≤ A := by
apply le_trans _ hbound
apply Nat.add_le_add_right
apply Nat.add_le_add_right
apply Nat.size_le_size
simp only [List.length_cons] at hlen
nlinarith
constructor
· have hh := coarseBinaryAddWithWork_box two (2 * k + 1) (V + k) (rest.length * (V + k)) D A
contribution.1 remainder.1 hcon hrest.1 habound
change CoarseBinaryBox two (2 * k + 1) ((rest.length + 1) * (V + k)) D A
(coarseBinaryAddWithWork contribution.1 remainder.1).1
simpa only [Nat.add_mul, Nat.one_mul, Nat.add_comm] using hh
· have htc := coarseChildThresholdWithWork_cost B q A allowance draw ha hBbits hqbits
have hlc := coarseChildAllowanceWithWork_cost L A threshold.1 (ht draw) hLbits
have hsc := coarseChildAllowanceWithWork_cost q A allowance ha hqbits
have hpc := coarseBinaryPenaltyWithWork_cost two (2 * k + 1) V D A evaluated.1 hchild.1 htwo htw hvbound
have hmc := coarseBinaryMapWithWork_cost two (2 * k + 1) V D A (2200 * (A + 1) ^ 2)
(coarseContributionWithWork threshold.1 scale.1) penalty.1 hpen
(fun a ha => coarseContributionWithWork_cost threshold.1 scale.1 a A
(ht draw) hs.2.2.2.2 ha.2.2.2.2)
have hac := coarseBinaryAddWithWork_cost two (2 * k + 1) (V + k) (rest.length * (V + k)) D A
contribution.1 remainder.1 hcon hrest.1
have haddr : Nat.size start ≤ A := (Nat.size_le_size (by omega)).trans hNbits
have hchildlen : Nat.size child.word.length ≤ A := (Nat.size_le_size (by omega)).trans hNbits
have hstep : threshold.2 + childAllowance.2 + penalty.2 + scale.2 + contribution.2 +
(coarseBinaryAddWithWork contribution.1 remainder.1).2 +
Nat.size start + Nat.size child.word.length + 10 ≤
100000000 * (A + 1) ^ 2 * (2 * k + 1) := by
nlinarith only [htc, hlc, hsc, hpc, hmc, hac, haddr, hchildlen,
Nat.zero_le A, Nat.zero_le k]
change threshold.2 + childAllowance.2 + evaluated.2 + penalty.2 + scale.2 + contribution.2 +
remainder.2 + (coarseBinaryAddWithWork contribution.1 remainder.1).2 +
Nat.size start + Nat.size child.word.length + 9 + (rest.length + 1) ≤ _
have heval := hchild.2
change evaluated.2 ≤ _ at heval
have hrec := hrest.2
change remainder.2 + rest.length ≤ _ at hrec
simp only [coarseBinaryChildrenWeight, List.length_cons]
nlinarith only [hstep, heval, hrec]
end BinaryFraction
end EditApproximation
end OAI
|