Almost-linear randomized approximation of edit distance

import Mathlibnamespace OAI.EditDistortionend OAI.EditDistortion/-! A uniform almost-linear approximation scheme for edit distance.The statement retains the concrete binary algorithm and its exact resource accounting. -/sectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationdef bitWordValue : List Bool → ℕ  | [] => 0  | bit :: bits => bit.toNat + 2 * bitWordValue bitsdef bitSum (a b carry : Bool) : Bool := xor (xor a b) carrydef bitCarry (a b carry : Bool) : Bool := (a && b) || (a && carry) || (b && carry)structure UnreducedRational where  num : ℤ  den : ℕ  den_pos : 0 < dendef orderingMatches (o : Ordering) (a b : ℕ) : Prop :=  (o = .lt ∧ a < b) ∨ (o = .eq ∧ a = b) ∨ (o = .gt ∧ b < a)def bitOrdering (high : Ordering) (a b : Bool) : Ordering :=  match high with  | .lt => .lt  | .gt => .gt  | .eq => if a = b then .eq else if a then .gt else .ltdef bitDifference (a b borrow : Bool) : Bool := xor (xor a b) borrowdef bitBorrow (a b borrow : Bool) : Bool := ((!a) && (b || borrow)) || (b && borrow)structure SignedBinary where  negative : Bool  bits : List Booldef signedMagnitude (negative : Bool) (magnitude : ℕ) : ℤ :=  if negative then -(magnitude : ℤ) else magnitudedef trimBitWordWithWork : List Bool → List Bool × ℕ  | [] => ([], 1)  | bit :: bits =>    let tail := trimBitWordWithWork bits    (if tail.1 = [] ∧ bit = false then [] else bit :: tail.1, tail.2 + 3)def balancedCut (lo width M i : ℕ) : ℕ := lo + i * width / Mdef gridRound (spacing position : ℕ) : ℕ := spacing * (position / spacing)def rationalMinimum (fallback : ℚ) : List ℚ → ℚ  | [] => fallback  | value :: rest => min value (rationalMinimum fallback rest)structure RationalBellmanAction (Parent : Type u_1) (Child : Type u_2) (M : ℕ) where  center : Parent  connection : ℚ  childState : Fin M → Childdef rationalRefinementUpdate (δ cone : ℚ) : Option ℚ → ℚ  | none => cone  | some online => min cone (max (cone / (1 + δ)) online)def heightExponent (N : ℕ) : ℕ := Nat.clog 2 (Nat.clog 2 (N + 2))def coarseExponent (ell : ℕ) : ℕ := Nat.sqrt (Nat.sqrt (Nat.log 2 ell))structure IntegerParameters where  H : ℕ  ell : ℕ  p : ℕ  B : ℕ  initialFactor : ℕ  M : ℕ  P : ℕ  T : ℕ  S : ℕstructure RationalParameters where  F : ℚ  initialSlope : ℚ  coneSlope : ℚ  delta : ℚ  kappa : ℚ  tau : ℚ  theta : ℚ  gamma : ℚ  eta : ℚdef gridPointsBetween (g lo hi : ℕ) : List ℕ :=  (List.range' (lo ⌈/⌉ g) ((hi / g + 1) - lo ⌈/⌉ g)).map fun i => g * idef scaledSeedValue (U : ℕ) (a gap : ℚ) : ℚ :=  max (⌈(U : ℚ) / a⌉₊ : ℚ) |gap|def dyadicScales (N : ℕ) : List ℕ :=  (List.range (Nat.log 2 N + 1)).map fun k => 2 ^ kdef seedGridSpacing (b P : ℕ) : ℕ := max 1 (b / P)def finiteAssignments {α : Type u_1} : (M : ℕ) → (Fin M → List α) → List (Fin M → α)  | 0, _ => [Fin.elim0]  | M + 1, choices =>    (choices 0).flatMap fun head =>      (finiteAssignments M (fun i => choices i.succ)).map fun tail => Fin.cons head taildef powerTwoWord (n : ℕ) : List Bool := List.replicate n false ++ [true]def filterWithWork {α : Type u_1} (test : α → Bool × ℕ) : List α → List α × ℕ  | [] => ([], 0)  | a :: rest =>    let current := test a    let tail := filterWithWork test rest    (if current.1 then a :: tail.1 else tail.1, current.2 + tail.2 + 3)def allWithWork {α : Type u_1} (test : α → Bool × ℕ) : List α → Bool × ℕ  | [] => (true, 0)  | a :: rest =>    let current := test a    let tail := allWithWork test rest    (current.1 && tail.1, current.2 + tail.2 + 3)def arithmeticMapWithWork {α : Type u_1} {β : Type u_2} (f : α → β × ℕ) : List α → List β × ℕ  | [] => ([], 0)  | a :: rest =>    let current := f a    let tail := arithmeticMapWithWork f rest    (current.1 :: tail.1, current.2 + tail.2 + 3)def arithmeticFlatMapWithWork {α : Type u_1} {β : Type u_2} (f : α → List β × ℕ) : List α → List β × ℕ  | [] => ([], 0)  | a :: rest =>    let current := f a    let tail := arithmeticFlatMapWithWork f rest    (current.1 ++ tail.1, current.2 + tail.2 + current.1.length + 3)def upperMedian (values : List ℕ) : ℕ :=  (values.mergeSort (· ≤ ·)).getD (values.length / 2) 0def filterMapWithWork {α : Type u_1} {β : Type u_2} (f : α → Option β × ℕ) : List α → List β × ℕ  | [] => ([], 0)  | a :: rest =>    let first := f a    let tail := filterMapWithWork f rest    (match first.1 with | none => tail.1 | some b => b :: tail.1, first.2 + tail.2 + 3)def cellGridPoints (side : ℚ) (g cell : ℕ) : List ℕ :=  (List.range' ⌈(cell : ℚ) * side / g⌉₊    (⌈((cell : ℚ) + 1) * side / g⌉₊ - ⌈(cell : ℚ) * side / g⌉₊)).map fun i => g * idef groupRoundSpacing (exponent : ℕ) (h : ℚ) : ℕ :=  ⌈max 1 ((2 : ℚ) ^ (-(exponent : ℤ)) * h)⌉₊def refinementFactor (A : ℚ) (F : ℕ) : ℚ := max 1 (A / F)def localCellCoordinates (side : ℚ) (p radius : ℕ) : List ℕ :=  let first := ⌊((p - radius : ℕ) : ℚ) / side⌋₊  let last := ⌊((p + radius : ℕ) : ℚ) / side⌋₊  List.range' first (last + 1 - first)def dyadicSeedPassCount (f initial : ℕ) : ℕ := (initial - f) ⌈/⌉ (f - 2)def dyadicSeedExponent (f initial pass : ℕ) : ℕ := initial - pass * (f - 2)def memberByWithWork {α : Type u_1} (equal : α → α → Bool × ℕ) (a : α) : List α → Bool × ℕ  | [] => (false, 1)  | b :: rest =>    let test := equal a b    let tail := memberByWithWork equal a rest    (test.1 || tail.1, test.2 + tail.2 + 1)inductive BinaryMemo (α : Type u_1) where  | empty  | node (value : Option α) (left right : BinaryMemo α)def binaryMemoKey : ℕ → ℕ → List Bool  | 0, _ => []  | d + 1, n => decide (n % 2 = 1) :: binaryMemoKey d (n / 2)inductive FiniteQuery (ι : Type u_1) where  | done (value : ℚ)  | read (key : ι) (next : ℚ → FiniteQuery ι)def finiteAnswerTable {κ : Type u_1} [DecidableEq κ] : List κ → List ℚ → κ → ℚ  | key :: keys, value :: values, query =>      if query = key then value else finiteAnswerTable keys values query  | _, _, _ => 0def queryFinRange (n m : ℕ) (h : n = m) : List (Fin m) :=  (List.finRange n).map fun i => ⟨i.val, by simpa only [← h] using i.isLt⟩def queryInsertWithWork {α : Type u_1} (le : α → α → Bool × ℕ) (a : α) : List α → List α × ℕ  | [] => ([a], 1)  | b :: rest =>    let test := le a b    if test.1 then (a :: b :: rest, test.2 + 2)    else      let tail := queryInsertWithWork le a rest      (b :: tail.1, test.2 + tail.2 + 2)def integerSymbolCode : ℤ → ℕ  | .ofNat n => 2 * n  | .negSucc n => 2 * n + 1inductive PositionCounts where  | empty  | node (count : ℕ) (left right : PositionCounts)def integerMagnitude : List ℤ → ℕ  | [] => 0  | z :: zs => max z.natAbs (integerMagnitude zs)def integerInputPositionBits (target : List ℤ) : ℕ := Nat.size target.lengthdef dpLength {α : Type u_1} : List α → ℕ × ℕ  | [] => (0, 1)  | _ :: rest => let result := dpLength rest; (result.1 + 1, result.2 + 1)def dpDrop {α : Type u_1} : ℕ → List α → List α × ℕ  | 0, word => (word, 1)  | _ + 1, [] => ([], 1)  | n + 1, _ :: rest => let result := dpDrop n rest; (result.1, result.2 + 1)def dpTake {α : Type u_1} : ℕ → List α → List α × ℕ  | 0, _ => ([], 1)  | _ + 1, [] => ([], 1)  | n + 1, first :: rest => let result := dpTake n rest; (first :: result.1, result.2 + 1)def dpGetD : List ℕ → ℕ → ℕ × ℕ  | [], _ => (0, 1)  | first :: _, 0 => (first, 1)  | _ :: rest, n + 1 => let result := dpGetD rest n; (result.1, result.2 + 1)def dpMember {α : Type u_1} [DecidableEq α] (a : α) : List α → Bool × ℕ  | [] => (false, 1)  | first :: rest => if a = first then (true, 1) else      let result := dpMember a rest; (result.1, result.2 + 1)def dpMinimum (fallback : ℕ) : List ℕ → ℕ × ℕ  | [] => (fallback, 1)  | first :: rest => let result := dpMinimum fallback rest; (min first result.1, result.2 + 1)def integerMagnitudeWithWork : List ℤ → ℕ × ℕ  | [] => (0, 0)  | z :: rest =>    let tail := integerMagnitudeWithWork rest    (max z.natAbs tail.1, tail.2 + 2)def inputBitLengthWithWork (n : ℕ) : ℕ × ℕ :=  if h : n = 0 then (0, 1) else    let tail := inputBitLengthWithWork (n / 2)    (tail.1 + 1, tail.2 + 2)termination_by ndecreasing_by exact Nat.div_lt_self (by omega) (by decide)def naturalPairWithWork (a b : ℕ) : ℕ × ℕ :=  if a < b then (b * b + a, 4) else (a * a + a + b, 5)def inspectBitPrefix : ℕ → List Bool → Bool × ℕ  | 0, [] => (true, 1)  | 0, _ :: _ => (false, 1)  | _ + 1, [] => (true, 1)  | n + 1, _ :: rest =>    let result := inspectBitPrefix n rest    (result.1, result.2 + 1)def memoRequestCells (bits addressCells : ℕ) : ℕ := addressCells + 8 * (bits + 1) + 64def arithmeticMapAllocation {α : Type u_1} (allocation : α → ℕ) : List α → ℕ  | [] => 0  | a :: rest => allocation a + arithmeticMapAllocation allocation rest + 1def arithmeticFlatMapAllocation {α : Type u_1} {β : Type u_2} (f : α → List β × ℕ)    (allocation : α → ℕ) : List α → ℕ  | [] => 0  | x :: xs => allocation x + arithmeticFlatMapAllocation f allocation xs + (f x).1.lengthdef filterAllocation {α : Type u_1} (test : α → Bool × ℕ) (allocation : α → ℕ) : List α → ℕ  | [] => 0  | x :: xs => allocation x + filterAllocation test allocation xs + if (test x).1 then 1 else 0def filterMapAllocation {α : Type u_1} {β : Type u_2} (f : α → Option β × ℕ)    (allocation : α → ℕ) : List α → ℕ  | [] => 0  | x :: xs => allocation x + filterMapAllocation f allocation xs + if (f x).1.isSome then 1 else 0def naturalEqualAllocation (a b : ℕ) : ℕ := a.bits.length + b.bits.length + 1def memberByAllocation {α : Type u_1} (allocation : α → α → ℕ) (a : α) : List α → ℕ  | [] => 0  | b :: rest => allocation a b + memberByAllocation allocation a rest + 1def naturalWordLEAllocation (a b : List Bool) : ℕ := a.length + b.length + 1def vectorMapAllocation (d : ℕ) (allocation : Fin d → ℕ) : ℕ :=  (∑ i, allocation i) + 3 * ddef allAllocation {α : Type u_1} (allocation : α → ℕ) : List α → ℕ  | [] => 0  | x :: xs => allocation x + allAllocation allocation xs + 1def queryInsertAllocation {α : Type u_1} (le : α → α → Bool × ℕ)    (allocation : α → α → ℕ) (a : α) : List α → ℕ  | [] => 1  | b :: rest => allocation a b + if (le a b).1 then 2 else queryInsertAllocation le allocation a rest + 1def wordLEAllocation (_a _b : List Bool) : ℕ := 0def indexedLeafAllocation (symbolBits positionBits : ℕ) (symbol : Option ℕ) (lo hi : ℕ) : ℕ :=  match symbol with  | none => 1  | some _ => if lo = hi then 1 else symbolBits + 2 * positionBits + 4def storedNaturalBits (values : List ℕ) : ℕ :=  1 + (values.map fun a => Nat.size a + 1).sumdef coarseHistoryKeyCost {α : Type u_1} {β : Type u_2} {ι : Type u_3} (cost : ι → ℕ) : Sum α (Sum ι β) → ℕ  | .inr (.inl entry) => cost entry  | _ => 0def bitAddNilLeftWithWork (right : List Bool) (carry : Bool) : List Bool × ℕ :=  match right with  | [] => (if carry then [true] else [], 1)  | b :: bs =>    let rest := bitAddNilLeftWithWork bs (OAI.EditApproximation.bitCarry false b carry)    (OAI.EditApproximation.bitSum false b carry :: rest.1, rest.2 + 9)termination_by structural rightdef bitCompareNilLeftWithWork (right : List Bool) : Ordering × ℕ :=  match right with  | [] => (.eq, 1)  | b :: bs =>    let high := bitCompareNilLeftWithWork bs    (OAI.EditApproximation.bitOrdering high.1 false b, high.2 + 4)termination_by structural rightdef bitSubtractNilLeftWithWork (right : List Bool) (borrow : Bool) : List Bool × Bool × ℕ :=  match right with  | [] => ([], borrow, 1)  | b :: bs =>    let rest := bitSubtractNilLeftWithWork bs (OAI.EditApproximation.bitBorrow false b borrow)    (OAI.EditApproximation.bitDifference false b borrow :: rest.1, rest.2.1, rest.2.2 + 9)termination_by structural rightstructure BinaryFraction where  numerator : OAI.EditApproximation.SignedBinary  denominator : List Bool  denominator_pos : 0 < OAI.EditApproximation.bitWordValue denominatordef rationalActionValue {Parent : Type u_1} {Child : Type u_2} {M : ℕ}    (distance : Parent → Parent → ℚ) (L : ℚ) (child : Child → ℚ)    (query : Parent) (action : OAI.EditApproximation.RationalBellmanAction Parent Child M) : ℚ :=  L * distance query action.center + action.connection + ∑ i, child (action.childState i)def inputHeight (N : ℕ) : ℕ := 2 ^ OAI.EditApproximation.heightExponent Ndef smallLogExponent (N : ℕ) : ℕ := Nat.clog 2 (max 1 (OAI.EditApproximation.heightExponent N))def rationalParameters (ell : ℕ) : OAI.EditApproximation.RationalParameters :=  { F := ell, initialSlope := 32 * ell, coneSlope := 128 * ell,    delta := 1 / (ell : ℚ) ^ 10, kappa := 1 / (ell : ℚ) ^ 4,    tau := 1 / (ell : ℚ) ^ 4, theta := 1 / (ell : ℚ) ^ 40,    gamma := 1 / (ell : ℚ) ^ 20, eta := (ell : ℚ) ^ 5 }def materializedAssignmentsWithWork {α : Type u_1} :    (M : ℕ) → (Fin M → List α) → List (Vector α M) × ℕ  | 0, _ => ([Vector.ofFn Fin.elim0], 1)  | M + 1, choices =>    let previous := materializedAssignmentsWithWork M (fun i => choices i.succ)    let expanded := OAI.EditApproximation.arithmeticFlatMapWithWork (fun head =>      OAI.EditApproximation.arithmeticMapWithWork (fun tail : Vector α M =>        (Vector.ofFn (Fin.cons head tail.get), 3 * (M + 1))) previous.1) (choices 0)    (expanded.1, previous.2 + expanded.2 + 1)def dyadicScalesWithWork (N : ℕ) : List ℕ × ℕ :=  let count := max 1 N.bits.length  let values := OAI.EditApproximation.arithmeticMapWithWork (fun e =>    let word := OAI.EditApproximation.powerTwoWord e    (OAI.EditApproximation.bitWordValue word, e + 3)) (List.range count)  (values.1, values.2 + N.bits.length + count + 2)def dedupByWithWork {α : Type u_1} (equal : α → α → Bool × ℕ) : List α → List α × ℕ  | [] => ([], 1)  | a :: rest =>    let tail := dedupByWithWork equal rest    let member := OAI.EditApproximation.memberByWithWork equal a rest    (if member.1 then tail.1 else a :: tail.1, tail.2 + member.2 + 2)def queryEraseLoopWithWork {α : Type u_1} (equal : α → α → Bool × ℕ) :    List α → List α → List α × ℕ  | [], seen => (seen.reverse, seen.length + 1)  | a :: rest, seen =>    let test := OAI.EditApproximation.memberByWithWork equal a seen    let tail := queryEraseLoopWithWork equal rest (if test.1 then seen else a :: seen)    (tail.1, test.2 + tail.2 + 2)structure RecursiveMemoResult (κ : Type u_1) where  value : ℚ  memory : OAI.EditApproximation.BinaryMemo ℚ  freshKeys : List κ  dictionaryVisits : ℕ  requests : ℕdef querySortWithWork {α : Type u_1} (le : α → α → Bool × ℕ) : List α → List α × ℕ  | [] => ([], 1)  | a :: rest =>    let tail := querySortWithWork le rest    let inserted := OAI.EditApproximation.queryInsertWithWork le a tail.1    (inserted.1, tail.2 + inserted.2 + 1)def encodeIntegerSymbolsWithWork : List ℤ → List ℕ × ℕ  | [] => ([], 0)  | z :: zs =>    let rest := encodeIntegerSymbolsWithWork zs    (OAI.EditApproximation.integerSymbolCode z :: rest.1, rest.2 + 3)def integerInputSymbolBits (source target : List ℤ) : ℕ :=  Nat.size (2 * OAI.EditApproximation.integerMagnitude (source ++ target))def dpSingleton {α : Type u_1} [DecidableEq α] (a : α) (word : List α) : ℕ × ℕ :=  if word = [] then (1, 1) else    let count := OAI.EditApproximation.dpLength word    let found := OAI.EditApproximation.dpMember a word    (count.1 - if found.1 then 1 else 0, count.2 + found.2 + 2)def dpCandidateAllocation {α : Type u_1} (target : List α) (j k : ℕ) : ℕ :=  (OAI.EditApproximation.dpTake k (OAI.EditApproximation.dpDrop j target).1).1.lengthdef integerInputInspectionWithWork (source target : List ℤ) : (ℕ × ℕ) × ℕ :=  let left := OAI.EditApproximation.integerMagnitudeWithWork source  let right := OAI.EditApproximation.integerMagnitudeWithWork target  let lengths := (OAI.EditApproximation.dpLength source, OAI.EditApproximation.dpLength target)  let symbols := OAI.EditApproximation.inputBitLengthWithWork (2 * max left.1 right.1)  let positions := OAI.EditApproximation.inputBitLengthWithWork lengths.2.1  ((symbols.1, positions.1),    left.2 + right.2 + lengths.1.2 + lengths.2.2 + symbols.2 + positions.2 + 4)def bitAddNilLeftAllocation (right : List Bool) (carry : Bool) : ℕ :=  match right with  | [] => if carry then 1 else 0  | b :: bs => bitAddNilLeftAllocation bs (OAI.EditApproximation.bitCarry false b carry) + 1termination_by structural rightdef bitSubtractNilLeftAllocation (right : List Bool) (borrow : Bool) : ℕ :=  match right with  | [] => 0  | b :: bs => bitSubtractNilLeftAllocation bs (OAI.EditApproximation.bitBorrow false b borrow) + 1termination_by structural rightdef trimBitWordAllocation : List Bool → ℕ  | [] => 0  | bit :: bits => trimBitWordAllocation bits +      if (OAI.EditApproximation.trimBitWordWithWork bits).1 = [] ∧ bit = false then 0 else 1def dedupByAllocation {α : Type u_1} (equal : α → α → Bool × ℕ)    (allocation : α → α → ℕ) : List α → ℕ  | [] => 0  | a :: rest => dedupByAllocation equal allocation rest + OAI.EditApproximation.memberByAllocation allocation a rest +      if (OAI.EditApproximation.memberByWithWork equal a rest).1 then 0 else 1def dyadicScalesAllocation (N : ℕ) : ℕ :=  OAI.EditApproximation.arithmeticMapAllocation (fun e => e + 1) (List.range (max 1 N.bits.length)) + N.bits.length + max 1 N.bits.lengthdef queryRangeValidAllocation (B range : ℕ) : ℕ :=  (0 : ℕ).bits.length + range.bits.length + OAI.EditApproximation.naturalWordLEAllocation range.bits B.bitsdef queryEraseLoopAllocation {α : Type u_1} (equal : α → α → Bool × ℕ)    (allocation : α → α → ℕ) : List α → List α → ℕ  | [], seen => seen.length  | a :: rest, seen =>    OAI.EditApproximation.memberByAllocation allocation a seen +      queryEraseLoopAllocation equal allocation rest (if (OAI.EditApproximation.memberByWithWork equal a seen).1 then seen else a :: seen) +      if (OAI.EditApproximation.memberByWithWork equal a seen).1 then 0 else 1def queryEncodedLEAllocation {α : Type u_1} (code : α → ℕ × ℕ) (allocation : α → ℕ) (a b : α) : ℕ :=  allocation a + allocation b + OAI.EditApproximation.naturalWordLEAllocation (code a).1.bits (code b).1.bits +    Nat.size (code a).1 + Nat.size (code b).1def bitAddWithWork (left right : List Bool) (carry : Bool) : List Bool × ℕ :=  match left with  | [] => OAI.EditApproximation.bitAddNilLeftWithWork right carry  | a :: as =>    match right with    | [] =>      let rest := bitAddWithWork as [] (OAI.EditApproximation.bitCarry a false carry)      (OAI.EditApproximation.bitSum a false carry :: rest.1, rest.2 + 9)    | b :: bs =>      let rest := bitAddWithWork as bs (OAI.EditApproximation.bitCarry a b carry)      (OAI.EditApproximation.bitSum a b carry :: rest.1, rest.2 + 9)termination_by structural leftdef bitCompareWithWork (left right : List Bool) : Ordering × ℕ :=  match left with  | [] => OAI.EditApproximation.bitCompareNilLeftWithWork right  | a :: as =>    match right with    | [] =>      let high := bitCompareWithWork as []      (OAI.EditApproximation.bitOrdering high.1 a false, high.2 + 4)    | b :: bs =>      let high := bitCompareWithWork as bs      (OAI.EditApproximation.bitOrdering high.1 a b, high.2 + 4)termination_by structural leftdef bitSubtractWithWork (left right : List Bool) (borrow : Bool) : List Bool × Bool × ℕ :=  match left with  | [] => OAI.EditApproximation.bitSubtractNilLeftWithWork right borrow  | a :: as =>    match right with    | [] =>      let rest := bitSubtractWithWork as [] (OAI.EditApproximation.bitBorrow a false borrow)      (OAI.EditApproximation.bitDifference a false borrow :: rest.1, rest.2.1, rest.2.2 + 9)    | b :: bs =>      let rest := bitSubtractWithWork as bs (OAI.EditApproximation.bitBorrow a b borrow)      (OAI.EditApproximation.bitDifference a b borrow :: rest.1, rest.2.1, rest.2.2 + 9)termination_by structural leftdef rationalBellman {Parent : Type u_1} {Child : Type u_2} {M : ℕ}    (fallback : Parent → ℚ) (distance : Parent → Parent → ℚ) (L : ℚ)    (actions : List (OAI.EditApproximation.RationalBellmanAction Parent Child M)) (child : Child → ℚ) (query : Parent) : ℚ :=  OAI.EditApproximation.rationalMinimum (fallback query) (actions.map (OAI.EditApproximation.rationalActionValue distance L child query))def inputSmallLog (N : ℕ) : ℕ := 2 ^ OAI.EditApproximation.smallLogExponent Nstructure BinaryBellmanAction (Parent : Type u_1) (Child : Type u_2) (M : ℕ) where  center : Parent  connection : OAI.EditApproximation.BinaryFraction  childState : Fin M → Childdef queryEraseWithWork {α : Type u_1} (equal : α → α → Bool × ℕ) (xs : List α) :    List α × ℕ := OAI.EditApproximation.queryEraseLoopWithWork equal xs []inductive BitQuery (ι : Type u_1) (β : Type u_2) where  | done (value : β)  | read (key : ι) (next : OAI.EditApproximation.BinaryFraction → BitQuery ι β)  | charge (work : ℕ) (next : BitQuery ι β)def dpCandidate {α : Type u_1} [DecidableEq α] (a : α) (target : List α)    (previous : List ℕ) (j k : ℕ) : ℕ × ℕ :=  let suffix := OAI.EditApproximation.dpDrop j target  let piece := OAI.EditApproximation.dpTake k suffix.1  let one := OAI.EditApproximation.dpSingleton a piece.1  let old := OAI.EditApproximation.dpGetD previous (j + k)  (one.1 + old.1, suffix.2 + piece.2 + one.2 + old.2 + 3)def dpCellAllocation {α : Type u_1} (target : List α) (j : ℕ) : ℕ :=  OAI.EditApproximation.dpCandidateAllocation target j 0 +    ((List.range (target.length - j + 1)).map (OAI.EditApproximation.dpCandidateAllocation target j)).sum +      4 * (target.length - j + 1)def initialThresholdQ (N : ℕ) : ℚ := (OAI.EditApproximation.inputHeight N : ℚ) ^ 4def initialLambda (N : ℕ) : ℚ := 1 / (64 * OAI.EditApproximation.inputHeight N)structure BitRecursiveMemoResult (κ : Type u_1) where  value : OAI.EditApproximation.BinaryFraction  memory : OAI.EditApproximation.BinaryMemo OAI.EditApproximation.BinaryFraction  freshKeys : List κ  dictionaryVisits : ℕ  requests : ℕ  localWork : ℕstructure RefinementParameterWords where  tau : OAI.EditApproximation.BinaryFraction  factor : OAI.EditApproximation.BinaryFraction  eta : OAI.EditApproximation.BinaryFraction  kappa : OAI.EditApproximation.BinaryFraction  delta : OAI.EditApproximation.BinaryFractiondef inspectAccuracyWithWork (budget : ℕ) (epsilon : OAI.EditApproximation.BinaryFraction) : Option OAI.EditApproximation.BinaryFraction × ℕ :=  let numerator := OAI.EditApproximation.inspectBitPrefix budget epsilon.numerator.bits  let denominator := OAI.EditApproximation.inspectBitPrefix budget epsilon.denominator  (if numerator.1 && denominator.1 then some epsilon else none,    numerator.2 + denominator.2 + 2)local instance queryRoundsNeZero (N : ℕ) : NeZero (OAI.EditApproximation.inputHeight N ^ 2) :=  ⟨pow_ne_zero _ (Nat.ne_of_gt (Nat.two_pow_pos _))⟩def bitAddAllocation (left right : List Bool) (carry : Bool) : ℕ :=  match left with  | [] => OAI.EditApproximation.bitAddNilLeftAllocation right carry  | a :: as =>    match right with    | [] => bitAddAllocation as [] (OAI.EditApproximation.bitCarry a false carry) + 1    | b :: bs => bitAddAllocation as bs (OAI.EditApproximation.bitCarry a b carry) + 1termination_by structural leftdef bitSubtractAllocation (left right : List Bool) (borrow : Bool) : ℕ :=  match left with  | [] => OAI.EditApproximation.bitSubtractNilLeftAllocation right borrow  | a :: as =>    match right with    | [] => bitSubtractAllocation as [] (OAI.EditApproximation.bitBorrow a false borrow) + 1    | b :: bs => bitSubtractAllocation as bs (OAI.EditApproximation.bitBorrow a b borrow) + 1termination_by structural leftdef materializedAssignmentsAllocation {α : Type u_1} :    (M : ℕ) → (Fin M → List α) → ℕ  | 0, _ => 1  | M + 1, choices =>    let previous := (OAI.EditApproximation.materializedAssignmentsWithWork M (fun i => choices i.succ)).1    let build := fun head => OAI.EditApproximation.arithmeticMapWithWork (fun tail : Vector α M =>      (Vector.ofFn (Fin.cons head tail.get), 3 * (M + 1))) previous    materializedAssignmentsAllocation M (fun i => choices i.succ) +      OAI.EditApproximation.arithmeticFlatMapAllocation build        (fun _ => OAI.EditApproximation.arithmeticMapAllocation (fun _ : Vector α M => M + 1) previous) (choices 0)def queryEraseAllocation {α : Type u_1} (equal : α → α → Bool × ℕ)    (allocation : α → α → ℕ) (xs : List α) : ℕ := OAI.EditApproximation.queryEraseLoopAllocation equal allocation xs []def querySortAllocation {α : Type u_1} (le : α → α → Bool × ℕ)    (allocation : α → α → ℕ) : List α → ℕ  | [] => 0  | a :: rest => querySortAllocation le allocation rest +    OAI.EditApproximation.queryInsertAllocation le allocation a (OAI.EditApproximation.querySortWithWork le rest).1def binaryNaturalAddWithWork (a b : ℕ) : List Bool × ℕ :=  OAI.EditApproximation.bitAddWithWork a.bits b.bits falsedef bitMulWithWork : List Bool → List Bool → List Bool × ℕ  | [], _ => ([], 1)  | bit :: bits, right =>    let rest := bitMulWithWork bits right    if bit then      let total := OAI.EditApproximation.bitAddWithWork (false :: rest.1) right false      (total.1, rest.2 + total.2 + 2)    else (false :: rest.1, rest.2 + 2)def binaryNaturalCompareWithWork (a b : ℕ) : Ordering × ℕ := OAI.EditApproximation.bitCompareWithWork a.bits b.bitsdef binaryNaturalSubtractWithWork (a b : ℕ) : List Bool × ℕ :=  let result := OAI.EditApproximation.bitSubtractWithWork a.bits b.bits false  (result.1, result.2.2)def integerParameters (N : ℕ) : OAI.EditApproximation.IntegerParameters :=  let H := OAI.EditApproximation.inputHeight N  let ell := OAI.EditApproximation.inputSmallLog N  let p := OAI.EditApproximation.coarseExponent ell  { H, ell, p, B := H ^ p, initialFactor := H ^ (p + 4),    M := 2 ^ (OAI.EditApproximation.heightExponent N / 20), P := H ^ (p + 20),    T := 2 ^ ((3 * OAI.EditApproximation.heightExponent N + 3) / 4), S := H / ell ^ 2 }def bitDivModWithWork (divisor : List Bool) : List Bool → List Bool × List Bool × ℕ  | [] => ([], [], 1)  | bit :: bits =>    let previous := bitDivModWithWork divisor bits    let candidate := bit :: previous.2.1    let comparison := OAI.EditApproximation.bitCompareWithWork candidate divisor    if comparison.1 = .lt then      (false :: previous.1, candidate, previous.2.2 + comparison.2 + 4)    else      let reduced := OAI.EditApproximation.bitSubtractWithWork candidate divisor false      (true :: previous.1, reduced.1, previous.2.2 + comparison.2 + reduced.2.2 + 5)def wordLEWithWork (a b : List Bool) : Bool × ℕ :=  let compared := OAI.EditApproximation.bitCompareWithWork b a  (!(decide (compared.1 = .lt)), compared.2 + 1)def computedSeedInitialExponent (N : ℕ) : ℕ :=  (OAI.EditApproximation.coarseExponent (OAI.EditApproximation.inputSmallLog N) + 4) * OAI.EditApproximation.heightExponent Ndef queryOrderedInputsWithWork {α : Type u_1} (equal le : α → α → Bool × ℕ)    (xs : List α) : List α × ℕ :=  let unique := OAI.EditApproximation.queryEraseWithWork equal xs  let sorted := OAI.EditApproximation.querySortWithWork le unique.1  (sorted.1, unique.2 + sorted.2 + 1)def queryActionInputsWithWork {Parent : Type u_1} {Child : Type u_2} {M : ℕ}    (actions : List (OAI.EditApproximation.BinaryBellmanAction Parent Child M)) : List Child × ℕ :=  let inputs := OAI.EditApproximation.arithmeticFlatMapWithWork (fun action =>    OAI.EditApproximation.arithmeticMapWithWork (fun i : Fin M => (action.childState i, 1)) (List.finRange M)) actions  (inputs.1, inputs.2 + M + 1)def largeAccuracyInput (N : ℕ) (epsilon : ℚ) : Prop :=  2 ^ 1000 ≤ OAI.EditApproximation.inputSmallLog N ∧ 10 ≤ (OAI.EditApproximation.inputSmallLog N : ℚ) * epsilondef dpCell {α : Type u_1} [DecidableEq α] (a : α) (target : List α)    (previous : List ℕ) (j : ℕ) : ℕ × ℕ :=  let fallback := OAI.EditApproximation.dpCandidate a target previous j 0  let candidates := (List.range (target.length - j + 1)).map (OAI.EditApproximation.dpCandidate a target previous j)  let minimum := OAI.EditApproximation.dpMinimum fallback.1 (candidates.map Prod.fst)  (minimum.1, fallback.2 + (candidates.map Prod.snd).sum + minimum.2 +    (OAI.EditApproximation.dpLength target).2 + 3 * candidates.length + 4)def suffixDPAllocation {α : Type u_1} : List α → List α → ℕ  | [], target => target.length + 1  | _ :: rest, target => suffixDPAllocation rest target +      (List.ofFn fun j : Fin (target.length + 1) => OAI.EditApproximation.dpCellAllocation target j.val).sum +        3 * (target.length + 1)def binaryNaturalAddAllocation (a b : ℕ) : ℕ := OAI.EditApproximation.bitAddAllocation a.bits b.bits falsedef queryOrderedInputsAllocation {α : Type u_1} (equal le : α → α → Bool × ℕ)    (equalAllocation leAllocation : α → α → ℕ) (xs : List α) : ℕ :=  OAI.EditApproximation.queryEraseAllocation equal equalAllocation xs +    OAI.EditApproximation.querySortAllocation le leAllocation (OAI.EditApproximation.queryEraseWithWork equal xs).1def queryActionInputsAllocation {Parent : Type u_1} {Child : Type u_2} {M : ℕ}    (actions : List (OAI.EditApproximation.BinaryBellmanAction Parent Child M)) : ℕ :=  OAI.EditApproximation.arithmeticFlatMapAllocation (fun action =>    OAI.EditApproximation.arithmeticMapWithWork (fun i : Fin M => (action.childState i, 1)) (List.finRange M))    (fun _ => OAI.EditApproximation.arithmeticMapAllocation (fun _ : Fin M => 1) (List.finRange M) + M) actionsdef binaryNaturalMulWithWork (a b : ℕ) : List Bool × ℕ := OAI.EditApproximation.bitMulWithWork a.bits b.bitsdef binaryNaturalDivModWithWork (n d : ℕ) : List Bool × List Bool × ℕ :=  OAI.EditApproximation.bitDivModWithWork d.bits n.bitsdef bitCeilDivWithWork (divisor bits : List Bool) : List Bool × ℕ :=  let divided := OAI.EditApproximation.bitDivModWithWork divisor bits  let zeroCheck := OAI.EditApproximation.bitCompareWithWork divided.2.1 []  if zeroCheck.1 = .eq then (divided.1, divided.2.2 + zeroCheck.2 + 3)  else    let rounded := OAI.EditApproximation.bitAddWithWork divided.1 [true] false    (rounded.1, divided.2.2 + zeroCheck.2 + rounded.2 + 3)def wordMinWithWork (a b : List Bool) : List Bool × ℕ :=  let compared := OAI.EditApproximation.wordLEWithWork a b  (if compared.1 then a else b, compared.2 + 1)def wordInsertWithWork (a : List Bool) : List (List Bool) → List (List Bool) × ℕ  | [] => ([a], 1)  | b :: rest =>    let compared := OAI.EditApproximation.wordLEWithWork a b    if compared.1 then (a :: b :: rest, compared.2 + 2) else      let tail := wordInsertWithWork a rest      (b :: tail.1, compared.2 + tail.2 + 2)def saturatingSubtractWithWork (a b : ℕ) : List Bool × ℕ :=  let test := OAI.EditApproximation.binaryNaturalCompareWithWork a b  if test.1 = .lt then ([], test.2 + 1) else    let result := OAI.EditApproximation.binaryNaturalSubtractWithWork a b    (result.1, test.2 + result.2 + 2)def computedSeedPassCount (N : ℕ) : ℕ :=  OAI.EditApproximation.dyadicSeedPassCount (OAI.EditApproximation.smallLogExponent N) (OAI.EditApproximation.computedSeedInitialExponent N)def bitPowerWithWork (base : List Bool) : ℕ → List Bool × ℕ  | 0 => ([true], 1)  | n + 1 =>    let previous := bitPowerWithWork base n    let product := OAI.EditApproximation.bitMulWithWork previous.1 base    let answer := OAI.EditApproximation.trimBitWordWithWork product.1    (answer.1, previous.2 + product.2 + answer.2 + 2)def queryEncodedLEWithWork {α : Type u_1} (code : α → ℕ × ℕ) (a b : α) : Bool × ℕ :=  let left := code a  let right := code b  let comparison := OAI.EditApproximation.wordLEWithWork left.1.bits right.1.bits  (comparison.1, left.2 + right.2 + comparison.2 + Nat.size left.1 + Nat.size right.1 + 3)instance largeAccuracyInput_decidable (N : ℕ) (epsilon : ℚ) : Decidable (OAI.EditApproximation.largeAccuracyInput N epsilon) :=  inferInstanceAs (Decidable (2 ^ 1000 ≤ OAI.EditApproximation.inputSmallLog N ∧ 10 ≤ (OAI.EditApproximation.inputSmallLog N : ℚ) * epsilon))def chargedSuffixDP {α : Type u_1} [DecidableEq α] : List α → List α → List ℕ × ℕ  | [], target =>    (List.ofFn (fun j : Fin (target.length + 1) => target.length - j.val),      4 * (target.length + 1))  | a :: rest, target =>    let previous := chargedSuffixDP rest target    let cells := List.ofFn fun j : Fin (target.length + 1) => OAI.EditApproximation.dpCell a target previous.1 j.val    (cells.map Prod.fst, previous.2 + (cells.map Prod.snd).sum +      2 * (OAI.EditApproximation.dpLength target).2 + 2 * cells.length + 3)def computedCoarseDepth (N n : ℕ) : ℕ := Nat.clog (OAI.EditApproximation.integerParameters N).B (max 1 n)def queryRangeValidWithWork (B range : ℕ) : Bool × ℕ :=  let positive := OAI.EditApproximation.binaryNaturalCompareWithWork 0 range  let bounded := OAI.EditApproximation.wordLEWithWork range.bits B.bits  (decide (positive.1 = .lt) && bounded.1, positive.2 + bounded.2 + 2)def coarsePaddedReadWithWork {α : Type u_1} (n : ℕ) (source : List α) (offset : ℕ) :    Option (Option α) × ℕ :=  let inside := OAI.EditApproximation.binaryNaturalCompareWithWork offset n  (if inside.1 = .lt then some source[offset]? else none,    inside.2 + Nat.size n + Nat.size offset + 2)def coarseRangeCopyWithWork (read : ℕ → ℕ) : ℕ → ℕ → List ℕ × ℕ  | _, 0 => ([], 1)  | start, length + 1 =>    let next := OAI.EditApproximation.binaryNaturalAddWithWork start 1    let tail := coarseRangeCopyWithWork read (OAI.EditApproximation.bitWordValue next.1) length    (read start :: tail.1, tail.2 + next.2 + Nat.size start + Nat.size (read start) + 3)def bitMulAllocation : List Bool → List Bool → ℕ  | [], _ => 0  | bit :: bits, right =>    bitMulAllocation bits right + 1 +      if bit then OAI.EditApproximation.bitAddAllocation (false :: (OAI.EditApproximation.bitMulWithWork bits right).1) right false else 0def bitDivModAllocation (divisor : List Bool) : List Bool → ℕ  | [] => 0  | bit :: bits =>    let candidate := bit :: (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1    bitDivModAllocation divisor bits + 2 +      if (OAI.EditApproximation.bitCompareWithWork candidate divisor).1 = .lt then 0      else OAI.EditApproximation.bitSubtractAllocation candidate divisor falsedef saturatingSubtractAllocation (a b : ℕ) : ℕ :=  a.bits.length + b.bits.length +    if (OAI.EditApproximation.binaryNaturalCompareWithWork a b).1 = .lt then 0 else OAI.EditApproximation.bitSubtractAllocation a.bits b.bits falsedef makeStateAllocation (n lo hi : ℕ) : ℕ :=  OAI.EditApproximation.naturalWordLEAllocation lo.bits hi.bits + OAI.EditApproximation.naturalWordLEAllocation hi.bits n.bits +    if ((OAI.EditApproximation.wordLEWithWork lo.bits hi.bits).1 && (OAI.EditApproximation.wordLEWithWork hi.bits n.bits).1) = true then 2 else 0def translatedEndpointAllocation (reference root endpoint : ℕ) : ℕ :=  OAI.EditApproximation.bitSubtractAllocation endpoint.bits root.bits false +    OAI.EditApproximation.binaryNaturalAddAllocation reference (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalSubtractWithWork endpoint root).1)def wordInsertAllocation (a : List Bool) : List (List Bool) → ℕ  | [] => 1  | b :: rest => OAI.EditApproximation.wordLEAllocation a b +    if (OAI.EditApproximation.wordLEWithWork a b).1 then 2 else wordInsertAllocation a rest + 1def wordSortWithWork : List (List Bool) → List (List Bool) × ℕ  | [] => ([], 1)  | a :: rest =>    let tail := wordSortWithWork rest    let inserted := OAI.EditApproximation.wordInsertWithWork a tail.1    (inserted.1, tail.2 + inserted.2 + 2)def binaryGridRoundWithWork (spacing position : ℕ) : List Bool × ℕ :=  let quotient := OAI.EditApproximation.binaryNaturalDivModWithWork position spacing  let rounded := OAI.EditApproximation.bitMulWithWork spacing.bits quotient.1  (rounded.1, quotient.2.2 + rounded.2 + 2)def gridPointsWithWork (g lo hi : ℕ) : List ℕ × ℕ :=  let lower := OAI.EditApproximation.bitCeilDivWithWork g.bits lo.bits  let upper := OAI.EditApproximation.binaryNaturalDivModWithWork hi g  let stop := OAI.EditApproximation.binaryNaturalAddWithWork (OAI.EditApproximation.bitWordValue upper.1) 1  let count := OAI.EditApproximation.saturatingSubtractWithWork (OAI.EditApproximation.bitWordValue stop.1) (OAI.EditApproximation.bitWordValue lower.1)  let indices := List.range' (OAI.EditApproximation.bitWordValue lower.1) (OAI.EditApproximation.bitWordValue count.1)  let points := OAI.EditApproximation.arithmeticMapWithWork (fun i =>    let product := OAI.EditApproximation.binaryNaturalMulWithWork g i    (OAI.EditApproximation.bitWordValue product.1, product.2 + Nat.size i + 2)) indices  (points.1, lower.2 + upper.2.2 + stop.2 + count.2 + points.2 +    Nat.size g + Nat.size lo + Nat.size hi + 5)def seedGridSpacingWithWork (b P : ℕ) : List Bool × ℕ :=  let quotient := OAI.EditApproximation.binaryNaturalDivModWithWork b P  let test := OAI.EditApproximation.wordLEWithWork quotient.1 [true]  (if test.1 then [true] else quotient.1, quotient.2.2 + test.2 + 2)def balancedCutWithWork (lo width M i : ℕ) : List Bool × ℕ :=  let product := OAI.EditApproximation.binaryNaturalMulWithWork i width  let quotient := OAI.EditApproximation.binaryNaturalDivModWithWork (OAI.EditApproximation.bitWordValue product.1) M  let result := OAI.EditApproximation.binaryNaturalAddWithWork lo (OAI.EditApproximation.bitWordValue quotient.1)  (result.1, product.2 + quotient.2.2 + result.2 + 2)def triangularMassWithWork (K : ℕ) : List Bool × ℕ :=  let next := OAI.EditApproximation.binaryNaturalAddWithWork K 1  let product := OAI.EditApproximation.binaryNaturalMulWithWork K (OAI.EditApproximation.bitWordValue next.1)  let quotient := OAI.EditApproximation.binaryNaturalDivModWithWork (OAI.EditApproximation.bitWordValue product.1) 2  (quotient.1, next.2 + product.2 + quotient.2.2 + 3)def refinementBaseWithWork (ell : List Bool) : List Bool × ℕ :=  let power := OAI.EditApproximation.bitPowerWithWork ell 10  let increment := OAI.EditApproximation.bitAddWithWork power.1 [true] false  let result := OAI.EditApproximation.trimBitWordWithWork increment.1  (result.1, power.2 + increment.2 + result.2 + 2)def queryPairWithWork (a b : ℕ) : ℕ × ℕ :=  let test := OAI.EditApproximation.binaryNaturalCompareWithWork a b  if test.1 = .lt then    let square := OAI.EditApproximation.binaryNaturalMulWithWork b b    let result := OAI.EditApproximation.binaryNaturalAddWithWork (OAI.EditApproximation.bitWordValue square.1) a    (OAI.EditApproximation.bitWordValue result.1, test.2 + square.2 + result.2 + 3)  else    let square := OAI.EditApproximation.binaryNaturalMulWithWork a a    let linear := OAI.EditApproximation.binaryNaturalAddWithWork (OAI.EditApproximation.bitWordValue square.1) a    let result := OAI.EditApproximation.binaryNaturalAddWithWork (OAI.EditApproximation.bitWordValue linear.1) b    (OAI.EditApproximation.bitWordValue result.1, test.2 + square.2 + linear.2 + result.2 + 4)def queryCellValidWithWork (n exponent : ℕ) (cell : ℕ × ℕ) : Bool × ℕ :=  let cap := OAI.EditApproximation.binaryNaturalMulWithWork n (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.powerTwoWord exponent))  let left := OAI.EditApproximation.wordLEWithWork cell.1.bits cap.1  let right := OAI.EditApproximation.wordLEWithWork cell.2.bits cap.1  (left.1 && right.1, cap.2 + left.2 + right.2 + exponent + 4)def queryFinOfNatWithWork (bound value : ℕ) (hb : 0 < bound) : Fin bound × ℕ := by  have proof_bitOrdering_matches_4 (high : Ordering) (a : Bool) (b : Bool) (x : ℕ) (y : ℕ) (h : OAI.EditApproximation.orderingMatches high x y) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitOrdering high a b) (a.toNat + 2 * x) (b.toNat + 2 * y) := by    rcases h with ⟨rfl, h⟩ | ⟨rfl, rfl⟩ | ⟨rfl, h⟩    · exact Or.inl ⟨rfl, by cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩    · cases a <;> cases b <;> simp [OAI.EditApproximation.bitOrdering, OAI.EditApproximation.orderingMatches]    · exact Or.inr (Or.inr ⟨rfl, by        cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩)  have proof_bitCompareWithWork_matches_5 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitCompareWithWork left right).1 (OAI.EditApproximation.bitWordValue left) (OAI.EditApproximation.bitWordValue right) := by    induction left generalizing right with    | nil =>      simp only [OAI.EditApproximation.bitCompareWithWork]      induction right with      | nil => (simp [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.orderingMatches, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        simpa only [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareNilLeftWithWork bs).1 false b 0 (OAI.EditApproximation.bitWordValue bs) ih    | cons a as ih =>      cases right with      | nil =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as []).1 a false (OAI.EditApproximation.bitWordValue as) 0 (ih [])      | cons b bs =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue] using          proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as bs).1 a b (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs) (ih bs)  have proof_bitCompareWithWork_lt_16 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .lt ↔ OAI.EditApproximation.bitWordValue left < OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_bitSubtractor_value_17 (a : Bool) (b : Bool) (borrow : Bool) :      a.toNat + 2 * (OAI.EditApproximation.bitBorrow a b borrow).toNat =        b.toNat + borrow.toNat + (OAI.EditApproximation.bitDifference a b borrow).toNat := by    cases a <;> cases b <;> cases borrow <;> decide  have proof_bitSubtractionRippleEquation_18 (a : ℕ) (b : ℕ) (borrow : ℕ) (nextBorrow : ℕ) (difference : ℕ) (left : ℕ) (right : ℕ) (result : ℕ) (tail : ℕ) (htail : Eq.{1} (HAdd.hAdd.{0, 0, 0} (HAdd.hAdd.{0, 0, 0} result right) nextBorrow) (HAdd.hAdd.{0, 0, 0} left tail)) (hbit : Eq.{1} (HAdd.hAdd.{0, 0, 0} a (HMul.hMul.{0, 0, 0} 2 nextBorrow))    (HAdd.hAdd.{0, 0, 0} (HAdd.hAdd.{0, 0, 0} b borrow) difference)) :      (difference + 2 * result) + (b + 2 * right) + borrow =        (a + 2 * left) + 2 * tail := by    omega  have proof_bitSubtractWithWork_value_19 (left : List.{0} Bool) (right : List.{0} Bool) (borrow : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork left right borrow).1 + OAI.EditApproximation.bitWordValue right + borrow.toNat =        OAI.EditApproximation.bitWordValue left + 2 ^ max left.length right.length *          (OAI.EditApproximation.bitSubtractWithWork left right borrow).2.1.toNat := by    induction left generalizing right borrow with    | nil =>      induction right generalizing borrow with      | nil => (simp [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitSubtractNilLeftWithWork, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        have h := ih (OAI.EditApproximation.bitBorrow false b borrow)        have hb := proof_bitSubtractor_value_17 false b borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitSubtractNilLeftWithWork, OAI.EditApproximation.bitWordValue,          List.length_nil, List.length_cons, Nat.zero_max, pow_succ, Bool.toNat_false] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 0 b.toNat borrow.toNat (OAI.EditApproximation.bitBorrow false b borrow).toNat          (OAI.EditApproximation.bitDifference false b borrow).toNat 0 (OAI.EditApproximation.bitWordValue bs)          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractNilLeftWithWork bs (OAI.EditApproximation.bitBorrow false b borrow)).1)          (2 ^ bs.length * (OAI.EditApproximation.bitSubtractNilLeftWithWork bs (OAI.EditApproximation.bitBorrow false b borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_zero, Nat.add_zero, Nat.zero_add, Nat.mul_assoc,          Nat.mul_left_comm] using hs    | cons a as ih =>      cases right with      | nil =>        have h := ih [] (OAI.EditApproximation.bitBorrow a false borrow)        have hb := proof_bitSubtractor_value_17 a false borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitWordValue, List.length_nil, List.length_cons,          Nat.max_zero, pow_succ, Bool.toNat_false] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 a.toNat 0 borrow.toNat (OAI.EditApproximation.bitBorrow a false borrow).toNat          (OAI.EditApproximation.bitDifference a false borrow).toNat (OAI.EditApproximation.bitWordValue as) 0          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork as [] (OAI.EditApproximation.bitBorrow a false borrow)).1)          (2 ^ as.length * (OAI.EditApproximation.bitSubtractWithWork as [] (OAI.EditApproximation.bitBorrow a false borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_zero, Nat.add_zero, Nat.zero_add, Nat.mul_assoc,          Nat.mul_left_comm] using hs      | cons b bs =>        have h := ih bs (OAI.EditApproximation.bitBorrow a b borrow)        have hb := proof_bitSubtractor_value_17 a b borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitWordValue, List.length_cons, Nat.succ_max_succ,          pow_succ] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 a.toNat b.toNat borrow.toNat (OAI.EditApproximation.bitBorrow a b borrow).toNat          (OAI.EditApproximation.bitDifference a b borrow).toNat (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs)          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork as bs (OAI.EditApproximation.bitBorrow a b borrow)).1)          (2 ^ max as.length bs.length * (OAI.EditApproximation.bitSubtractWithWork as bs (OAI.EditApproximation.bitBorrow a b borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_assoc, Nat.mul_left_comm] using hs  have proof_bitWordValue_lt_pow_length_20 (bits : List.{0} Bool) : OAI.EditApproximation.bitWordValue bits < 2 ^ bits.length := by    induction bits with    | nil => (simp [OAI.EditApproximation.bitWordValue])    | cons bit bits ih =>      cases bit <;> (simp only [OAI.EditApproximation.bitWordValue, List.length_cons, pow_succ, Bool.toNat_false, Bool.toNat_true]) <;> omega  have proof_bitSubtractWithWork_length_21 (left : List.{0} Bool) (right : List.{0} Bool) (borrow : Bool) :      (OAI.EditApproximation.bitSubtractWithWork left right borrow).1.length = max left.length right.length := by    induction left generalizing right borrow with    | nil =>      simp only [OAI.EditApproximation.bitSubtractWithWork]      induction right generalizing borrow with      | nil => simp [OAI.EditApproximation.bitSubtractNilLeftWithWork]      | cons b bs ih => simp [OAI.EditApproximation.bitSubtractNilLeftWithWork, ih]    | cons a as ih =>      cases right with      | nil => simp [OAI.EditApproximation.bitSubtractWithWork, ih]      | cons b bs => simp [OAI.EditApproximation.bitSubtractWithWork, ih, Nat.succ_max_succ]  have proof_bitSubtractWithWork_sub_22 (left : List.{0} Bool) (right : List.{0} Bool) (h : LE.le.{0} (OAI.EditApproximation.bitWordValue right) (OAI.EditApproximation.bitWordValue left)) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork left right false).1 = OAI.EditApproximation.bitWordValue left - OAI.EditApproximation.bitWordValue right := by    have hvalue := proof_bitSubtractWithWork_value_19 left right false    have hlt := proof_bitWordValue_lt_pow_length_20 (OAI.EditApproximation.bitSubtractWithWork left right false).1    rw [proof_bitSubtractWithWork_length_21] at hlt    cases hb : (OAI.EditApproximation.bitSubtractWithWork left right false).2.1    · simp only [hb, Bool.toNat_false, Nat.mul_zero, Nat.add_zero] at hvalue      omega    · simp only [hb, Bool.toNat_true, Bool.toNat_false, Nat.mul_one, Nat.add_zero] at hvalue      omega  have proof_bitDivModWithWork_value_23 (divisor : List.{0} Bool) (bits : List.{0} Bool) (hd : LT.lt.{0} 0 (OAI.EditApproximation.bitWordValue divisor)) :      OAI.EditApproximation.bitWordValue bits = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).1 +        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 ∧        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 < OAI.EditApproximation.bitWordValue divisor := by    induction bits with    | nil => (simp [OAI.EditApproximation.bitDivModWithWork, OAI.EditApproximation.bitWordValue, hd])    | cons bit bits ih =>      let previous := OAI.EditApproximation.bitDivModWithWork divisor bits      let candidate := bit :: previous.2.1      have hp : OAI.EditApproximation.bitWordValue bits = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue previous.1 +          OAI.EditApproximation.bitWordValue previous.2.1 := ih.1      have hr : OAI.EditApproximation.bitWordValue previous.2.1 < OAI.EditApproximation.bitWordValue divisor := ih.2      have hc : OAI.EditApproximation.bitWordValue candidate < 2 * OAI.EditApproximation.bitWordValue divisor := by        dsimp only [candidate, OAI.EditApproximation.bitWordValue]        cases bit <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega      by_cases hlt : (OAI.EditApproximation.bitCompareWithWork candidate divisor).1 = .lt      · have hv := (proof_bitCompareWithWork_lt_16 candidate divisor).1 hlt        simp only [OAI.EditApproximation.bitDivModWithWork, show (OAI.EditApproximation.bitCompareWithWork (bit :: (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1)          divisor).1 = .lt from hlt, ↓reduceIte]        change OAI.EditApproximation.bitWordValue (bit :: bits) = OAI.EditApproximation.bitWordValue divisor *          OAI.EditApproximation.bitWordValue (false :: previous.1) + OAI.EditApproximation.bitWordValue candidate ∧ OAI.EditApproximation.bitWordValue candidate < _        constructor        · (simp only [OAI.EditApproximation.bitWordValue, Bool.toNat_false])          dsimp only [candidate, OAI.EditApproximation.bitWordValue]          nlinarith only [hp]        · exact hv      · have hv : OAI.EditApproximation.bitWordValue divisor ≤ OAI.EditApproximation.bitWordValue candidate := by          exact Nat.le_of_not_gt (fun h => hlt ((proof_bitCompareWithWork_lt_16 candidate divisor).2 h))        have hs := proof_bitSubtractWithWork_sub_22 candidate divisor hv        simp only [OAI.EditApproximation.bitDivModWithWork, show (OAI.EditApproximation.bitCompareWithWork (bit :: (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1)          divisor).1 ≠ .lt from hlt, ↓reduceIte]        change OAI.EditApproximation.bitWordValue (bit :: bits) = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue (true :: previous.1) +          OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork candidate divisor false).1 ∧          OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork candidate divisor false).1 < _        rw [hs]        constructor        · (simp only [OAI.EditApproximation.bitWordValue, Bool.toNat_true])          have he := Nat.sub_add_cancel hv          dsimp only [candidate, OAI.EditApproximation.bitWordValue] at he ⊢          nlinarith only [hp, he]        · omega  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_binaryNaturalDivModWithWork_spec_24 (n : ℕ) (d : ℕ) (hd : LT.lt.{0} 0 d) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalDivModWithWork n d).1 = n / d ∧        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalDivModWithWork n d).2.1 = n % d := by    have h := proof_bitDivModWithWork_value_23 d.bits n.bits (by simpa only [proof_bitWordValue_bits_15] using hd)    simp only [proof_bitWordValue_bits_15] at h    have hmod : n % d = OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork d.bits n.bits).2.1 := by      conv_lhs => rw [h.1]      simp only [Nat.add_mod, Nat.mul_mod_right, Nat.zero_add, Nat.mod_eq_of_lt h.2]    have hdiv : n / d = OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork d.bits n.bits).1 := by      conv_lhs => rw [h.1]      rw [Nat.mul_add_div hd, Nat.div_eq_of_lt h.2, Nat.add_zero]    exact ⟨hdiv.symm, hmod.symm⟩  exact    let result := OAI.EditApproximation.binaryNaturalDivModWithWork value bound    (⟨OAI.EditApproximation.bitWordValue result.2.1, by      rw [(proof_binaryNaturalDivModWithWork_spec_24 value bound hb).2]      exact Nat.mod_lt value hb⟩, result.2.2 + 1)def coarseDenominatorWithWork (allowanceDen q L branching : List Bool) (D : ℕ) :    List Bool × ℕ :=  let first := OAI.EditApproximation.bitMulWithWork L branching  let base := OAI.EditApproximation.bitMulWithWork first.1 q  let trimmedBase := OAI.EditApproximation.trimBitWordWithWork base.1  let power := OAI.EditApproximation.bitPowerWithWork trimmedBase.1 D  let initial := OAI.EditApproximation.bitMulWithWork allowanceDen q  let product := OAI.EditApproximation.bitMulWithWork initial.1 power.1  let result := OAI.EditApproximation.trimBitWordWithWork product.1  (result.1, first.2 + base.2 + trimmedBase.2 + power.2 + initial.2 + product.2 + result.2 + 7)def coarseFramedReadWithWork {α : Type u_1} (k n : ℕ) (word : List α) (i : ℕ) :    Option (Option α) × ℕ :=  let lower := OAI.EditApproximation.binaryNaturalCompareWithWork i k  if lower.1 = .lt then (none, lower.2 + Nat.size k + Nat.size n + Nat.size i + 2) else  let finish := OAI.EditApproximation.binaryNaturalAddWithWork k n  let upper := OAI.EditApproximation.binaryNaturalCompareWithWork i (OAI.EditApproximation.bitWordValue finish.1)  if upper.1 = .lt then    let offset := OAI.EditApproximation.saturatingSubtractWithWork i k    (some word[OAI.EditApproximation.bitWordValue offset.1]?, lower.2 + finish.2 + upper.2 + offset.2 +      Nat.size k + Nat.size n + Nat.size i + 4)  else (none, lower.2 + finish.2 + upper.2 + Nat.size k + Nat.size n + Nat.size i + 3)def coarseDescriptorWithWork (B d n start : ℕ) : List Bool × ℕ :=  let capacity := OAI.EditApproximation.bitPowerWithWork B.bits d  let remaining := OAI.EditApproximation.saturatingSubtractWithWork n start  let clipped := OAI.EditApproximation.wordMinWithWork capacity.1 remaining.1  (clipped.1, capacity.2 + remaining.2 + clipped.2 +    Nat.size B + Nat.size d + Nat.size n + Nat.size start + 4)def coarseChildOffsetWithWork (offset capacity index : ℕ) : List Bool × ℕ :=  let displacement := OAI.EditApproximation.binaryNaturalMulWithWork index capacity  let result := OAI.EditApproximation.binaryNaturalAddWithWork offset (OAI.EditApproximation.bitWordValue displacement.1)  (result.1, displacement.2 + result.2 + Nat.size index + Nat.size capacity + Nat.size offset + 3)def coarseInputGuardWithWork (sourceLo sourceHi targetLo targetHi : ℕ) : Bool × ℕ :=  let sourceWidth := OAI.EditApproximation.saturatingSubtractWithWork sourceHi sourceLo  let targetWidth := OAI.EditApproximation.saturatingSubtractWithWork targetHi targetLo  let twice := OAI.EditApproximation.binaryNaturalMulWithWork 2 (OAI.EditApproximation.bitWordValue sourceWidth.1)  let compared := OAI.EditApproximation.binaryNaturalCompareWithWork (OAI.EditApproximation.bitWordValue twice.1) (OAI.EditApproximation.bitWordValue targetWidth.1)  (decide (compared.1 = .lt), sourceWidth.2 + targetWidth.2 + twice.2 + compared.2 + 6)def bitPowerAllocation (base : List Bool) : ℕ → ℕ  | 0 => 1  | n + 1 =>    let previous := (OAI.EditApproximation.bitPowerWithWork base n).1    bitPowerAllocation base n + OAI.EditApproximation.bitMulAllocation previous base +      OAI.EditApproximation.trimBitWordAllocation (OAI.EditApproximation.bitMulWithWork previous base).1def bitCeilDivAllocation (divisor bits : List Bool) : ℕ :=  let divided := OAI.EditApproximation.bitDivModWithWork divisor bits  OAI.EditApproximation.bitDivModAllocation divisor bits +    if (OAI.EditApproximation.bitCompareWithWork divided.2.1 []).1 = .eq then 0    else 1 + OAI.EditApproximation.bitAddAllocation divided.1 [true] falsedef binaryNaturalMulAllocation (a b : ℕ) : ℕ := OAI.EditApproximation.bitMulAllocation a.bits b.bitsdef binaryNaturalDivAllocation (a b : ℕ) : ℕ := OAI.EditApproximation.bitDivModAllocation b.bits a.bitsdef triangularMassAllocation (K : ℕ) : ℕ :=  let next := (OAI.EditApproximation.binaryNaturalAddWithWork K 1).1  let product := (OAI.EditApproximation.binaryNaturalMulWithWork K (OAI.EditApproximation.bitWordValue next)).1  OAI.EditApproximation.bitAddAllocation K.bits (1 : ℕ).bits false +    OAI.EditApproximation.bitMulAllocation K.bits (OAI.EditApproximation.bitWordValue next).bits +    OAI.EditApproximation.bitDivModAllocation (2 : ℕ).bits (OAI.EditApproximation.bitWordValue product).bitsdef binaryIntervalRoundWithWork (spacing lo hi : ℕ) : (List Bool × List Bool) × ℕ :=  let left := OAI.EditApproximation.binaryGridRoundWithWork spacing lo  let right := OAI.EditApproximation.binaryGridRoundWithWork spacing hi  ((left.1, right.1), left.2 + right.2 + 1)def computedQueryBase (N : ℕ) : List Bool :=  (OAI.EditApproximation.refinementBaseWithWork (OAI.EditApproximation.inputSmallLog N).bits).1def coarsePreparedSlicesWithWork (source target : List ℕ)    (sourceLo sourceHi targetLo targetHi : ℕ) : Option (List ℕ × List ℕ) × ℕ :=  let guard := OAI.EditApproximation.coarseInputGuardWithWork sourceLo sourceHi targetLo targetHi  if guard.1 then (none, guard.2) else  let copiedSource := OAI.EditApproximation.coarseRangeCopyWithWork (fun i => source[i]?.getD 0) sourceLo (sourceHi - sourceLo)  let copiedTarget := OAI.EditApproximation.coarseRangeCopyWithWork (fun i => target[i]?.getD 0) targetLo (targetHi - targetLo)  (some (copiedSource.1, copiedTarget.1), guard.2 + copiedSource.2 + copiedTarget.2)def gridPointsAllocation (g lo hi : ℕ) : ℕ :=  let lower := (OAI.EditApproximation.bitCeilDivWithWork g.bits lo.bits).1  let upper := (OAI.EditApproximation.binaryNaturalDivModWithWork hi g).1  let stop := (OAI.EditApproximation.binaryNaturalAddWithWork (OAI.EditApproximation.bitWordValue upper) 1).1  let count := (OAI.EditApproximation.saturatingSubtractWithWork (OAI.EditApproximation.bitWordValue stop) (OAI.EditApproximation.bitWordValue lower)).1  let indices := List.range' (OAI.EditApproximation.bitWordValue lower) (OAI.EditApproximation.bitWordValue count)  OAI.EditApproximation.bitCeilDivAllocation g.bits lo.bits + OAI.EditApproximation.binaryNaturalDivAllocation hi g +    OAI.EditApproximation.binaryNaturalAddAllocation (OAI.EditApproximation.bitWordValue upper) 1 +    OAI.EditApproximation.saturatingSubtractAllocation (OAI.EditApproximation.bitWordValue stop) (OAI.EditApproximation.bitWordValue lower) +    indices.length + OAI.EditApproximation.arithmeticMapAllocation (fun i => OAI.EditApproximation.binaryNaturalMulAllocation g i) indicesdef balancedCutAllocation (lo width M i : ℕ) : ℕ :=  let product := (OAI.EditApproximation.binaryNaturalMulWithWork i width).1  let quotient := (OAI.EditApproximation.binaryNaturalDivModWithWork (OAI.EditApproximation.bitWordValue product) M).1  OAI.EditApproximation.binaryNaturalMulAllocation i width + OAI.EditApproximation.binaryNaturalDivAllocation (OAI.EditApproximation.bitWordValue product) M +    OAI.EditApproximation.binaryNaturalAddAllocation lo (OAI.EditApproximation.bitWordValue quotient)def seedGridSpacingAllocation (b P : ℕ) : ℕ :=  OAI.EditApproximation.binaryNaturalDivAllocation b P + OAI.EditApproximation.naturalWordLEAllocation (OAI.EditApproximation.binaryNaturalDivModWithWork b P).1 [true] + 1def queryCellValidAllocation (n exponent : ℕ) (cell : ℕ × ℕ) : ℕ :=  let cap := (OAI.EditApproximation.binaryNaturalMulWithWork n (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.powerTwoWord exponent))).1  OAI.EditApproximation.binaryNaturalMulAllocation n (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.powerTwoWord exponent)) +    OAI.EditApproximation.naturalWordLEAllocation cell.1.bits cap + OAI.EditApproximation.naturalWordLEAllocation cell.2.bits cap + exponent + 1def queryPairAllocation (a b : ℕ) : ℕ :=  a.bits.length + b.bits.length +    if (OAI.EditApproximation.binaryNaturalCompareWithWork a b).1 = .lt then      OAI.EditApproximation.binaryNaturalMulAllocation b b + OAI.EditApproximation.binaryNaturalAddAllocation (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalMulWithWork b b).1) a    else      OAI.EditApproximation.binaryNaturalMulAllocation a a + OAI.EditApproximation.binaryNaturalAddAllocation (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalMulWithWork a a).1) a +        OAI.EditApproximation.binaryNaturalAddAllocation          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalAddWithWork (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalMulWithWork a a).1) a).1) bdef binaryGridRoundAllocation (spacing position : ℕ) : ℕ :=  OAI.EditApproximation.binaryNaturalDivAllocation position spacing +    OAI.EditApproximation.bitMulAllocation spacing.bits (OAI.EditApproximation.binaryNaturalDivModWithWork position spacing).1def wordSortAllocation : List (List Bool) → ℕ  | [] => 0  | a :: rest => wordSortAllocation rest +    OAI.EditApproximation.wordInsertAllocation a (OAI.EditApproximation.wordSortWithWork rest).1 + 0def reduceOnlineIntegerAllocation (K integer : ℕ) : ℕ :=  OAI.EditApproximation.triangularMassAllocation K +    OAI.EditApproximation.bitDivModAllocation (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.triangularMassWithWork K).1).bits integer.bits + Nat.size integerdef coarsePreparedInputStorage (source target : List ℕ)    (sourceLo sourceHi targetLo targetHi : ℕ) : ℕ :=  match (OAI.EditApproximation.coarsePreparedSlicesWithWork source target sourceLo sourceHi targetLo targetHi).1 with  | none => 1  | some (x, y) => 1 + OAI.EditApproximation.storedNaturalBits x + OAI.EditApproximation.storedNaturalBits yend OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen Finsetdef optimizerTriangularMass (K : ℕ) : ℕ := ∑ j ∈ range K, (j + 1)def rationalLogApproximation (r : ℚ) (K : ℕ) : ℚ :=  2 * ∑ k ∈ range K, (((r - 1) / (r + 1)) ^ (2 * k + 1) / (2 * k + 1))def rationalLinearizationMaximizer {ι : Type u_1} (coordinates : Finset ι)    (vertices : List (ι → ℚ)) (gradient : ι → ℚ) : ι → ℚ :=  (vertices.argmax fun p => ∑ i ∈ coordinates, gradient i * p i).getD (fun _ => 0)def bandCoordinates {β : Type u_1} {σ : Type u_2} [Fintype β] [DecidableEq β] [DecidableEq σ]    (band : Finset (β → σ)) : Finset (β × σ) :=  band.biUnion fun action => univ.image fun child => (child, action child)def actionVector {β : Type u_1} {σ : Type u_2} [Fintype β] [DecidableEq σ]    (mass : β → ℚ) (action : β → σ) (coordinate : β × σ) : ℚ :=  if coordinate.2 = action coordinate.1 then mass coordinate.1 / (∑ child, mass child) else 0def rationalOptimisticHistory {ι : Type u_1} (κ : ℚ)    (gain decrement : ℕ → ι → ℚ) (t : ℕ) (i : ι) : ℚ :=  ∑ j ∈ range t, (gain j i + (1 - 2 * κ) * decrement j i)def rejectionBitCount (N : ℕ) : ℕ := Nat.clog 2 Ndef vectorMapWithWork {α : Type u_1} (d : ℕ) (f : Fin d → α × ℕ) : Vector α d × ℕ :=  let cells := Vector.ofFn f  (cells.map Prod.fst, (cells.map Prod.snd).toList.sum + 6 * d)def TreeLayer (M : ℕ) : ℕ → Type  | 0 => PUnit  | d + 1 => TreeLayer M d × Fin Mdef intervalTreeDepth (M nx : ℕ) : ℕ := Nat.clog M (max 1 nx)def rationalMaximum (fallback : ℚ) : List ℚ → ℚ  | [] => fallback  | value :: rest => max value (rationalMaximum fallback rest)def rationalDyadicCeiling (value : ℚ) : ℚ := (2 : ℚ) ^ Int.clog 2 valuedef listedBandCoordinates {M : ℕ} {σ : Type u_1} [DecidableEq σ]    (band : List (Fin M → σ)) : List (Fin M × σ) :=  (band.flatMap fun action => List.ofFn fun child => (child, action child)).dedupdef childGain {β : Type u_1} {σ : Type u_2} (mass : β → ℚ) (table : ℕ → β × σ → ℚ)    (t : ℕ) (i : β × σ) : ℚ := -table t i / mass i.1def childDecrement {β : Type u_1} {σ : Type u_2} (mass : β → ℚ) (table : ℕ → β × σ → ℚ)    (t : ℕ) (i : β × σ) : ℚ := (table t i - table (t + 1) i) / mass i.1def naturalEqualWithWork (a b : ℕ) : Bool × ℕ :=  let result := OAI.EditApproximation.binaryNaturalCompareWithWork a b  (decide (result.1 = .eq), result.2 + 1)def translatedEndpointWithWork (reference root endpoint : ℕ) : ℕ × ℕ :=  let difference := OAI.EditApproximation.binaryNaturalSubtractWithWork endpoint root  let result := OAI.EditApproximation.binaryNaturalAddWithWork reference (OAI.EditApproximation.bitWordValue difference.1)  (OAI.EditApproximation.bitWordValue result.1, difference.2 + result.2 + 2)def rationalOnlineMinimum : List ℚ → Option ℚ  | [] => none  | first :: rest => some (OAI.EditApproximation.rationalMinimum first rest)def dyadicQueryWindow (N : ℕ) (w a F : ℚ) : List ℕ :=  (OAI.EditApproximation.dyadicScales N).filter fun (b : ℕ) => decide (w / (16 * F) ≤ b ∧ (b : ℚ) ≤ 8 * a * w)def actionCurrentInputCover {Parent : Type u_1} {Child : Type u_2} [DecidableEq Child] {M : ℕ}    (actions : List (OAI.EditApproximation.RationalBellmanAction Parent Child M)) : Finset Child :=  (List.finRange actions.length).toFinset.biUnion fun index =>    Finset.univ.image (actions.get index).childStatedef boundedOnlineInteger (n : ℕ) (hn : 0 < n) (integer : ℕ) : Fin n :=  ⟨integer % n, Nat.mod_lt _ hn⟩def orderedInputs {ι : Type u_1} [DecidableEq ι] (encode : ι → ℕ)    (hinjective : Function.Injective encode) (inputs : Finset ι) : List ι :=  let _ : LinearOrder ι := LinearOrder.lift' encode hinjective  inputs.sort (· ≤ ·)def CoarseThresholdDraws (B : ℕ) : ℕ → Type  | 0 => PUnit  | D + 1 => (Fin B → Fin B) × (Fin B → CoarseThresholdDraws B D)def coarseThresholdContribution (threshold scale value : ℚ) : ℚ :=  if threshold ≤ value then max value scale else 0def coarseChildThreshold (B : ℕ) (Q allowance : ℚ) (draw : Fin B) : ℚ :=  allowance * (draw.val + 1 : ℕ) / ((B : ℚ) * Q)def coarseCommonDenominator (allowanceDen q L B D : ℕ) : ℕ :=  allowanceDen * q * (L * B * q) ^ Ddef rationalSmoothedGradient {ι : Type u_1} (G : ℕ) (linear p : ι → ℚ) (i : ι) : ℚ :=  -OAI.EditApproximation.rationalLogApproximation (p i + 1 / (G : ℚ) ^ 50) (G ^ 60) - 1 + linear idef rationalOnlineLinear {ι : Type u_1} (η κ : ℚ)    (gain decrement : ℕ → ι → ℚ) (t : ℕ) (i : ι) : ℚ :=  η * (OAI.EditApproximation.rationalOptimisticHistory κ gain decrement t i + gain t i)def triangularChoice : (K : ℕ) → Fin (OAI.EditApproximation.optimizerTriangularMass K) → Fin K  | 0, integer => Fin.elim0 integer  | K + 1, integer =>    if h : integer.val < OAI.EditApproximation.optimizerTriangularMass K then      (triangularChoice K ⟨integer.val, h⟩).castSucc    else ⟨K, by omega⟩instance treeLayerFintype (M : ℕ) : (d : ℕ) → Fintype (OAI.EditApproximation.TreeLayer M d)  | 0 => inferInstanceAs (Fintype PUnit)  | d + 1 =>    letI := treeLayerFintype M d    inferInstanceAs (Fintype (OAI.EditApproximation.TreeLayer M d × Fin M))abbrev PhysicalNode (M J : ℕ) := Σ d : Fin (J + 1), OAI.EditApproximation.TreeLayer M d.valdef finiteRationalOptimizer {ι : Type u_1} (coordinates : Finset ι)    (vertices : List (ι → ℚ)) (linear : ι → ℚ) (G : ℕ) : ℕ → ι → ℚ  | 0 => vertices.headD (fun _ => 0)  | j + 1 =>    let p := finiteRationalOptimizer coordinates vertices linear G j    let selected := OAI.EditApproximation.rationalLinearizationMaximizer coordinates vertices      (OAI.EditApproximation.rationalSmoothedGradient G linear p)    fun i => (1 - 2 / ((j : ℚ) + 2)) * p i + (2 / ((j : ℚ) + 2)) * selected iinstance physicalNodeFintype (M J : ℕ) : Fintype (OAI.EditApproximation.PhysicalNode M J) := inferInstanceabbrev PhysicalInternalNode (M J : ℕ) := {node : OAI.EditApproximation.PhysicalNode M J // node.1.val < J}def finiteOptimizerAction {β : Type u_1} {σ : Type u_2} [Fintype β] [DecidableEq β] [DecidableEq σ]    (band : List (β → σ)) (hband : band ≠ []) (mass : β → ℚ)    (linear : β × σ → ℚ) (G j : ℕ) : β → σ :=  let coordinates := OAI.EditApproximation.bandCoordinates band.toFinset  let vertices := band.map (OAI.EditApproximation.actionVector mass)  let gradient := OAI.EditApproximation.rationalSmoothedGradient G linear (OAI.EditApproximation.finiteRationalOptimizer coordinates vertices linear G j)  (band.argmax fun action => ∑ coordinate ∈ coordinates,    gradient coordinate * OAI.EditApproximation.actionVector mass action coordinate).getD (band.head hband)def finiteOptimizerActionDraw {β : Type u_1} {σ : Type u_2} [Fintype β] [DecidableEq β] [DecidableEq σ]    (band : List (β → σ)) (hband : band ≠ []) (mass : β → ℚ)    (linear : β × σ → ℚ) (G K : ℕ) (integer : Fin (OAI.EditApproximation.optimizerTriangularMass K)) : β → σ :=  OAI.EditApproximation.finiteOptimizerAction band hband mass linear G (OAI.EditApproximation.triangularChoice K integer).valend OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.BinaryFractiondef width (a : OAI.EditApproximation.BinaryFraction) : ℕ := max a.numerator.bits.length a.denominator.lengthdef denominatorInteger (a : OAI.EditApproximation.BinaryFraction) : OAI.EditApproximation.SignedBinary := ⟨false, a.denominator⟩def zero : OAI.EditApproximation.BinaryFraction := ⟨⟨false, []⟩, [true], by decide⟩def canonicalizeWithWork (a : OAI.EditApproximation.BinaryFraction) : OAI.EditApproximation.BinaryFraction × ℕ := by  have proof_trimBitWordWithWork_value_6 (bits : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.trimBitWordWithWork bits).1 = OAI.EditApproximation.bitWordValue bits := by    induction bits with    | nil => rfl    | cons bit bits ih =>      simp only [OAI.EditApproximation.trimBitWordWithWork]      split_ifs with h      · have ht : OAI.EditApproximation.bitWordValue bits = 0 := by rw [← ih, h.1]; rfl        simp [h.2, OAI.EditApproximation.bitWordValue, ht]      · (simp only [OAI.EditApproximation.bitWordValue, ih])  exact    let numerator := OAI.EditApproximation.trimBitWordWithWork a.numerator.bits    let denominator := OAI.EditApproximation.trimBitWordWithWork a.denominator    (⟨⟨a.numerator.negative, numerator.1⟩, denominator.1, by        rw [proof_trimBitWordWithWork_value_6]        exact a.denominator_pos⟩, numerator.2 + denominator.2 + 2)def inversePowerTwo (n : ℕ) : OAI.EditApproximation.BinaryFraction := by  have proof_powerTwoWord_value_13 (n : ℕ) : OAI.EditApproximation.bitWordValue (OAI.EditApproximation.powerTwoWord n) = 2 ^ n := by    induction n with    | zero => (simp [OAI.EditApproximation.powerTwoWord, OAI.EditApproximation.bitWordValue])    | succ n ih =>      (simp only [OAI.EditApproximation.powerTwoWord, List.replicate_succ, List.cons_append, OAI.EditApproximation.bitWordValue,        Bool.toNat_false, zero_add] at *)      rw [ih, pow_succ]      omega  exact    ⟨⟨false, [true]⟩, OAI.EditApproximation.powerTwoWord n, by rw [proof_powerTwoWord_value_13]; positivity⟩def doubleFraction (a : OAI.EditApproximation.BinaryFraction) : OAI.EditApproximation.BinaryFraction :=  ⟨⟨a.numerator.negative, false :: a.numerator.bits⟩, a.denominator, a.denominator_pos⟩def absolute (a : OAI.EditApproximation.BinaryFraction) : OAI.EditApproximation.BinaryFraction :=  ⟨⟨false, a.numerator.bits⟩, a.denominator, a.denominator_pos⟩def naturalCeilingWithWork (a : OAI.EditApproximation.BinaryFraction) : List Bool × ℕ :=  if a.numerator.negative then ([], 1)  else    let result := OAI.EditApproximation.bitCeilDivWithWork a.denominator a.numerator.bits    (result.1, result.2 + 1)def ofNaturalWord (bits : List Bool) : OAI.EditApproximation.BinaryFraction :=  ⟨⟨false, bits⟩, [true], by decide⟩def naturalFloorWithWork (a : OAI.EditApproximation.BinaryFraction) : List Bool × ℕ :=  if a.numerator.negative then ([], 1) else    let quotient := OAI.EditApproximation.bitDivModWithWork a.denominator a.numerator.bits    (quotient.1, quotient.2.2 + 1)def queryDataReadBudget (M n : ℕ) {κ : Type u_1} (keys : List κ) : ℕ :=  1 + keys.length * (24 * max (Nat.size M) (Nat.size n) + 9)def onlineParametersWithWork (ell : List Bool) (hell : 0 < OAI.EditApproximation.bitWordValue ell) :    (OAI.EditApproximation.BinaryFraction × OAI.EditApproximation.BinaryFraction) × ℕ := by  have proof_trimBitWordWithWork_value_6 (bits : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.trimBitWordWithWork bits).1 = OAI.EditApproximation.bitWordValue bits := by    induction bits with    | nil => rfl    | cons bit bits ih =>      simp only [OAI.EditApproximation.trimBitWordWithWork]      split_ifs with h      · have ht : OAI.EditApproximation.bitWordValue bits = 0 := by rw [← ih, h.1]; rfl        simp [h.2, OAI.EditApproximation.bitWordValue, ht]      · (simp only [OAI.EditApproximation.bitWordValue, ih])  have proof_bitAdder_value_1 (a : Bool) (b : Bool) (carry : Bool) :      (OAI.EditApproximation.bitSum a b carry).toNat + 2 * (OAI.EditApproximation.bitCarry a b carry).toNat =        a.toNat + b.toNat + carry.toNat := by    cases a <;> cases b <;> cases carry <;> decide  have proof_bitAddWithWork_value_2 (left : List.{0} Bool) (right : List.{0} Bool) (carry : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitAddWithWork left right carry).1 =        OAI.EditApproximation.bitWordValue left + OAI.EditApproximation.bitWordValue right + carry.toNat := by    induction left generalizing right carry with    | nil =>      simp only [OAI.EditApproximation.bitAddWithWork]      induction right generalizing carry with      | nil => cases carry <;> simp [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue]      | cons b bs ih =>        simp only [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 false b carry        simp only [Bool.toNat_false] at h        omega    | cons a as ih =>      cases right with      | nil =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a false carry        simp only [Bool.toNat_false] at h        omega      | cons b bs =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a b carry        omega  have proof_bitMulWithWork_value_0 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitMulWithWork left right).1 = OAI.EditApproximation.bitWordValue left * OAI.EditApproximation.bitWordValue right := by    induction left with    | nil => simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue]    | cons bit bits ih =>      cases bit <;> simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue, proof_bitAddWithWork_value_2, ih] <;> ring  have proof_bitPowerWithWork_value_76 (base : List.{0} Bool) (n : ℕ) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitPowerWithWork base n).1 = OAI.EditApproximation.bitWordValue base ^ n := by    induction n with    | zero => (simp [OAI.EditApproximation.bitPowerWithWork, OAI.EditApproximation.bitWordValue])    | succ n ih =>      simp only [OAI.EditApproximation.bitPowerWithWork, proof_trimBitWordWithWork_value_6, proof_bitMulWithWork_value_0, ih, pow_succ]  exact    let etaPower := OAI.EditApproximation.bitPowerWithWork ell 5    let kappaPower := OAI.EditApproximation.bitPowerWithWork ell 4    let eta : OAI.EditApproximation.BinaryFraction := ⟨⟨false, etaPower.1⟩, [true], by decide⟩    let kappa : OAI.EditApproximation.BinaryFraction := ⟨⟨false, [true]⟩, kappaPower.1, by      rw [proof_bitPowerWithWork_value_76]      exact Nat.pow_pos hell⟩    ((eta, kappa), etaPower.2 + kappaPower.2 + 2)def refinementDecrementWithWork (ell : List Bool) (hell : 0 < OAI.EditApproximation.bitWordValue ell) : OAI.EditApproximation.BinaryFraction × ℕ := by  have proof_trimBitWordWithWork_value_6 (bits : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.trimBitWordWithWork bits).1 = OAI.EditApproximation.bitWordValue bits := by    induction bits with    | nil => rfl    | cons bit bits ih =>      simp only [OAI.EditApproximation.trimBitWordWithWork]      split_ifs with h      · have ht : OAI.EditApproximation.bitWordValue bits = 0 := by rw [← ih, h.1]; rfl        simp [h.2, OAI.EditApproximation.bitWordValue, ht]      · (simp only [OAI.EditApproximation.bitWordValue, ih])  have proof_bitAdder_value_1 (a : Bool) (b : Bool) (carry : Bool) :      (OAI.EditApproximation.bitSum a b carry).toNat + 2 * (OAI.EditApproximation.bitCarry a b carry).toNat =        a.toNat + b.toNat + carry.toNat := by    cases a <;> cases b <;> cases carry <;> decide  have proof_bitAddWithWork_value_2 (left : List.{0} Bool) (right : List.{0} Bool) (carry : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitAddWithWork left right carry).1 =        OAI.EditApproximation.bitWordValue left + OAI.EditApproximation.bitWordValue right + carry.toNat := by    induction left generalizing right carry with    | nil =>      simp only [OAI.EditApproximation.bitAddWithWork]      induction right generalizing carry with      | nil => cases carry <;> simp [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue]      | cons b bs ih =>        simp only [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 false b carry        simp only [Bool.toNat_false] at h        omega    | cons a as ih =>      cases right with      | nil =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a false carry        simp only [Bool.toNat_false] at h        omega      | cons b bs =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a b carry        omega  have proof_bitMulWithWork_value_0 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitMulWithWork left right).1 = OAI.EditApproximation.bitWordValue left * OAI.EditApproximation.bitWordValue right := by    induction left with    | nil => simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue]    | cons bit bits ih =>      cases bit <;> simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue, proof_bitAddWithWork_value_2, ih] <;> ring  have proof_bitPowerWithWork_value_76 (base : List.{0} Bool) (n : ℕ) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitPowerWithWork base n).1 = OAI.EditApproximation.bitWordValue base ^ n := by    induction n with    | zero => (simp [OAI.EditApproximation.bitPowerWithWork, OAI.EditApproximation.bitWordValue])    | succ n ih =>      simp only [OAI.EditApproximation.bitPowerWithWork, proof_trimBitWordWithWork_value_6, proof_bitMulWithWork_value_0, ih, pow_succ]  exact    let denominator := OAI.EditApproximation.bitPowerWithWork ell 10    (⟨⟨false, [true]⟩, denominator.1, by      rw [proof_bitPowerWithWork_value_76]      exact Nat.pow_pos hell⟩, denominator.2 + 1)abbrev CoarseBinaryArray := Option (List OAI.EditApproximation.BinaryFraction)def coarseRootDenominator (B q L d : ℕ) : List Bool × ℕ :=  OAI.EditApproximation.coarseDenominatorWithWork (1 : ℕ).bits q.bits L.bits B.bits ddef naturalListEqualWithWork : List ℕ → List ℕ → Bool × ℕ  | [], [] => (true, 1)  | a :: left, b :: right =>    let test := OAI.EditApproximation.naturalEqualWithWork a b    if test.1 then      let tail := naturalListEqualWithWork left right      (tail.1, test.2 + tail.2 + 2)    else (false, test.2 + 2)  | _, _ => (false, 1)def canonicalizeAllocation (a : OAI.EditApproximation.BinaryFraction) : ℕ :=  OAI.EditApproximation.trimBitWordAllocation a.numerator.bits + OAI.EditApproximation.trimBitWordAllocation a.denominatordef invAllocation (a : OAI.EditApproximation.BinaryFraction) : ℕ :=  if (OAI.EditApproximation.bitCompareWithWork a.numerator.bits []).1 = .eq then 1 else 0def naturalCeilingAllocation (a : OAI.EditApproximation.BinaryFraction) : ℕ :=  if a.numerator.negative then 0 else OAI.EditApproximation.bitCeilDivAllocation a.denominator a.numerator.bitsdef gatheredLookupAllocation {κ : Type u_1} (equal : κ → κ → Bool × ℕ)    (allocation : κ → κ → ℕ) : List κ → List OAI.EditApproximation.BinaryFraction → κ → ℕ  | key :: keys, _value :: values, query =>    allocation query key + if (equal query key).1 then 0      else gatheredLookupAllocation equal allocation keys values query  | _, _, _ => 0def naturalFloorAllocation (a : OAI.EditApproximation.BinaryFraction) : ℕ :=  if a.numerator.negative then 0 else OAI.EditApproximation.bitDivModAllocation a.denominator a.numerator.bitsdef signedPowerTwoAllocation (e : ℤ) : ℕ :=  if 0 ≤ e then e.toNat + 2 else (-e).toNat + 2def invWithWork (a : OAI.EditApproximation.BinaryFraction) : OAI.EditApproximation.BinaryFraction × ℕ := by  have proof_bitOrdering_matches_4 (high : Ordering) (a : Bool) (b : Bool) (x : ℕ) (y : ℕ) (h : OAI.EditApproximation.orderingMatches high x y) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitOrdering high a b) (a.toNat + 2 * x) (b.toNat + 2 * y) := by    rcases h with ⟨rfl, h⟩ | ⟨rfl, rfl⟩ | ⟨rfl, h⟩    · exact Or.inl ⟨rfl, by cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩    · cases a <;> cases b <;> simp [OAI.EditApproximation.bitOrdering, OAI.EditApproximation.orderingMatches]    · exact Or.inr (Or.inr ⟨rfl, by        cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩)  have proof_bitCompareWithWork_matches_5 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitCompareWithWork left right).1 (OAI.EditApproximation.bitWordValue left) (OAI.EditApproximation.bitWordValue right) := by    induction left generalizing right with    | nil =>      simp only [OAI.EditApproximation.bitCompareWithWork]      induction right with      | nil => (simp [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.orderingMatches, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        simpa only [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareNilLeftWithWork bs).1 false b 0 (OAI.EditApproximation.bitWordValue bs) ih    | cons a as ih =>      cases right with      | nil =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as []).1 a false (OAI.EditApproximation.bitWordValue as) 0 (ih [])      | cons b bs =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue] using          proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as bs).1 a b (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs) (ih bs)  have proof_bitCompareWithWork_eq_3 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .eq ↔ OAI.EditApproximation.bitWordValue left = OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  exact    let comparison := OAI.EditApproximation.bitCompareWithWork a.numerator.bits []    if h : comparison.1 = .eq then (OAI.EditApproximation.BinaryFraction.zero, comparison.2 + 2) else      (⟨⟨a.numerator.negative, a.denominator⟩, a.numerator.bits, by        have hnonzero : OAI.EditApproximation.bitWordValue a.numerator.bits ≠ 0 := by          intro hzero          exact h ((proof_bitCompareWithWork_eq_3 a.numerator.bits []).2 hzero)        omega⟩, comparison.2 + 2)def signedPowerTwoWithWork (e : ℤ) : OAI.EditApproximation.BinaryFraction × ℕ :=  if 0 ≤ e then    (⟨⟨false, OAI.EditApproximation.powerTwoWord e.toNat⟩, [true], by decide⟩, e.toNat + 3)  else (OAI.EditApproximation.BinaryFraction.inversePowerTwo (-e).toNat, (-e).toNat + 3)def fixedDenominatorWithWork (a : OAI.EditApproximation.BinaryFraction) (denominator : List Bool)    (hden : 0 < OAI.EditApproximation.bitWordValue denominator) : OAI.EditApproximation.BinaryFraction × ℕ :=  let product := OAI.EditApproximation.bitMulWithWork a.numerator.bits denominator  let quotient := OAI.EditApproximation.bitDivModWithWork a.denominator product.1  let raw : OAI.EditApproximation.BinaryFraction := ⟨⟨a.numerator.negative, quotient.1⟩, denominator, hden⟩  let answer := OAI.EditApproximation.BinaryFraction.canonicalizeWithWork raw  (answer.1, product.2 + quotient.2.2 + answer.2 + 4)def finalAnswerWithWork (N : ℕ) (a : OAI.EditApproximation.BinaryFraction) : List Bool × ℕ :=  let floor := OAI.EditApproximation.BinaryFraction.naturalFloorWithWork a  let clamped := OAI.EditApproximation.wordMinWithWork N.bits floor.1  (clamped.1, floor.2 + clamped.2 + Nat.size N + 2)def coarseGridNatWithWork (denominator : List Bool)    (hden : 0 < OAI.EditApproximation.bitWordValue denominator) (n : ℕ) : OAI.EditApproximation.BinaryFraction × ℕ :=  let product := OAI.EditApproximation.bitMulWithWork n.bits denominator  let raw : OAI.EditApproximation.BinaryFraction := ⟨⟨false, product.1⟩, denominator, hden⟩  let answer := OAI.EditApproximation.BinaryFraction.canonicalizeWithWork raw  (answer.1, product.2 + answer.2 + 3)def coarseBinaryMapWithWork (f : OAI.EditApproximation.BinaryFraction → OAI.EditApproximation.BinaryFraction × ℕ) :    OAI.EditApproximation.BinaryFraction.CoarseBinaryArray → OAI.EditApproximation.BinaryFraction.CoarseBinaryArray × ℕ  | none => (none, 0)  | some values =>    let result := OAI.EditApproximation.arithmeticMapWithWork f values    (some result.1, result.2)def fixedDenominatorAllocation (a : OAI.EditApproximation.BinaryFraction) (denominator : List Bool)    (hden : 0 < OAI.EditApproximation.bitWordValue denominator) : ℕ :=  let product := OAI.EditApproximation.bitMulWithWork a.numerator.bits denominator  let quotient := OAI.EditApproximation.bitDivModWithWork a.denominator product.1  let raw : OAI.EditApproximation.BinaryFraction := ⟨⟨a.numerator.negative, quotient.1⟩, denominator, hden⟩  OAI.EditApproximation.bitMulAllocation a.numerator.bits denominator + OAI.EditApproximation.bitDivModAllocation a.denominator product.1 +    OAI.EditApproximation.BinaryFraction.canonicalizeAllocation rawdef finalAnswerAllocation (N : ℕ) (a : OAI.EditApproximation.BinaryFraction) : ℕ :=  OAI.EditApproximation.BinaryFraction.naturalFloorAllocation a + OAI.EditApproximation.naturalWordLEAllocation N.bits (OAI.EditApproximation.BinaryFraction.naturalFloorWithWork a).1 + Nat.size N + 1def powerDenominatorWithWork (a : OAI.EditApproximation.BinaryFraction) (base : List Bool)    (hbase : 0 < OAI.EditApproximation.bitWordValue base) (n : ℕ) : OAI.EditApproximation.BinaryFraction × ℕ := by  have proof_trimBitWordWithWork_value_6 (bits : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.trimBitWordWithWork bits).1 = OAI.EditApproximation.bitWordValue bits := by    induction bits with    | nil => rfl    | cons bit bits ih =>      simp only [OAI.EditApproximation.trimBitWordWithWork]      split_ifs with h      · have ht : OAI.EditApproximation.bitWordValue bits = 0 := by rw [← ih, h.1]; rfl        simp [h.2, OAI.EditApproximation.bitWordValue, ht]      · (simp only [OAI.EditApproximation.bitWordValue, ih])  have proof_bitAdder_value_1 (a : Bool) (b : Bool) (carry : Bool) :      (OAI.EditApproximation.bitSum a b carry).toNat + 2 * (OAI.EditApproximation.bitCarry a b carry).toNat =        a.toNat + b.toNat + carry.toNat := by    cases a <;> cases b <;> cases carry <;> decide  have proof_bitAddWithWork_value_2 (left : List.{0} Bool) (right : List.{0} Bool) (carry : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitAddWithWork left right carry).1 =        OAI.EditApproximation.bitWordValue left + OAI.EditApproximation.bitWordValue right + carry.toNat := by    induction left generalizing right carry with    | nil =>      simp only [OAI.EditApproximation.bitAddWithWork]      induction right generalizing carry with      | nil => cases carry <;> simp [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue]      | cons b bs ih =>        simp only [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 false b carry        simp only [Bool.toNat_false] at h        omega    | cons a as ih =>      cases right with      | nil =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a false carry        simp only [Bool.toNat_false] at h        omega      | cons b bs =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a b carry        omega  have proof_bitMulWithWork_value_0 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitMulWithWork left right).1 = OAI.EditApproximation.bitWordValue left * OAI.EditApproximation.bitWordValue right := by    induction left with    | nil => simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue]    | cons bit bits ih =>      cases bit <;> simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue, proof_bitAddWithWork_value_2, ih] <;> ring  have proof_bitPowerWithWork_value_76 (base : List.{0} Bool) (n : ℕ) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitPowerWithWork base n).1 = OAI.EditApproximation.bitWordValue base ^ n := by    induction n with    | zero => (simp [OAI.EditApproximation.bitPowerWithWork, OAI.EditApproximation.bitWordValue])    | succ n ih =>      simp only [OAI.EditApproximation.bitPowerWithWork, proof_trimBitWordWithWork_value_6, proof_bitMulWithWork_value_0, ih, pow_succ]  exact    let denominator := OAI.EditApproximation.bitPowerWithWork base n    let answer := OAI.EditApproximation.BinaryFraction.fixedDenominatorWithWork a denominator.1 (by      rw [proof_bitPowerWithWork_value_76]      exact Nat.pow_pos hbase)    (answer.1, denominator.2 + answer.2 + 1)def powerDenominatorAllocation (a : OAI.EditApproximation.BinaryFraction) (base : List Bool)    (hbase : 0 < OAI.EditApproximation.bitWordValue base) (n : ℕ) : ℕ := by  have proof_trimBitWordWithWork_value_6 (bits : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.trimBitWordWithWork bits).1 = OAI.EditApproximation.bitWordValue bits := by    induction bits with    | nil => rfl    | cons bit bits ih =>      simp only [OAI.EditApproximation.trimBitWordWithWork]      split_ifs with h      · have ht : OAI.EditApproximation.bitWordValue bits = 0 := by rw [← ih, h.1]; rfl        simp [h.2, OAI.EditApproximation.bitWordValue, ht]      · (simp only [OAI.EditApproximation.bitWordValue, ih])  have proof_bitAdder_value_1 (a : Bool) (b : Bool) (carry : Bool) :      (OAI.EditApproximation.bitSum a b carry).toNat + 2 * (OAI.EditApproximation.bitCarry a b carry).toNat =        a.toNat + b.toNat + carry.toNat := by    cases a <;> cases b <;> cases carry <;> decide  have proof_bitAddWithWork_value_2 (left : List.{0} Bool) (right : List.{0} Bool) (carry : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitAddWithWork left right carry).1 =        OAI.EditApproximation.bitWordValue left + OAI.EditApproximation.bitWordValue right + carry.toNat := by    induction left generalizing right carry with    | nil =>      simp only [OAI.EditApproximation.bitAddWithWork]      induction right generalizing carry with      | nil => cases carry <;> simp [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue]      | cons b bs ih =>        simp only [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 false b carry        simp only [Bool.toNat_false] at h        omega    | cons a as ih =>      cases right with      | nil =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a false carry        simp only [Bool.toNat_false] at h        omega      | cons b bs =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a b carry        omega  have proof_bitMulWithWork_value_0 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitMulWithWork left right).1 = OAI.EditApproximation.bitWordValue left * OAI.EditApproximation.bitWordValue right := by    induction left with    | nil => simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue]    | cons bit bits ih =>      cases bit <;> simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue, proof_bitAddWithWork_value_2, ih] <;> ring  have proof_bitPowerWithWork_value_76 (base : List.{0} Bool) (n : ℕ) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitPowerWithWork base n).1 = OAI.EditApproximation.bitWordValue base ^ n := by    induction n with    | zero => (simp [OAI.EditApproximation.bitPowerWithWork, OAI.EditApproximation.bitWordValue])    | succ n ih =>      simp only [OAI.EditApproximation.bitPowerWithWork, proof_trimBitWordWithWork_value_6, proof_bitMulWithWork_value_0, ih, pow_succ]  exact    OAI.EditApproximation.bitPowerAllocation base n + OAI.EditApproximation.BinaryFraction.fixedDenominatorAllocation a (OAI.EditApproximation.bitPowerWithWork base n).1      (by rw [proof_bitPowerWithWork_value_76]; exact Nat.pow_pos hbase)def finishCachedWithWork (raw : OAI.EditApproximation.BinaryFraction × ℕ) (base : List Bool)    (hbase : 0 < OAI.EditApproximation.bitWordValue base) (remaining : ℕ) : OAI.EditApproximation.BinaryFraction × ℕ :=  let result := OAI.EditApproximation.BinaryFraction.powerDenominatorWithWork raw.1 base hbase remaining  (result.1, raw.2 + result.2 + 1)def finishCachedAllocation (raw : OAI.EditApproximation.BinaryFraction × ℕ) (allocation : ℕ)    (base : List Bool) (hbase : 0 < OAI.EditApproximation.bitWordValue base) (remaining : ℕ) : ℕ :=  allocation + OAI.EditApproximation.BinaryFraction.powerDenominatorAllocation raw.1 base hbase remainingend OAI.EditApproximation.BinaryFractionendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationdef physicalChild {M J : ℕ} (node : OAI.EditApproximation.PhysicalNode M J) (hbelow : node.1.val < J)    (i : Fin M) : OAI.EditApproximation.PhysicalNode M J :=  ⟨⟨node.1.val + 1, by omega⟩, (node.2, i)⟩instance treeLayerDecidableEq (M : ℕ) : (d : ℕ) → DecidableEq (OAI.EditApproximation.TreeLayer M d)  | 0 => inferInstanceAs (DecidableEq PUnit)  | d + 1 =>    letI := treeLayerDecidableEq M d    inferInstanceAs (DecidableEq (OAI.EditApproximation.TreeLayer M d × Fin M))def treeLayerCode (M : ℕ) : (d : ℕ) → OAI.EditApproximation.TreeLayer M d → ℕ  | 0, _ => 0  | d + 1, path => path.2.val + M * treeLayerCode M d path.1def localOnlineMassBound (M P H : ℕ) : ℕ :=  OAI.EditApproximation.optimizerTriangularMass ((H + M * (40 * P + 2) ^ 2 + 2) ^ 80)def treeLayerCodeWithWork (M : ℕ) : (d : ℕ) → OAI.EditApproximation.TreeLayer M d → ℕ × ℕ  | 0, _ => (0, 1)  | d + 1, path => let previous := treeLayerCodeWithWork M d path.1      (path.2.val + M * previous.1, previous.2 + 3)def queryNaturalIndexWithWork (a : ℕ) : List ℕ → ℕ × ℕ  | [] => (0, 1)  | b :: rest =>    let test := OAI.EditApproximation.naturalEqualWithWork a b    if test.1 then (0, test.2 + 1)    else      let tail := queryNaturalIndexWithWork a rest      (tail.1 + 1, test.2 + tail.2 + 2)def scheduledSeedWordWithWork (N pass : ℕ) : OAI.EditApproximation.BinaryFraction × ℕ :=  OAI.EditApproximation.BinaryFraction.signedPowerTwoWithWork    ((OAI.EditApproximation.dyadicSeedExponent (OAI.EditApproximation.smallLogExponent N) (OAI.EditApproximation.computedSeedInitialExponent N) pass : ℕ) : ℤ)def coarseLetterMatchWithWork : Option (Option ℕ) → Option ℕ → Bool × ℕ  | none, _ => (false, 1)  | some none, none => (true, 1)  | some (some a), some b => OAI.EditApproximation.naturalEqualWithWork a b  | _, _ => (false, 1)def queryNaturalIndexAllocation (a : ℕ) : List ℕ → ℕ  | [] => 0  | b :: rest => OAI.EditApproximation.naturalEqualAllocation a b +      if (OAI.EditApproximation.naturalEqualWithWork a b).1 then 1 else queryNaturalIndexAllocation a rest + 1def physicalNodeCode {M J : ℕ} (node : OAI.EditApproximation.PhysicalNode M J) : ℕ :=  OAI.EditApproximation.treeLayerCode M node.1.val node.2 + M ^ J * node.1.valdef queryScaleDispatchWithWork (N b : ℕ) : ℕ × ℕ :=  let scales := OAI.EditApproximation.dyadicScalesWithWork N  let index := OAI.EditApproximation.queryNaturalIndexWithWork b scales.1  (index.1, scales.2 + index.2 + scales.1.length + 2)def queryScaleDispatchAllocation (N b : ℕ) : ℕ :=  OAI.EditApproximation.dyadicScalesAllocation N + OAI.EditApproximation.queryNaturalIndexAllocation b (OAI.EditApproximation.dyadicScalesWithWork N).1 +    (OAI.EditApproximation.dyadicScalesWithWork N).1.lengthdef queryScalePresentWithWork (N b : ℕ) : Bool × ℕ :=  let found := OAI.EditApproximation.queryScaleDispatchWithWork N b  let test := OAI.EditApproximation.binaryNaturalCompareWithWork found.1 (max 1 N.bits.length)  (decide (test.1 = .lt), found.2 + test.2 + 2)def queryScalePresentAllocation (N b : ℕ) : ℕ :=  OAI.EditApproximation.queryScaleDispatchAllocation N b + (OAI.EditApproximation.queryScaleDispatchWithWork N b).1.bits.length + (max 1 N.bits.length).bits.lengthend OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen MeasureTheory ProbabilityTheorydef physicalScaleIndex (N b : ℕ) (hb : b ∈ OAI.EditApproximation.dyadicScales N) :    Fin (OAI.EditApproximation.dyadicScales N).length :=  ⟨(OAI.EditApproximation.dyadicScales N).idxOf b, List.idxOf_lt_length_of_mem hb⟩abbrev PositiveDrawRange (B : ℕ) := {n : Fin (B + 1) // 0 < n.val}abbrev PhysicalLocalGroupKey (M J N n exponent : ℕ) :=  OAI.EditApproximation.PhysicalInternalNode M J × Fin (OAI.EditApproximation.dyadicScales N).length ×    Fin (n * 2 ^ exponent + 1) × Fin (n * 2 ^ exponent + 1)noncomputable def rejectionSuccessParameter (N R : ℕ) (hN : 0 < N) (hNR : N ≤ R) : unitInterval :=  ⟨(N : ℝ) / R, div_nonneg (Nat.cast_nonneg _) (Nat.cast_nonneg _),    (div_le_one₀ (by exact_mod_cast hN.trans_le hNR : (0 : ℝ) < R)).mpr (by exact_mod_cast hNR)⟩def scheduledSeedFactor (N pass : ℕ) : ℚ :=  (2 : ℚ) ^ OAI.EditApproximation.dyadicSeedExponent (OAI.EditApproximation.smallLogExponent N) (OAI.EditApproximation.computedSeedInitialExponent N) passdef scheduledSeedMultiplier (N pass : ℕ) : ℕ :=  2 ^ (OAI.EditApproximation.dyadicSeedExponent (OAI.EditApproximation.smallLogExponent N) (OAI.EditApproximation.computedSeedInitialExponent N) pass - OAI.EditApproximation.smallLogExponent N)instance computedBranching_neZero (N : ℕ) : NeZero (OAI.EditApproximation.integerParameters N).M :=  ⟨pow_ne_zero _ (by decide : (2 : ℕ) ≠ 0)⟩instance computedCoarseBranching_neZero (N : ℕ) : NeZero (OAI.EditApproximation.integerParameters N).B :=  ⟨pow_ne_zero _ (pow_ne_zero _ (by decide : (2 : ℕ) ≠ 0))⟩instance computedSourceTime_neZero (N : ℕ) : NeZero (OAI.EditApproximation.inputHeight N ^ 2) :=  ⟨pow_ne_zero _ (pow_ne_zero _ (by decide : (2 : ℕ) ≠ 0))⟩abbrev CommonRangeKey (ι : Type u_1) (B : ℕ) := ι × OAI.EditApproximation.PositiveDrawRange Bdef positiveDrawRangeOfLE (B n : ℕ) (hn : 0 < n) (hB : n ≤ B) : OAI.EditApproximation.PositiveDrawRange B :=  ⟨⟨n, Nat.lt_succ_of_le hB⟩, hn⟩instance positiveDrawRange_nezero {B : ℕ} (n : OAI.EditApproximation.PositiveDrawRange B) : NeZero n.val.val :=  ⟨Nat.ne_of_gt n.property⟩end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.SignedBinarydef value (a : OAI.EditApproximation.SignedBinary) : ℤ := OAI.EditApproximation.signedMagnitude a.negative (OAI.EditApproximation.bitWordValue a.bits)def ofInt (a : ℤ) : OAI.EditApproximation.SignedBinary := ⟨decide (a < 0), a.natAbs.bits⟩def neg (a : OAI.EditApproximation.SignedBinary) : OAI.EditApproximation.SignedBinary := ⟨!a.negative, a.bits⟩def addWithWork (a b : OAI.EditApproximation.SignedBinary) : OAI.EditApproximation.SignedBinary × ℕ :=  if a.negative = b.negative then    let total := OAI.EditApproximation.bitAddWithWork a.bits b.bits false    (⟨a.negative, total.1⟩, total.2 + 4)  else    let comparison := OAI.EditApproximation.bitCompareWithWork a.bits b.bits    match comparison.1 with    | .eq => (⟨false, []⟩, comparison.2 + 4)    | .lt =>      let difference := OAI.EditApproximation.bitSubtractWithWork b.bits a.bits false      (⟨b.negative, difference.1⟩, comparison.2 + difference.2.2 + 4)    | .gt =>      let difference := OAI.EditApproximation.bitSubtractWithWork a.bits b.bits false      (⟨a.negative, difference.1⟩, comparison.2 + difference.2.2 + 4)def mulWithWork (a b : OAI.EditApproximation.SignedBinary) : OAI.EditApproximation.SignedBinary × ℕ :=  let product := OAI.EditApproximation.bitMulWithWork a.bits b.bits  (⟨xor a.negative b.negative, product.1⟩, product.2 + 4)def nonzeroWithWork (bits : List Bool) : Bool × ℕ :=  let comparison := OAI.EditApproximation.bitCompareWithWork bits []  (if comparison.1 = .eq then false else true, comparison.2 + 1)def addAllocation (a b : OAI.EditApproximation.SignedBinary) : ℕ :=  if a.negative = b.negative then OAI.EditApproximation.bitAddAllocation a.bits b.bits false  else match (OAI.EditApproximation.bitCompareWithWork a.bits b.bits).1 with    | .eq => 0    | .lt => OAI.EditApproximation.bitSubtractAllocation b.bits a.bits false    | .gt => OAI.EditApproximation.bitSubtractAllocation a.bits b.bits falsedef mulAllocation (a b : OAI.EditApproximation.SignedBinary) : ℕ := OAI.EditApproximation.bitMulAllocation a.bits b.bitsdef ltWithWork (a b : OAI.EditApproximation.SignedBinary) : Bool × ℕ :=  if a.negative then    if b.negative then      let comparison := OAI.EditApproximation.bitCompareWithWork b.bits a.bits      (comparison.1 == .lt, comparison.2 + 2)    else      let left := OAI.EditApproximation.SignedBinary.nonzeroWithWork a.bits      let right := OAI.EditApproximation.SignedBinary.nonzeroWithWork b.bits      (left.1 || right.1, left.2 + right.2 + 4)  else    if b.negative then (false, 2)    else      let comparison := OAI.EditApproximation.bitCompareWithWork a.bits b.bits      (comparison.1 == .lt, comparison.2 + 2)end OAI.EditApproximation.SignedBinaryendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.BinaryFractiondef value (a : OAI.EditApproximation.BinaryFraction) : ℚ := (a.numerator.value : ℚ) / OAI.EditApproximation.bitWordValue a.denominatordef representation (a : OAI.EditApproximation.BinaryFraction) : OAI.EditApproximation.UnreducedRational :=  ⟨a.numerator.value, OAI.EditApproximation.bitWordValue a.denominator, a.denominator_pos⟩def addWithWork (a b : OAI.EditApproximation.BinaryFraction) : OAI.EditApproximation.BinaryFraction × ℕ := by  have proof_bitAdder_value_1 (a : Bool) (b : Bool) (carry : Bool) :      (OAI.EditApproximation.bitSum a b carry).toNat + 2 * (OAI.EditApproximation.bitCarry a b carry).toNat =        a.toNat + b.toNat + carry.toNat := by    cases a <;> cases b <;> cases carry <;> decide  have proof_bitAddWithWork_value_2 (left : List.{0} Bool) (right : List.{0} Bool) (carry : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitAddWithWork left right carry).1 =        OAI.EditApproximation.bitWordValue left + OAI.EditApproximation.bitWordValue right + carry.toNat := by    induction left generalizing right carry with    | nil =>      simp only [OAI.EditApproximation.bitAddWithWork]      induction right generalizing carry with      | nil => cases carry <;> simp [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue]      | cons b bs ih =>        simp only [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 false b carry        simp only [Bool.toNat_false] at h        omega    | cons a as ih =>      cases right with      | nil =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a false carry        simp only [Bool.toNat_false] at h        omega      | cons b bs =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a b carry        omega  have proof_bitMulWithWork_value_0 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitMulWithWork left right).1 = OAI.EditApproximation.bitWordValue left * OAI.EditApproximation.bitWordValue right := by    induction left with    | nil => simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue]    | cons bit bits ih =>      cases bit <;> simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue, proof_bitAddWithWork_value_2, ih] <;> ring  exact    let first := a.numerator.mulWithWork b.denominatorInteger    let second := b.numerator.mulWithWork a.denominatorInteger    let numerator := first.1.addWithWork second.1    let denominator := OAI.EditApproximation.bitMulWithWork a.denominator b.denominator    (⟨numerator.1, denominator.1, by        change 0 < OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitMulWithWork a.denominator b.denominator).1        rw [proof_bitMulWithWork_value_0]        exact Nat.mul_pos a.denominator_pos b.denominator_pos⟩,      first.2 + second.2 + numerator.2 + denominator.2 + 8)def mulWithWork (a b : OAI.EditApproximation.BinaryFraction) : OAI.EditApproximation.BinaryFraction × ℕ := by  have proof_bitAdder_value_1 (a : Bool) (b : Bool) (carry : Bool) :      (OAI.EditApproximation.bitSum a b carry).toNat + 2 * (OAI.EditApproximation.bitCarry a b carry).toNat =        a.toNat + b.toNat + carry.toNat := by    cases a <;> cases b <;> cases carry <;> decide  have proof_bitAddWithWork_value_2 (left : List.{0} Bool) (right : List.{0} Bool) (carry : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitAddWithWork left right carry).1 =        OAI.EditApproximation.bitWordValue left + OAI.EditApproximation.bitWordValue right + carry.toNat := by    induction left generalizing right carry with    | nil =>      simp only [OAI.EditApproximation.bitAddWithWork]      induction right generalizing carry with      | nil => cases carry <;> simp [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue]      | cons b bs ih =>        simp only [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 false b carry        simp only [Bool.toNat_false] at h        omega    | cons a as ih =>      cases right with      | nil =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a false carry        simp only [Bool.toNat_false] at h        omega      | cons b bs =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a b carry        omega  have proof_bitMulWithWork_value_0 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitMulWithWork left right).1 = OAI.EditApproximation.bitWordValue left * OAI.EditApproximation.bitWordValue right := by    induction left with    | nil => simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue]    | cons bit bits ih =>      cases bit <;> simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue, proof_bitAddWithWork_value_2, ih] <;> ring  exact    let numerator := a.numerator.mulWithWork b.numerator    let denominator := OAI.EditApproximation.bitMulWithWork a.denominator b.denominator    (⟨numerator.1, denominator.1, by        change 0 < OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitMulWithWork a.denominator b.denominator).1        rw [proof_bitMulWithWork_value_0]        exact Nat.mul_pos a.denominator_pos b.denominator_pos⟩,      numerator.2 + denominator.2 + 4)def neg (a : OAI.EditApproximation.BinaryFraction) : OAI.EditApproximation.BinaryFraction :=  ⟨a.numerator.neg, a.denominator, a.denominator_pos⟩def ltWithWork (a b : OAI.EditApproximation.BinaryFraction) : Bool × ℕ :=  let left := a.numerator.mulWithWork b.denominatorInteger  let right := b.numerator.mulWithWork a.denominatorInteger  let compared := left.1.ltWithWork right.1  (compared.1, left.2 + right.2 + compared.2 + 4)def nat (n : ℕ) : OAI.EditApproximation.BinaryFraction :=  ⟨OAI.EditApproximation.SignedBinary.ofInt n, [true], by decide⟩def coarseGridAddWithWork (a b : OAI.EditApproximation.BinaryFraction) : OAI.EditApproximation.BinaryFraction × ℕ :=  let total := a.numerator.addWithWork b.numerator  let raw : OAI.EditApproximation.BinaryFraction := ⟨total.1, a.denominator, a.denominator_pos⟩  let answer := OAI.EditApproximation.BinaryFraction.canonicalizeWithWork raw  (answer.1, total.2 + answer.2 + 3)def coarseReadShiftWithWork (k n : ℕ) (target : List ℕ) (letter : Option (Option ℕ))    (start : ℕ) (shift : Fin (2 * k + 1)) : ℕ × ℕ :=  match letter with  | none => (0, 1)  | some letter =>    let position := OAI.EditApproximation.binaryNaturalAddWithWork start shift.val    let actual := OAI.EditApproximation.coarseFramedReadWithWork k n target (OAI.EditApproximation.bitWordValue position.1)    let matched := OAI.EditApproximation.coarseLetterMatchWithWork actual.1 letter    (if matched.1 then 0 else 1, position.2 + actual.2 + matched.2 + 3)def addAllocation (a b : OAI.EditApproximation.BinaryFraction) : ℕ :=  a.numerator.mulAllocation b.denominatorInteger +  b.numerator.mulAllocation a.denominatorInteger +  ((a.numerator.mulWithWork b.denominatorInteger).1.addAllocation    (b.numerator.mulWithWork a.denominatorInteger).1) +  OAI.EditApproximation.bitMulAllocation a.denominator b.denominatordef mulAllocation (a b : OAI.EditApproximation.BinaryFraction) : ℕ :=  a.numerator.mulAllocation b.numerator + OAI.EditApproximation.bitMulAllocation a.denominator b.denominatordef ltAllocation (a b : OAI.EditApproximation.BinaryFraction) : ℕ :=  a.numerator.mulAllocation b.denominatorInteger +  b.numerator.mulAllocation a.denominatorIntegerdef canonicalAddWithWork (a b : OAI.EditApproximation.BinaryFraction) : OAI.EditApproximation.BinaryFraction × ℕ :=  let raw := a.addWithWork b  let result := OAI.EditApproximation.BinaryFraction.canonicalizeWithWork raw.1  (result.1, raw.2 + result.2)def canonicalMulWithWork (a b : OAI.EditApproximation.BinaryFraction) : OAI.EditApproximation.BinaryFraction × ℕ :=  let raw := a.mulWithWork b  let result := OAI.EditApproximation.BinaryFraction.canonicalizeWithWork raw.1  (result.1, raw.2 + result.2)def one : OAI.EditApproximation.BinaryFraction := OAI.EditApproximation.BinaryFraction.nat 1def dyadicScanWithWork (a candidate : OAI.EditApproximation.BinaryFraction) : ℕ → OAI.EditApproximation.BinaryFraction × ℕ  | 0 => (candidate, 1)  | n + 1 =>    let comparison := candidate.ltWithWork a    if comparison.1 then      let next := dyadicScanWithWork a (OAI.EditApproximation.BinaryFraction.doubleFraction candidate) n      (next.1, comparison.2 + next.2 + 2)    else (candidate, comparison.2 + 1)def maxWithWork (a b : OAI.EditApproximation.BinaryFraction) : OAI.EditApproximation.BinaryFraction × ℕ :=  let comparison := a.ltWithWork b  (if comparison.1 then b else a, comparison.2 + 1)def leWithWork (a b : OAI.EditApproximation.BinaryFraction) : Bool × ℕ :=  let result := b.ltWithWork a  (!result.1, result.2 + 1)def minWithWork (a b : OAI.EditApproximation.BinaryFraction) : OAI.EditApproximation.BinaryFraction × ℕ :=  let comparison := a.ltWithWork b  (if comparison.1 then a else b, comparison.2 + 1)def queryScaleAt (words : List OAI.EditApproximation.BinaryFraction) (scales : List ℚ)    (h : words.map OAI.EditApproximation.BinaryFraction.value = scales) (i : Fin scales.length) : OAI.EditApproximation.BinaryFraction :=  words[i.val]'(by have hl := congrArg List.length h; simp only [List.length_map] at hl; omega)def gatheredWordLookupWithWork {κ : Type u_1} (equal : κ → κ → Bool × ℕ) :    List κ → List OAI.EditApproximation.BinaryFraction → κ → OAI.EditApproximation.BinaryFraction × ℕ  | key :: keys, value :: values, query =>      let test := equal query key      if test.1 then (value, test.2 + 1)      else        let rest := gatheredWordLookupWithWork equal keys values query        (rest.1, test.2 + rest.2 + 1)  | _, _, _ => (OAI.EditApproximation.BinaryFraction.nat 0, 1)def coarseGridZipAddWithWork : List OAI.EditApproximation.BinaryFraction → List OAI.EditApproximation.BinaryFraction → List OAI.EditApproximation.BinaryFraction × ℕ  | a :: left, b :: right =>    let here := OAI.EditApproximation.BinaryFraction.coarseGridAddWithWork a b    let tail := coarseGridZipAddWithWork left right    (here.1 :: tail.1, here.2 + tail.2 + 3)  | _, _ => ([], 0)def coarseBinaryRead (array : OAI.EditApproximation.BinaryFraction.CoarseBinaryArray) (i : ℕ) : OAI.EditApproximation.BinaryFraction :=  match array with  | none => OAI.EditApproximation.BinaryFraction.nat 0  | some cells => cells[i]?.getD (OAI.EditApproximation.BinaryFraction.nat 0)def canonicalAddAllocation (a b : OAI.EditApproximation.BinaryFraction) : ℕ :=  a.addAllocation b + OAI.EditApproximation.BinaryFraction.canonicalizeAllocation (a.addWithWork b).1def canonicalMulAllocation (a b : OAI.EditApproximation.BinaryFraction) : ℕ :=  a.mulAllocation b + OAI.EditApproximation.BinaryFraction.canonicalizeAllocation (a.mulWithWork b).1def minAllocation (a b : OAI.EditApproximation.BinaryFraction) : ℕ := OAI.EditApproximation.BinaryFraction.ltAllocation a bdef maxAllocation (a b : OAI.EditApproximation.BinaryFraction) : ℕ := OAI.EditApproximation.BinaryFraction.ltAllocation a bdef leAllocation (a b : OAI.EditApproximation.BinaryFraction) : ℕ := OAI.EditApproximation.BinaryFraction.ltAllocation b adef dyadicScanAllocation (a candidate : OAI.EditApproximation.BinaryFraction) : ℕ → ℕ  | 0 => 0  | n + 1 =>    OAI.EditApproximation.BinaryFraction.ltAllocation candidate a + if (candidate.ltWithWork a).1 then      dyadicScanAllocation a (OAI.EditApproximation.BinaryFraction.doubleFraction candidate) n + 1 else 0def equalAllocation (a b : OAI.EditApproximation.BinaryFraction) : ℕ :=  OAI.EditApproximation.BinaryFraction.ltAllocation b a + OAI.EditApproximation.BinaryFraction.ltAllocation a b + 0def subWithWork (a b : OAI.EditApproximation.BinaryFraction) : OAI.EditApproximation.BinaryFraction × ℕ :=  let result := OAI.EditApproximation.BinaryFraction.canonicalAddWithWork a b.neg  (result.1, result.2 + 1)def divWithWork (a b : OAI.EditApproximation.BinaryFraction) : OAI.EditApproximation.BinaryFraction × ℕ :=  let inverse := b.invWithWork  let result := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork a inverse.1  (result.1, inverse.2 + result.2 + 1)def powWithWork (a : OAI.EditApproximation.BinaryFraction) : ℕ → OAI.EditApproximation.BinaryFraction × ℕ  | 0 => (OAI.EditApproximation.BinaryFraction.one, 1)  | k + 1 =>    let previous := powWithWork a k    let result := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork previous.1 a    (result.1, previous.2 + result.2 + 1)def dotListWithWork {d : ℕ} (left right : Vector OAI.EditApproximation.BinaryFraction d) : List (Fin d) → OAI.EditApproximation.BinaryFraction × ℕ  | [] => (OAI.EditApproximation.BinaryFraction.zero, 1)  | i :: rest =>    let tail := dotListWithWork left right rest    let product := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (left.get i) (right.get i)    let result := OAI.EditApproximation.BinaryFraction.canonicalAddWithWork product.1 tail.1    (result.1, tail.2 + product.2 + result.2 + 5)def dyadicCeilingWithWork (a : OAI.EditApproximation.BinaryFraction) : OAI.EditApproximation.BinaryFraction × ℕ :=  let result := OAI.EditApproximation.BinaryFraction.dyadicScanWithWork a (OAI.EditApproximation.BinaryFraction.inversePowerTwo a.width) (2 * a.width)  (result.1, result.2 + 3 * a.width + 5)def maximumWithWork (fallback : OAI.EditApproximation.BinaryFraction) : List OAI.EditApproximation.BinaryFraction → OAI.EditApproximation.BinaryFraction × ℕ  | [] => (fallback, 1)  | head :: rest =>    let tail := maximumWithWork fallback rest    let result := OAI.EditApproximation.BinaryFraction.maxWithWork head tail.1    (result.1, tail.2 + result.2 + 1)def minimumWithWork (fallback : OAI.EditApproximation.BinaryFraction) : List OAI.EditApproximation.BinaryFraction → OAI.EditApproximation.BinaryFraction × ℕ  | [] => (fallback, 1)  | head :: rest =>    let tail := minimumWithWork fallback rest    let result := OAI.EditApproximation.BinaryFraction.minWithWork head tail.1    (result.1, tail.2 + result.2 + 1)def scaledCeilingWithWork (multiplier : ℕ) (a : OAI.EditApproximation.BinaryFraction) : List Bool × ℕ :=  let product := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat multiplier) a  let result := OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork product.1  (result.1, product.2 + result.2 + Nat.size multiplier + 3)def coarseContributionWithWork (threshold scale a : OAI.EditApproximation.BinaryFraction) : OAI.EditApproximation.BinaryFraction × ℕ :=  let test := OAI.EditApproximation.BinaryFraction.leWithWork threshold a  if test.1 then    let result := OAI.EditApproximation.BinaryFraction.maxWithWork a scale    (result.1, test.2 + result.2 + 2)  else    let result := OAI.EditApproximation.BinaryFraction.coarseGridNatWithWork a.denominator a.denominator_pos 0    (result.1, test.2 + result.2 + 2)def coarseGridScanWithWork (two previous : OAI.EditApproximation.BinaryFraction) :    List OAI.EditApproximation.BinaryFraction → List OAI.EditApproximation.BinaryFraction × ℕ  | [] => ([previous], 0)  | head :: rest =>    let added := OAI.EditApproximation.BinaryFraction.coarseGridAddWithWork previous two    let next := OAI.EditApproximation.BinaryFraction.minWithWork head added.1    let tail := coarseGridScanWithWork two next.1 rest    (previous :: tail.1, added.2 + next.2 + tail.2 + 3)def coarseGridZipMinimumWithWork : List OAI.EditApproximation.BinaryFraction → List OAI.EditApproximation.BinaryFraction → List OAI.EditApproximation.BinaryFraction × ℕ  | a :: left, b :: right =>    let here := OAI.EditApproximation.BinaryFraction.minWithWork a b    let tail := coarseGridZipMinimumWithWork left right    (here.1 :: tail.1, here.2 + tail.2 + 3)  | _, _ => ([], 0)def coarseBinaryAddWithWork : OAI.EditApproximation.BinaryFraction.CoarseBinaryArray → OAI.EditApproximation.BinaryFraction.CoarseBinaryArray → OAI.EditApproximation.BinaryFraction.CoarseBinaryArray × ℕ  | none, right => (right, 0)  | left, none => (left, 0)  | some left, some right =>    let result := OAI.EditApproximation.BinaryFraction.coarseGridZipAddWithWork left right    (some result.1, result.2)def divAllocation (a b : OAI.EditApproximation.BinaryFraction) : ℕ :=  OAI.EditApproximation.BinaryFraction.invAllocation b + OAI.EditApproximation.BinaryFraction.canonicalMulAllocation a b.invWithWork.1def subAllocation (a b : OAI.EditApproximation.BinaryFraction) : ℕ := OAI.EditApproximation.BinaryFraction.canonicalAddAllocation a b.negdef optimizerUpdateCellAllocation {d : ℕ} (step complement : OAI.EditApproximation.BinaryFraction)    (previous selected : Vector OAI.EditApproximation.BinaryFraction d) (i : Fin d) : ℕ :=  OAI.EditApproximation.BinaryFraction.canonicalMulAllocation complement (previous.get i) + OAI.EditApproximation.BinaryFraction.canonicalMulAllocation step (selected.get i) +    OAI.EditApproximation.BinaryFraction.canonicalAddAllocation (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork complement (previous.get i)).1      (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork step (selected.get i)).1def dyadicCeilingAllocation (a : OAI.EditApproximation.BinaryFraction) : ℕ :=  OAI.EditApproximation.BinaryFraction.dyadicScanAllocation a (OAI.EditApproximation.BinaryFraction.inversePowerTwo a.width) (2 * a.width) + a.width + 2def roundedSpacingAllocation (theta envelope : OAI.EditApproximation.BinaryFraction) : ℕ :=  let product := (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork theta envelope).1  OAI.EditApproximation.BinaryFraction.canonicalMulAllocation theta envelope + OAI.EditApproximation.BinaryFraction.maxAllocation OAI.EditApproximation.BinaryFraction.one product +    OAI.EditApproximation.BinaryFraction.naturalCeilingAllocation (OAI.EditApproximation.BinaryFraction.maxWithWork OAI.EditApproximation.BinaryFraction.one product).1def scaledCeilingAllocation (multiplier : ℕ) (a : OAI.EditApproximation.BinaryFraction) : ℕ :=  OAI.EditApproximation.BinaryFraction.canonicalMulAllocation (OAI.EditApproximation.BinaryFraction.nat multiplier) a +    OAI.EditApproximation.BinaryFraction.naturalCeilingAllocation (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat multiplier) a).1 + Nat.size multiplier + 1def groupTermsAllocation {M : ℕ} (h : OAI.EditApproximation.BinaryFraction) (envelope : Vector OAI.EditApproximation.BinaryFraction M)    (indices : List (Fin M)) : ℕ :=  OAI.EditApproximation.arithmeticMapAllocation (fun i => OAI.EditApproximation.BinaryFraction.equalAllocation (envelope.get i) h + 2) indicesdef logarithmPartialWithWork (b : OAI.EditApproximation.BinaryFraction) : ℕ → OAI.EditApproximation.BinaryFraction × ℕ  | 0 => (OAI.EditApproximation.BinaryFraction.zero, 1)  | k + 1 =>    let previous := logarithmPartialWithWork b k    let power := OAI.EditApproximation.BinaryFraction.powWithWork b (2 * k + 1)    let term := OAI.EditApproximation.BinaryFraction.divWithWork power.1 (OAI.EditApproximation.BinaryFraction.nat (2 * k + 1))    let result := OAI.EditApproximation.BinaryFraction.canonicalAddWithWork previous.1 term.1    (result.1, previous.2 + power.2 + term.2 + result.2 + Nat.size (2 * k + 1) + 5)def dotWithWork {d : ℕ} (left right : Vector OAI.EditApproximation.BinaryFraction d) : OAI.EditApproximation.BinaryFraction × ℕ :=  OAI.EditApproximation.BinaryFraction.dotListWithWork left right (List.finRange d)def distanceWithWork (a b : OAI.EditApproximation.BinaryFraction) : OAI.EditApproximation.BinaryFraction × ℕ :=  let difference := a.subWithWork b  (difference.1.absolute, difference.2 + 1)def affineErrorWithWork (position offset velocity prediction tolerance : OAI.EditApproximation.BinaryFraction) :    Bool × ℕ :=  let displacement := position.subWithWork offset  let product := velocity.canonicalMulWithWork prediction  let error := displacement.1.subWithWork product.1  let comparison := error.1.absolute.leWithWork tolerance  (comparison.1, displacement.2 + product.2 + error.2 + comparison.2 + 4)def bandToleranceWithWork (tau theta : OAI.EditApproximation.BinaryFraction) (b M : ℕ) : OAI.EditApproximation.BinaryFraction × ℕ :=  let product := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork tau theta  let scale := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork product.1 (OAI.EditApproximation.BinaryFraction.nat b)  let result := OAI.EditApproximation.BinaryFraction.divWithWork scale.1 (OAI.EditApproximation.BinaryFraction.nat M)  (result.1, product.2 + scale.2 + result.2 + Nat.size b + Nat.size M + 3)def medianSeedWithWork (N multiplier : ℕ) (values : List OAI.EditApproximation.BinaryFraction) : List Bool × ℕ :=  let rounded := OAI.EditApproximation.arithmeticMapWithWork (OAI.EditApproximation.BinaryFraction.scaledCeilingWithWork multiplier) values  let sorted := OAI.EditApproximation.wordSortWithWork rounded.1  let middle := sorted.1.getD (values.length / 2) []  let clamped := OAI.EditApproximation.wordMinWithWork N.bits middle  (clamped.1, rounded.2 + sorted.2 + values.length + clamped.2 + Nat.size N + 3)def groupSampleCountWithWork (M Q b : ℕ) (h : OAI.EditApproximation.BinaryFraction) : List Bool × ℕ :=  let qm := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat Q) (OAI.EditApproximation.BinaryFraction.nat M)  let numerator := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork qm.1 h  let ratio := OAI.EditApproximation.BinaryFraction.divWithWork numerator.1 (OAI.EditApproximation.BinaryFraction.nat b)  let ceiling := OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork ratio.1  let result := OAI.EditApproximation.wordMinWithWork M.bits ceiling.1  (result.1, qm.2 + numerator.2 + ratio.2 + ceiling.2 + result.2 +    Nat.size M + Nat.size Q + Nat.size b + 5)def gainReadWithWork {β : Type u_1} {σ : Type u_2} (mass : β → OAI.EditApproximation.BinaryFraction)    (read : ℕ → β × σ → OAI.EditApproximation.BinaryFraction × ℕ) (s : ℕ) (i : β × σ) : OAI.EditApproximation.BinaryFraction × ℕ :=  let word := read s i  let result := OAI.EditApproximation.BinaryFraction.divWithWork word.1.neg (mass i.1)  (result.1, word.2 + result.2 + 1)def decrementReadWithWork {β : Type u_1} {σ : Type u_2} (mass : β → OAI.EditApproximation.BinaryFraction)    (read : ℕ → β × σ → OAI.EditApproximation.BinaryFraction × ℕ) (s : ℕ) (i : β × σ) : OAI.EditApproximation.BinaryFraction × ℕ :=  let first := read s i  let second := read (s + 1) i  let difference := OAI.EditApproximation.BinaryFraction.subWithWork first.1 second.1  let result := OAI.EditApproximation.BinaryFraction.divWithWork difference.1 (mass i.1)  (result.1, first.2 + second.2 + difference.2 + result.2 + 1)def scaledSeedWithWork (U : ℕ) (a gap : OAI.EditApproximation.BinaryFraction) : OAI.EditApproximation.BinaryFraction × ℕ :=  let ratio := OAI.EditApproximation.BinaryFraction.divWithWork (OAI.EditApproximation.BinaryFraction.nat U) a  let rounded := OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork ratio.1  let result := OAI.EditApproximation.BinaryFraction.maxWithWork (OAI.EditApproximation.BinaryFraction.ofNaturalWord rounded.1) gap.absolute  (result.1, ratio.2 + rounded.2 + result.2 + Nat.size U + 3)def initialScaleGuardWithWork (U b : ℕ) (A : OAI.EditApproximation.BinaryFraction) : Bool × ℕ :=  let square := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork A A  let denominator := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat 16) square.1  let lower := OAI.EditApproximation.BinaryFraction.divWithWork (OAI.EditApproximation.BinaryFraction.nat U) denominator.1  let factor := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat 4) A  let upper := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork factor.1 (OAI.EditApproximation.BinaryFraction.nat U)  let low := OAI.EditApproximation.BinaryFraction.leWithWork lower.1 (OAI.EditApproximation.BinaryFraction.nat b)  let high := OAI.EditApproximation.BinaryFraction.leWithWork (OAI.EditApproximation.BinaryFraction.nat b) upper.1  (low.1 && high.1, square.2 + denominator.2 + lower.2 + factor.2 + upper.2 + low.2 + high.2 +    Nat.size U + Nat.size b + 7)def initialCenterGuardWithWork (b U : ℕ) (A : OAI.EditApproximation.BinaryFraction) : Bool × ℕ :=  let lower := OAI.EditApproximation.BinaryFraction.divWithWork (OAI.EditApproximation.BinaryFraction.nat b) (OAI.EditApproximation.BinaryFraction.nat 2)  let factor := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat 4) A  let upper := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork factor.1 (OAI.EditApproximation.BinaryFraction.nat b)  let low := OAI.EditApproximation.BinaryFraction.leWithWork lower.1 (OAI.EditApproximation.BinaryFraction.nat U)  let high := OAI.EditApproximation.BinaryFraction.leWithWork (OAI.EditApproximation.BinaryFraction.nat U) upper.1  (low.1 && high.1, lower.2 + factor.2 + upper.2 + low.2 + high.2 + Nat.size b + Nat.size U + 5)def cellCoordinatesWithWork (side : OAI.EditApproximation.BinaryFraction) (p radius : ℕ) : List ℕ × ℕ :=  let lower := OAI.EditApproximation.saturatingSubtractWithWork p radius  let upper := OAI.EditApproximation.binaryNaturalAddWithWork p radius  let firstQ := OAI.EditApproximation.BinaryFraction.divWithWork (OAI.EditApproximation.BinaryFraction.nat (OAI.EditApproximation.bitWordValue lower.1)) side  let lastQ := OAI.EditApproximation.BinaryFraction.divWithWork (OAI.EditApproximation.BinaryFraction.nat (OAI.EditApproximation.bitWordValue upper.1)) side  let first := OAI.EditApproximation.BinaryFraction.naturalFloorWithWork firstQ.1  let last := OAI.EditApproximation.BinaryFraction.naturalFloorWithWork lastQ.1  let stop := OAI.EditApproximation.binaryNaturalAddWithWork (OAI.EditApproximation.bitWordValue last.1) 1  let count := OAI.EditApproximation.saturatingSubtractWithWork (OAI.EditApproximation.bitWordValue stop.1) (OAI.EditApproximation.bitWordValue first.1)  let values := List.range' (OAI.EditApproximation.bitWordValue first.1) (OAI.EditApproximation.bitWordValue count.1)  (values, lower.2 + upper.2 + firstQ.2 + lastQ.2 + first.2 + last.2 + stop.2 + count.2 +    values.length + Nat.size p + Nat.size radius + 9)def cellGridPointsWithWork (side : OAI.EditApproximation.BinaryFraction) (g cell : ℕ) : List ℕ × ℕ :=  let next := OAI.EditApproximation.binaryNaturalAddWithWork cell 1  let lower := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat cell) side  let upper := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat (OAI.EditApproximation.bitWordValue next.1)) side  let firstQ := OAI.EditApproximation.BinaryFraction.divWithWork lower.1 (OAI.EditApproximation.BinaryFraction.nat g)  let lastQ := OAI.EditApproximation.BinaryFraction.divWithWork upper.1 (OAI.EditApproximation.BinaryFraction.nat g)  let first := OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork firstQ.1  let last := OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork lastQ.1  let count := OAI.EditApproximation.saturatingSubtractWithWork (OAI.EditApproximation.bitWordValue last.1) (OAI.EditApproximation.bitWordValue first.1)  let indices := List.range' (OAI.EditApproximation.bitWordValue first.1) (OAI.EditApproximation.bitWordValue count.1)  let points := OAI.EditApproximation.arithmeticMapWithWork (fun i =>    let product := OAI.EditApproximation.binaryNaturalMulWithWork g i    (OAI.EditApproximation.bitWordValue product.1, product.2 + Nat.size i + 2)) indices  (points.1, next.2 + lower.2 + upper.2 + firstQ.2 + lastQ.2 + first.2 + last.2 + count.2 +    points.2 + indices.length + Nat.size cell + Nat.size g + 10)def centerEligibilityWithWork (b F : ℕ) (a initial : OAI.EditApproximation.BinaryFraction) : Bool × ℕ :=  let denominator := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat 4) a  let lower := OAI.EditApproximation.BinaryFraction.divWithWork (OAI.EditApproximation.BinaryFraction.nat b) denominator.1  let factor := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat 8) (OAI.EditApproximation.BinaryFraction.nat F)  let upper := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork factor.1 (OAI.EditApproximation.BinaryFraction.nat b)  let low := OAI.EditApproximation.BinaryFraction.leWithWork lower.1 initial  let high := OAI.EditApproximation.BinaryFraction.leWithWork initial upper.1  (low.1 && high.1, denominator.2 + lower.2 + factor.2 + upper.2 + low.2 + high.2 +    Nat.size b + Nat.size F + 8)def refinementScaleGuardWithWork (F b : ℕ) (a w : OAI.EditApproximation.BinaryFraction) : Bool × ℕ :=  let denominator := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat 16) (OAI.EditApproximation.BinaryFraction.nat F)  let lower := OAI.EditApproximation.BinaryFraction.divWithWork w denominator.1  let factor := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat 8) a  let upper := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork factor.1 w  let low := OAI.EditApproximation.BinaryFraction.leWithWork lower.1 (OAI.EditApproximation.BinaryFraction.nat b)  let high := OAI.EditApproximation.BinaryFraction.leWithWork (OAI.EditApproximation.BinaryFraction.nat b) upper.1  (low.1 && high.1, denominator.2 + lower.2 + factor.2 + upper.2 + low.2 + high.2 +    Nat.size b + Nat.size F + 8)def coarseDivideWithWork (a divisor : OAI.EditApproximation.BinaryFraction) : OAI.EditApproximation.BinaryFraction × ℕ :=  let quotient := OAI.EditApproximation.BinaryFraction.divWithWork a divisor  let result := OAI.EditApproximation.BinaryFraction.fixedDenominatorWithWork quotient.1 a.denominator a.denominator_pos  (result.1, quotient.2 + result.2 + 2)def coarseGridLeftWithWork (two : OAI.EditApproximation.BinaryFraction) : List OAI.EditApproximation.BinaryFraction → List OAI.EditApproximation.BinaryFraction × ℕ  | [] => ([], 0)  | head :: rest => OAI.EditApproximation.BinaryFraction.coarseGridScanWithWork two head restdef coarseMinimumWithWork : List OAI.EditApproximation.BinaryFraction → OAI.EditApproximation.BinaryFraction × ℕ  | [] => (OAI.EditApproximation.BinaryFraction.nat 0, 1)  | a :: rest => OAI.EditApproximation.BinaryFraction.minimumWithWork a restdef powAllocation (a : OAI.EditApproximation.BinaryFraction) : ℕ → ℕ  | 0 => 0  | n + 1 => powAllocation a n + OAI.EditApproximation.BinaryFraction.canonicalMulAllocation (OAI.EditApproximation.BinaryFraction.powWithWork a n).1 adef dotListAllocation {d : ℕ} (left right : Vector OAI.EditApproximation.BinaryFraction d) : List (Fin d) → ℕ  | [] => 0  | i :: rest => dotListAllocation left right rest +      OAI.EditApproximation.BinaryFraction.canonicalMulAllocation (left.get i) (right.get i) +      OAI.EditApproximation.BinaryFraction.canonicalAddAllocation (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (left.get i) (right.get i)).1 (OAI.EditApproximation.BinaryFraction.dotListWithWork left right rest).1def minimumAllocation (fallback : OAI.EditApproximation.BinaryFraction) : List OAI.EditApproximation.BinaryFraction → ℕ  | [] => 0  | head :: rest => minimumAllocation fallback rest +      OAI.EditApproximation.BinaryFraction.minAllocation head (OAI.EditApproximation.BinaryFraction.minimumWithWork fallback rest).1def maximumAllocation (fallback : OAI.EditApproximation.BinaryFraction) : List OAI.EditApproximation.BinaryFraction → ℕ  | [] => 0  | head :: rest => maximumAllocation fallback rest +      OAI.EditApproximation.BinaryFraction.maxAllocation head (OAI.EditApproximation.BinaryFraction.maximumWithWork fallback rest).1def distanceAllocation (a b : OAI.EditApproximation.BinaryFraction) : ℕ := OAI.EditApproximation.BinaryFraction.subAllocation a b + 0def optimizerUpdateAllocation {d : ℕ} (j : ℕ) (previous selected : Vector OAI.EditApproximation.BinaryFraction d) : ℕ :=  let step := (OAI.EditApproximation.BinaryFraction.divWithWork (OAI.EditApproximation.BinaryFraction.nat 2) (OAI.EditApproximation.BinaryFraction.nat (j + 2))).1  let complement := (OAI.EditApproximation.BinaryFraction.subWithWork OAI.EditApproximation.BinaryFraction.one step).1  OAI.EditApproximation.BinaryFraction.divAllocation (OAI.EditApproximation.BinaryFraction.nat 2) (OAI.EditApproximation.BinaryFraction.nat (j + 2)) + OAI.EditApproximation.BinaryFraction.subAllocation OAI.EditApproximation.BinaryFraction.one step +    OAI.EditApproximation.vectorMapAllocation d (OAI.EditApproximation.BinaryFraction.optimizerUpdateCellAllocation step complement previous selected) +    Nat.size (j + 2) + 1def affineErrorAllocation (position offset velocity prediction tolerance : OAI.EditApproximation.BinaryFraction) : ℕ :=  let displacement := (OAI.EditApproximation.BinaryFraction.subWithWork position offset).1  let product := (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork velocity prediction).1  OAI.EditApproximation.BinaryFraction.subAllocation position offset + OAI.EditApproximation.BinaryFraction.canonicalMulAllocation velocity prediction +    OAI.EditApproximation.BinaryFraction.subAllocation displacement product + OAI.EditApproximation.BinaryFraction.leAllocation (OAI.EditApproximation.BinaryFraction.subWithWork displacement product).1.absolute tolerancedef bandToleranceAllocation (tau theta : OAI.EditApproximation.BinaryFraction) (b M : ℕ) : ℕ :=  let product := (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork tau theta).1  let scale := (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork product (OAI.EditApproximation.BinaryFraction.nat b)).1  OAI.EditApproximation.BinaryFraction.canonicalMulAllocation tau theta + OAI.EditApproximation.BinaryFraction.canonicalMulAllocation product (OAI.EditApproximation.BinaryFraction.nat b) +    OAI.EditApproximation.BinaryFraction.divAllocation scale (OAI.EditApproximation.BinaryFraction.nat M) + Nat.size b + Nat.size Mdef initialScaleGuardAllocation (U b : ℕ) (A : OAI.EditApproximation.BinaryFraction) : ℕ :=  let square := (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork A A).1  let denominator := (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat 16) square).1  let lower := (OAI.EditApproximation.BinaryFraction.divWithWork (OAI.EditApproximation.BinaryFraction.nat U) denominator).1  let factor := (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat 4) A).1  let upper := (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork factor (OAI.EditApproximation.BinaryFraction.nat U)).1  OAI.EditApproximation.BinaryFraction.canonicalMulAllocation A A + OAI.EditApproximation.BinaryFraction.canonicalMulAllocation (OAI.EditApproximation.BinaryFraction.nat 16) square + OAI.EditApproximation.BinaryFraction.divAllocation (OAI.EditApproximation.BinaryFraction.nat U) denominator +    OAI.EditApproximation.BinaryFraction.canonicalMulAllocation (OAI.EditApproximation.BinaryFraction.nat 4) A + OAI.EditApproximation.BinaryFraction.canonicalMulAllocation factor (OAI.EditApproximation.BinaryFraction.nat U) +    OAI.EditApproximation.BinaryFraction.leAllocation lower (OAI.EditApproximation.BinaryFraction.nat b) + OAI.EditApproximation.BinaryFraction.leAllocation (OAI.EditApproximation.BinaryFraction.nat b) upper + Nat.size U + Nat.size bdef initialCenterGuardAllocation (b U : ℕ) (A : OAI.EditApproximation.BinaryFraction) : ℕ :=  let lower := (OAI.EditApproximation.BinaryFraction.divWithWork (OAI.EditApproximation.BinaryFraction.nat b) (OAI.EditApproximation.BinaryFraction.nat 2)).1  let factor := (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat 4) A).1  let upper := (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork factor (OAI.EditApproximation.BinaryFraction.nat b)).1  OAI.EditApproximation.BinaryFraction.divAllocation (OAI.EditApproximation.BinaryFraction.nat b) (OAI.EditApproximation.BinaryFraction.nat 2) + OAI.EditApproximation.BinaryFraction.canonicalMulAllocation (OAI.EditApproximation.BinaryFraction.nat 4) A + OAI.EditApproximation.BinaryFraction.canonicalMulAllocation factor (OAI.EditApproximation.BinaryFraction.nat b) +    OAI.EditApproximation.BinaryFraction.leAllocation lower (OAI.EditApproximation.BinaryFraction.nat U) + OAI.EditApproximation.BinaryFraction.leAllocation (OAI.EditApproximation.BinaryFraction.nat U) upper + Nat.size b + Nat.size Udef scaledSeedAllocation (U : ℕ) (a gap : OAI.EditApproximation.BinaryFraction) : ℕ :=  let ratio := (OAI.EditApproximation.BinaryFraction.divWithWork (OAI.EditApproximation.BinaryFraction.nat U) a).1  let rounded := (OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork ratio).1  OAI.EditApproximation.BinaryFraction.divAllocation (OAI.EditApproximation.BinaryFraction.nat U) a + OAI.EditApproximation.BinaryFraction.naturalCeilingAllocation ratio +    OAI.EditApproximation.BinaryFraction.maxAllocation (OAI.EditApproximation.BinaryFraction.ofNaturalWord rounded) gap.absolute + Nat.size U + 2def centerEligibilityAllocation (b F : ℕ) (a initial : OAI.EditApproximation.BinaryFraction) : ℕ :=  OAI.EditApproximation.BinaryFraction.canonicalMulAllocation (OAI.EditApproximation.BinaryFraction.nat 4) a +    OAI.EditApproximation.BinaryFraction.divAllocation (OAI.EditApproximation.BinaryFraction.nat b) (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat 4) a).1 +    OAI.EditApproximation.BinaryFraction.canonicalMulAllocation (OAI.EditApproximation.BinaryFraction.nat 8) (OAI.EditApproximation.BinaryFraction.nat F) +    OAI.EditApproximation.BinaryFraction.canonicalMulAllocation (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat 8) (OAI.EditApproximation.BinaryFraction.nat F)).1 (OAI.EditApproximation.BinaryFraction.nat b) +    OAI.EditApproximation.BinaryFraction.leAllocation (OAI.EditApproximation.BinaryFraction.divWithWork (OAI.EditApproximation.BinaryFraction.nat b) (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat 4) a).1).1 initial +    OAI.EditApproximation.BinaryFraction.leAllocation initial (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat 8) (OAI.EditApproximation.BinaryFraction.nat F)).1 (OAI.EditApproximation.BinaryFraction.nat b)).1 + Nat.size b + Nat.size Fdef refinementScaleGuardAllocation (F b : ℕ) (a w : OAI.EditApproximation.BinaryFraction) : ℕ :=  OAI.EditApproximation.BinaryFraction.canonicalMulAllocation (OAI.EditApproximation.BinaryFraction.nat 16) (OAI.EditApproximation.BinaryFraction.nat F) +    OAI.EditApproximation.BinaryFraction.divAllocation w (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat 16) (OAI.EditApproximation.BinaryFraction.nat F)).1 +    OAI.EditApproximation.BinaryFraction.canonicalMulAllocation (OAI.EditApproximation.BinaryFraction.nat 8) a +    OAI.EditApproximation.BinaryFraction.canonicalMulAllocation (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat 8) a).1 w +    OAI.EditApproximation.BinaryFraction.leAllocation (OAI.EditApproximation.BinaryFraction.divWithWork w (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat 16) (OAI.EditApproximation.BinaryFraction.nat F)).1).1 (OAI.EditApproximation.BinaryFraction.nat b) +    OAI.EditApproximation.BinaryFraction.leAllocation (OAI.EditApproximation.BinaryFraction.nat b) (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat 8) a).1 w).1 + Nat.size b + Nat.size Fdef cellCoordinatesAllocation (side : OAI.EditApproximation.BinaryFraction) (p radius : ℕ) : ℕ :=  let lower := (OAI.EditApproximation.saturatingSubtractWithWork p radius).1  let upper := (OAI.EditApproximation.binaryNaturalAddWithWork p radius).1  let firstQ := (OAI.EditApproximation.BinaryFraction.divWithWork (OAI.EditApproximation.BinaryFraction.nat (OAI.EditApproximation.bitWordValue lower)) side).1  let lastQ := (OAI.EditApproximation.BinaryFraction.divWithWork (OAI.EditApproximation.BinaryFraction.nat (OAI.EditApproximation.bitWordValue upper)) side).1  let first := (OAI.EditApproximation.BinaryFraction.naturalFloorWithWork firstQ).1  let last := (OAI.EditApproximation.BinaryFraction.naturalFloorWithWork lastQ).1  let stop := (OAI.EditApproximation.binaryNaturalAddWithWork (OAI.EditApproximation.bitWordValue last) 1).1  let count := (OAI.EditApproximation.saturatingSubtractWithWork (OAI.EditApproximation.bitWordValue stop) (OAI.EditApproximation.bitWordValue first)).1  OAI.EditApproximation.saturatingSubtractAllocation p radius + OAI.EditApproximation.binaryNaturalAddAllocation p radius +    OAI.EditApproximation.BinaryFraction.divAllocation (OAI.EditApproximation.BinaryFraction.nat (OAI.EditApproximation.bitWordValue lower)) side + OAI.EditApproximation.BinaryFraction.divAllocation (OAI.EditApproximation.BinaryFraction.nat (OAI.EditApproximation.bitWordValue upper)) side +    OAI.EditApproximation.BinaryFraction.naturalFloorAllocation firstQ + OAI.EditApproximation.BinaryFraction.naturalFloorAllocation lastQ +    OAI.EditApproximation.binaryNaturalAddAllocation (OAI.EditApproximation.bitWordValue last) 1 +    OAI.EditApproximation.saturatingSubtractAllocation (OAI.EditApproximation.bitWordValue stop) (OAI.EditApproximation.bitWordValue first) + OAI.EditApproximation.bitWordValue count +    Nat.size p + Nat.size radiusdef cellGridPointsAllocation (side : OAI.EditApproximation.BinaryFraction) (g cell : ℕ) : ℕ :=  let next := (OAI.EditApproximation.binaryNaturalAddWithWork cell 1).1  let lower := (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat cell) side).1  let upper := (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat (OAI.EditApproximation.bitWordValue next)) side).1  let firstQ := (OAI.EditApproximation.BinaryFraction.divWithWork lower (OAI.EditApproximation.BinaryFraction.nat g)).1  let lastQ := (OAI.EditApproximation.BinaryFraction.divWithWork upper (OAI.EditApproximation.BinaryFraction.nat g)).1  let first := (OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork firstQ).1  let last := (OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork lastQ).1  let count := (OAI.EditApproximation.saturatingSubtractWithWork (OAI.EditApproximation.bitWordValue last) (OAI.EditApproximation.bitWordValue first)).1  let indices := List.range' (OAI.EditApproximation.bitWordValue first) (OAI.EditApproximation.bitWordValue count)  OAI.EditApproximation.binaryNaturalAddAllocation cell 1 + OAI.EditApproximation.BinaryFraction.canonicalMulAllocation (OAI.EditApproximation.BinaryFraction.nat cell) side +    OAI.EditApproximation.BinaryFraction.canonicalMulAllocation (OAI.EditApproximation.BinaryFraction.nat (OAI.EditApproximation.bitWordValue next)) side + OAI.EditApproximation.BinaryFraction.divAllocation lower (OAI.EditApproximation.BinaryFraction.nat g) + OAI.EditApproximation.BinaryFraction.divAllocation upper (OAI.EditApproximation.BinaryFraction.nat g) +    OAI.EditApproximation.BinaryFraction.naturalCeilingAllocation firstQ + OAI.EditApproximation.BinaryFraction.naturalCeilingAllocation lastQ +    OAI.EditApproximation.saturatingSubtractAllocation (OAI.EditApproximation.bitWordValue last) (OAI.EditApproximation.bitWordValue first) +    OAI.EditApproximation.arithmeticMapAllocation (fun i => OAI.EditApproximation.binaryNaturalMulAllocation g i + Nat.size i) indices +    indices.length + Nat.size cell + Nat.size gdef medianSeedAllocation (N multiplier : ℕ) (values : List OAI.EditApproximation.BinaryFraction) : ℕ :=  let rounded := (OAI.EditApproximation.arithmeticMapWithWork (OAI.EditApproximation.BinaryFraction.scaledCeilingWithWork multiplier) values).1  let sorted := (OAI.EditApproximation.wordSortWithWork rounded).1  OAI.EditApproximation.arithmeticMapAllocation (OAI.EditApproximation.BinaryFraction.scaledCeilingAllocation multiplier) values + OAI.EditApproximation.wordSortAllocation rounded +    OAI.EditApproximation.wordLEAllocation N.bits (sorted.getD (values.length / 2) []) +    Nat.size Ndef groupSampleCountAllocation (M Q b : ℕ) (h : OAI.EditApproximation.BinaryFraction) : ℕ :=  let qm := (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat Q) (OAI.EditApproximation.BinaryFraction.nat M)).1  let numerator := (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork qm h).1  let ratio := (OAI.EditApproximation.BinaryFraction.divWithWork numerator (OAI.EditApproximation.BinaryFraction.nat b)).1  OAI.EditApproximation.BinaryFraction.canonicalMulAllocation (OAI.EditApproximation.BinaryFraction.nat Q) (OAI.EditApproximation.BinaryFraction.nat M) + OAI.EditApproximation.BinaryFraction.canonicalMulAllocation qm h +    OAI.EditApproximation.BinaryFraction.divAllocation numerator (OAI.EditApproximation.BinaryFraction.nat b) + OAI.EditApproximation.BinaryFraction.naturalCeilingAllocation ratio +    OAI.EditApproximation.wordLEAllocation M.bits (OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork ratio).1 +    Nat.size M + Nat.size Q + Nat.size bdef refinementUpdateAllocation (delta cone : OAI.EditApproximation.BinaryFraction) : Option OAI.EditApproximation.BinaryFraction → ℕ  | none => 0  | some online =>    let denominator := (OAI.EditApproximation.BinaryFraction.canonicalAddWithWork OAI.EditApproximation.BinaryFraction.one delta).1    let lower := (OAI.EditApproximation.BinaryFraction.divWithWork cone denominator).1    let clipped := (OAI.EditApproximation.BinaryFraction.maxWithWork lower online).1    OAI.EditApproximation.BinaryFraction.canonicalAddAllocation OAI.EditApproximation.BinaryFraction.one delta + OAI.EditApproximation.BinaryFraction.divAllocation cone denominator +      OAI.EditApproximation.BinaryFraction.maxAllocation lower online + OAI.EditApproximation.BinaryFraction.minAllocation cone clippeddef coefficientAllocation (kappa : OAI.EditApproximation.BinaryFraction) : ℕ :=  OAI.EditApproximation.BinaryFraction.canonicalMulAllocation (OAI.EditApproximation.BinaryFraction.nat 2) kappa + OAI.EditApproximation.BinaryFraction.subAllocation OAI.EditApproximation.BinaryFraction.one (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat 2) kappa).1 + 0def gainReadAllocation {β : Type u_1} {σ : Type u_2} (mass : β → OAI.EditApproximation.BinaryFraction)    (read : ℕ → β × σ → OAI.EditApproximation.BinaryFraction × ℕ) (footprint : ℕ → β × σ → ℕ)    (s : ℕ) (i : β × σ) : ℕ :=  footprint s i + OAI.EditApproximation.BinaryFraction.divAllocation (read s i).1.neg (mass i.1) + 0def decrementReadAllocation {β : Type u_1} {σ : Type u_2} (mass : β → OAI.EditApproximation.BinaryFraction)    (read : ℕ → β × σ → OAI.EditApproximation.BinaryFraction × ℕ) (footprint : ℕ → β × σ → ℕ)    (s : ℕ) (i : β × σ) : ℕ :=  footprint s i + footprint (s + 1) i + OAI.EditApproximation.BinaryFraction.subAllocation (read s i).1 (read (s + 1) i).1 +    OAI.EditApproximation.BinaryFraction.divAllocation (OAI.EditApproximation.BinaryFraction.subWithWork (read s i).1 (read (s + 1) i).1).1 (mass i.1) + 0def logarithmWithWork (r : OAI.EditApproximation.BinaryFraction) (k : ℕ) : OAI.EditApproximation.BinaryFraction × ℕ :=  let numerator := OAI.EditApproximation.BinaryFraction.subWithWork r OAI.EditApproximation.BinaryFraction.one  let denominator := OAI.EditApproximation.BinaryFraction.canonicalAddWithWork r OAI.EditApproximation.BinaryFraction.one  let ratio := OAI.EditApproximation.BinaryFraction.divWithWork numerator.1 denominator.1  let subtotal :=  OAI.EditApproximation.BinaryFraction.logarithmPartialWithWork ratio.1 k  let result := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat 2) subtotal.1  (result.1, numerator.2 + denominator.2 + ratio.2 + subtotal.2 + result.2 + 5)def optimisticTermReadWithWork {β : Type u_1} {σ : Type u_2} (mass : β → OAI.EditApproximation.BinaryFraction)    (read : ℕ → β × σ → OAI.EditApproximation.BinaryFraction × ℕ) (coefficient : OAI.EditApproximation.BinaryFraction)    (s : ℕ) (i : β × σ) : OAI.EditApproximation.BinaryFraction × ℕ :=  let gain := OAI.EditApproximation.BinaryFraction.gainReadWithWork mass read s i  let decrement := OAI.EditApproximation.BinaryFraction.decrementReadWithWork mass read s i  let scaled := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork coefficient decrement.1  let total := OAI.EditApproximation.BinaryFraction.canonicalAddWithWork gain.1 scaled.1  (total.1, gain.2 + decrement.2 + scaled.2 + total.2 + 2)def queryExponentsWithWork (N F : ℕ) (a w : OAI.EditApproximation.BinaryFraction) : List ℕ × ℕ :=  let count := max 1 N.bits.length  let selected := OAI.EditApproximation.filterWithWork (fun e =>    let guard := OAI.EditApproximation.BinaryFraction.refinementScaleGuardWithWork F (2 ^ e) a w    (guard.1, guard.2 + e + 2)) (List.range count)  (selected.1, selected.2 + count + N.bits.length + 2)def seedMedianWithWork (N multiplier : ℕ) (values : List OAI.EditApproximation.BinaryFraction) : List Bool × ℕ :=  let median := OAI.EditApproximation.BinaryFraction.medianSeedWithWork N multiplier values  let trimmed := OAI.EditApproximation.trimBitWordWithWork median.1  (trimmed.1, median.2 + trimmed.2 + 1)def coarseGridPenaltyWithWork (two : OAI.EditApproximation.BinaryFraction) (source : List OAI.EditApproximation.BinaryFraction) :    List OAI.EditApproximation.BinaryFraction × ℕ :=  let left := OAI.EditApproximation.BinaryFraction.coarseGridLeftWithWork two source  let right := OAI.EditApproximation.BinaryFraction.coarseGridLeftWithWork two source.reverse  let result := OAI.EditApproximation.BinaryFraction.coarseGridZipMinimumWithWork left.1 right.1.reverse  (result.1, left.2 + right.2 + result.2 + 3 * source.length)def coarseChildThresholdWithWork (B q : ℕ) (allowance : OAI.EditApproximation.BinaryFraction) (draw : Fin B) :    OAI.EditApproximation.BinaryFraction × ℕ :=  let numerator := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork allowance (OAI.EditApproximation.BinaryFraction.nat (draw.val + 1))  let divisor := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat B) (OAI.EditApproximation.BinaryFraction.nat q)  let result := OAI.EditApproximation.BinaryFraction.coarseDivideWithWork numerator.1 divisor.1  (result.1, numerator.2 + divisor.2 + result.2 + Nat.size (draw.val + 1) + Nat.size B + Nat.size q + 4)def coarseChildAllowanceWithWork (L : ℕ) (threshold : OAI.EditApproximation.BinaryFraction) : OAI.EditApproximation.BinaryFraction × ℕ :=  let result := OAI.EditApproximation.BinaryFraction.coarseDivideWithWork threshold (OAI.EditApproximation.BinaryFraction.nat L)  (result.1, result.2 + Nat.size L + 1)def logarithmPartialAllocation (b : OAI.EditApproximation.BinaryFraction) : ℕ → ℕ  | 0 => 0  | n + 1 =>    let previous := (OAI.EditApproximation.BinaryFraction.logarithmPartialWithWork b n).1    let power := (OAI.EditApproximation.BinaryFraction.powWithWork b (2 * n + 1)).1    let term := (OAI.EditApproximation.BinaryFraction.divWithWork power (OAI.EditApproximation.BinaryFraction.nat (2 * n + 1))).1    logarithmPartialAllocation b n + OAI.EditApproximation.BinaryFraction.powAllocation b (2 * n + 1) +      OAI.EditApproximation.BinaryFraction.divAllocation power (OAI.EditApproximation.BinaryFraction.nat (2 * n + 1)) + OAI.EditApproximation.BinaryFraction.canonicalAddAllocation previous term + Nat.size (2 * n + 1) + 1def bandMassAllocation {M : ℕ} (mass : Vector OAI.EditApproximation.BinaryFraction M) : ℕ :=  OAI.EditApproximation.BinaryFraction.dotListAllocation mass (Vector.replicate M OAI.EditApproximation.BinaryFraction.one) (List.finRange M) + 2 * Mdef sumListAllocation (values : List OAI.EditApproximation.BinaryFraction) : ℕ :=  OAI.EditApproximation.BinaryFraction.dotListAllocation (Vector.ofFn values.get) (Vector.replicate values.length OAI.EditApproximation.BinaryFraction.one)    (List.finRange values.length) + 3 * values.lengthdef naturalDistanceLeAllocation (a b radius : ℕ) : ℕ :=  OAI.EditApproximation.BinaryFraction.distanceAllocation (OAI.EditApproximation.BinaryFraction.nat a) (OAI.EditApproximation.BinaryFraction.nat b) + OAI.EditApproximation.BinaryFraction.leAllocation (OAI.EditApproximation.BinaryFraction.distanceWithWork (OAI.EditApproximation.BinaryFraction.nat a) (OAI.EditApproximation.BinaryFraction.nat b)).1 (OAI.EditApproximation.BinaryFraction.nat radius) +    Nat.size a + Nat.size b + Nat.size radiusdef queryExponentsAllocation (N F : ℕ) (a w : OAI.EditApproximation.BinaryFraction) : ℕ :=  let count := max 1 N.bits.length  OAI.EditApproximation.filterAllocation (fun e => ((OAI.EditApproximation.BinaryFraction.refinementScaleGuardWithWork F (2 ^ e) a w).1,      (OAI.EditApproximation.BinaryFraction.refinementScaleGuardWithWork F (2 ^ e) a w).2 + e + 2))    (fun e => OAI.EditApproximation.BinaryFraction.refinementScaleGuardAllocation F (2 ^ e) a w + e + 1) (List.range count) +    count + N.bits.lengthdef seedMedianAllocation (N multiplier : ℕ) (values : List OAI.EditApproximation.BinaryFraction) : ℕ :=  OAI.EditApproximation.BinaryFraction.medianSeedAllocation N multiplier values +    OAI.EditApproximation.trimBitWordAllocation (OAI.EditApproximation.BinaryFraction.medianSeedWithWork N multiplier values).1 + 0def onlineMinimumAllocation : List OAI.EditApproximation.BinaryFraction → ℕ  | [] => 0  | first :: rest => OAI.EditApproximation.BinaryFraction.minimumAllocation first restdef optimisticTermReadAllocation {β : Type u_1} {σ : Type u_2} (mass : β → OAI.EditApproximation.BinaryFraction)    (read : ℕ → β × σ → OAI.EditApproximation.BinaryFraction × ℕ) (footprint : ℕ → β × σ → ℕ)    (coefficient : OAI.EditApproximation.BinaryFraction) (s : ℕ) (i : β × σ) : ℕ :=  let gain := (OAI.EditApproximation.BinaryFraction.gainReadWithWork mass read s i).1  let decrement := (OAI.EditApproximation.BinaryFraction.decrementReadWithWork mass read s i).1  OAI.EditApproximation.BinaryFraction.gainReadAllocation mass read footprint s i + OAI.EditApproximation.BinaryFraction.decrementReadAllocation mass read footprint s i +    OAI.EditApproximation.BinaryFraction.canonicalMulAllocation coefficient decrement +    OAI.EditApproximation.BinaryFraction.canonicalAddAllocation gain (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork coefficient decrement).1 + 0def gradientCellWithWork {d : ℕ} (G : ℕ) (linear point : Vector OAI.EditApproximation.BinaryFraction d)    (i : Fin d) : OAI.EditApproximation.BinaryFraction × ℕ :=  let smoothing := OAI.EditApproximation.BinaryFraction.powWithWork (OAI.EditApproximation.BinaryFraction.nat G) 50  let inverse := smoothing.1.invWithWork  let shifted := OAI.EditApproximation.BinaryFraction.canonicalAddWithWork (point.get i) inverse.1  let logarithm := OAI.EditApproximation.BinaryFraction.logarithmWithWork shifted.1 (G ^ 60)  let deficit := OAI.EditApproximation.BinaryFraction.subWithWork logarithm.1.neg OAI.EditApproximation.BinaryFraction.one  let result := OAI.EditApproximation.BinaryFraction.canonicalAddWithWork deficit.1 (linear.get i)  (result.1, smoothing.2 + inverse.2 + shifted.2 + logarithm.2 + deficit.2 + result.2 +    Nat.size G + 70)def queryScalesWithWork (N F : ℕ) (a value : OAI.EditApproximation.BinaryFraction) : List ℕ × ℕ :=  let exponents := OAI.EditApproximation.BinaryFraction.queryExponentsWithWork N F a value  let scales := OAI.EditApproximation.arithmeticMapWithWork (fun e => (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.powerTwoWord e), e + 3)) exponents.1  (scales.1, exponents.2 + scales.2 + 1)def querySeedMedianWithWork (N multiplier : ℕ) (words : List OAI.EditApproximation.BinaryFraction) : OAI.EditApproximation.BinaryFraction × ℕ :=  let result := OAI.EditApproximation.BinaryFraction.seedMedianWithWork N multiplier words  (OAI.EditApproximation.BinaryFraction.ofNaturalWord result.1, result.2 + result.1.length + 1)def coarseBinaryPenaltyWithWork (two : OAI.EditApproximation.BinaryFraction) : OAI.EditApproximation.BinaryFraction.CoarseBinaryArray → OAI.EditApproximation.BinaryFraction.CoarseBinaryArray × ℕ  | none => (none, 0)  | some values =>    let result := OAI.EditApproximation.BinaryFraction.coarseGridPenaltyWithWork two values    (some result.1, result.2)def logarithmAllocation (r : OAI.EditApproximation.BinaryFraction) (n : ℕ) : ℕ :=  let numerator := (OAI.EditApproximation.BinaryFraction.subWithWork r OAI.EditApproximation.BinaryFraction.one).1  let denominator := (OAI.EditApproximation.BinaryFraction.canonicalAddWithWork r OAI.EditApproximation.BinaryFraction.one).1  let ratio := (OAI.EditApproximation.BinaryFraction.divWithWork numerator denominator).1  OAI.EditApproximation.BinaryFraction.subAllocation r OAI.EditApproximation.BinaryFraction.one + OAI.EditApproximation.BinaryFraction.canonicalAddAllocation r OAI.EditApproximation.BinaryFraction.one + OAI.EditApproximation.BinaryFraction.divAllocation numerator denominator +    OAI.EditApproximation.BinaryFraction.logarithmPartialAllocation ratio n + OAI.EditApproximation.BinaryFraction.canonicalMulAllocation (OAI.EditApproximation.BinaryFraction.nat 2) (OAI.EditApproximation.BinaryFraction.logarithmPartialWithWork ratio n).1def queryScalesAllocation (N F : ℕ) (a value : OAI.EditApproximation.BinaryFraction) : ℕ :=  OAI.EditApproximation.BinaryFraction.queryExponentsAllocation N F a value +    OAI.EditApproximation.arithmeticMapAllocation (fun e => e + 1) (OAI.EditApproximation.BinaryFraction.queryExponentsWithWork N F a value).1def coarseIndexChildren {B : ℕ} (k q L : ℕ) (two : OAI.EditApproximation.BinaryFraction)    (width : Fin B → ℕ)    (evaluate : Fin B → OAI.EditApproximation.BinaryFraction → ℕ → OAI.EditApproximation.BinaryFraction.CoarseBinaryArray × ℕ)    (draw : Fin B → Fin B) (allowance : OAI.EditApproximation.BinaryFraction) :    List (Fin B) → ℕ → OAI.EditApproximation.BinaryFraction.CoarseBinaryArray × ℕ  | [], _ => (none, 0)  | i :: rest, start =>    let threshold := OAI.EditApproximation.BinaryFraction.coarseChildThresholdWithWork B q allowance (draw i)    let childAllowance := OAI.EditApproximation.BinaryFraction.coarseChildAllowanceWithWork L threshold.1    let evaluated := evaluate i childAllowance.1 start    let penalty := OAI.EditApproximation.BinaryFraction.coarseBinaryPenaltyWithWork two evaluated.1    let scale := OAI.EditApproximation.BinaryFraction.coarseChildAllowanceWithWork q allowance    let contribution := OAI.EditApproximation.BinaryFraction.coarseBinaryMapWithWork (OAI.EditApproximation.BinaryFraction.coarseContributionWithWork threshold.1 scale.1) penalty.1    let remainder := coarseIndexChildren k q L two width evaluate draw allowance rest (start + width i)    let total := OAI.EditApproximation.BinaryFraction.coarseBinaryAddWithWork contribution.1 remainder.1    (total.1, threshold.2 + childAllowance.2 + evaluated.2 + penalty.2 + scale.2 + contribution.2 +      remainder.2 + total.2 + Nat.size start + Nat.size (width i) + 9)def gradientCellAllocation {d : ℕ} (G : ℕ) (linear point : Vector OAI.EditApproximation.BinaryFraction d)    (i : Fin d) : ℕ :=  let smoothing := (OAI.EditApproximation.BinaryFraction.powWithWork (OAI.EditApproximation.BinaryFraction.nat G) 50).1  let inverse := smoothing.invWithWork.1  let shifted := (OAI.EditApproximation.BinaryFraction.canonicalAddWithWork (point.get i) inverse).1  let logarithm := (OAI.EditApproximation.BinaryFraction.logarithmWithWork shifted (G ^ 60)).1  let deficit := (OAI.EditApproximation.BinaryFraction.subWithWork logarithm.neg OAI.EditApproximation.BinaryFraction.one).1  OAI.EditApproximation.BinaryFraction.powAllocation (OAI.EditApproximation.BinaryFraction.nat G) 50 + OAI.EditApproximation.BinaryFraction.invAllocation smoothing +    OAI.EditApproximation.BinaryFraction.canonicalAddAllocation (point.get i) inverse + OAI.EditApproximation.BinaryFraction.logarithmAllocation shifted (G ^ 60) +    OAI.EditApproximation.BinaryFraction.subAllocation logarithm.neg OAI.EditApproximation.BinaryFraction.one + OAI.EditApproximation.BinaryFraction.canonicalAddAllocation deficit (linear.get i) + Nat.size G + 1def coarseIndexedWithWork {B : ℕ} (k q L n : ℕ) (source target : List ℕ)    (two : OAI.EditApproximation.BinaryFraction) : (d offset : ℕ) → OAI.EditApproximation.CoarseThresholdDraws B d →    OAI.EditApproximation.BinaryFraction → ℕ → OAI.EditApproximation.BinaryFraction.CoarseBinaryArray × ℕ  | 0, offset, _, allowance, start =>    let descriptor := OAI.EditApproximation.coarseDescriptorWithWork B 0 n offset    let size := OAI.EditApproximation.bitWordValue descriptor.1    let prune := OAI.EditApproximation.BinaryFraction.leWithWork (OAI.EditApproximation.BinaryFraction.nat size) allowance    if prune.1 then (none, descriptor.2 + prune.2 + Nat.size size + 1) else    let letter := OAI.EditApproximation.coarsePaddedReadWithWork n source offset    let cells := OAI.EditApproximation.arithmeticMapWithWork (fun shift : Fin (2 * k + 1) =>      let mismatch := OAI.EditApproximation.BinaryFraction.coarseReadShiftWithWork k n target letter.1 start shift      let value := OAI.EditApproximation.BinaryFraction.coarseGridNatWithWork allowance.denominator allowance.denominator_pos mismatch.1      (value.1, value.2 + mismatch.2)) (List.finRange (2 * k + 1))    (some cells.1, descriptor.2 + letter.2 + prune.2 + cells.2 +      Nat.size size + 3 * (2 * k + 1) + 1)  | d + 1, offset, (draws, below), allowance, start =>    let descriptor := OAI.EditApproximation.coarseDescriptorWithWork B (d + 1) n offset    let size := OAI.EditApproximation.bitWordValue descriptor.1    let prune := OAI.EditApproximation.BinaryFraction.leWithWork (OAI.EditApproximation.BinaryFraction.nat size) allowance    if prune.1 then (none, descriptor.2 + prune.2 + Nat.size size + 1) else    let capacity := OAI.EditApproximation.bitPowerWithWork B.bits d    let childOffset := fun i : Fin B =>      OAI.EditApproximation.coarseChildOffsetWithWork offset (OAI.EditApproximation.bitWordValue capacity.1) i.val    let childSize := fun i : Fin B =>      OAI.EditApproximation.coarseDescriptorWithWork B d n (OAI.EditApproximation.bitWordValue (childOffset i).1)    let result := OAI.EditApproximation.BinaryFraction.coarseIndexChildren k q L two      (fun i => OAI.EditApproximation.bitWordValue (childSize i).1)      (fun i a s =>        let evaluated := coarseIndexedWithWork k q L n source target two d          (OAI.EditApproximation.bitWordValue (childOffset i).1) (below i) a s        let next := OAI.EditApproximation.binaryNaturalAddWithWork s (OAI.EditApproximation.bitWordValue (childSize i).1)        (evaluated.1, evaluated.2 + 3 * ((childOffset i).2 + (childSize i).2 + next.2 + 3)))      draws allowance (List.finRange B) start    (result.1, descriptor.2 + capacity.2 + result.2 + prune.2 + Nat.size size + B + 1)def gradientAllocation {d : ℕ} (G : ℕ) (linear point : Vector OAI.EditApproximation.BinaryFraction d) : ℕ :=  OAI.EditApproximation.vectorMapAllocation d (OAI.EditApproximation.BinaryFraction.gradientCellAllocation G linear point)end OAI.EditApproximation.BinaryFractionendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.BinaryFractionopen Finsetdef gradientWithWork {d : ℕ} (G : ℕ) (linear point : Vector OAI.EditApproximation.BinaryFraction d) :    Vector OAI.EditApproximation.BinaryFraction d × ℕ :=  OAI.EditApproximation.vectorMapWithWork d (OAI.EditApproximation.BinaryFraction.gradientCellWithWork G linear point)def scoredArgmaxWithWork {α : Type u_1} (score : α → OAI.EditApproximation.BinaryFraction × ℕ) :    List α → Option (α × OAI.EditApproximation.BinaryFraction) × ℕ  | [] => (none, 0)  | a :: rest =>    let tail := scoredArgmaxWithWork score rest    let current := score a    match tail.1 with    | none => (some (a, current.1), tail.2 + current.2 + 1)    | some best =>      let comparison := current.1.ltWithWork best.2      (if comparison.1 then some best else some (a, current.1),        tail.2 + current.2 + comparison.2 + 2)def optimizerUpdateWithWork {d : ℕ} (j : ℕ) (previous selected : Vector OAI.EditApproximation.BinaryFraction d) :    Vector OAI.EditApproximation.BinaryFraction d × ℕ :=  let step := OAI.EditApproximation.BinaryFraction.divWithWork (OAI.EditApproximation.BinaryFraction.nat 2) (OAI.EditApproximation.BinaryFraction.nat (j + 2))  let complement := OAI.EditApproximation.BinaryFraction.subWithWork OAI.EditApproximation.BinaryFraction.one step.1  let result := OAI.EditApproximation.vectorMapWithWork d fun i =>    let first := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork complement.1 (previous.get i)    let second := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork step.1 (selected.get i)    let total := OAI.EditApproximation.BinaryFraction.canonicalAddWithWork first.1 second.1    (total.1, first.2 + second.2 + total.2 + 4)  (result.1, step.2 + complement.2 + result.2 + Nat.size (j + 2) + 4)def bandMassTotalWithWork {M : ℕ} (mass : Vector OAI.EditApproximation.BinaryFraction M) : OAI.EditApproximation.BinaryFraction × ℕ :=  OAI.EditApproximation.BinaryFraction.dotWithWork mass (Vector.replicate M OAI.EditApproximation.BinaryFraction.one)def coefficientWithWork (kappa : OAI.EditApproximation.BinaryFraction) : OAI.EditApproximation.BinaryFraction × ℕ :=  let scaled := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat 2) kappa  let difference := OAI.EditApproximation.BinaryFraction.subWithWork OAI.EditApproximation.BinaryFraction.one scaled.1  (difference.1, scaled.2 + difference.2 + 1)def naturalDistanceLeWithWork (a b radius : ℕ) : Bool × ℕ :=  let distance := OAI.EditApproximation.BinaryFraction.distanceWithWork (OAI.EditApproximation.BinaryFraction.nat a) (OAI.EditApproximation.BinaryFraction.nat b)  let result := distance.1.leWithWork (OAI.EditApproximation.BinaryFraction.nat radius)  (result.1, distance.2 + result.2 + Nat.size a + Nat.size b + Nat.size radius + 3)def onlineMinimumWithWork : List OAI.EditApproximation.BinaryFraction → Option OAI.EditApproximation.BinaryFraction × ℕ  | [] => (none, 1)  | first :: rest =>    let result := OAI.EditApproximation.BinaryFraction.minimumWithWork first rest    (some result.1, result.2 + 1)def refinementUpdateWithWork (delta cone : OAI.EditApproximation.BinaryFraction) : Option OAI.EditApproximation.BinaryFraction → OAI.EditApproximation.BinaryFraction × ℕ  | none => (cone, 1)  | some online =>    let denominator := OAI.EditApproximation.BinaryFraction.canonicalAddWithWork OAI.EditApproximation.BinaryFraction.one delta    let lower := OAI.EditApproximation.BinaryFraction.divWithWork cone denominator.1    let clipped := OAI.EditApproximation.BinaryFraction.maxWithWork lower.1 online    let result := OAI.EditApproximation.BinaryFraction.minWithWork cone clipped.1    (result.1, denominator.2 + lower.2 + clipped.2 + result.2 + 2)def equalWithWork (a b : OAI.EditApproximation.BinaryFraction) : Bool × ℕ :=  let left := a.leWithWork b  let right := b.leWithWork a  (left.1 && right.1, left.2 + right.2 + 1)def roundedSpacingWithWork (theta envelope : OAI.EditApproximation.BinaryFraction) : List Bool × ℕ :=  let product := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork theta envelope  let clipped := OAI.EditApproximation.BinaryFraction.maxWithWork OAI.EditApproximation.BinaryFraction.one product.1  let rounded := OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork clipped.1  (rounded.1, product.2 + clipped.2 + rounded.2 + 2)def maximizerWithWork {d : ℕ} (gradient : Vector OAI.EditApproximation.BinaryFraction d)    (vertices : List (Vector OAI.EditApproximation.BinaryFraction d)) : Vector OAI.EditApproximation.BinaryFraction d × ℕ :=  let selected := OAI.EditApproximation.BinaryFraction.scoredArgmaxWithWork (OAI.EditApproximation.BinaryFraction.dotWithWork gradient) vertices  ((selected.1.map Prod.fst).getD (Vector.replicate d OAI.EditApproximation.BinaryFraction.zero), selected.2 + d + 1)def groupTermsWithWork {M : ℕ} (h : OAI.EditApproximation.BinaryFraction) (envelope values : Vector OAI.EditApproximation.BinaryFraction M)    (indices : List (Fin M)) : List OAI.EditApproximation.BinaryFraction × ℕ :=  OAI.EditApproximation.arithmeticMapWithWork (fun i =>    let test := OAI.EditApproximation.BinaryFraction.equalWithWork (envelope.get i) h    (if test.1 then values.get i else OAI.EditApproximation.BinaryFraction.zero, test.2 + 2)) indicesdef selectGroupWithWork {ι : Type u_1} (members : List ι) (hne : members ≠ [])    (estimate : ι → OAI.EditApproximation.BinaryFraction × ℕ) : ι × ℕ :=  let selected := OAI.EditApproximation.BinaryFraction.scoredArgmaxWithWork (fun member =>    let result := estimate member    (result.1.neg, result.2 + 1)) members  ((selected.1.map Prod.fst).getD (members.head hne), selected.2 + 1)def finiteOptimizerWithWork {d : ℕ} (vertices : List (Vector OAI.EditApproximation.BinaryFraction d))    (linear : Vector OAI.EditApproximation.BinaryFraction d) (G : ℕ) : ℕ → Vector OAI.EditApproximation.BinaryFraction d × ℕ  | 0 => (vertices.headD (Vector.replicate d OAI.EditApproximation.BinaryFraction.zero), d + 1)  | j + 1 =>    let previous := finiteOptimizerWithWork vertices linear G j    let gradient := OAI.EditApproximation.BinaryFraction.gradientWithWork G linear previous.1    let selected := OAI.EditApproximation.BinaryFraction.maximizerWithWork gradient.1 vertices    let updated := OAI.EditApproximation.BinaryFraction.optimizerUpdateWithWork j previous.1 selected.1    (updated.1, previous.2 + gradient.2 + selected.2 + updated.2 + 3)def selectionWithWork {α : Type u_1} {d : ℕ}    (vertices : List (α × Vector OAI.EditApproximation.BinaryFraction d)) (linear : Vector OAI.EditApproximation.BinaryFraction d) (G j : ℕ) :    Option α × ℕ :=  let iterate := OAI.EditApproximation.BinaryFraction.finiteOptimizerWithWork (vertices.map Prod.snd) linear G j  let gradient := OAI.EditApproximation.BinaryFraction.gradientWithWork G linear iterate.1  let selected := OAI.EditApproximation.BinaryFraction.scoredArgmaxWithWork (fun vertex => OAI.EditApproximation.BinaryFraction.dotWithWork gradient.1 vertex.2) vertices  (selected.1.map fun chosen => chosen.1.1, iterate.2 + gradient.2 + selected.2 + 1)end OAI.EditApproximation.BinaryFractionendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.BitQuerydef value {ι : Type u_1} {β : Type u_2} (oracle : ι → OAI.EditApproximation.BinaryFraction) : OAI.EditApproximation.BitQuery ι β → β  | .done result => result  | .read key next => value oracle (next (oracle key))  | .charge _ next => value oracle nextdef work {ι : Type u_1} {β : Type u_2} (oracle : ι → OAI.EditApproximation.BinaryFraction) (readWork : ι → ℕ) : OAI.EditApproximation.BitQuery ι β → ℕ  | .done _ => 0  | .read key next => readWork key + work oracle readWork (next (oracle key))  | .charge steps next => steps + work oracle readWork nextdef bind {ι : Type u_1} {α : Type u_2} {β : Type u_3} : OAI.EditApproximation.BitQuery ι α → (α → OAI.EditApproximation.BitQuery ι β) → OAI.EditApproximation.BitQuery ι β  | .done result, next => next result  | .read key continuation, next => .read key (fun word => bind (continuation word) next)  | .charge steps continuation, next => .charge steps (bind continuation next)def compute {ι : Type u_1} {α : Type u_2} (execution : α × ℕ) : OAI.EditApproximation.BitQuery ι α :=  .charge execution.2 (.done execution.1)def mapKeysWithWork {ι : Type u_1} {κ : Type u_2} {β : Type u_3} (f : ι → κ × ℕ) : OAI.EditApproximation.BitQuery ι β → OAI.EditApproximation.BitQuery κ β  | .done result => .done result  | .read key next => .charge (f key).2      (.read (f key).1 (fun word => mapKeysWithWork f (next word)))  | .charge steps next => .charge steps (mapKeysWithWork f next)def restrictWithWork {ι : Type u_1} (P : ι → Prop)    (test : ι → Bool × ℕ) (htest : ∀ key, (test key).1 = true ↔ P key) :    OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction → OAI.EditApproximation.BitQuery {key // P key} OAI.EditApproximation.BinaryFraction  | .done result => .done result  | .charge steps next => .charge steps (restrictWithWork P test htest next)  | .read key next => .charge (test key).2      (if h : (test key).1 = true then        .read ⟨key, (htest key).mp h⟩ (fun word => restrictWithWork P test htest (next word))       else restrictWithWork P test htest (next (OAI.EditApproximation.BinaryFraction.nat 0)))def runMemo {ι : Type u_1} {κ : Type u_2}    (ask : ι → OAI.EditApproximation.BinaryMemo OAI.EditApproximation.BinaryFraction → OAI.EditApproximation.BitRecursiveMemoResult κ) :    OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction → OAI.EditApproximation.BinaryMemo OAI.EditApproximation.BinaryFraction → OAI.EditApproximation.BitRecursiveMemoResult κ  | .done result, memory => ⟨result, memory, [], 0, 0, 0⟩  | .read key next, memory =>    let first := ask key memory    let rest := runMemo ask (next first.value) first.memory    ⟨rest.value, rest.memory, first.freshKeys ++ rest.freshKeys,      first.dictionaryVisits + rest.dictionaryVisits, first.requests + rest.requests,      first.localWork + rest.localWork⟩  | .charge steps next, memory =>    let rest := runMemo ask next memory    {rest with localWork := steps + rest.localWork}inductive Footprint {ι : Type u_1} {β : Type u_2} : OAI.EditApproximation.BitQuery ι β → Type _ where  | done (value : β) : Footprint (.done value)  | read (key : ι) (next : OAI.EditApproximation.BinaryFraction → OAI.EditApproximation.BitQuery ι β)      (continuation : ∀ word, Footprint (next word)) : Footprint (.read key next)  | charge {steps : ℕ} {next : OAI.EditApproximation.BitQuery ι β} (cells : ℕ)      (continuation : Footprint next) : Footprint (.charge steps next)def collect {ι : Type u_1} {κ : Type u_2} {β : Type u_3} (reader : κ → OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction) :    List κ → (List OAI.EditApproximation.BinaryFraction → OAI.EditApproximation.BitQuery ι β) → OAI.EditApproximation.BitQuery ι β  | [], next => next []  | key :: rest, next => (reader key).bind (fun word =>      .charge 3 (collect reader rest (fun words => next (word :: words))))def normalize {ι : Type u_1} (program : OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction)    (base : List Bool) (hbase : 0 < OAI.EditApproximation.bitWordValue base) (remaining : ℕ) :    OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction :=  program.bind fun word => OAI.EditApproximation.BitQuery.compute (OAI.EditApproximation.BinaryFraction.finishCachedWithWork (word, 0) base hbase remaining)end OAI.EditApproximation.BitQueryendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen EditDistortiondef substring {α : Type u} (word : List α) (lo hi : ℕ) : List α :=  (word.take hi).drop lostructure TargetInterval (length : ℕ) where  lo : ℕ  hi : ℕ  ordered : lo ≤ hi  valid : hi ≤ lengthdef occurrenceDeficit {α : Type u} [DecidableEq α] (a : α) (word : List α) : ℕ :=  word.length - if a ∈ word then 1 else 0def natListMinimum (fallback : ℕ) : List ℕ → ℕ  | [] => fallback  | first :: rest => min first (natListMinimum fallback rest)def coarsePadTo {α : Type u} (n : ℕ) (word : List α) : List (Option α) :=  word.map some ++ List.replicate (n - word.length) nonedef connectionBudget {n : ℕ} (start : ℕ) (states : List (OAI.EditApproximation.TargetInterval n))    (finish : ℕ) : ℕ :=  match states with  | [] => Nat.dist start finish  | state :: rest => Nat.dist start state.lo + connectionBudget state.hi rest finishdef singletonCost {α : Type u} [DecidableEq α] (a : α) (word : List α) : ℕ :=  if word = [] then 1 else OAI.EditApproximation.occurrenceDeficit a worddef makeTargetState (n lo hi : ℕ) : Option (OAI.EditApproximation.TargetInterval n) :=  if h : lo ≤ hi ∧ hi ≤ n then some ⟨lo, hi, h.1, h.2⟩ else nonedef targetEndpointDistance {n : ℕ} (q r : OAI.EditApproximation.TargetInterval n) : ℕ :=  Nat.dist q.lo r.lo + Nat.dist q.hi r.hidef targetStates (n : ℕ) : List (OAI.EditApproximation.TargetInterval n) :=  (List.range (n + 1)).flatMap fun lo =>    (List.range (n + 1)).filterMap fun hi => OAI.EditApproximation.makeTargetState n lo hidef shortSourceCost {α : Type u_1} [DecidableEq α] (source target : List α) : ℕ :=  match source with  | [] => target.length  | a :: _ => OAI.EditApproximation.singletonCost a targetdef exactSuffixDP {α : Type u_1} [DecidableEq α] : List α → List α → List ℕ  | [], target => List.ofFn fun j : Fin (target.length + 1) => target.length - j.val  | a :: rest, target =>    let previous := exactSuffixDP rest target    List.ofFn fun j : Fin (target.length + 1) =>      OAI.EditApproximation.natListMinimum (OAI.EditApproximation.singletonCost a [] + previous.getD j.val 0)        ((List.range (target.length - j.val + 1)).map fun k =>          OAI.EditApproximation.singletonCost a ((target.drop j.val).take k) + previous.getD (j.val + k) 0)def exactSuffixAnswer {α : Type u_1} [DecidableEq α] (source target : List α) : ℕ :=  (OAI.EditApproximation.exactSuffixDP source target).getD 0 0end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationdef sourceChild {n M : ℕ} (parent : OAI.EditApproximation.TargetInterval n) (child : Fin M) : OAI.EditApproximation.TargetInterval n := by  have proof_balancedCut_monotone_7 (lo : ℕ) (width : ℕ) (M : ℕ) : Monotone (OAI.EditApproximation.balancedCut lo width M) := by    intro i j hij    exact Nat.add_le_add_left (Nat.div_le_div_right (Nat.mul_le_mul_right width hij)) lo  have proof_balancedCut_last_9 (lo : ℕ) (width : ℕ) (M : ℕ) (hM : LT.lt.{0} 0 M) :      OAI.EditApproximation.balancedCut lo width M M = lo + width := by    simp only [OAI.EditApproximation.balancedCut, Nat.mul_div_cancel_left _ hM]  have proof_balancedCut_bounds_8 (lo : ℕ) (width : ℕ) (M : ℕ) (i : ℕ) (hM : LT.lt.{0} 0 M) (hi : LE.le.{0} i M) :      lo ≤ OAI.EditApproximation.balancedCut lo width M i ∧ OAI.EditApproximation.balancedCut lo width M i ≤ lo + width := by    constructor    · exact Nat.le_add_right _ _    · rw [← proof_balancedCut_last_9 lo width M hM]      exact proof_balancedCut_monotone_7 lo width M hi  exact    { lo := OAI.EditApproximation.balancedCut parent.lo (parent.hi - parent.lo) M child.val      hi := OAI.EditApproximation.balancedCut parent.lo (parent.hi - parent.lo) M (child.val + 1)      ordered := proof_balancedCut_monotone_7 _ _ _ (Nat.le_succ _)      valid := by        have hM : 0 < M := Nat.zero_lt_of_lt child.isLt        have hbound := (proof_balancedCut_bounds_8 parent.lo (parent.hi - parent.lo) M (child.val + 1)          hM (by omega)).2        rw [Nat.add_sub_of_le parent.ordered] at hbound        exact hbound.trans parent.valid }def roundInterval {n : ℕ} (spacing : ℕ) (state : OAI.EditApproximation.TargetInterval n) : OAI.EditApproximation.TargetInterval n := by  have proof_gridRound_mono_10 (spacing : ℕ) : Monotone (OAI.EditApproximation.gridRound spacing) := by    intro p q hpq    exact Nat.mul_le_mul_left spacing (Nat.div_le_div_right hpq)  have proof_gridRound_le_11 (spacing : ℕ) (position : ℕ) : OAI.EditApproximation.gridRound spacing position ≤ position :=    Nat.mul_div_le _ _  exact {    lo := OAI.EditApproximation.gridRound spacing state.lo    hi := OAI.EditApproximation.gridRound spacing state.hi    ordered := proof_gridRound_mono_10 spacing state.ordered    valid := (proof_gridRound_le_11 spacing state.hi).trans state.valid  }def localTargetStates (n g radius : ℕ) (q : OAI.EditApproximation.TargetInterval n) : List (OAI.EditApproximation.TargetInterval n) :=  (OAI.EditApproximation.gridPointsBetween g (q.lo - radius) (q.lo + radius)).flatMap fun lo =>    (OAI.EditApproximation.gridPointsBetween g (q.hi - radius) (q.hi + radius)).filterMap fun hi =>      OAI.EditApproximation.makeTargetState n lo hidef rationalStateGap {α : Type u_1} (source target : List α) (q : OAI.EditApproximation.TargetInterval target.length) : ℚ :=  (q.hi : ℚ) - q.lo - source.lengthdef gridStateBox (n g radius lo hi : ℕ) : List (OAI.EditApproximation.TargetInterval n) :=  (OAI.EditApproximation.gridPointsBetween g (lo - radius) (lo + radius)).flatMap fun s =>    (OAI.EditApproximation.gridPointsBetween g (hi - radius) (hi + radius)).filterMap fun t =>      OAI.EditApproximation.makeTargetState n s tabbrev PhysicalEntry (M J ny : ℕ) := OAI.EditApproximation.PhysicalNode M J × OAI.EditApproximation.TargetInterval nydef makeStateWithWork (n lo hi : ℕ) : Option (OAI.EditApproximation.TargetInterval n) × ℕ := by  have proof_bitOrdering_matches_4 (high : Ordering) (a : Bool) (b : Bool) (x : ℕ) (y : ℕ) (h : OAI.EditApproximation.orderingMatches high x y) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitOrdering high a b) (a.toNat + 2 * x) (b.toNat + 2 * y) := by    rcases h with ⟨rfl, h⟩ | ⟨rfl, rfl⟩ | ⟨rfl, h⟩    · exact Or.inl ⟨rfl, by cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩    · cases a <;> cases b <;> simp [OAI.EditApproximation.bitOrdering, OAI.EditApproximation.orderingMatches]    · exact Or.inr (Or.inr ⟨rfl, by        cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩)  have proof_bitCompareWithWork_matches_5 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitCompareWithWork left right).1 (OAI.EditApproximation.bitWordValue left) (OAI.EditApproximation.bitWordValue right) := by    induction left generalizing right with    | nil =>      simp only [OAI.EditApproximation.bitCompareWithWork]      induction right with      | nil => (simp [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.orderingMatches, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        simpa only [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareNilLeftWithWork bs).1 false b 0 (OAI.EditApproximation.bitWordValue bs) ih    | cons a as ih =>      cases right with      | nil =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as []).1 a false (OAI.EditApproximation.bitWordValue as) 0 (ih [])      | cons b bs =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue] using          proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as bs).1 a b (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs) (ih bs)  have proof_bitCompareWithWork_lt_16 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .lt ↔ OAI.EditApproximation.bitWordValue left < OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_wordLEWithWork_value_26 (a : List.{0} Bool) (b : List.{0} Bool) :      (OAI.EditApproximation.wordLEWithWork a b).1 = true ↔ OAI.EditApproximation.bitWordValue a ≤ OAI.EditApproximation.bitWordValue b := by    simp only [OAI.EditApproximation.wordLEWithWork, Bool.not_eq_true', decide_eq_false_iff_not,      proof_bitCompareWithWork_lt_16, not_lt]  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  exact    let first := OAI.EditApproximation.wordLEWithWork lo.bits hi.bits    let second := OAI.EditApproximation.wordLEWithWork hi.bits n.bits    if h : (first.1 && second.1) = true then      (some ⟨lo, hi,        by have hp : first.1 = true ∧ second.1 = true := by simpa only [Bool.and_eq_true] using h           simpa only [first, proof_wordLEWithWork_value_26, proof_bitWordValue_bits_15] using hp.1,        by have hp : first.1 = true ∧ second.1 = true := by simpa only [Bool.and_eq_true] using h           simpa only [second, proof_wordLEWithWork_value_26, proof_bitWordValue_bits_15] using hp.2⟩,        first.2 + second.2 + 4)    else (none, first.2 + second.2 + 2)def cellTargetStates (n g : ℕ) (side : ℚ) (cell : ℕ × ℕ) : List (OAI.EditApproximation.TargetInterval n) :=  (OAI.EditApproximation.cellGridPoints side g cell.1).flatMap fun lo =>    (OAI.EditApproximation.cellGridPoints side g cell.2).filterMap fun hi => OAI.EditApproximation.makeTargetState n lo hidef gridGapStates (n g anchor radius sourceLength gapRadius : ℕ) : List (OAI.EditApproximation.TargetInterval n) :=  (OAI.EditApproximation.gridPointsBetween g (anchor - radius) (anchor + radius)).flatMap fun lo =>    (OAI.EditApproximation.gridPointsBetween g (lo + sourceLength - gapRadius) (lo + sourceLength + gapRadius)).filterMap      fun hi => OAI.EditApproximation.makeTargetState n lo hiabbrev PhysicalChildTables (M ny : ℕ) := Fin M → ℕ → OAI.EditApproximation.TargetInterval ny → ℚabbrev PhysicalRationalAction (M ny : ℕ) :=  OAI.EditApproximation.RationalBellmanAction (OAI.EditApproximation.TargetInterval ny) (Fin M × OAI.EditApproximation.TargetInterval ny) Mdef localTargetCells {n : ℕ} (side : ℚ) (radius : ℕ) (q : OAI.EditApproximation.TargetInterval n) : List (ℕ × ℕ) :=  (OAI.EditApproximation.localCellCoordinates side q.lo radius).flatMap fun lo =>    (OAI.EditApproximation.localCellCoordinates side q.hi radius).map fun hi => (lo, hi)def coordinateEqualWithWork {M n : ℕ} (a b : Fin M × OAI.EditApproximation.TargetInterval n) : Bool × ℕ :=  let child := OAI.EditApproximation.naturalEqualWithWork a.1.val b.1.val  let lo := OAI.EditApproximation.naturalEqualWithWork a.2.lo b.2.lo  let hi := OAI.EditApproximation.naturalEqualWithWork a.2.hi b.2.hi  (child.1 && lo.1 && hi.1, child.2 + lo.2 + hi.2 + 2)def queryIntervalEqualWithWork {n : ℕ} (a b : OAI.EditApproximation.TargetInterval n) : Bool × ℕ :=  let lo := OAI.EditApproximation.naturalEqualWithWork a.lo b.lo  let hi := OAI.EditApproximation.naturalEqualWithWork a.hi b.hi  (lo.1 && hi.1, lo.2 + hi.2 + 1)def childInputCode {M n : ℕ} (input : Fin M × OAI.EditApproximation.TargetInterval n) : ℕ :=  input.1.val + M * (input.2.lo + (n + 1) * input.2.hi)def queryChildCodeWithWork {M n : ℕ} (input : Fin M × OAI.EditApproximation.TargetInterval n) : ℕ × ℕ :=  let width := OAI.EditApproximation.binaryNaturalAddWithWork n 1  let high := OAI.EditApproximation.binaryNaturalMulWithWork (OAI.EditApproximation.bitWordValue width.1) input.2.hi  let coordinate := OAI.EditApproximation.binaryNaturalAddWithWork input.2.lo (OAI.EditApproximation.bitWordValue high.1)  let scaled := OAI.EditApproximation.binaryNaturalMulWithWork M (OAI.EditApproximation.bitWordValue coordinate.1)  let result := OAI.EditApproximation.binaryNaturalAddWithWork input.1.val (OAI.EditApproximation.bitWordValue scaled.1)  (OAI.EditApproximation.bitWordValue result.1, width.2 + high.2 + coordinate.2 + scaled.2 + result.2 + 5)def querySliceHeadWithWork {α : Type u_1} (source : List α)    (interval : OAI.EditApproximation.TargetInterval source.length) : Option α × ℕ :=  let test := OAI.EditApproximation.binaryNaturalCompareWithWork interval.lo interval.hi  (if test.1 = .lt then source[interval.lo]? else none,    test.2 + Nat.size interval.lo + Nat.size interval.hi + 3)def rankedBitProgramValue {κ : Type u_1} (rank : κ → ℕ)    (program : (key : κ) → OAI.EditApproximation.BitQuery {child : κ // rank child < rank key} OAI.EditApproximation.BinaryFraction)    (key : κ) : OAI.EditApproximation.BinaryFraction :=  (program key).value (fun child => rankedBitProgramValue rank program child.val)termination_by rank keydecreasing_by exact child.propertydef scheduledRefinementWordWithWork (N pass : ℕ) : OAI.EditApproximation.BinaryFraction × ℕ :=  if pass < OAI.EditApproximation.computedSeedPassCount N then    let e := OAI.EditApproximation.dyadicSeedExponent (OAI.EditApproximation.smallLogExponent N) (OAI.EditApproximation.computedSeedInitialExponent N) pass -      OAI.EditApproximation.smallLogExponent N    let value := OAI.EditApproximation.BinaryFraction.signedPowerTwoWithWork (e : ℤ)    (value.1, value.2 + 5)  else (OAI.EditApproximation.BinaryFraction.nat 1, 3)def coordinateEqualAllocation {M n : ℕ} (a b : Fin M × OAI.EditApproximation.TargetInterval n) : ℕ :=  OAI.EditApproximation.naturalEqualAllocation a.1.val b.1.val + OAI.EditApproximation.naturalEqualAllocation a.2.lo b.2.lo +    OAI.EditApproximation.naturalEqualAllocation a.2.hi b.2.hi + 2def queryIntervalEqualAllocation {n : ℕ} (a b : OAI.EditApproximation.TargetInterval n) : ℕ :=  OAI.EditApproximation.naturalEqualAllocation a.lo b.lo + OAI.EditApproximation.naturalEqualAllocation a.hi b.hi + 1def sourceChildAllocation {n M : ℕ} (parent : OAI.EditApproximation.TargetInterval n) (i : Fin M) : ℕ :=  let width := (OAI.EditApproximation.saturatingSubtractWithWork parent.hi parent.lo).1  let next := (OAI.EditApproximation.binaryNaturalAddWithWork i.val 1).1  OAI.EditApproximation.saturatingSubtractAllocation parent.hi parent.lo + OAI.EditApproximation.binaryNaturalAddAllocation i.val 1 +    OAI.EditApproximation.balancedCutAllocation parent.lo (OAI.EditApproximation.bitWordValue width) M i.val +    OAI.EditApproximation.balancedCutAllocation parent.lo (OAI.EditApproximation.bitWordValue width) M (OAI.EditApproximation.bitWordValue next) + 2def zeroConnectionAllocation {n : ℕ} (start : ℕ) : List (OAI.EditApproximation.TargetInterval n) → ℕ → ℕ  | [], finish => OAI.EditApproximation.naturalEqualAllocation start finish  | state :: rest, finish => OAI.EditApproximation.naturalEqualAllocation start state.lo +    zeroConnectionAllocation state.hi rest finish + 1def queryChildCodeAllocation {M n : ℕ} (input : Fin M × OAI.EditApproximation.TargetInterval n) : ℕ :=  let width := (OAI.EditApproximation.binaryNaturalAddWithWork n 1).1  let high := (OAI.EditApproximation.binaryNaturalMulWithWork (OAI.EditApproximation.bitWordValue width) input.2.hi).1  let coordinate := (OAI.EditApproximation.binaryNaturalAddWithWork input.2.lo (OAI.EditApproximation.bitWordValue high)).1  let scaled := (OAI.EditApproximation.binaryNaturalMulWithWork M (OAI.EditApproximation.bitWordValue coordinate)).1  OAI.EditApproximation.binaryNaturalAddAllocation n 1 + OAI.EditApproximation.binaryNaturalMulAllocation (OAI.EditApproximation.bitWordValue width) input.2.hi +    OAI.EditApproximation.binaryNaturalAddAllocation input.2.lo (OAI.EditApproximation.bitWordValue high) +    OAI.EditApproximation.binaryNaturalMulAllocation M (OAI.EditApproximation.bitWordValue coordinate) +    OAI.EditApproximation.binaryNaturalAddAllocation input.1.val (OAI.EditApproximation.bitWordValue scaled)def roundStateAllocation {n : ℕ} (spacing : ℕ) (q : OAI.EditApproximation.TargetInterval n) : ℕ :=  OAI.EditApproximation.binaryGridRoundAllocation spacing q.lo + OAI.EditApproximation.binaryGridRoundAllocation spacing q.hi + 2def actionEqualAllocation {n M : ℕ} (a b : Fin M → OAI.EditApproximation.TargetInterval n) : ℕ :=  OAI.EditApproximation.allAllocation (fun i => OAI.EditApproximation.naturalEqualAllocation (a i).lo (b i).lo +    OAI.EditApproximation.naturalEqualAllocation (a i).hi (b i).hi) (List.finRange M)structure RawUnskippedBand (M ny : ℕ) where  center : OAI.EditApproximation.TargetInterval ny  actions : List (Fin M → OAI.EditApproximation.TargetInterval ny)  nonempty : actions ≠ []def sourceIntervalAt (M n : ℕ) : (d : ℕ) → OAI.EditApproximation.TreeLayer M d → OAI.EditApproximation.TargetInterval n  | 0, _ => ⟨0, n, Nat.zero_le _, le_rfl⟩  | d + 1, node => OAI.EditApproximation.sourceChild (sourceIntervalAt M n d node.1) node.2def initialConeValue {α : Type u_1} (source target : List α)    (U : OAI.EditApproximation.TargetInterval target.length → ℕ) (a L0 : ℚ)    (query center : OAI.EditApproximation.TargetInterval target.length) : ℚ :=  OAI.EditApproximation.scaledSeedValue (U center) a (OAI.EditApproximation.rationalStateGap source target center) +    L0 * OAI.EditApproximation.targetEndpointDistance query centerdef wideChildStateList {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx)    (r : OAI.EditApproximation.TargetInterval ny) (b P : ℕ) (i : Fin M) : List (OAI.EditApproximation.TargetInterval ny) :=  OAI.EditApproximation.gridStateBox ny (OAI.EditApproximation.seedGridSpacing b P) (10 * b)    (r.lo + ((OAI.EditApproximation.sourceChild parent i).lo - parent.lo))    (r.lo + ((OAI.EditApproximation.sourceChild parent i).hi - parent.lo))def bandCutShift {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx)    (states : Fin M → OAI.EditApproximation.TargetInterval ny) (j : Fin M) : ℚ :=  (states j).lo - ((OAI.EditApproximation.sourceChild parent j).lo : ℚ)def localInitialConeCenters {n : ℕ} (N P : ℕ) (A : ℚ)    (U : OAI.EditApproximation.TargetInterval n → ℕ) (q : OAI.EditApproximation.TargetInterval n) : List (OAI.EditApproximation.TargetInterval n) :=  ((OAI.EditApproximation.dyadicScales N).filter (fun (b : ℕ) => decide      ((U q : ℚ) / (16 * A ^ 2) ≤ (b : ℚ) ∧ (b : ℚ) ≤ 4 * A * U q))).flatMap fun b =>    (OAI.EditApproximation.localTargetStates n (OAI.EditApproximation.seedGridSpacing b P) (U q) q).filter fun r =>      decide ((b : ℚ) / 2 ≤ U r ∧ (U r : ℚ) ≤ 4 * A * b)def gridStateBoxWithWork (n g radius lo hi : ℕ) : List (OAI.EditApproximation.TargetInterval n) × ℕ :=  let leftLow := OAI.EditApproximation.saturatingSubtractWithWork lo radius  let leftHigh := OAI.EditApproximation.binaryNaturalAddWithWork lo radius  let rightLow := OAI.EditApproximation.saturatingSubtractWithWork hi radius  let rightHigh := OAI.EditApproximation.binaryNaturalAddWithWork hi radius  let left := OAI.EditApproximation.gridPointsWithWork g (OAI.EditApproximation.bitWordValue leftLow.1) (OAI.EditApproximation.bitWordValue leftHigh.1)  let right := OAI.EditApproximation.gridPointsWithWork g (OAI.EditApproximation.bitWordValue rightLow.1) (OAI.EditApproximation.bitWordValue rightHigh.1)  let states := OAI.EditApproximation.arithmeticFlatMapWithWork (fun s => OAI.EditApproximation.filterMapWithWork (OAI.EditApproximation.makeStateWithWork n s) right.1) left.1  (states.1, leftLow.2 + leftHigh.2 + rightLow.2 + rightHigh.2 + left.2 + right.2 + states.2 + 6)def sourceChildWithWork {n M : ℕ} (parent : OAI.EditApproximation.TargetInterval n) (i : Fin M) : OAI.EditApproximation.TargetInterval n × ℕ := by  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_bitOrdering_matches_4 (high : Ordering) (a : Bool) (b : Bool) (x : ℕ) (y : ℕ) (h : OAI.EditApproximation.orderingMatches high x y) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitOrdering high a b) (a.toNat + 2 * x) (b.toNat + 2 * y) := by    rcases h with ⟨rfl, h⟩ | ⟨rfl, rfl⟩ | ⟨rfl, h⟩    · exact Or.inl ⟨rfl, by cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩    · cases a <;> cases b <;> simp [OAI.EditApproximation.bitOrdering, OAI.EditApproximation.orderingMatches]    · exact Or.inr (Or.inr ⟨rfl, by        cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩)  have proof_bitCompareWithWork_matches_5 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitCompareWithWork left right).1 (OAI.EditApproximation.bitWordValue left) (OAI.EditApproximation.bitWordValue right) := by    induction left generalizing right with    | nil =>      simp only [OAI.EditApproximation.bitCompareWithWork]      induction right with      | nil => (simp [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.orderingMatches, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        simpa only [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareNilLeftWithWork bs).1 false b 0 (OAI.EditApproximation.bitWordValue bs) ih    | cons a as ih =>      cases right with      | nil =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as []).1 a false (OAI.EditApproximation.bitWordValue as) 0 (ih [])      | cons b bs =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue] using          proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as bs).1 a b (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs) (ih bs)  have proof_bitCompareWithWork_lt_16 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .lt ↔ OAI.EditApproximation.bitWordValue left < OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_binaryNaturalCompareWithWork_lt_53 (a : ℕ) (b : ℕ) :      (OAI.EditApproximation.binaryNaturalCompareWithWork a b).1 = .lt ↔ a < b := by    simpa only [OAI.EditApproximation.binaryNaturalCompareWithWork, proof_bitWordValue_bits_15] using proof_bitCompareWithWork_lt_16 a.bits b.bits  have proof_bitSubtractor_value_17 (a : Bool) (b : Bool) (borrow : Bool) :      a.toNat + 2 * (OAI.EditApproximation.bitBorrow a b borrow).toNat =        b.toNat + borrow.toNat + (OAI.EditApproximation.bitDifference a b borrow).toNat := by    cases a <;> cases b <;> cases borrow <;> decide  have proof_bitSubtractionRippleEquation_18 (a : ℕ) (b : ℕ) (borrow : ℕ) (nextBorrow : ℕ) (difference : ℕ) (left : ℕ) (right : ℕ) (result : ℕ) (tail : ℕ) (htail : Eq.{1} (HAdd.hAdd.{0, 0, 0} (HAdd.hAdd.{0, 0, 0} result right) nextBorrow) (HAdd.hAdd.{0, 0, 0} left tail)) (hbit : Eq.{1} (HAdd.hAdd.{0, 0, 0} a (HMul.hMul.{0, 0, 0} 2 nextBorrow))    (HAdd.hAdd.{0, 0, 0} (HAdd.hAdd.{0, 0, 0} b borrow) difference)) :      (difference + 2 * result) + (b + 2 * right) + borrow =        (a + 2 * left) + 2 * tail := by    omega  have proof_bitSubtractWithWork_value_19 (left : List.{0} Bool) (right : List.{0} Bool) (borrow : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork left right borrow).1 + OAI.EditApproximation.bitWordValue right + borrow.toNat =        OAI.EditApproximation.bitWordValue left + 2 ^ max left.length right.length *          (OAI.EditApproximation.bitSubtractWithWork left right borrow).2.1.toNat := by    induction left generalizing right borrow with    | nil =>      induction right generalizing borrow with      | nil => (simp [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitSubtractNilLeftWithWork, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        have h := ih (OAI.EditApproximation.bitBorrow false b borrow)        have hb := proof_bitSubtractor_value_17 false b borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitSubtractNilLeftWithWork, OAI.EditApproximation.bitWordValue,          List.length_nil, List.length_cons, Nat.zero_max, pow_succ, Bool.toNat_false] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 0 b.toNat borrow.toNat (OAI.EditApproximation.bitBorrow false b borrow).toNat          (OAI.EditApproximation.bitDifference false b borrow).toNat 0 (OAI.EditApproximation.bitWordValue bs)          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractNilLeftWithWork bs (OAI.EditApproximation.bitBorrow false b borrow)).1)          (2 ^ bs.length * (OAI.EditApproximation.bitSubtractNilLeftWithWork bs (OAI.EditApproximation.bitBorrow false b borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_zero, Nat.add_zero, Nat.zero_add, Nat.mul_assoc,          Nat.mul_left_comm] using hs    | cons a as ih =>      cases right with      | nil =>        have h := ih [] (OAI.EditApproximation.bitBorrow a false borrow)        have hb := proof_bitSubtractor_value_17 a false borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitWordValue, List.length_nil, List.length_cons,          Nat.max_zero, pow_succ, Bool.toNat_false] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 a.toNat 0 borrow.toNat (OAI.EditApproximation.bitBorrow a false borrow).toNat          (OAI.EditApproximation.bitDifference a false borrow).toNat (OAI.EditApproximation.bitWordValue as) 0          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork as [] (OAI.EditApproximation.bitBorrow a false borrow)).1)          (2 ^ as.length * (OAI.EditApproximation.bitSubtractWithWork as [] (OAI.EditApproximation.bitBorrow a false borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_zero, Nat.add_zero, Nat.zero_add, Nat.mul_assoc,          Nat.mul_left_comm] using hs      | cons b bs =>        have h := ih bs (OAI.EditApproximation.bitBorrow a b borrow)        have hb := proof_bitSubtractor_value_17 a b borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitWordValue, List.length_cons, Nat.succ_max_succ,          pow_succ] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 a.toNat b.toNat borrow.toNat (OAI.EditApproximation.bitBorrow a b borrow).toNat          (OAI.EditApproximation.bitDifference a b borrow).toNat (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs)          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork as bs (OAI.EditApproximation.bitBorrow a b borrow)).1)          (2 ^ max as.length bs.length * (OAI.EditApproximation.bitSubtractWithWork as bs (OAI.EditApproximation.bitBorrow a b borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_assoc, Nat.mul_left_comm] using hs  have proof_bitWordValue_lt_pow_length_20 (bits : List.{0} Bool) : OAI.EditApproximation.bitWordValue bits < 2 ^ bits.length := by    induction bits with    | nil => (simp [OAI.EditApproximation.bitWordValue])    | cons bit bits ih =>      cases bit <;> (simp only [OAI.EditApproximation.bitWordValue, List.length_cons, pow_succ, Bool.toNat_false, Bool.toNat_true]) <;> omega  have proof_bitSubtractWithWork_length_21 (left : List.{0} Bool) (right : List.{0} Bool) (borrow : Bool) :      (OAI.EditApproximation.bitSubtractWithWork left right borrow).1.length = max left.length right.length := by    induction left generalizing right borrow with    | nil =>      simp only [OAI.EditApproximation.bitSubtractWithWork]      induction right generalizing borrow with      | nil => simp [OAI.EditApproximation.bitSubtractNilLeftWithWork]      | cons b bs ih => simp [OAI.EditApproximation.bitSubtractNilLeftWithWork, ih]    | cons a as ih =>      cases right with      | nil => simp [OAI.EditApproximation.bitSubtractWithWork, ih]      | cons b bs => simp [OAI.EditApproximation.bitSubtractWithWork, ih, Nat.succ_max_succ]  have proof_bitSubtractWithWork_sub_22 (left : List.{0} Bool) (right : List.{0} Bool) (h : LE.le.{0} (OAI.EditApproximation.bitWordValue right) (OAI.EditApproximation.bitWordValue left)) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork left right false).1 = OAI.EditApproximation.bitWordValue left - OAI.EditApproximation.bitWordValue right := by    have hvalue := proof_bitSubtractWithWork_value_19 left right false    have hlt := proof_bitWordValue_lt_pow_length_20 (OAI.EditApproximation.bitSubtractWithWork left right false).1    rw [proof_bitSubtractWithWork_length_21] at hlt    cases hb : (OAI.EditApproximation.bitSubtractWithWork left right false).2.1    · simp only [hb, Bool.toNat_false, Nat.mul_zero, Nat.add_zero] at hvalue      omega    · simp only [hb, Bool.toNat_true, Bool.toNat_false, Nat.mul_one, Nat.add_zero] at hvalue      omega  have proof_binaryNaturalSubtractWithWork_value_54 (a : ℕ) (b : ℕ) (h : LE.le.{0} b a) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalSubtractWithWork a b).1 = a - b := by    simpa only [OAI.EditApproximation.binaryNaturalSubtractWithWork, proof_bitWordValue_bits_15] using      proof_bitSubtractWithWork_sub_22 a.bits b.bits (by simpa only [proof_bitWordValue_bits_15] using h)  have proof_saturatingSubtractWithWork_value_50 (a : ℕ) (b : ℕ) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.saturatingSubtractWithWork a b).1 = a - b := by    unfold OAI.EditApproximation.saturatingSubtractWithWork    dsimp only    split_ifs with h    · have hlt := (proof_binaryNaturalCompareWithWork_lt_53 a b).mp h      simp only [OAI.EditApproximation.bitWordValue, Nat.sub_eq_zero_of_le hlt.le]    · exact proof_binaryNaturalSubtractWithWork_value_54 a b (le_of_not_gt (fun hab =>        h ((proof_binaryNaturalCompareWithWork_lt_53 a b).mpr hab)))  have proof_bitAdder_value_1 (a : Bool) (b : Bool) (carry : Bool) :      (OAI.EditApproximation.bitSum a b carry).toNat + 2 * (OAI.EditApproximation.bitCarry a b carry).toNat =        a.toNat + b.toNat + carry.toNat := by    cases a <;> cases b <;> cases carry <;> decide  have proof_bitAddWithWork_value_2 (left : List.{0} Bool) (right : List.{0} Bool) (carry : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitAddWithWork left right carry).1 =        OAI.EditApproximation.bitWordValue left + OAI.EditApproximation.bitWordValue right + carry.toNat := by    induction left generalizing right carry with    | nil =>      simp only [OAI.EditApproximation.bitAddWithWork]      induction right generalizing carry with      | nil => cases carry <;> simp [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue]      | cons b bs ih =>        simp only [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 false b carry        simp only [Bool.toNat_false] at h        omega    | cons a as ih =>      cases right with      | nil =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a false carry        simp only [Bool.toNat_false] at h        omega      | cons b bs =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a b carry        omega  have proof_bitMulWithWork_value_0 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitMulWithWork left right).1 = OAI.EditApproximation.bitWordValue left * OAI.EditApproximation.bitWordValue right := by    induction left with    | nil => simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue]    | cons bit bits ih =>      cases bit <;> simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue, proof_bitAddWithWork_value_2, ih] <;> ring  have proof_binaryNaturalMulWithWork_value_55 (a : ℕ) (b : ℕ) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalMulWithWork a b).1 = a * b := by    simp [OAI.EditApproximation.binaryNaturalMulWithWork, proof_bitMulWithWork_value_0, proof_bitWordValue_bits_15]  have proof_bitDivModWithWork_value_23 (divisor : List.{0} Bool) (bits : List.{0} Bool) (hd : LT.lt.{0} 0 (OAI.EditApproximation.bitWordValue divisor)) :      OAI.EditApproximation.bitWordValue bits = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).1 +        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 ∧        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 < OAI.EditApproximation.bitWordValue divisor := by    induction bits with    | nil => (simp [OAI.EditApproximation.bitDivModWithWork, OAI.EditApproximation.bitWordValue, hd])    | cons bit bits ih =>      let previous := OAI.EditApproximation.bitDivModWithWork divisor bits      let candidate := bit :: previous.2.1      have hp : OAI.EditApproximation.bitWordValue bits = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue previous.1 +          OAI.EditApproximation.bitWordValue previous.2.1 := ih.1      have hr : OAI.EditApproximation.bitWordValue previous.2.1 < OAI.EditApproximation.bitWordValue divisor := ih.2      have hc : OAI.EditApproximation.bitWordValue candidate < 2 * OAI.EditApproximation.bitWordValue divisor := by        dsimp only [candidate, OAI.EditApproximation.bitWordValue]        cases bit <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega      by_cases hlt : (OAI.EditApproximation.bitCompareWithWork candidate divisor).1 = .lt      · have hv := (proof_bitCompareWithWork_lt_16 candidate divisor).1 hlt        simp only [OAI.EditApproximation.bitDivModWithWork, show (OAI.EditApproximation.bitCompareWithWork (bit :: (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1)          divisor).1 = .lt from hlt, ↓reduceIte]        change OAI.EditApproximation.bitWordValue (bit :: bits) = OAI.EditApproximation.bitWordValue divisor *          OAI.EditApproximation.bitWordValue (false :: previous.1) + OAI.EditApproximation.bitWordValue candidate ∧ OAI.EditApproximation.bitWordValue candidate < _        constructor        · (simp only [OAI.EditApproximation.bitWordValue, Bool.toNat_false])          dsimp only [candidate, OAI.EditApproximation.bitWordValue]          nlinarith only [hp]        · exact hv      · have hv : OAI.EditApproximation.bitWordValue divisor ≤ OAI.EditApproximation.bitWordValue candidate := by          exact Nat.le_of_not_gt (fun h => hlt ((proof_bitCompareWithWork_lt_16 candidate divisor).2 h))        have hs := proof_bitSubtractWithWork_sub_22 candidate divisor hv        simp only [OAI.EditApproximation.bitDivModWithWork, show (OAI.EditApproximation.bitCompareWithWork (bit :: (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1)          divisor).1 ≠ .lt from hlt, ↓reduceIte]        change OAI.EditApproximation.bitWordValue (bit :: bits) = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue (true :: previous.1) +          OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork candidate divisor false).1 ∧          OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork candidate divisor false).1 < _        rw [hs]        constructor        · (simp only [OAI.EditApproximation.bitWordValue, Bool.toNat_true])          have he := Nat.sub_add_cancel hv          dsimp only [candidate, OAI.EditApproximation.bitWordValue] at he ⊢          nlinarith only [hp, he]        · omega  have proof_binaryNaturalDivModWithWork_spec_24 (n : ℕ) (d : ℕ) (hd : LT.lt.{0} 0 d) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalDivModWithWork n d).1 = n / d ∧        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalDivModWithWork n d).2.1 = n % d := by    have h := proof_bitDivModWithWork_value_23 d.bits n.bits (by simpa only [proof_bitWordValue_bits_15] using hd)    simp only [proof_bitWordValue_bits_15] at h    have hmod : n % d = OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork d.bits n.bits).2.1 := by      conv_lhs => rw [h.1]      simp only [Nat.add_mod, Nat.mul_mod_right, Nat.zero_add, Nat.mod_eq_of_lt h.2]    have hdiv : n / d = OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork d.bits n.bits).1 := by      conv_lhs => rw [h.1]      rw [Nat.mul_add_div hd, Nat.div_eq_of_lt h.2, Nat.add_zero]    exact ⟨hdiv.symm, hmod.symm⟩  have proof_binaryNaturalAddWithWork_value_52 (a : ℕ) (b : ℕ) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalAddWithWork a b).1 = a + b := by    simp [OAI.EditApproximation.binaryNaturalAddWithWork, proof_bitAddWithWork_value_2, proof_bitWordValue_bits_15]  have proof_balancedCutWithWork_value_51 (lo : ℕ) (width : ℕ) (M : ℕ) (i : ℕ) (hM : LT.lt.{0} 0 M) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.balancedCutWithWork lo width M i).1 = OAI.EditApproximation.balancedCut lo width M i := by    simp only [OAI.EditApproximation.balancedCutWithWork, proof_binaryNaturalAddWithWork_value_52,      (proof_binaryNaturalDivModWithWork_spec_24 _ M hM).1, proof_binaryNaturalMulWithWork_value_55, OAI.EditApproximation.balancedCut]  exact    let width := OAI.EditApproximation.saturatingSubtractWithWork parent.hi parent.lo    let next := OAI.EditApproximation.binaryNaturalAddWithWork i.val 1    let left := OAI.EditApproximation.balancedCutWithWork parent.lo (OAI.EditApproximation.bitWordValue width.1) M i.val    let right := OAI.EditApproximation.balancedCutWithWork parent.lo (OAI.EditApproximation.bitWordValue width.1) M (OAI.EditApproximation.bitWordValue next.1)    let heql : OAI.EditApproximation.bitWordValue left.1 = (OAI.EditApproximation.sourceChild parent i).lo := by      simp only [left, width, proof_balancedCutWithWork_value_51 _ _ _ _ (Nat.zero_lt_of_lt i.isLt),        proof_saturatingSubtractWithWork_value_50, OAI.EditApproximation.sourceChild]    let heqh : OAI.EditApproximation.bitWordValue right.1 = (OAI.EditApproximation.sourceChild parent i).hi := by      simp only [right, width, next, proof_balancedCutWithWork_value_51 _ _ _ _ (Nat.zero_lt_of_lt i.isLt),        proof_saturatingSubtractWithWork_value_50, proof_binaryNaturalAddWithWork_value_52, OAI.EditApproximation.sourceChild]    (⟨OAI.EditApproximation.bitWordValue left.1, OAI.EditApproximation.bitWordValue right.1,      by rw [heql, heqh]; exact (OAI.EditApproximation.sourceChild parent i).ordered,      by rw [heqh]; exact (OAI.EditApproximation.sourceChild parent i).valid⟩,      width.2 + next.2 + left.2 + right.2 + 4)def cellRepresentativeStates (n P F b : ℕ) (a : ℚ) (initial : OAI.EditApproximation.TargetInterval n → ℚ)    (theta : ℚ) (cell : ℕ × ℕ) : List (OAI.EditApproximation.TargetInterval n) :=  (OAI.EditApproximation.cellTargetStates n (OAI.EditApproximation.seedGridSpacing b P) (theta * b) cell).filter fun r => decide    ((b : ℚ) / (4 * a) ≤ initial r ∧ initial r ≤ 8 * F * b)def groupRoundedStateList {α : Type u_1} (source target : List α) {M : ℕ}    (parent : OAI.EditApproximation.TargetInterval source.length) (b exponent : ℕ) (cell : ℕ × ℕ)    (i : Fin M) (h : ℚ) : List (OAI.EditApproximation.TargetInterval target.length) :=  OAI.EditApproximation.gridGapStates target.length (OAI.EditApproximation.groupRoundSpacing exponent h)    (⌊(cell.1 : ℚ) * ((2 : ℚ) ^ (-(exponent : ℤ)) * b)⌋₊ +      ((OAI.EditApproximation.sourceChild parent i).lo - parent.lo)) (12 * b)    (OAI.EditApproximation.substring source (OAI.EditApproximation.sourceChild parent i).lo (OAI.EditApproximation.sourceChild parent i).hi).length ⌈2 * h⌉₊def rawInitialConeCenters {n : ℕ} (N P : ℕ) (A : ℚ) (value : ℕ)    (q : OAI.EditApproximation.TargetInterval n) : List (OAI.EditApproximation.TargetInterval n) :=  ((OAI.EditApproximation.dyadicScales N).filter fun (b : ℕ) => decide    ((value : ℚ) / (16 * A ^ 2) ≤ b ∧ (b : ℚ) ≤ 4 * A * value)).flatMap fun b =>      OAI.EditApproximation.localTargetStates n (OAI.EditApproximation.seedGridSpacing b P) value qdef historyInputCode {M n : ℕ} (input : Fin M × ℕ × OAI.EditApproximation.TargetInterval n) : ℕ :=  Nat.pair input.2.1 (OAI.EditApproximation.childInputCode (input.1, input.2.2))def localOnlineSourceKeys {n : ℕ} (N P F : ℕ) (a : ℚ)    (initial : OAI.EditApproximation.TargetInterval n → ℚ) (q : OAI.EditApproximation.TargetInterval n) :    List (ℕ × OAI.EditApproximation.TargetInterval n) :=  (OAI.EditApproximation.dyadicQueryWindow N (initial q) a F).map fun b => (b, OAI.EditApproximation.roundInterval (OAI.EditApproximation.seedGridSpacing b P) q)def queryHistoryCodeWithWork {M n : ℕ} (input : Fin M × ℕ × OAI.EditApproximation.TargetInterval n) : ℕ × ℕ :=  let child := OAI.EditApproximation.queryChildCodeWithWork (input.1, input.2.2)  let pair := OAI.EditApproximation.queryPairWithWork input.2.1 child.1  (pair.1, child.2 + pair.2 + 1)def queryOrderedChildInputsWithWork {M n : ℕ} (inputs : List (Fin M × OAI.EditApproximation.TargetInterval n)) :    List (Fin M × OAI.EditApproximation.TargetInterval n) × ℕ :=  OAI.EditApproximation.queryOrderedInputsWithWork OAI.EditApproximation.coordinateEqualWithWork    (OAI.EditApproximation.queryEncodedLEWithWork OAI.EditApproximation.queryChildCodeWithWork) inputsdef queryHistoryEqualWithWork {M n : ℕ} (a b : Fin M × ℕ × OAI.EditApproximation.TargetInterval n) : Bool × ℕ :=  let child := OAI.EditApproximation.coordinateEqualWithWork (a.1, a.2.2) (b.1, b.2.2)  let time := OAI.EditApproximation.naturalEqualWithWork a.2.1 b.2.1  (child.1 && time.1, child.2 + time.2 + 1)def queryGapStatesWithWork (n g anchor radius sourceLength gapRadius : ℕ) :    List (OAI.EditApproximation.TargetInterval n) × ℕ :=  let lo := OAI.EditApproximation.saturatingSubtractWithWork anchor radius  let hi := OAI.EditApproximation.binaryNaturalAddWithWork anchor radius  let left := OAI.EditApproximation.gridPointsWithWork g (OAI.EditApproximation.bitWordValue lo.1) (OAI.EditApproximation.bitWordValue hi.1)  let states := OAI.EditApproximation.arithmeticFlatMapWithWork (fun first =>    let center := OAI.EditApproximation.binaryNaturalAddWithWork first sourceLength    let lower := OAI.EditApproximation.saturatingSubtractWithWork (OAI.EditApproximation.bitWordValue center.1) gapRadius    let upper := OAI.EditApproximation.binaryNaturalAddWithWork (OAI.EditApproximation.bitWordValue center.1) gapRadius    let right := OAI.EditApproximation.gridPointsWithWork g (OAI.EditApproximation.bitWordValue lower.1) (OAI.EditApproximation.bitWordValue upper.1)    let valid := OAI.EditApproximation.filterMapWithWork (OAI.EditApproximation.makeStateWithWork n first) right.1    (valid.1, center.2 + lower.2 + upper.2 + right.2 + valid.2 + 4)) left.1  (states.1, lo.2 + hi.2 + left.2 + states.2 + 3)def queryOnlineKeyEqualWithWork {n : ℕ} (a b : ℕ × OAI.EditApproximation.TargetInterval n) : Bool × ℕ :=  let scale := OAI.EditApproximation.naturalEqualWithWork a.1 b.1  let state := OAI.EditApproximation.queryIntervalEqualWithWork a.2 b.2  (scale.1 && state.1, scale.2 + state.2 + 1)def physicalEntryCode {M J n : ℕ} (state : OAI.EditApproximation.PhysicalEntry M J n) : ℕ :=  OAI.EditApproximation.childInputCode ((0 : Fin 1), state.2) + (n + 1) ^ 2 * OAI.EditApproximation.physicalNodeCode state.1def rankedBitLocalWork {κ : Type u_1} (rank : κ → ℕ)    (program : (key : κ) → OAI.EditApproximation.BitQuery {child : κ // rank child < rank key} OAI.EditApproximation.BinaryFraction)    (key : κ) : ℕ :=  (program key).work (fun child => OAI.EditApproximation.rankedBitProgramValue rank program child.val) (fun _ => 0)def refinementParameterWordsWithWork (N pass : ℕ) (word : List Bool)    (hpositive : 0 < OAI.EditApproximation.bitWordValue word) : OAI.EditApproximation.RefinementParameterWords × ℕ :=  let online := OAI.EditApproximation.BinaryFraction.onlineParametersWithWork word hpositive  let factor := OAI.EditApproximation.scheduledRefinementWordWithWork N pass  let decrement := OAI.EditApproximation.BinaryFraction.refinementDecrementWithWork word hpositive  (⟨online.1.2, factor.1, online.1.1, online.1.2, decrement.1⟩,    online.2 + factor.2 + decrement.2 + 5)def queryHistoryEqualAllocation {M n : ℕ} (a b : Fin M × ℕ × OAI.EditApproximation.TargetInterval n) : ℕ :=  OAI.EditApproximation.coordinateEqualAllocation (a.1, a.2.2) (b.1, b.2.2) + OAI.EditApproximation.naturalEqualAllocation a.2.1 b.2.1 + 1def queryOnlineKeyEqualAllocation {n : ℕ} (a b : ℕ × OAI.EditApproximation.TargetInterval n) : ℕ :=  OAI.EditApproximation.naturalEqualAllocation a.1 b.1 + OAI.EditApproximation.queryIntervalEqualAllocation a.2 b.2 + 1def gridStateBoxAllocation (n g radius lo hi : ℕ) : ℕ :=  let leftLow := (OAI.EditApproximation.saturatingSubtractWithWork lo radius).1  let leftHigh := (OAI.EditApproximation.binaryNaturalAddWithWork lo radius).1  let rightLow := (OAI.EditApproximation.saturatingSubtractWithWork hi radius).1  let rightHigh := (OAI.EditApproximation.binaryNaturalAddWithWork hi radius).1  let left := (OAI.EditApproximation.gridPointsWithWork g (OAI.EditApproximation.bitWordValue leftLow) (OAI.EditApproximation.bitWordValue leftHigh)).1  let right := (OAI.EditApproximation.gridPointsWithWork g (OAI.EditApproximation.bitWordValue rightLow) (OAI.EditApproximation.bitWordValue rightHigh)).1  OAI.EditApproximation.saturatingSubtractAllocation lo radius + OAI.EditApproximation.binaryNaturalAddAllocation lo radius +    OAI.EditApproximation.saturatingSubtractAllocation hi radius + OAI.EditApproximation.binaryNaturalAddAllocation hi radius +    OAI.EditApproximation.gridPointsAllocation g (OAI.EditApproximation.bitWordValue leftLow) (OAI.EditApproximation.bitWordValue leftHigh) +    OAI.EditApproximation.gridPointsAllocation g (OAI.EditApproximation.bitWordValue rightLow) (OAI.EditApproximation.bitWordValue rightHigh) +    OAI.EditApproximation.arithmeticFlatMapAllocation (fun s => OAI.EditApproximation.filterMapWithWork (OAI.EditApproximation.makeStateWithWork n s) right)      (fun s => OAI.EditApproximation.filterMapAllocation (OAI.EditApproximation.makeStateWithWork n s) (OAI.EditApproximation.makeStateAllocation n s) right) leftdef queryHistoryCodeAllocation {M n : ℕ} (input : Fin M × ℕ × OAI.EditApproximation.TargetInterval n) : ℕ :=  OAI.EditApproximation.queryChildCodeAllocation (input.1, input.2.2) +    OAI.EditApproximation.queryPairAllocation input.2.1 (OAI.EditApproximation.queryChildCodeWithWork (input.1, input.2.2)).1def queryOrderedChildInputsAllocation {M n : ℕ} (inputs : List (Fin M × OAI.EditApproximation.TargetInterval n)) : ℕ :=  OAI.EditApproximation.queryOrderedInputsAllocation OAI.EditApproximation.coordinateEqualWithWork (OAI.EditApproximation.queryEncodedLEWithWork OAI.EditApproximation.queryChildCodeWithWork)    OAI.EditApproximation.coordinateEqualAllocation (OAI.EditApproximation.queryEncodedLEAllocation OAI.EditApproximation.queryChildCodeWithWork OAI.EditApproximation.queryChildCodeAllocation) inputsdef actionMemberAllocation {n M : ℕ} (a : Fin M → OAI.EditApproximation.TargetInterval n) : List (Fin M → OAI.EditApproximation.TargetInterval n) → ℕ  | [] => 0  | b :: rest => OAI.EditApproximation.actionEqualAllocation a b + actionMemberAllocation a restdef queryGapStatesAllocation (n g anchor radius sourceLength gapRadius : ℕ) : ℕ :=  let lo := (OAI.EditApproximation.saturatingSubtractWithWork anchor radius).1  let hi := (OAI.EditApproximation.binaryNaturalAddWithWork anchor radius).1  let left := (OAI.EditApproximation.gridPointsWithWork g (OAI.EditApproximation.bitWordValue lo) (OAI.EditApproximation.bitWordValue hi)).1  let build := fun first =>    let center := OAI.EditApproximation.binaryNaturalAddWithWork first sourceLength    let lower := OAI.EditApproximation.saturatingSubtractWithWork (OAI.EditApproximation.bitWordValue center.1) gapRadius    let upper := OAI.EditApproximation.binaryNaturalAddWithWork (OAI.EditApproximation.bitWordValue center.1) gapRadius    let right := OAI.EditApproximation.gridPointsWithWork g (OAI.EditApproximation.bitWordValue lower.1) (OAI.EditApproximation.bitWordValue upper.1)    let valid := OAI.EditApproximation.filterMapWithWork (OAI.EditApproximation.makeStateWithWork n first) right.1    (valid.1, center.2 + lower.2 + upper.2 + right.2 + valid.2 + 4)  let allocation := fun first =>    let center := (OAI.EditApproximation.binaryNaturalAddWithWork first sourceLength).1    let lower := (OAI.EditApproximation.saturatingSubtractWithWork (OAI.EditApproximation.bitWordValue center) gapRadius).1    let upper := (OAI.EditApproximation.binaryNaturalAddWithWork (OAI.EditApproximation.bitWordValue center) gapRadius).1    let right := (OAI.EditApproximation.gridPointsWithWork g (OAI.EditApproximation.bitWordValue lower) (OAI.EditApproximation.bitWordValue upper)).1    OAI.EditApproximation.binaryNaturalAddAllocation first sourceLength + OAI.EditApproximation.saturatingSubtractAllocation (OAI.EditApproximation.bitWordValue center) gapRadius +      OAI.EditApproximation.binaryNaturalAddAllocation (OAI.EditApproximation.bitWordValue center) gapRadius + OAI.EditApproximation.gridPointsAllocation g (OAI.EditApproximation.bitWordValue lower) (OAI.EditApproximation.bitWordValue upper) +      OAI.EditApproximation.filterMapAllocation (OAI.EditApproximation.makeStateWithWork n first) (OAI.EditApproximation.makeStateAllocation n first) right  OAI.EditApproximation.saturatingSubtractAllocation anchor radius + OAI.EditApproximation.binaryNaturalAddAllocation anchor radius +    OAI.EditApproximation.gridPointsAllocation g (OAI.EditApproximation.bitWordValue lo) (OAI.EditApproximation.bitWordValue hi) + OAI.EditApproximation.arithmeticFlatMapAllocation build allocation leftdef wideActionList {nx ny : ℕ} (M : ℕ) (parent : OAI.EditApproximation.TargetInterval nx)    (r : OAI.EditApproximation.TargetInterval ny) (b P : ℕ) : List (Fin M → OAI.EditApproximation.TargetInterval ny) :=  OAI.EditApproximation.finiteAssignments M (OAI.EditApproximation.wideChildStateList parent r b P)def physicalSourceInterval {M J : ℕ} (nx : ℕ) (node : OAI.EditApproximation.PhysicalNode M J) : OAI.EditApproximation.TargetInterval nx :=  OAI.EditApproximation.sourceIntervalAt M nx node.1.val node.2def localInitialConeTable {α : Type u_1} (source target : List α)    (U : OAI.EditApproximation.TargetInterval target.length → ℕ) (N P F : ℕ) (A a : ℚ)    (q : OAI.EditApproximation.TargetInterval target.length) : ℚ :=  if U q = 0 then 0 else    OAI.EditApproximation.rationalMinimum ((32 * F + 1) * N)      ((OAI.EditApproximation.localInitialConeCenters N P A U q).map        (OAI.EditApproximation.initialConeValue source target U a (32 * F) q))def wideChildGridWithWork {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx)    (r : OAI.EditApproximation.TargetInterval ny) (b P : ℕ) (i : Fin M) : List (OAI.EditApproximation.TargetInterval ny) × ℕ :=  let child := OAI.EditApproximation.sourceChildWithWork parent i  let spacing := OAI.EditApproximation.seedGridSpacingWithWork b P  let radius := OAI.EditApproximation.binaryNaturalMulWithWork 10 b  let leftOffset := OAI.EditApproximation.saturatingSubtractWithWork child.1.lo parent.lo  let rightOffset := OAI.EditApproximation.saturatingSubtractWithWork child.1.hi parent.lo  let left := OAI.EditApproximation.binaryNaturalAddWithWork r.lo (OAI.EditApproximation.bitWordValue leftOffset.1)  let right := OAI.EditApproximation.binaryNaturalAddWithWork r.lo (OAI.EditApproximation.bitWordValue rightOffset.1)  let grid := OAI.EditApproximation.gridStateBoxWithWork ny (OAI.EditApproximation.bitWordValue spacing.1) (OAI.EditApproximation.bitWordValue radius.1)    (OAI.EditApproximation.bitWordValue left.1) (OAI.EditApproximation.bitWordValue right.1)  (grid.1, child.2 + spacing.2 + radius.2 + leftOffset.2 + rightOffset.2 + left.2 + right.2 + grid.2 + 8)def queryOrderedHistoryInputsWithWork {M n : ℕ} (inputs : List (Fin M × ℕ × OAI.EditApproximation.TargetInterval n)) :    List (Fin M × ℕ × OAI.EditApproximation.TargetInterval n) × ℕ :=  OAI.EditApproximation.queryOrderedInputsWithWork OAI.EditApproximation.queryHistoryEqualWithWork    (OAI.EditApproximation.queryEncodedLEWithWork OAI.EditApproximation.queryHistoryCodeWithWork) inputsdef queryNeededInputsWithWork {n M : ℕ}    (selected online : List (OAI.EditApproximation.BinaryBellmanAction (OAI.EditApproximation.TargetInterval n) (Fin M × OAI.EditApproximation.TargetInterval n) M)) :    List (Fin M × OAI.EditApproximation.TargetInterval n) × ℕ :=  let first := OAI.EditApproximation.queryActionInputsWithWork selected  let second := OAI.EditApproximation.queryActionInputsWithWork online  let sorted := OAI.EditApproximation.queryOrderedChildInputsWithWork (first.1 ++ second.1)  (sorted.1, first.2 + second.2 + first.1.length + sorted.2 + 2)def computedQueryParameters (N pass : ℕ) : OAI.EditApproximation.RefinementParameterWords := by  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_computed_small_word_pos_125 (N : ℕ) : 0 < OAI.EditApproximation.bitWordValue (OAI.EditApproximation.inputSmallLog N).bits := by    rw [proof_bitWordValue_bits_15]    exact Nat.two_pow_pos _  exact    (OAI.EditApproximation.refinementParameterWordsWithWork N pass (OAI.EditApproximation.inputSmallLog N).bits (proof_computed_small_word_pos_125 N)).1def wideChildGridAllocation {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx)    (r : OAI.EditApproximation.TargetInterval ny) (b P : ℕ) (i : Fin M) : ℕ :=  let child := (OAI.EditApproximation.sourceChildWithWork parent i).1  let spacing := (OAI.EditApproximation.seedGridSpacingWithWork b P).1  let radius := (OAI.EditApproximation.binaryNaturalMulWithWork 10 b).1  let leftOffset := (OAI.EditApproximation.saturatingSubtractWithWork child.lo parent.lo).1  let rightOffset := (OAI.EditApproximation.saturatingSubtractWithWork child.hi parent.lo).1  let left := (OAI.EditApproximation.binaryNaturalAddWithWork r.lo (OAI.EditApproximation.bitWordValue leftOffset)).1  let right := (OAI.EditApproximation.binaryNaturalAddWithWork r.lo (OAI.EditApproximation.bitWordValue rightOffset)).1  OAI.EditApproximation.sourceChildAllocation parent i + OAI.EditApproximation.seedGridSpacingAllocation b P + OAI.EditApproximation.binaryNaturalMulAllocation 10 b +    OAI.EditApproximation.saturatingSubtractAllocation child.lo parent.lo + OAI.EditApproximation.saturatingSubtractAllocation child.hi parent.lo +    OAI.EditApproximation.binaryNaturalAddAllocation r.lo (OAI.EditApproximation.bitWordValue leftOffset) +    OAI.EditApproximation.binaryNaturalAddAllocation r.lo (OAI.EditApproximation.bitWordValue rightOffset) +    OAI.EditApproximation.gridStateBoxAllocation ny (OAI.EditApproximation.bitWordValue spacing) (OAI.EditApproximation.bitWordValue radius) (OAI.EditApproximation.bitWordValue left) (OAI.EditApproximation.bitWordValue right)def queryOrderedHistoryInputsAllocation {M n : ℕ} (inputs : List (Fin M × ℕ × OAI.EditApproximation.TargetInterval n)) : ℕ :=  OAI.EditApproximation.queryOrderedInputsAllocation OAI.EditApproximation.queryHistoryEqualWithWork (OAI.EditApproximation.queryEncodedLEWithWork OAI.EditApproximation.queryHistoryCodeWithWork)    OAI.EditApproximation.queryHistoryEqualAllocation (OAI.EditApproximation.queryEncodedLEAllocation OAI.EditApproximation.queryHistoryCodeWithWork OAI.EditApproximation.queryHistoryCodeAllocation) inputsdef queryNeededInputsAllocation {n M : ℕ}    (selected online : List (OAI.EditApproximation.BinaryBellmanAction (OAI.EditApproximation.TargetInterval n) (Fin M × OAI.EditApproximation.TargetInterval n) M)) : ℕ :=  let first := (OAI.EditApproximation.queryActionInputsWithWork selected).1  let second := (OAI.EditApproximation.queryActionInputsWithWork online).1  OAI.EditApproximation.queryActionInputsAllocation selected + OAI.EditApproximation.queryActionInputsAllocation online + first.length +    OAI.EditApproximation.queryOrderedChildInputsAllocation (first ++ second)def physicalSource {α : Type u_1} {M J : ℕ} (source : List α) (node : OAI.EditApproximation.PhysicalNode M J) : List α :=  OAI.EditApproximation.substring source (OAI.EditApproximation.physicalSourceInterval source.length node).lo (OAI.EditApproximation.physicalSourceInterval source.length node).hidef wideActionGridWithWork {nx ny : ℕ} (M : ℕ) (parent : OAI.EditApproximation.TargetInterval nx)    (r : OAI.EditApproximation.TargetInterval ny) (b P : ℕ) : List (Vector (OAI.EditApproximation.TargetInterval ny) M) × ℕ :=  let choices := OAI.EditApproximation.vectorMapWithWork M (OAI.EditApproximation.wideChildGridWithWork parent r b P)  let product := OAI.EditApproximation.materializedAssignmentsWithWork M choices.1.get  (product.1, choices.2 + product.2 + 1)def physicalCoarsePreparationCost {M J : ℕ} (source target : List ℕ)    (entry : OAI.EditApproximation.PhysicalEntry M J target.length) : ℕ :=  let interval := OAI.EditApproximation.physicalSourceInterval source.length entry.1  (OAI.EditApproximation.coarsePreparedSlicesWithWork source target interval.lo interval.hi entry.2.lo entry.2.hi).2def wideActionGridAllocation {nx ny : ℕ} (M : ℕ) (parent : OAI.EditApproximation.TargetInterval nx)    (r : OAI.EditApproximation.TargetInterval ny) (b P : ℕ) : ℕ :=  let choices := (OAI.EditApproximation.vectorMapWithWork M (OAI.EditApproximation.wideChildGridWithWork parent r b P)).1  OAI.EditApproximation.vectorMapAllocation M (OAI.EditApproximation.wideChildGridAllocation parent r b P) + OAI.EditApproximation.materializedAssignmentsAllocation M choices.getend OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.BinaryFractiondef sumListWithWork (values : List OAI.EditApproximation.BinaryFraction) : OAI.EditApproximation.BinaryFraction × ℕ :=  let result := OAI.EditApproximation.BinaryFraction.bandMassTotalWithWork (Vector.ofFn values.get)  (result.1, result.2 + 6 * values.length)def connectionTermsWithWork {n : ℕ} (start : OAI.EditApproximation.BinaryFraction) :    List (OAI.EditApproximation.TargetInterval n) → OAI.EditApproximation.BinaryFraction → List OAI.EditApproximation.BinaryFraction × ℕ  | [], finish =>    let result := OAI.EditApproximation.BinaryFraction.distanceWithWork start finish    ([result.1], result.2 + 2)  | state :: rest, finish =>    let current := OAI.EditApproximation.BinaryFraction.distanceWithWork start (OAI.EditApproximation.BinaryFraction.nat state.lo)    let tail := connectionTermsWithWork (OAI.EditApproximation.BinaryFraction.nat state.hi) rest finish    (current.1 :: tail.1,      current.2 + tail.2 + Nat.size state.lo + Nat.size state.hi + 6)def bandEnvelopeReadWithWork {M n : ℕ} (b : ℕ) (band : List (Fin M → OAI.EditApproximation.TargetInterval n))    (read : Fin M → OAI.EditApproximation.TargetInterval n → OAI.EditApproximation.BinaryFraction × ℕ) (i : Fin M) : OAI.EditApproximation.BinaryFraction × ℕ :=  let values := OAI.EditApproximation.arithmeticMapWithWork (fun action => read i (action i)) band  let floor := OAI.EditApproximation.BinaryFraction.divWithWork (OAI.EditApproximation.BinaryFraction.nat b) (OAI.EditApproximation.BinaryFraction.nat M)  let maximum := OAI.EditApproximation.BinaryFraction.maximumWithWork OAI.EditApproximation.BinaryFraction.zero values.1  let input := OAI.EditApproximation.BinaryFraction.maxWithWork floor.1 maximum.1  let result := OAI.EditApproximation.BinaryFraction.dyadicCeilingWithWork input.1  (result.1, values.2 + floor.2 + maximum.2 + input.2 + result.2 + band.length + 4)def onlineLinearReadWithWork {β : Type u_1} {σ : Type u_2} (mass : β → OAI.EditApproximation.BinaryFraction)    (read : ℕ → β × σ → OAI.EditApproximation.BinaryFraction × ℕ) (eta kappa : OAI.EditApproximation.BinaryFraction)    (t : ℕ) (i : β × σ) : OAI.EditApproximation.BinaryFraction × ℕ :=  let coefficient := OAI.EditApproximation.BinaryFraction.coefficientWithWork kappa  let terms := OAI.EditApproximation.vectorMapWithWork t fun s => OAI.EditApproximation.BinaryFraction.optimisticTermReadWithWork mass read coefficient.1 s.val i  let history := OAI.EditApproximation.BinaryFraction.bandMassTotalWithWork terms.1  let current := OAI.EditApproximation.BinaryFraction.gainReadWithWork mass read t i  let total := OAI.EditApproximation.BinaryFraction.canonicalAddWithWork history.1 current.1  let result := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork eta total.1  (result.1, coefficient.2 + terms.2 + history.2 + current.2 + total.2 + result.2 + 3)def targetCellsWithWork {n : ℕ} (side : OAI.EditApproximation.BinaryFraction) (radius : ℕ)    (q : OAI.EditApproximation.TargetInterval n) : List (ℕ × ℕ) × ℕ :=  let left := OAI.EditApproximation.BinaryFraction.cellCoordinatesWithWork side q.lo radius  let right := OAI.EditApproximation.BinaryFraction.cellCoordinatesWithWork side q.hi radius  let cells := OAI.EditApproximation.arithmeticFlatMapWithWork (fun lo =>    OAI.EditApproximation.arithmeticMapWithWork (fun hi => ((lo, hi), 1)) right.1) left.1  (cells.1, left.2 + right.2 + cells.2 + 2)def cellStatesWithWork (n g : ℕ) (side : OAI.EditApproximation.BinaryFraction) (cell : ℕ × ℕ) :    List (OAI.EditApproximation.TargetInterval n) × ℕ :=  let left := OAI.EditApproximation.BinaryFraction.cellGridPointsWithWork side g cell.1  let right := OAI.EditApproximation.BinaryFraction.cellGridPointsWithWork side g cell.2  let states := OAI.EditApproximation.arithmeticFlatMapWithWork (fun lo =>    OAI.EditApproximation.filterMapWithWork (OAI.EditApproximation.makeStateWithWork n lo) right.1) left.1  (states.1, left.2 + right.2 + states.2 + 2)def bandCoordinatesWithWork {M n : ℕ} (band : List (Fin M → OAI.EditApproximation.TargetInterval n)) :    List (Fin M × OAI.EditApproximation.TargetInterval n) × ℕ :=  let raw := OAI.EditApproximation.arithmeticFlatMapWithWork (fun action =>    OAI.EditApproximation.arithmeticMapWithWork (fun i : Fin M => ((i, action i), 1)) (List.finRange M)) band  let unique := OAI.EditApproximation.dedupByWithWork OAI.EditApproximation.coordinateEqualWithWork raw.1  (unique.1, raw.2 + unique.2 + 1)def countedBandCoordinateWithWork {M n : ℕ} (mass : Vector OAI.EditApproximation.BinaryFraction M)    (total : OAI.EditApproximation.BinaryFraction) (action : Fin M → OAI.EditApproximation.TargetInterval n)    (coordinate : Fin M × OAI.EditApproximation.TargetInterval n) : OAI.EditApproximation.BinaryFraction × ℕ :=  let test := OAI.EditApproximation.coordinateEqualWithWork coordinate (coordinate.1, action coordinate.1)  let result := if test.1 then OAI.EditApproximation.BinaryFraction.divWithWork (mass.get coordinate.1) total else (OAI.EditApproximation.BinaryFraction.zero, 1)  (result.1, test.2 + result.2 + 1)def representativeScaleReadWithWork {n : ℕ} (P F : ℕ) (a : OAI.EditApproximation.BinaryFraction)    (read : OAI.EditApproximation.TargetInterval n → OAI.EditApproximation.BinaryFraction × ℕ) (radius : List Bool)    (query : OAI.EditApproximation.TargetInterval n) (e : ℕ) : List (ℕ × OAI.EditApproximation.TargetInterval n) × ℕ :=  let b := 2 ^ e  let spacing := OAI.EditApproximation.seedGridSpacingWithWork b P  let points := OAI.EditApproximation.gridStateBoxWithWork n (OAI.EditApproximation.bitWordValue spacing.1) (OAI.EditApproximation.bitWordValue radius) query.lo query.hi  let selected := OAI.EditApproximation.filterWithWork (fun r =>    let word := read r    let guard := OAI.EditApproximation.BinaryFraction.centerEligibilityWithWork b F a word.1    (guard.1, guard.2 + word.2)) points.1  let labeled := OAI.EditApproximation.arithmeticMapWithWork (fun r => ((b, r), 1)) selected.1  (labeled.1, spacing.2 + points.2 + selected.2 + labeled.2 + e + 5)def queryRawCentersWithWork {n : ℕ} (N P F : ℕ) (a value : OAI.EditApproximation.BinaryFraction)    (q : OAI.EditApproximation.TargetInterval n) : List (OAI.EditApproximation.TargetInterval n) × ℕ :=  let scales := OAI.EditApproximation.BinaryFraction.queryScalesWithWork N F a value  let radius := OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork value  let centers := OAI.EditApproximation.arithmeticFlatMapWithWork (fun b =>    let spacing := OAI.EditApproximation.seedGridSpacingWithWork b P    let states := OAI.EditApproximation.gridStateBoxWithWork n (OAI.EditApproximation.bitWordValue spacing.1) (OAI.EditApproximation.bitWordValue radius.1) q.lo q.hi    (states.1, spacing.2 + states.2 + 1)) scales.1  let unique := OAI.EditApproximation.queryEraseWithWork OAI.EditApproximation.queryIntervalEqualWithWork centers.1  (unique.1, scales.2 + radius.2 + centers.2 + unique.2 + 3)def queryWideInputsWithWork {nx ny : ℕ} (M : ℕ) (parent : OAI.EditApproximation.TargetInterval nx) (P : ℕ)    (representatives : List (ℕ × OAI.EditApproximation.TargetInterval ny)) : List (Fin M × OAI.EditApproximation.TargetInterval ny) × ℕ :=  let raw := OAI.EditApproximation.arithmeticFlatMapWithWork (fun br =>    OAI.EditApproximation.arithmeticFlatMapWithWork (fun i : Fin M =>      let states := OAI.EditApproximation.wideChildGridWithWork parent br.2 br.1 P i      let labeled := OAI.EditApproximation.arithmeticMapWithWork (fun r => ((i, r), 1)) states.1      (labeled.1, states.2 + labeled.2 + 1)) (List.finRange M)) representatives  let unique := OAI.EditApproximation.queryEraseWithWork OAI.EditApproximation.coordinateEqualWithWork raw.1  (unique.1, raw.2 + unique.2 + M + 2)def queryRawHistoryInputsWithWork {nx ny : ℕ} (M : ℕ) (parent : OAI.EditApproximation.TargetInterval nx)    (P history : ℕ) (representatives : List (ℕ × OAI.EditApproximation.TargetInterval ny)) :    List (Fin M × ℕ × OAI.EditApproximation.TargetInterval ny) × ℕ :=  let inputs := OAI.EditApproximation.arithmeticFlatMapWithWork (fun br =>    OAI.EditApproximation.arithmeticFlatMapWithWork (fun i : Fin M =>      let states := OAI.EditApproximation.wideChildGridWithWork parent br.2 br.1 P i      let times := OAI.EditApproximation.arithmeticFlatMapWithWork (fun t =>        OAI.EditApproximation.arithmeticMapWithWork (fun r => ((i, t, r), 1)) states.1) (List.range history)      (times.1, states.2 + times.2 + history + 2)) (List.finRange M)) representatives  (inputs.1, inputs.2 + M + 1)def queryGroupRoundedStatesWithWork {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx)    (b exponent : ℕ) (cell : ℕ × ℕ) (i : Fin M) (h : OAI.EditApproximation.BinaryFraction) :    List (OAI.EditApproximation.TargetInterval ny) × ℕ :=  let theta := OAI.EditApproximation.BinaryFraction.inversePowerTwo exponent  let spacing := OAI.EditApproximation.BinaryFraction.roundedSpacingWithWork theta h  let child := OAI.EditApproximation.sourceChildWithWork parent i  let offset := OAI.EditApproximation.saturatingSubtractWithWork child.1.lo parent.lo  let base := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat cell.1) theta  let position := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork base.1 (OAI.EditApproximation.BinaryFraction.nat b)  let floor := OAI.EditApproximation.BinaryFraction.naturalFloorWithWork position.1  let anchor := OAI.EditApproximation.binaryNaturalAddWithWork (OAI.EditApproximation.bitWordValue floor.1) (OAI.EditApproximation.bitWordValue offset.1)  let radius := OAI.EditApproximation.binaryNaturalMulWithWork 12 b  let length := OAI.EditApproximation.saturatingSubtractWithWork child.1.hi child.1.lo  let twice := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat 2) h  let gap := OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork twice.1  let states := OAI.EditApproximation.queryGapStatesWithWork ny (OAI.EditApproximation.bitWordValue spacing.1) (OAI.EditApproximation.bitWordValue anchor.1)    (OAI.EditApproximation.bitWordValue radius.1) (OAI.EditApproximation.bitWordValue length.1) (OAI.EditApproximation.bitWordValue gap.1)  (states.1, spacing.2 + child.2 + offset.2 + base.2 + position.2 + floor.2 + anchor.2 +    radius.2 + length.2 + twice.2 + gap.2 + states.2 + exponent + 12)def queryOnlineIntegerReadWithWork {n : ℕ} (keys : List (ℕ × OAI.EditApproximation.TargetInterval n))    (values : List OAI.EditApproximation.BinaryFraction) (b : ℕ) (q : OAI.EditApproximation.TargetInterval n) : ℕ × ℕ :=  let word := OAI.EditApproximation.BinaryFraction.gatheredWordLookupWithWork OAI.EditApproximation.queryOnlineKeyEqualWithWork keys values (b, q)  let floor := OAI.EditApproximation.BinaryFraction.naturalFloorWithWork word.1  (OAI.EditApproximation.bitWordValue floor.1, word.2 + floor.2 + 1)def queryChildReadWithWork {M n : ℕ} (keys : List (Fin M × OAI.EditApproximation.TargetInterval n))    (values : List OAI.EditApproximation.BinaryFraction) (i : Fin M) (q : OAI.EditApproximation.TargetInterval n) : OAI.EditApproximation.BinaryFraction × ℕ :=  OAI.EditApproximation.BinaryFraction.gatheredWordLookupWithWork OAI.EditApproximation.coordinateEqualWithWork keys values (i, q)def queryHistoryReadWithWork {M n : ℕ} (keys : List (Fin M × ℕ × OAI.EditApproximation.TargetInterval n))    (values : List OAI.EditApproximation.BinaryFraction) (s : ℕ) (input : Fin M × OAI.EditApproximation.TargetInterval n) : OAI.EditApproximation.BinaryFraction × ℕ :=  OAI.EditApproximation.BinaryFraction.gatheredWordLookupWithWork OAI.EditApproximation.queryHistoryEqualWithWork keys values (input.1, s, input.2)def queryParentReadWithWork {n : ℕ} (keys : List (OAI.EditApproximation.TargetInterval n))    (words : List OAI.EditApproximation.BinaryFraction) (r : OAI.EditApproximation.TargetInterval n) : OAI.EditApproximation.BinaryFraction × ℕ :=  OAI.EditApproximation.BinaryFraction.gatheredWordLookupWithWork OAI.EditApproximation.queryIntervalEqualWithWork keys words rdef initialGridReadWithWork {n : ℕ} (P : ℕ) (A : OAI.EditApproximation.BinaryFraction)    (read : OAI.EditApproximation.TargetInterval n → List Bool × ℕ) (radius : ℕ) (q : OAI.EditApproximation.TargetInterval n) (b : ℕ) :    List (OAI.EditApproximation.TargetInterval n) × ℕ :=  let spacing := OAI.EditApproximation.seedGridSpacingWithWork b P  let points := OAI.EditApproximation.gridStateBoxWithWork n (OAI.EditApproximation.bitWordValue spacing.1) radius q.lo q.hi  let selected := OAI.EditApproximation.filterWithWork (fun r =>    let word := read r    let guard := OAI.EditApproximation.BinaryFraction.initialCenterGuardWithWork b (OAI.EditApproximation.bitWordValue word.1) A    (guard.1, guard.2 + word.2)) points.1  (selected.1, spacing.2 + points.2 + selected.2 + 2)def queryInitialConeCentersWithWork {n : ℕ} (N P : ℕ) (A value : OAI.EditApproximation.BinaryFraction)    (q : OAI.EditApproximation.TargetInterval n) : List (OAI.EditApproximation.TargetInterval n) × ℕ :=  let radius := OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork value  let scales := OAI.EditApproximation.dyadicScalesWithWork N  let active := OAI.EditApproximation.filterWithWork (fun b => OAI.EditApproximation.BinaryFraction.initialScaleGuardWithWork (OAI.EditApproximation.bitWordValue radius.1) b A) scales.1  let centers := OAI.EditApproximation.arithmeticFlatMapWithWork (fun b =>    let spacing := OAI.EditApproximation.seedGridSpacingWithWork b P    let states := OAI.EditApproximation.gridStateBoxWithWork n (OAI.EditApproximation.bitWordValue spacing.1) (OAI.EditApproximation.bitWordValue radius.1) q.lo q.hi    (states.1, spacing.2 + states.2 + 1)) active.1  (centers.1, radius.2 + scales.2 + active.2 + centers.2 + 2)def connectionTermsAllocation {n : ℕ} (start : OAI.EditApproximation.BinaryFraction) :    List (OAI.EditApproximation.TargetInterval n) → OAI.EditApproximation.BinaryFraction → ℕ  | [], finish => OAI.EditApproximation.BinaryFraction.distanceAllocation start finish + 1  | state :: rest, finish => OAI.EditApproximation.BinaryFraction.distanceAllocation start (OAI.EditApproximation.BinaryFraction.nat state.lo) +    connectionTermsAllocation (OAI.EditApproximation.BinaryFraction.nat state.hi) rest finish + Nat.size state.lo + Nat.size state.hi + 3def endpointDistanceAllocation {n : ℕ} (q r : OAI.EditApproximation.TargetInterval n) : ℕ :=  OAI.EditApproximation.BinaryFraction.distanceAllocation (OAI.EditApproximation.BinaryFraction.nat q.lo) (OAI.EditApproximation.BinaryFraction.nat r.lo) + OAI.EditApproximation.BinaryFraction.distanceAllocation (OAI.EditApproximation.BinaryFraction.nat q.hi) (OAI.EditApproximation.BinaryFraction.nat r.hi) +    OAI.EditApproximation.BinaryFraction.canonicalAddAllocation (OAI.EditApproximation.BinaryFraction.distanceWithWork (OAI.EditApproximation.BinaryFraction.nat q.lo) (OAI.EditApproximation.BinaryFraction.nat r.lo)).1      (OAI.EditApproximation.BinaryFraction.distanceWithWork (OAI.EditApproximation.BinaryFraction.nat q.hi) (OAI.EditApproximation.BinaryFraction.nat r.hi)).1 + Nat.size q.lo + Nat.size q.hi + Nat.size r.lo + Nat.size r.hidef stateGapAllocation {n : ℕ} (sourceLength : ℕ) (r : OAI.EditApproximation.TargetInterval n) : ℕ :=  OAI.EditApproximation.BinaryFraction.subAllocation (OAI.EditApproximation.BinaryFraction.nat r.hi) (OAI.EditApproximation.BinaryFraction.nat r.lo) +    OAI.EditApproximation.BinaryFraction.subAllocation (OAI.EditApproximation.BinaryFraction.subWithWork (OAI.EditApproximation.BinaryFraction.nat r.hi) (OAI.EditApproximation.BinaryFraction.nat r.lo)).1 (OAI.EditApproximation.BinaryFraction.nat sourceLength) + Nat.size r.hi + Nat.size r.lo + Nat.size sourceLengthdef queryChildReadAllocation {M n : ℕ} (keys : List (Fin M × OAI.EditApproximation.TargetInterval n))    (values : List OAI.EditApproximation.BinaryFraction) (i : Fin M) (q : OAI.EditApproximation.TargetInterval n) : ℕ :=  OAI.EditApproximation.BinaryFraction.gatheredLookupAllocation OAI.EditApproximation.coordinateEqualWithWork OAI.EditApproximation.coordinateEqualAllocation keys values (i, q)def queryHistoryReadAllocation {M n : ℕ} (keys : List (Fin M × ℕ × OAI.EditApproximation.TargetInterval n))    (values : List OAI.EditApproximation.BinaryFraction) (s : ℕ) (input : Fin M × OAI.EditApproximation.TargetInterval n) : ℕ :=  OAI.EditApproximation.BinaryFraction.gatheredLookupAllocation OAI.EditApproximation.queryHistoryEqualWithWork OAI.EditApproximation.queryHistoryEqualAllocation keys values (input.1, s, input.2)def queryOnlineIntegerReadAllocation {n : ℕ} (keys : List (ℕ × OAI.EditApproximation.TargetInterval n))    (values : List OAI.EditApproximation.BinaryFraction) (b : ℕ) (q : OAI.EditApproximation.TargetInterval n) : ℕ :=  let word := (OAI.EditApproximation.BinaryFraction.gatheredWordLookupWithWork OAI.EditApproximation.queryOnlineKeyEqualWithWork keys values (b, q)).1  OAI.EditApproximation.BinaryFraction.gatheredLookupAllocation OAI.EditApproximation.queryOnlineKeyEqualWithWork OAI.EditApproximation.queryOnlineKeyEqualAllocation keys values (b, q) +    OAI.EditApproximation.BinaryFraction.naturalFloorAllocation worddef bandCoordinatesAllocation {M n : ℕ} (band : List (Fin M → OAI.EditApproximation.TargetInterval n)) : ℕ :=  let build := fun action : Fin M → OAI.EditApproximation.TargetInterval n =>    OAI.EditApproximation.arithmeticMapWithWork (fun i : Fin M => ((i, action i), 1)) (List.finRange M)  let raw := (OAI.EditApproximation.arithmeticFlatMapWithWork build band).1  OAI.EditApproximation.arithmeticFlatMapAllocation build    (fun _ => OAI.EditApproximation.arithmeticMapAllocation (fun _ : Fin M => 1) (List.finRange M) + M) band +    OAI.EditApproximation.dedupByAllocation OAI.EditApproximation.coordinateEqualWithWork OAI.EditApproximation.coordinateEqualAllocation rawdef scoredArgmaxAllocation {α : Type u_1} (score : α → OAI.EditApproximation.BinaryFraction × ℕ)    (allocation : α → ℕ) : List α → ℕ  | [] => 0  | a :: rest =>    scoredArgmaxAllocation score allocation rest + allocation a +      match (OAI.EditApproximation.BinaryFraction.scoredArgmaxWithWork score rest).1 with      | none => 1      | some best => OAI.EditApproximation.BinaryFraction.ltAllocation (score a).1 best.2 + 1def anchorGuardAllocation {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx) (r : OAI.EditApproximation.TargetInterval ny)    (b : ℕ) (states : Fin M → OAI.EditApproximation.TargetInterval ny) (i : Fin M) : ℕ :=  let left := (OAI.EditApproximation.translatedEndpointWithWork r.lo parent.lo (OAI.EditApproximation.sourceChild parent i).lo).1  let right := (OAI.EditApproximation.translatedEndpointWithWork r.lo parent.lo (OAI.EditApproximation.sourceChild parent i).hi).1  let radius := OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalMulWithWork 6 b).1  OAI.EditApproximation.translatedEndpointAllocation r.lo parent.lo (OAI.EditApproximation.sourceChild parent i).lo +    OAI.EditApproximation.translatedEndpointAllocation r.lo parent.lo (OAI.EditApproximation.sourceChild parent i).hi + OAI.EditApproximation.binaryNaturalMulAllocation 6 b +    OAI.EditApproximation.BinaryFraction.naturalDistanceLeAllocation left (states i).lo radius + OAI.EditApproximation.BinaryFraction.naturalDistanceLeAllocation right (states i).hi radiusdef bandEnvelopeReadAllocation {M n : ℕ} (b : ℕ) (band : List (Fin M → OAI.EditApproximation.TargetInterval n))    (read : Fin M → OAI.EditApproximation.TargetInterval n → OAI.EditApproximation.BinaryFraction × ℕ)    (footprint : Fin M → OAI.EditApproximation.TargetInterval n → ℕ) (i : Fin M) : ℕ :=  let values := (OAI.EditApproximation.arithmeticMapWithWork (fun action => read i (action i)) band).1  let floor := (OAI.EditApproximation.BinaryFraction.divWithWork (OAI.EditApproximation.BinaryFraction.nat b) (OAI.EditApproximation.BinaryFraction.nat M)).1  let maximum := (OAI.EditApproximation.BinaryFraction.maximumWithWork OAI.EditApproximation.BinaryFraction.zero values).1  OAI.EditApproximation.arithmeticMapAllocation (fun action => footprint i (action i)) band +    OAI.EditApproximation.BinaryFraction.divAllocation (OAI.EditApproximation.BinaryFraction.nat b) (OAI.EditApproximation.BinaryFraction.nat M) + OAI.EditApproximation.BinaryFraction.maximumAllocation OAI.EditApproximation.BinaryFraction.zero values + OAI.EditApproximation.BinaryFraction.maxAllocation floor maximum +    OAI.EditApproximation.BinaryFraction.dyadicCeilingAllocation (OAI.EditApproximation.BinaryFraction.maxWithWork floor maximum).1 + 0def targetCellsAllocation {n : ℕ} (side : OAI.EditApproximation.BinaryFraction) (radius : ℕ) (q : OAI.EditApproximation.TargetInterval n) : ℕ :=  let left := (OAI.EditApproximation.BinaryFraction.cellCoordinatesWithWork side q.lo radius).1  let right := (OAI.EditApproximation.BinaryFraction.cellCoordinatesWithWork side q.hi radius).1  OAI.EditApproximation.BinaryFraction.cellCoordinatesAllocation side q.lo radius + OAI.EditApproximation.BinaryFraction.cellCoordinatesAllocation side q.hi radius +    OAI.EditApproximation.arithmeticFlatMapAllocation (fun lo => OAI.EditApproximation.arithmeticMapWithWork (fun hi => ((lo, hi), 1)) right)      (fun _ => OAI.EditApproximation.arithmeticMapAllocation (fun _ => 1) right) leftdef cellStatesAllocation (n g : ℕ) (side : OAI.EditApproximation.BinaryFraction) (cell : ℕ × ℕ) : ℕ :=  let left := (OAI.EditApproximation.BinaryFraction.cellGridPointsWithWork side g cell.1).1  let right := (OAI.EditApproximation.BinaryFraction.cellGridPointsWithWork side g cell.2).1  OAI.EditApproximation.BinaryFraction.cellGridPointsAllocation side g cell.1 + OAI.EditApproximation.BinaryFraction.cellGridPointsAllocation side g cell.2 +    OAI.EditApproximation.arithmeticFlatMapAllocation (fun lo => OAI.EditApproximation.filterMapWithWork (OAI.EditApproximation.makeStateWithWork n lo) right)      (fun lo => OAI.EditApproximation.filterMapAllocation (OAI.EditApproximation.makeStateWithWork n lo) (OAI.EditApproximation.makeStateAllocation n lo) right) leftdef queryRawCentersAllocation {n : ℕ} (N P F : ℕ) (a value : OAI.EditApproximation.BinaryFraction) (q : OAI.EditApproximation.TargetInterval n) : ℕ :=  let build := fun b =>    let spacing := OAI.EditApproximation.seedGridSpacingWithWork b P    let states := OAI.EditApproximation.gridStateBoxWithWork n (OAI.EditApproximation.bitWordValue spacing.1) (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork value).1) q.lo q.hi    (states.1, spacing.2 + states.2 + 1)  let allocation := fun b => OAI.EditApproximation.seedGridSpacingAllocation b P +    OAI.EditApproximation.gridStateBoxAllocation n (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.seedGridSpacingWithWork b P).1)      (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork value).1) q.lo q.hi  let centers := (OAI.EditApproximation.arithmeticFlatMapWithWork build (OAI.EditApproximation.BinaryFraction.queryScalesWithWork N F a value).1).1  OAI.EditApproximation.BinaryFraction.queryScalesAllocation N F a value + OAI.EditApproximation.BinaryFraction.naturalCeilingAllocation value +    OAI.EditApproximation.arithmeticFlatMapAllocation build allocation (OAI.EditApproximation.BinaryFraction.queryScalesWithWork N F a value).1 +    OAI.EditApproximation.queryEraseAllocation OAI.EditApproximation.queryIntervalEqualWithWork OAI.EditApproximation.queryIntervalEqualAllocation centersdef queryOnlineKeysAllocation {n : ℕ} (N P F : ℕ) (_hP : 0 < P)    (a value : OAI.EditApproximation.BinaryFraction) (q : OAI.EditApproximation.TargetInterval n) : ℕ :=  OAI.EditApproximation.BinaryFraction.queryScalesAllocation N F a value + OAI.EditApproximation.arithmeticMapAllocation (fun b =>    OAI.EditApproximation.seedGridSpacingAllocation b P + OAI.EditApproximation.roundStateAllocation (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.seedGridSpacingWithWork b P).1) q + 1)      (OAI.EditApproximation.BinaryFraction.queryScalesWithWork N F a value).1def representativeScaleReadAllocation {n : ℕ} (P F : ℕ) (a : OAI.EditApproximation.BinaryFraction)    (read : OAI.EditApproximation.TargetInterval n → OAI.EditApproximation.BinaryFraction × ℕ) (allocation : OAI.EditApproximation.TargetInterval n → ℕ)    (radius : List Bool) (query : OAI.EditApproximation.TargetInterval n) (e : ℕ) : ℕ :=  let b := 2 ^ e  let spacing := (OAI.EditApproximation.seedGridSpacingWithWork b P).1  let points := (OAI.EditApproximation.gridStateBoxWithWork n (OAI.EditApproximation.bitWordValue spacing) (OAI.EditApproximation.bitWordValue radius) query.lo query.hi).1  let test := fun r => ((OAI.EditApproximation.BinaryFraction.centerEligibilityWithWork b F a (read r).1).1,    (OAI.EditApproximation.BinaryFraction.centerEligibilityWithWork b F a (read r).1).2 + (read r).2)  let selected := (OAI.EditApproximation.filterWithWork test points).1  OAI.EditApproximation.seedGridSpacingAllocation b P + OAI.EditApproximation.gridStateBoxAllocation n (OAI.EditApproximation.bitWordValue spacing) (OAI.EditApproximation.bitWordValue radius) query.lo query.hi +    OAI.EditApproximation.filterAllocation test (fun r => OAI.EditApproximation.BinaryFraction.centerEligibilityAllocation b F a (read r).1 + allocation r) points +    OAI.EditApproximation.arithmeticMapAllocation (fun _ => 1) selected + e + 1def queryWideInputsAllocation {nx ny : ℕ} (M : ℕ) (parent : OAI.EditApproximation.TargetInterval nx) (P : ℕ)    (representatives : List (ℕ × OAI.EditApproximation.TargetInterval ny)) : ℕ :=  let build := fun br : ℕ × OAI.EditApproximation.TargetInterval ny =>    OAI.EditApproximation.arithmeticFlatMapWithWork (fun i : Fin M =>      let states := OAI.EditApproximation.wideChildGridWithWork parent br.2 br.1 P i      let labeled := OAI.EditApproximation.arithmeticMapWithWork (fun r => ((i, r), 1)) states.1      (labeled.1, states.2 + labeled.2 + 1)) (List.finRange M)  let one := fun (br : ℕ × OAI.EditApproximation.TargetInterval ny) (i : Fin M) =>    OAI.EditApproximation.wideChildGridAllocation parent br.2 br.1 P i +      OAI.EditApproximation.arithmeticMapAllocation (fun _ => 1) (OAI.EditApproximation.wideChildGridWithWork parent br.2 br.1 P i).1  OAI.EditApproximation.arithmeticFlatMapAllocation build    (fun br => OAI.EditApproximation.arithmeticFlatMapAllocation (fun i : Fin M =>      let states := OAI.EditApproximation.wideChildGridWithWork parent br.2 br.1 P i      let labeled := OAI.EditApproximation.arithmeticMapWithWork (fun r => ((i, r), 1)) states.1      (labeled.1, states.2 + labeled.2 + 1)) (one br) (List.finRange M)) representatives +    OAI.EditApproximation.queryEraseAllocation OAI.EditApproximation.coordinateEqualWithWork OAI.EditApproximation.coordinateEqualAllocation (OAI.EditApproximation.arithmeticFlatMapWithWork build representatives).1 + Mdef queryRawHistoryInputsAllocation {nx ny : ℕ} (M : ℕ) (parent : OAI.EditApproximation.TargetInterval nx)    (P history : ℕ) (representatives : List (ℕ × OAI.EditApproximation.TargetInterval ny)) : ℕ :=  let child := fun (br : ℕ × OAI.EditApproximation.TargetInterval ny) (i : Fin M) =>    let states := OAI.EditApproximation.wideChildGridWithWork parent br.2 br.1 P i    let times := OAI.EditApproximation.arithmeticFlatMapWithWork (fun t =>      OAI.EditApproximation.arithmeticMapWithWork (fun r => ((i, t, r), 1)) states.1) (List.range history)    (times.1, states.2 + times.2 + history + 2)  let one := fun (br : ℕ × OAI.EditApproximation.TargetInterval ny) (i : Fin M) =>    OAI.EditApproximation.wideChildGridAllocation parent br.2 br.1 P i + history +      OAI.EditApproximation.arithmeticFlatMapAllocation (fun t => OAI.EditApproximation.arithmeticMapWithWork (fun r => ((i, t, r), 1))        (OAI.EditApproximation.wideChildGridWithWork parent br.2 br.1 P i).1)        (fun _ => OAI.EditApproximation.arithmeticMapAllocation (fun _ => 1) (OAI.EditApproximation.wideChildGridWithWork parent br.2 br.1 P i).1)        (List.range history)  OAI.EditApproximation.arithmeticFlatMapAllocation (fun br => OAI.EditApproximation.arithmeticFlatMapWithWork (child br) (List.finRange M))    (fun br => OAI.EditApproximation.arithmeticFlatMapAllocation (child br) (one br) (List.finRange M)) representatives + Mdef queryGroupRoundedStatesAllocation {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx)    (b exponent : ℕ) (cell : ℕ × ℕ) (i : Fin M) (h : OAI.EditApproximation.BinaryFraction) : ℕ :=  let theta := OAI.EditApproximation.BinaryFraction.inversePowerTwo exponent  let spacing := (OAI.EditApproximation.BinaryFraction.roundedSpacingWithWork theta h).1  let child := (OAI.EditApproximation.sourceChildWithWork parent i).1  let offset := (OAI.EditApproximation.saturatingSubtractWithWork child.lo parent.lo).1  let base := (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat cell.1) theta).1  let position := (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork base (OAI.EditApproximation.BinaryFraction.nat b)).1  let floor := (OAI.EditApproximation.BinaryFraction.naturalFloorWithWork position).1  let anchor := (OAI.EditApproximation.binaryNaturalAddWithWork (OAI.EditApproximation.bitWordValue floor) (OAI.EditApproximation.bitWordValue offset)).1  let radius := (OAI.EditApproximation.binaryNaturalMulWithWork 12 b).1  let length := (OAI.EditApproximation.saturatingSubtractWithWork child.hi child.lo).1  let twice := (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat 2) h).1  let gap := (OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork twice).1  OAI.EditApproximation.BinaryFraction.roundedSpacingAllocation theta h + OAI.EditApproximation.sourceChildAllocation parent i + OAI.EditApproximation.saturatingSubtractAllocation child.lo parent.lo +    OAI.EditApproximation.BinaryFraction.canonicalMulAllocation (OAI.EditApproximation.BinaryFraction.nat cell.1) theta + OAI.EditApproximation.BinaryFraction.canonicalMulAllocation base (OAI.EditApproximation.BinaryFraction.nat b) + OAI.EditApproximation.BinaryFraction.naturalFloorAllocation position +    OAI.EditApproximation.binaryNaturalAddAllocation (OAI.EditApproximation.bitWordValue floor) (OAI.EditApproximation.bitWordValue offset) + OAI.EditApproximation.binaryNaturalMulAllocation 12 b +    OAI.EditApproximation.saturatingSubtractAllocation child.hi child.lo + OAI.EditApproximation.BinaryFraction.canonicalMulAllocation (OAI.EditApproximation.BinaryFraction.nat 2) h + OAI.EditApproximation.BinaryFraction.naturalCeilingAllocation twice +    OAI.EditApproximation.queryGapStatesAllocation ny (OAI.EditApproximation.bitWordValue spacing) (OAI.EditApproximation.bitWordValue anchor) (OAI.EditApproximation.bitWordValue radius)      (OAI.EditApproximation.bitWordValue length) (OAI.EditApproximation.bitWordValue gap) + exponent + 2def groupIndexAllocation {M : ℕ} (h : OAI.EditApproximation.BinaryFraction) (envelope values : Vector OAI.EditApproximation.BinaryFraction M)    (indices : List (Fin M)) : ℕ :=  OAI.EditApproximation.BinaryFraction.groupTermsAllocation h envelope indices +    OAI.EditApproximation.BinaryFraction.sumListAllocation (OAI.EditApproximation.BinaryFraction.groupTermsWithWork h envelope values indices).1 + 0def queryParentReadAllocation {n : ℕ} (keys : List (OAI.EditApproximation.TargetInterval n))    (words : List OAI.EditApproximation.BinaryFraction) (r : OAI.EditApproximation.TargetInterval n) : ℕ :=  OAI.EditApproximation.BinaryFraction.gatheredLookupAllocation OAI.EditApproximation.queryIntervalEqualWithWork OAI.EditApproximation.queryIntervalEqualAllocation keys words rdef onlineLinearReadAllocation {β : Type u_1} {σ : Type u_2} (mass : β → OAI.EditApproximation.BinaryFraction)    (read : ℕ → β × σ → OAI.EditApproximation.BinaryFraction × ℕ) (footprint : ℕ → β × σ → ℕ)    (eta kappa : OAI.EditApproximation.BinaryFraction) (t : ℕ) (i : β × σ) : ℕ :=  let coefficient := (OAI.EditApproximation.BinaryFraction.coefficientWithWork kappa).1  let terms := (OAI.EditApproximation.vectorMapWithWork t fun s => OAI.EditApproximation.BinaryFraction.optimisticTermReadWithWork mass read coefficient s.val i).1  let history := (OAI.EditApproximation.BinaryFraction.bandMassTotalWithWork terms).1  let current := (OAI.EditApproximation.BinaryFraction.gainReadWithWork mass read t i).1  OAI.EditApproximation.BinaryFraction.coefficientAllocation kappa +    OAI.EditApproximation.vectorMapAllocation t (fun s => OAI.EditApproximation.BinaryFraction.optimisticTermReadAllocation mass read footprint coefficient s.val i) +    OAI.EditApproximation.BinaryFraction.bandMassAllocation terms + OAI.EditApproximation.BinaryFraction.gainReadAllocation mass read footprint t i + OAI.EditApproximation.BinaryFraction.canonicalAddAllocation history current +    OAI.EditApproximation.BinaryFraction.canonicalMulAllocation eta (OAI.EditApproximation.BinaryFraction.canonicalAddWithWork history current).1 + 0def countedBandCoordinateAllocation {M n : ℕ} (mass : Vector OAI.EditApproximation.BinaryFraction M)    (total : OAI.EditApproximation.BinaryFraction) (action : Fin M → OAI.EditApproximation.TargetInterval n) (coordinate : Fin M × OAI.EditApproximation.TargetInterval n) : ℕ :=  OAI.EditApproximation.coordinateEqualAllocation coordinate (coordinate.1, action coordinate.1) +    if (OAI.EditApproximation.coordinateEqualWithWork coordinate (coordinate.1, action coordinate.1)).1 then      OAI.EditApproximation.BinaryFraction.divAllocation (mass.get coordinate.1) total else 0def queryInitialConeCentersAllocation {n : ℕ} (N P : ℕ) (A value : OAI.EditApproximation.BinaryFraction)    (q : OAI.EditApproximation.TargetInterval n) : ℕ :=  let radius := (OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork value).1  let active := (OAI.EditApproximation.filterWithWork (fun b => OAI.EditApproximation.BinaryFraction.initialScaleGuardWithWork (OAI.EditApproximation.bitWordValue radius) b A) (OAI.EditApproximation.dyadicScalesWithWork N).1).1  let build := fun b =>    let spacing := (OAI.EditApproximation.seedGridSpacingWithWork b P).1    let states := OAI.EditApproximation.gridStateBoxWithWork n (OAI.EditApproximation.bitWordValue spacing) (OAI.EditApproximation.bitWordValue radius) q.lo q.hi    (states.1, (OAI.EditApproximation.seedGridSpacingWithWork b P).2 + states.2 + 1)  OAI.EditApproximation.BinaryFraction.naturalCeilingAllocation value + OAI.EditApproximation.dyadicScalesAllocation N +    OAI.EditApproximation.filterAllocation (fun b => OAI.EditApproximation.BinaryFraction.initialScaleGuardWithWork (OAI.EditApproximation.bitWordValue radius) b A)      (fun b => OAI.EditApproximation.BinaryFraction.initialScaleGuardAllocation (OAI.EditApproximation.bitWordValue radius) b A) (OAI.EditApproximation.dyadicScalesWithWork N).1 +    OAI.EditApproximation.arithmeticFlatMapAllocation build      (fun b => OAI.EditApproximation.seedGridSpacingAllocation b P + OAI.EditApproximation.gridStateBoxAllocation n        (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.seedGridSpacingWithWork b P).1) (OAI.EditApproximation.bitWordValue radius) q.lo q.hi) activedef connectionWithWork {n : ℕ} (start finish : OAI.EditApproximation.BinaryFraction)    (states : List (OAI.EditApproximation.TargetInterval n)) : OAI.EditApproximation.BinaryFraction × ℕ :=  let terms := OAI.EditApproximation.BinaryFraction.connectionTermsWithWork start states finish  let result := OAI.EditApproximation.BinaryFraction.sumListWithWork terms.1  (result.1, terms.2 + result.2 + 1)def envelopeVectorReadWithWork {M n : ℕ} (b : ℕ) (band : List (Fin M → OAI.EditApproximation.TargetInterval n))    (read : Fin M → OAI.EditApproximation.TargetInterval n → OAI.EditApproximation.BinaryFraction × ℕ) : Vector OAI.EditApproximation.BinaryFraction M × ℕ :=  OAI.EditApproximation.vectorMapWithWork M (OAI.EditApproximation.BinaryFraction.bandEnvelopeReadWithWork b band read)def bellmanActionReadWithWork {Parent : Type u_1} {Child : Type u_2} {M : ℕ}    (distance : Parent → Parent → OAI.EditApproximation.BinaryFraction × ℕ) (L : OAI.EditApproximation.BinaryFraction)    (read : Child → OAI.EditApproximation.BinaryFraction × ℕ) (query : Parent)    (action : OAI.EditApproximation.BinaryBellmanAction Parent Child M) : OAI.EditApproximation.BinaryFraction × ℕ :=  let words := OAI.EditApproximation.arithmeticMapWithWork (fun i => read (action.childState i)) (List.finRange M)  let dist := distance query action.center  let spatial := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork L dist.1  let connection := OAI.EditApproximation.BinaryFraction.canonicalAddWithWork spatial.1 action.connection  let children := OAI.EditApproximation.BinaryFraction.sumListWithWork words.1  let result := OAI.EditApproximation.BinaryFraction.canonicalAddWithWork connection.1 children.1  (result.1, words.2 + dist.2 + spatial.2 + connection.2 + children.2 + result.2 + 3)def cellCentersReadWithWork {n : ℕ} (P F b : ℕ) (a theta : OAI.EditApproximation.BinaryFraction)    (initial : OAI.EditApproximation.TargetInterval n → OAI.EditApproximation.BinaryFraction × ℕ) (cell : ℕ × ℕ) :    List (OAI.EditApproximation.TargetInterval n) × ℕ :=  let spacing := OAI.EditApproximation.seedGridSpacingWithWork b P  let side := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork theta (OAI.EditApproximation.BinaryFraction.nat b)  let states := OAI.EditApproximation.BinaryFraction.cellStatesWithWork n (OAI.EditApproximation.bitWordValue spacing.1) side.1 cell  let selected := OAI.EditApproximation.filterWithWork (fun r =>    let word := initial r    let tested := OAI.EditApproximation.BinaryFraction.centerEligibilityWithWork b F a word.1    (tested.1, word.2 + tested.2)) states.1  (selected.1, spacing.2 + side.2 + states.2 + selected.2 + 3)def countedBandVerticesWithWork {M n d : ℕ} (coordinates : Vector (Fin M × OAI.EditApproximation.TargetInterval n) d)    (mass : Vector OAI.EditApproximation.BinaryFraction M) (band : List (Fin M → OAI.EditApproximation.TargetInterval n)) :    List ((Fin M → OAI.EditApproximation.TargetInterval n) × Vector OAI.EditApproximation.BinaryFraction d) × ℕ :=  let total := OAI.EditApproximation.BinaryFraction.bandMassTotalWithWork mass  let vertices := band.map fun action =>    let vertex := OAI.EditApproximation.vectorMapWithWork d fun i =>      OAI.EditApproximation.BinaryFraction.countedBandCoordinateWithWork mass total.1 action (coordinates.get i)    ((action, vertex.1), vertex.2)  (vertices.map Prod.fst, total.2 + (vertices.map Prod.snd).sum + 8 * band.length)def onlineIndexSetupWithWork {M n : ℕ} (H : ℕ) (band : List (Fin M → OAI.EditApproximation.TargetInterval n)) :    ℕ × ℕ :=  let coordinates := OAI.EditApproximation.BinaryFraction.bandCoordinatesWithWork band  let sum := OAI.EditApproximation.binaryNaturalAddWithWork H coordinates.1.length  let offset := OAI.EditApproximation.binaryNaturalAddWithWork (OAI.EditApproximation.bitWordValue sum.1) 2  let power := OAI.EditApproximation.bitPowerWithWork offset.1 80  (OAI.EditApproximation.bitWordValue offset.1, coordinates.2 + sum.2 + offset.2 + power.2 + 3)def localRepresentativeReadWithWork {n : ℕ} (N P F : ℕ) (a : OAI.EditApproximation.BinaryFraction)    (read : OAI.EditApproximation.TargetInterval n → OAI.EditApproximation.BinaryFraction × ℕ) (query : OAI.EditApproximation.TargetInterval n) :    List (ℕ × OAI.EditApproximation.TargetInterval n) × ℕ :=  let queryWord := read query  let scales := OAI.EditApproximation.BinaryFraction.queryExponentsWithWork N F a queryWord.1  let radius := OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork queryWord.1  let result := OAI.EditApproximation.arithmeticFlatMapWithWork    (OAI.EditApproximation.BinaryFraction.representativeScaleReadWithWork P F a read radius.1 query) scales.1  (result.1, queryWord.2 + scales.2 + radius.2 + result.2 + 3)def queryGroupKeysWithWork {n : ℕ} (N F exponent : ℕ) (a value : OAI.EditApproximation.BinaryFraction)    (q : OAI.EditApproximation.TargetInterval n) : List (ℕ × (ℕ × ℕ)) × ℕ :=  let scales := OAI.EditApproximation.BinaryFraction.queryScalesWithWork N F a value  let radius := OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork value  let keys := OAI.EditApproximation.arithmeticFlatMapWithWork (fun b =>    let side := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.inversePowerTwo exponent) (OAI.EditApproximation.BinaryFraction.nat b)    let cells := OAI.EditApproximation.BinaryFraction.targetCellsWithWork side.1 (OAI.EditApproximation.bitWordValue radius.1) q    let labeled := OAI.EditApproximation.arithmeticMapWithWork (fun cell => ((b, cell), 1)) cells.1    (labeled.1, side.2 + cells.2 + labeled.2 + 2)) scales.1  (keys.1, scales.2 + radius.2 + keys.2 + exponent + 4)def queryMeanWithWork (count : ℕ) (words : List OAI.EditApproximation.BinaryFraction) : OAI.EditApproximation.BinaryFraction × ℕ :=  let total := OAI.EditApproximation.BinaryFraction.sumListWithWork words  let result := OAI.EditApproximation.BinaryFraction.divWithWork total.1 (OAI.EditApproximation.BinaryFraction.nat count)  (result.1, total.2 + result.2 + Nat.size count + 2)def initialCentersReadWithWork {n : ℕ} (N P : ℕ) (A : OAI.EditApproximation.BinaryFraction)    (read : OAI.EditApproximation.TargetInterval n → List Bool × ℕ) (q : OAI.EditApproximation.TargetInterval n) :    List (OAI.EditApproximation.TargetInterval n) × ℕ :=  let queryWord := read q  let Uq := OAI.EditApproximation.bitWordValue queryWord.1  let scales := OAI.EditApproximation.dyadicScalesWithWork N  let active := OAI.EditApproximation.filterWithWork (fun b => OAI.EditApproximation.BinaryFraction.initialScaleGuardWithWork Uq b A) scales.1  let centers := OAI.EditApproximation.arithmeticFlatMapWithWork (OAI.EditApproximation.BinaryFraction.initialGridReadWithWork P A read Uq q) active.1  (centers.1, queryWord.2 + scales.2 + active.2 + centers.2 + 3)def queryInitialSeedReadWithWork {n : ℕ} (value : OAI.EditApproximation.BinaryFraction) (q : OAI.EditApproximation.TargetInterval n)    (keys : List (OAI.EditApproximation.TargetInterval n)) (words : List OAI.EditApproximation.BinaryFraction) (r : OAI.EditApproximation.TargetInterval n) : List Bool × ℕ :=  let test := OAI.EditApproximation.queryIntervalEqualWithWork r q  if test.1 then    let result := OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork value    (result.1, test.2 + result.2 + 1)  else    let found := OAI.EditApproximation.BinaryFraction.queryParentReadWithWork keys words r    let result := OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork found.1    (result.1, test.2 + found.2 + result.2 + 1)def queryOverrideParentReadWithWork {n : ℕ} (value : OAI.EditApproximation.BinaryFraction) (q : OAI.EditApproximation.TargetInterval n)    (keys : List (OAI.EditApproximation.TargetInterval n)) (words : List OAI.EditApproximation.BinaryFraction) (r : OAI.EditApproximation.TargetInterval n) :    OAI.EditApproximation.BinaryFraction × ℕ :=  let test := OAI.EditApproximation.queryIntervalEqualWithWork r q  if test.1 then (value, test.2 + 1)  else    let found := OAI.EditApproximation.BinaryFraction.queryParentReadWithWork keys words r    (found.1, test.2 + found.2 + 1)def connectionAllocation {n : ℕ} (start finish : OAI.EditApproximation.BinaryFraction)    (states : List (OAI.EditApproximation.TargetInterval n)) : ℕ :=  OAI.EditApproximation.BinaryFraction.connectionTermsAllocation start states finish +    OAI.EditApproximation.BinaryFraction.sumListAllocation (OAI.EditApproximation.BinaryFraction.connectionTermsWithWork start states finish).1 + 0def coordinateVectorAllocation {M n : ℕ} (band : List (Fin M → OAI.EditApproximation.TargetInterval n)) : ℕ :=  OAI.EditApproximation.BinaryFraction.bandCoordinatesAllocation band + (OAI.EditApproximation.BinaryFraction.bandCoordinatesWithWork band).1.lengthdef maximizerAllocation {d : ℕ} (gradient : Vector OAI.EditApproximation.BinaryFraction d)    (vertices : List (Vector OAI.EditApproximation.BinaryFraction d)) : ℕ :=  OAI.EditApproximation.BinaryFraction.scoredArgmaxAllocation (OAI.EditApproximation.BinaryFraction.dotWithWork gradient)    (fun v => OAI.EditApproximation.BinaryFraction.dotListAllocation gradient v (List.finRange d)) vertices + ddef onlineIndexSetupAllocation {M n : ℕ} (H : ℕ) (band : List (Fin M → OAI.EditApproximation.TargetInterval n)) : ℕ :=  let coordinates := (OAI.EditApproximation.BinaryFraction.bandCoordinatesWithWork band).1  let sum := (OAI.EditApproximation.binaryNaturalAddWithWork H coordinates.length).1  let offset := (OAI.EditApproximation.binaryNaturalAddWithWork (OAI.EditApproximation.bitWordValue sum) 2).1  OAI.EditApproximation.BinaryFraction.bandCoordinatesAllocation band + OAI.EditApproximation.binaryNaturalAddAllocation H coordinates.length +    OAI.EditApproximation.binaryNaturalAddAllocation (OAI.EditApproximation.bitWordValue sum) 2 + OAI.EditApproximation.bitPowerAllocation offset 80def envelopeVectorReadAllocation {M n : ℕ} (b : ℕ) (band : List (Fin M → OAI.EditApproximation.TargetInterval n))    (read : Fin M → OAI.EditApproximation.TargetInterval n → OAI.EditApproximation.BinaryFraction × ℕ)    (footprint : Fin M → OAI.EditApproximation.TargetInterval n → ℕ) : ℕ :=  OAI.EditApproximation.vectorMapAllocation M (OAI.EditApproximation.BinaryFraction.bandEnvelopeReadAllocation b band read footprint)def roundedBandReadAllocation {n M : ℕ} (exponent b : ℕ) (band : List (Fin M → OAI.EditApproximation.TargetInterval n))    (hne : band ≠ []) (read : Fin M → OAI.EditApproximation.TargetInterval n → OAI.EditApproximation.BinaryFraction × ℕ)    (allocation : Fin M → OAI.EditApproximation.TargetInterval n → ℕ) : ℕ :=  OAI.EditApproximation.vectorMapAllocation M fun i =>    let envelope := (OAI.EditApproximation.BinaryFraction.bandEnvelopeReadWithWork b band read i).1    let spacing := OAI.EditApproximation.bitWordValue (OAI.EditApproximation.BinaryFraction.roundedSpacingWithWork (OAI.EditApproximation.BinaryFraction.inversePowerTwo exponent) envelope).1    OAI.EditApproximation.BinaryFraction.bandEnvelopeReadAllocation b band read allocation i +      OAI.EditApproximation.BinaryFraction.roundedSpacingAllocation (OAI.EditApproximation.BinaryFraction.inversePowerTwo exponent) envelope +      OAI.EditApproximation.roundStateAllocation spacing (band.head hne i) + exponent + 2def queryGroupKeysAllocation {n : ℕ} (N F exponent : ℕ) (a value : OAI.EditApproximation.BinaryFraction) (q : OAI.EditApproximation.TargetInterval n) : ℕ :=  let radius := (OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork value).1  let build := fun b =>    let side := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.inversePowerTwo exponent) (OAI.EditApproximation.BinaryFraction.nat b)    let cells := OAI.EditApproximation.BinaryFraction.targetCellsWithWork side.1 (OAI.EditApproximation.bitWordValue radius) q    let labeled := OAI.EditApproximation.arithmeticMapWithWork (fun cell => ((b, cell), 1)) cells.1    (labeled.1, side.2 + cells.2 + labeled.2 + 2)  OAI.EditApproximation.BinaryFraction.queryScalesAllocation N F a value + OAI.EditApproximation.BinaryFraction.naturalCeilingAllocation value +    OAI.EditApproximation.arithmeticFlatMapAllocation build (fun b =>      let side := (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.inversePowerTwo exponent) (OAI.EditApproximation.BinaryFraction.nat b)).1      OAI.EditApproximation.BinaryFraction.canonicalMulAllocation (OAI.EditApproximation.BinaryFraction.inversePowerTwo exponent) (OAI.EditApproximation.BinaryFraction.nat b) + OAI.EditApproximation.BinaryFraction.targetCellsAllocation side (OAI.EditApproximation.bitWordValue radius) q +        OAI.EditApproximation.arithmeticMapAllocation (fun _ => 1) (OAI.EditApproximation.BinaryFraction.targetCellsWithWork side (OAI.EditApproximation.bitWordValue radius) q).1)      (OAI.EditApproximation.BinaryFraction.queryScalesWithWork N F a value).1 + exponent + 2def initialCellAllocation (n P exponent : ℕ) (key : ℕ × ℕ × ℕ) : ℕ :=  OAI.EditApproximation.seedGridSpacingAllocation key.1 P + OAI.EditApproximation.BinaryFraction.canonicalMulAllocation (OAI.EditApproximation.BinaryFraction.inversePowerTwo exponent) (OAI.EditApproximation.BinaryFraction.nat key.1) +    OAI.EditApproximation.BinaryFraction.cellStatesAllocation n (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.seedGridSpacingWithWork key.1 P).1)      (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.inversePowerTwo exponent) (OAI.EditApproximation.BinaryFraction.nat key.1)).1 key.2 + exponent + 2def localRepresentativeReadAllocation {n : ℕ} (N P F : ℕ) (a : OAI.EditApproximation.BinaryFraction)    (read : OAI.EditApproximation.TargetInterval n → OAI.EditApproximation.BinaryFraction × ℕ) (allocation : OAI.EditApproximation.TargetInterval n → ℕ)    (query : OAI.EditApproximation.TargetInterval n) : ℕ :=  allocation query + OAI.EditApproximation.BinaryFraction.queryExponentsAllocation N F a (read query).1 + OAI.EditApproximation.BinaryFraction.naturalCeilingAllocation (read query).1 +    OAI.EditApproximation.arithmeticFlatMapAllocation      (OAI.EditApproximation.BinaryFraction.representativeScaleReadWithWork P F a read (OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork (read query).1).1 query)      (OAI.EditApproximation.BinaryFraction.representativeScaleReadAllocation P F a read allocation (OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork (read query).1).1 query)      (OAI.EditApproximation.BinaryFraction.queryExponentsWithWork N F a (read query).1).1def cellCentersReadAllocation {n : ℕ} (P F b : ℕ) (a theta : OAI.EditApproximation.BinaryFraction)    (initial : OAI.EditApproximation.TargetInterval n → OAI.EditApproximation.BinaryFraction × ℕ) (allocation : OAI.EditApproximation.TargetInterval n → ℕ)    (cell : ℕ × ℕ) : ℕ :=  let spacing := (OAI.EditApproximation.seedGridSpacingWithWork b P).1  let side := (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork theta (OAI.EditApproximation.BinaryFraction.nat b)).1  let states := (OAI.EditApproximation.BinaryFraction.cellStatesWithWork n (OAI.EditApproximation.bitWordValue spacing) side cell).1  let test := fun r => ((OAI.EditApproximation.BinaryFraction.centerEligibilityWithWork b F a (initial r).1).1,    (initial r).2 + (OAI.EditApproximation.BinaryFraction.centerEligibilityWithWork b F a (initial r).1).2)  OAI.EditApproximation.seedGridSpacingAllocation b P + OAI.EditApproximation.BinaryFraction.canonicalMulAllocation theta (OAI.EditApproximation.BinaryFraction.nat b) +    OAI.EditApproximation.BinaryFraction.cellStatesAllocation n (OAI.EditApproximation.bitWordValue spacing) side cell +    OAI.EditApproximation.filterAllocation test (fun r => allocation r + OAI.EditApproximation.BinaryFraction.centerEligibilityAllocation b F a (initial r).1) statesdef selectGroupAllocation {ι : Type u_1} (members : List ι) (estimate : ι → OAI.EditApproximation.BinaryFraction × ℕ)    (allocation : ι → ℕ) : ℕ :=  OAI.EditApproximation.BinaryFraction.scoredArgmaxAllocation (fun member => ((estimate member).1.neg, (estimate member).2 + 1)) allocation membersdef bellmanActionReadAllocation {Parent : Type u_1} {Child : Type u_2} {M : ℕ}    (distance : Parent → Parent → OAI.EditApproximation.BinaryFraction × ℕ) (distanceAllocation : Parent → Parent → ℕ)    (L : OAI.EditApproximation.BinaryFraction) (read : Child → OAI.EditApproximation.BinaryFraction × ℕ) (footprint : Child → ℕ)    (query : Parent) (action : OAI.EditApproximation.BinaryBellmanAction Parent Child M) : ℕ :=  let words := (OAI.EditApproximation.arithmeticMapWithWork (fun i => read (action.childState i)) (List.finRange M)).1  let dist := (distance query action.center).1  let spatial := (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork L dist).1  let connection := (OAI.EditApproximation.BinaryFraction.canonicalAddWithWork spatial action.connection).1  let children := (OAI.EditApproximation.BinaryFraction.sumListWithWork words).1  OAI.EditApproximation.arithmeticMapAllocation (fun i => footprint (action.childState i)) (List.finRange M) +    distanceAllocation query action.center + OAI.EditApproximation.BinaryFraction.canonicalMulAllocation L dist +    OAI.EditApproximation.BinaryFraction.canonicalAddAllocation spatial action.connection + OAI.EditApproximation.BinaryFraction.sumListAllocation words +    OAI.EditApproximation.BinaryFraction.canonicalAddAllocation connection childrendef countedBandVerticesAllocation {M n d : ℕ} (coordinates : Vector (Fin M × OAI.EditApproximation.TargetInterval n) d)    (mass : Vector OAI.EditApproximation.BinaryFraction M) (band : List (Fin M → OAI.EditApproximation.TargetInterval n)) : ℕ :=  OAI.EditApproximation.BinaryFraction.bandMassAllocation mass +    (band.map fun action => OAI.EditApproximation.vectorMapAllocation d fun i =>      OAI.EditApproximation.BinaryFraction.countedBandCoordinateAllocation mass (OAI.EditApproximation.BinaryFraction.bandMassTotalWithWork mass).1 action (coordinates.get i)).sum +    4 * band.lengthdef queryInitialSeedReadAllocation {n : ℕ} (value : OAI.EditApproximation.BinaryFraction) (q : OAI.EditApproximation.TargetInterval n)    (keys : List (OAI.EditApproximation.TargetInterval n)) (words : List OAI.EditApproximation.BinaryFraction) (r : OAI.EditApproximation.TargetInterval n) : ℕ :=  OAI.EditApproximation.queryIntervalEqualAllocation r q +    if (OAI.EditApproximation.queryIntervalEqualWithWork r q).1 then OAI.EditApproximation.BinaryFraction.naturalCeilingAllocation value    else OAI.EditApproximation.BinaryFraction.queryParentReadAllocation keys words r + OAI.EditApproximation.BinaryFraction.naturalCeilingAllocation (OAI.EditApproximation.BinaryFraction.queryParentReadWithWork keys words r).1def queryOverrideParentReadAllocation {n : ℕ} (q : OAI.EditApproximation.TargetInterval n)    (keys : List (OAI.EditApproximation.TargetInterval n)) (words : List OAI.EditApproximation.BinaryFraction) (r : OAI.EditApproximation.TargetInterval n) : ℕ :=  OAI.EditApproximation.queryIntervalEqualAllocation r q +    if (OAI.EditApproximation.queryIntervalEqualWithWork r q).1 then 0 else OAI.EditApproximation.BinaryFraction.queryParentReadAllocation keys words rdef prefixReadWithWork {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx) (r : OAI.EditApproximation.TargetInterval ny)    (states : Fin M → OAI.EditApproximation.TargetInterval ny) (read : Fin M → OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BinaryFraction × ℕ)    (j : ℕ) (p : OAI.EditApproximation.BinaryFraction) : OAI.EditApproximation.BinaryFraction × ℕ :=  let words := OAI.EditApproximation.arithmeticMapWithWork (fun i : Fin M =>    if i.val < j then read i (states i) else (OAI.EditApproximation.BinaryFraction.zero, 1)) (List.finRange M)  let finish := OAI.EditApproximation.BinaryFraction.canonicalAddWithWork (OAI.EditApproximation.BinaryFraction.nat (OAI.EditApproximation.balancedCut parent.lo (parent.hi - parent.lo) M j)) p  let connection := OAI.EditApproximation.BinaryFraction.connectionWithWork (OAI.EditApproximation.BinaryFraction.nat r.lo) finish.1 ((List.ofFn states).take j)  let total := OAI.EditApproximation.BinaryFraction.sumListWithWork words.1  let result := OAI.EditApproximation.BinaryFraction.canonicalAddWithWork connection.1 total.1  (result.1, words.2 + finish.2 + connection.2 + total.2 + result.2 +    Nat.size (OAI.EditApproximation.balancedCut parent.lo (parent.hi - parent.lo) M j) + Nat.size r.lo + 6 * M + 5)def bellmanReadWithWork {Parent : Type u_1} {Child : Type u_2} {M : ℕ}    (distance : Parent → Parent → OAI.EditApproximation.BinaryFraction × ℕ) (L fallback : OAI.EditApproximation.BinaryFraction)    (read : Child → OAI.EditApproximation.BinaryFraction × ℕ) (query : Parent)    (actions : List (OAI.EditApproximation.BinaryBellmanAction Parent Child M)) : OAI.EditApproximation.BinaryFraction × ℕ :=  let scores := OAI.EditApproximation.arithmeticMapWithWork (OAI.EditApproximation.BinaryFraction.bellmanActionReadWithWork distance L read query) actions  let result := OAI.EditApproximation.BinaryFraction.minimumWithWork fallback scores.1  (result.1, scores.2 + result.2 + 1)def queryWarmupInputsWithWork {nx ny : ℕ} (M : ℕ) (parent : OAI.EditApproximation.TargetInterval nx)    (N P F : ℕ) (a : OAI.EditApproximation.BinaryFraction) (initial : OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BinaryFraction × ℕ)    (q : OAI.EditApproximation.TargetInterval ny) : List (Fin M × OAI.EditApproximation.TargetInterval ny) × ℕ :=  let representatives := OAI.EditApproximation.BinaryFraction.localRepresentativeReadWithWork N P F a initial q  let inputs := OAI.EditApproximation.BinaryFraction.queryWideInputsWithWork M parent P representatives.1  (inputs.1, representatives.2 + inputs.2 + 1)def endpointConnectionAllocation {n M : ℕ} (r : OAI.EditApproximation.TargetInterval n)    (states : Fin M → OAI.EditApproximation.TargetInterval n) : ℕ :=  OAI.EditApproximation.BinaryFraction.connectionAllocation (OAI.EditApproximation.BinaryFraction.nat r.lo) (OAI.EditApproximation.BinaryFraction.nat r.hi) (List.ofFn states) + Nat.size r.lo + Nat.size r.hi + Mdef prefixReadAllocation {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx) (r : OAI.EditApproximation.TargetInterval ny)    (states : Fin M → OAI.EditApproximation.TargetInterval ny) (read : Fin M → OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BinaryFraction × ℕ)    (allocation : Fin M → OAI.EditApproximation.TargetInterval ny → ℕ) (j : ℕ) (p : OAI.EditApproximation.BinaryFraction) : ℕ :=  let words := (OAI.EditApproximation.arithmeticMapWithWork (fun i : Fin M =>    if i.val < j then read i (states i) else (OAI.EditApproximation.BinaryFraction.zero, 1)) (List.finRange M)).1  let finish := (OAI.EditApproximation.BinaryFraction.canonicalAddWithWork (OAI.EditApproximation.BinaryFraction.nat (OAI.EditApproximation.balancedCut parent.lo (parent.hi - parent.lo) M j)) p).1  OAI.EditApproximation.arithmeticMapAllocation (fun i : Fin M => if i.val < j then allocation i (states i) else 0)      (List.finRange M) +    OAI.EditApproximation.BinaryFraction.canonicalAddAllocation (OAI.EditApproximation.BinaryFraction.nat (OAI.EditApproximation.balancedCut parent.lo (parent.hi - parent.lo) M j)) p +    OAI.EditApproximation.BinaryFraction.connectionAllocation (OAI.EditApproximation.BinaryFraction.nat r.lo) finish ((List.ofFn states).take j) + OAI.EditApproximation.BinaryFraction.sumListAllocation words +    OAI.EditApproximation.BinaryFraction.canonicalAddAllocation (OAI.EditApproximation.BinaryFraction.connectionWithWork (OAI.EditApproximation.BinaryFraction.nat r.lo) finish ((List.ofFn states).take j)).1      (OAI.EditApproximation.BinaryFraction.sumListWithWork words).1 +    Nat.size (OAI.EditApproximation.balancedCut parent.lo (parent.hi - parent.lo) M j) + Nat.size r.lo + 2 * Mdef optimizerAllocation {d : ℕ} (vertices : List (Vector OAI.EditApproximation.BinaryFraction d))    (linear : Vector OAI.EditApproximation.BinaryFraction d) (G : ℕ) : ℕ → ℕ  | 0 => d  | j + 1 =>    let previous := (OAI.EditApproximation.BinaryFraction.finiteOptimizerWithWork vertices linear G j).1    let gradient := (OAI.EditApproximation.BinaryFraction.gradientWithWork G linear previous).1    let selected := (OAI.EditApproximation.BinaryFraction.maximizerWithWork gradient vertices).1    optimizerAllocation vertices linear G j + OAI.EditApproximation.BinaryFraction.gradientAllocation G linear previous +      OAI.EditApproximation.BinaryFraction.maximizerAllocation gradient vertices + OAI.EditApproximation.BinaryFraction.optimizerUpdateAllocation j previous selecteddef queryEarlierRepresentativesAllocation {n : ℕ} (N P F exponent : ℕ) (hP : 0 < P)    (a : OAI.EditApproximation.BinaryFraction) (initial : OAI.EditApproximation.TargetInterval n → OAI.EditApproximation.BinaryFraction × ℕ)    (allocation : OAI.EditApproximation.TargetInterval n → ℕ) (q : OAI.EditApproximation.TargetInterval n) : ℕ :=  let groups := (OAI.EditApproximation.BinaryFraction.queryGroupKeysWithWork N F exponent a (initial q).1 q).1  let build := fun key : ℕ × ℕ × ℕ =>    let centers := OAI.EditApproximation.BinaryFraction.cellCentersReadWithWork P F key.1 a (OAI.EditApproximation.BinaryFraction.inversePowerTwo exponent) initial key.2    let labeled := OAI.EditApproximation.arithmeticMapWithWork (fun r => ((key.1, r), 1)) centers.1    (labeled.1, centers.2 + labeled.2 + 1)  allocation q + OAI.EditApproximation.BinaryFraction.localRepresentativeReadAllocation N P F a initial allocation q +    OAI.EditApproximation.BinaryFraction.queryGroupKeysAllocation N F exponent a (initial q).1 q +    OAI.EditApproximation.arithmeticFlatMapAllocation build (fun key =>      OAI.EditApproximation.BinaryFraction.cellCentersReadAllocation P F key.1 a (OAI.EditApproximation.BinaryFraction.inversePowerTwo exponent) initial allocation key.2 +      OAI.EditApproximation.arithmeticMapAllocation (fun _ => 1)        (OAI.EditApproximation.BinaryFraction.cellCentersReadWithWork P F key.1 a (OAI.EditApproximation.BinaryFraction.inversePowerTwo exponent) initial key.2).1) groups +    OAI.EditApproximation.BinaryFraction.queryOnlineKeysAllocation N P F hP a (initial q).1 q +    2 * (OAI.EditApproximation.BinaryFraction.localRepresentativeReadWithWork N P F a initial q).1.length +    (OAI.EditApproximation.arithmeticFlatMapWithWork build groups).1.lengthdef queryWarmupInputsAllocation {nx ny : ℕ} (M : ℕ) (parent : OAI.EditApproximation.TargetInterval nx)    (N P F : ℕ) (a : OAI.EditApproximation.BinaryFraction)    (initial : OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BinaryFraction × ℕ) (allocation : OAI.EditApproximation.TargetInterval ny → ℕ)    (q : OAI.EditApproximation.TargetInterval ny) : ℕ :=  OAI.EditApproximation.BinaryFraction.localRepresentativeReadAllocation N P F a initial allocation q +    OAI.EditApproximation.BinaryFraction.queryWideInputsAllocation M parent P (OAI.EditApproximation.BinaryFraction.localRepresentativeReadWithWork N P F a initial q).1def bellmanReadAllocation {Parent : Type u_1} {Child : Type u_2} {M : ℕ}    (distance : Parent → Parent → OAI.EditApproximation.BinaryFraction × ℕ) (distanceAllocation : Parent → Parent → ℕ)    (L fallback : OAI.EditApproximation.BinaryFraction) (read : Child → OAI.EditApproximation.BinaryFraction × ℕ) (footprint : Child → ℕ)    (query : Parent) (actions : List (OAI.EditApproximation.BinaryBellmanAction Parent Child M)) : ℕ :=  let scores := (OAI.EditApproximation.arithmeticMapWithWork (OAI.EditApproximation.BinaryFraction.bellmanActionReadWithWork distance L read query) actions).1  OAI.EditApproximation.arithmeticMapAllocation (OAI.EditApproximation.BinaryFraction.bellmanActionReadAllocation distance distanceAllocation L read footprint query) actions +    OAI.EditApproximation.BinaryFraction.minimumAllocation fallback scoresdef prefixMinimumReadWithWork {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx) (r : OAI.EditApproximation.TargetInterval ny)    (actions : List (Fin M → OAI.EditApproximation.TargetInterval ny)) (hne : actions ≠ [])    (read : Fin M → OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BinaryFraction × ℕ) (j : ℕ) (p : OAI.EditApproximation.BinaryFraction) :    OAI.EditApproximation.BinaryFraction × ℕ :=  let fallback := OAI.EditApproximation.BinaryFraction.prefixReadWithWork parent r (actions.head hne) read j p  let scores := OAI.EditApproximation.arithmeticMapWithWork (fun action => OAI.EditApproximation.BinaryFraction.prefixReadWithWork parent r action read j p) actions  let result := OAI.EditApproximation.BinaryFraction.minimumWithWork fallback.1 scores.1  (result.1, fallback.2 + scores.2 + result.2 + 1)def localContinuationReadWithWork {Parent : Type u_1} {Child : Type u_2} {M : ℕ}    (distance : Parent → Parent → OAI.EditApproximation.BinaryFraction × ℕ) (L delta fallback : OAI.EditApproximation.BinaryFraction)    (old current : Child → OAI.EditApproximation.BinaryFraction × ℕ) (query : Parent)    (wide groups online : List (OAI.EditApproximation.BinaryBellmanAction Parent Child M)) : OAI.EditApproximation.BinaryFraction × ℕ :=  let warm := OAI.EditApproximation.BinaryFraction.bellmanReadWithWork distance L fallback old query wide  let cone := OAI.EditApproximation.BinaryFraction.bellmanReadWithWork distance L warm.1 current query groups  let scores := OAI.EditApproximation.arithmeticMapWithWork (OAI.EditApproximation.BinaryFraction.bellmanActionReadWithWork distance L current query) online  let onlineMin := OAI.EditApproximation.BinaryFraction.onlineMinimumWithWork scores.1  let result := OAI.EditApproximation.BinaryFraction.refinementUpdateWithWork delta cone.1 onlineMin.1  (result.1, warm.2 + cone.2 + scores.2 + onlineMin.2 + result.2 + 3)def prefixMinimumReadAllocation {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx) (r : OAI.EditApproximation.TargetInterval ny)    (actions : List (Fin M → OAI.EditApproximation.TargetInterval ny)) (hne : actions ≠ [])    (read : Fin M → OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BinaryFraction × ℕ)    (allocation : Fin M → OAI.EditApproximation.TargetInterval ny → ℕ) (j : ℕ) (p : OAI.EditApproximation.BinaryFraction) : ℕ :=  let fallback := (OAI.EditApproximation.BinaryFraction.prefixReadWithWork parent r (actions.head hne) read j p).1  let scores := (OAI.EditApproximation.arithmeticMapWithWork (fun action => OAI.EditApproximation.BinaryFraction.prefixReadWithWork parent r action read j p) actions).1  OAI.EditApproximation.BinaryFraction.prefixReadAllocation parent r (actions.head hne) read allocation j p +    OAI.EditApproximation.arithmeticMapAllocation (fun action => OAI.EditApproximation.BinaryFraction.prefixReadAllocation parent r action read allocation j p) actions +    OAI.EditApproximation.BinaryFraction.minimumAllocation fallback scoresdef localContinuationReadAllocation {Parent : Type u_1} {Child : Type u_2} {M : ℕ}    (distance : Parent → Parent → OAI.EditApproximation.BinaryFraction × ℕ) (distanceAllocation : Parent → Parent → ℕ)    (L delta fallback : OAI.EditApproximation.BinaryFraction) (old current : Child → OAI.EditApproximation.BinaryFraction × ℕ)    (oldAllocation currentAllocation : Child → ℕ) (query : Parent)    (wide groups online : List (OAI.EditApproximation.BinaryBellmanAction Parent Child M)) : ℕ :=  let warm := (OAI.EditApproximation.BinaryFraction.bellmanReadWithWork distance L fallback old query wide).1  let cone := (OAI.EditApproximation.BinaryFraction.bellmanReadWithWork distance L warm current query groups).1  let scores := (OAI.EditApproximation.arithmeticMapWithWork (OAI.EditApproximation.BinaryFraction.bellmanActionReadWithWork distance L current query) online).1  let onlineMin := (OAI.EditApproximation.BinaryFraction.onlineMinimumWithWork scores).1  OAI.EditApproximation.BinaryFraction.bellmanReadAllocation distance distanceAllocation L fallback old oldAllocation query wide +    OAI.EditApproximation.BinaryFraction.bellmanReadAllocation distance distanceAllocation L warm current currentAllocation query groups +    OAI.EditApproximation.arithmeticMapAllocation (OAI.EditApproximation.BinaryFraction.bellmanActionReadAllocation distance distanceAllocation L current currentAllocation query) online +    OAI.EditApproximation.BinaryFraction.onlineMinimumAllocation scores + OAI.EditApproximation.BinaryFraction.refinementUpdateAllocation delta cone onlineMindef endpointActionAllocation {ny M : ℕ} (center : OAI.EditApproximation.TargetInterval ny)    (states : Fin M → OAI.EditApproximation.TargetInterval ny) : ℕ := OAI.EditApproximation.BinaryFraction.endpointConnectionAllocation center states + M + 1def selectionAllocation {α : Type u_1} {d : ℕ}    (vertices : List (α × Vector OAI.EditApproximation.BinaryFraction d)) (linear : Vector OAI.EditApproximation.BinaryFraction d) (G j : ℕ) : ℕ :=  let iterate := (OAI.EditApproximation.BinaryFraction.finiteOptimizerWithWork (vertices.map Prod.snd) linear G j).1  let gradient := (OAI.EditApproximation.BinaryFraction.gradientWithWork G linear iterate).1  vertices.length + OAI.EditApproximation.BinaryFraction.optimizerAllocation (vertices.map Prod.snd) linear G j +    OAI.EditApproximation.BinaryFraction.gradientAllocation G linear iterate +    OAI.EditApproximation.BinaryFraction.scoredArgmaxAllocation (fun vertex => OAI.EditApproximation.BinaryFraction.dotWithWork gradient vertex.2)      (fun vertex => OAI.EditApproximation.BinaryFraction.dotListAllocation gradient vertex.2 (List.finRange d)) verticesdef cutGuardReadWithWork {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx) (r : OAI.EditApproximation.TargetInterval ny)    (actions : List (Fin M → OAI.EditApproximation.TargetInterval ny)) (hne : actions ≠ [])    (read : Fin M → OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BinaryFraction × ℕ) (states : Fin M → OAI.EditApproximation.TargetInterval ny)    (velocity tolerance : OAI.EditApproximation.BinaryFraction) (j : Fin M) : Bool × ℕ :=  if j.val = 0 then (true, 1) else    let shift := OAI.EditApproximation.BinaryFraction.subWithWork (OAI.EditApproximation.BinaryFraction.nat (states j).lo) (OAI.EditApproximation.BinaryFraction.nat (OAI.EditApproximation.sourceChild parent j).lo)    let offset := OAI.EditApproximation.BinaryFraction.subWithWork (OAI.EditApproximation.BinaryFraction.nat r.lo) (OAI.EditApproximation.BinaryFraction.nat parent.lo)    let prediction := OAI.EditApproximation.BinaryFraction.prefixMinimumReadWithWork parent r actions hne read j.val shift.1    let result := OAI.EditApproximation.BinaryFraction.affineErrorWithWork shift.1 offset.1 velocity prediction.1 tolerance    (result.1, shift.2 + offset.2 + prediction.2 + result.2 +      Nat.size (states j).lo + Nat.size (OAI.EditApproximation.sourceChild parent j).lo + Nat.size r.lo + Nat.size parent.lo + 5)def cutGuardReadAllocation {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx) (r : OAI.EditApproximation.TargetInterval ny)    (actions : List (Fin M → OAI.EditApproximation.TargetInterval ny)) (hne : actions ≠ [])    (read : Fin M → OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BinaryFraction × ℕ)    (allocation : Fin M → OAI.EditApproximation.TargetInterval ny → ℕ) (states : Fin M → OAI.EditApproximation.TargetInterval ny)    (velocity tolerance : OAI.EditApproximation.BinaryFraction) (j : Fin M) : ℕ :=  if j.val = 0 then 0 else    let shift := (OAI.EditApproximation.BinaryFraction.subWithWork (OAI.EditApproximation.BinaryFraction.nat (states j).lo) (OAI.EditApproximation.BinaryFraction.nat (OAI.EditApproximation.sourceChild parent j).lo)).1    let offset := (OAI.EditApproximation.BinaryFraction.subWithWork (OAI.EditApproximation.BinaryFraction.nat r.lo) (OAI.EditApproximation.BinaryFraction.nat parent.lo)).1    OAI.EditApproximation.BinaryFraction.subAllocation (OAI.EditApproximation.BinaryFraction.nat (states j).lo) (OAI.EditApproximation.BinaryFraction.nat (OAI.EditApproximation.sourceChild parent j).lo) +      OAI.EditApproximation.BinaryFraction.subAllocation (OAI.EditApproximation.BinaryFraction.nat r.lo) (OAI.EditApproximation.BinaryFraction.nat parent.lo) +      OAI.EditApproximation.BinaryFraction.prefixMinimumReadAllocation parent r actions hne read allocation j.val shift +      OAI.EditApproximation.BinaryFraction.affineErrorAllocation shift offset velocity        (OAI.EditApproximation.BinaryFraction.prefixMinimumReadWithWork parent r actions hne read j.val shift).1 tolerance +      Nat.size (states j).lo + Nat.size (OAI.EditApproximation.sourceChild parent j).lo + Nat.size r.lo + Nat.size parent.lodef bandPredicateReadAllocation {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx) (r : OAI.EditApproximation.TargetInterval ny)    (b : ℕ) (tau theta velocity : OAI.EditApproximation.BinaryFraction)    (actions : List (Fin M → OAI.EditApproximation.TargetInterval ny)) (hne : actions ≠ [])    (read : Fin M → OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BinaryFraction × ℕ)    (allocation : Fin M → OAI.EditApproximation.TargetInterval ny → ℕ) (states : Fin M → OAI.EditApproximation.TargetInterval ny) : ℕ :=  OAI.EditApproximation.zeroConnectionAllocation r.lo (List.ofFn states) r.hi + M +    OAI.EditApproximation.allAllocation (OAI.EditApproximation.BinaryFraction.anchorGuardAllocation parent r b states) (List.finRange M) +    OAI.EditApproximation.BinaryFraction.bandToleranceAllocation tau theta b M +    OAI.EditApproximation.allAllocation (OAI.EditApproximation.BinaryFraction.cutGuardReadAllocation parent r actions hne read allocation states velocity      (OAI.EditApproximation.BinaryFraction.bandToleranceWithWork tau theta b M).1) (List.finRange M)end OAI.EditApproximation.BinaryFractionendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen Finsetdef rationalConnectionBudget {n : ℕ} (start : ℚ) : List (OAI.EditApproximation.TargetInterval n) → ℚ → ℚ  | [], finish => |start - finish|  | state :: rest, finish => |start - state.lo| + rationalConnectionBudget state.hi rest finishdef bandChildEnvelope {ny M : ℕ} (b : ℕ)    (band : List (Fin M → OAI.EditApproximation.TargetInterval ny))    (initial : Fin M → OAI.EditApproximation.TargetInterval ny → ℚ) (i : Fin M) : ℚ :=  OAI.EditApproximation.rationalDyadicCeiling (max ((b : ℚ) / M)    (OAI.EditApproximation.rationalMaximum 0 (band.map fun action => initial i (action i))))def bandEnvelopeExponent {ny M : ℕ} (b : ℕ) (band : List (Fin M → OAI.EditApproximation.TargetInterval ny))    (initial : Fin M → OAI.EditApproximation.TargetInterval ny → ℚ) (i : Fin M) : ℤ :=  Int.clog 2 (max ((b : ℚ) / M) (OAI.EditApproximation.rationalMaximum 0 (band.map fun action => initial i (action i))))deriving instance DecidableEq for OAI.EditApproximation.TargetIntervaldef zeroConnectionWithWork {n : ℕ} (start : ℕ) : List (OAI.EditApproximation.TargetInterval n) → ℕ → Bool × ℕ  | [], finish => OAI.EditApproximation.naturalEqualWithWork start finish  | state :: rest, finish =>    let current := OAI.EditApproximation.naturalEqualWithWork start state.lo    let tail := zeroConnectionWithWork state.hi rest finish    (current.1 && tail.1, current.2 + tail.2 + 1)def roundStateWithWork {n : ℕ} (spacing : ℕ) (hspacing : 0 < spacing)    (q : OAI.EditApproximation.TargetInterval n) : OAI.EditApproximation.TargetInterval n × ℕ := by  have proof_bitAdder_value_1 (a : Bool) (b : Bool) (carry : Bool) :      (OAI.EditApproximation.bitSum a b carry).toNat + 2 * (OAI.EditApproximation.bitCarry a b carry).toNat =        a.toNat + b.toNat + carry.toNat := by    cases a <;> cases b <;> cases carry <;> decide  have proof_bitAddWithWork_value_2 (left : List.{0} Bool) (right : List.{0} Bool) (carry : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitAddWithWork left right carry).1 =        OAI.EditApproximation.bitWordValue left + OAI.EditApproximation.bitWordValue right + carry.toNat := by    induction left generalizing right carry with    | nil =>      simp only [OAI.EditApproximation.bitAddWithWork]      induction right generalizing carry with      | nil => cases carry <;> simp [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue]      | cons b bs ih =>        simp only [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 false b carry        simp only [Bool.toNat_false] at h        omega    | cons a as ih =>      cases right with      | nil =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a false carry        simp only [Bool.toNat_false] at h        omega      | cons b bs =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a b carry        omega  have proof_bitMulWithWork_value_0 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitMulWithWork left right).1 = OAI.EditApproximation.bitWordValue left * OAI.EditApproximation.bitWordValue right := by    induction left with    | nil => simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue]    | cons bit bits ih =>      cases bit <;> simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue, proof_bitAddWithWork_value_2, ih] <;> ring  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_bitOrdering_matches_4 (high : Ordering) (a : Bool) (b : Bool) (x : ℕ) (y : ℕ) (h : OAI.EditApproximation.orderingMatches high x y) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitOrdering high a b) (a.toNat + 2 * x) (b.toNat + 2 * y) := by    rcases h with ⟨rfl, h⟩ | ⟨rfl, rfl⟩ | ⟨rfl, h⟩    · exact Or.inl ⟨rfl, by cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩    · cases a <;> cases b <;> simp [OAI.EditApproximation.bitOrdering, OAI.EditApproximation.orderingMatches]    · exact Or.inr (Or.inr ⟨rfl, by        cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩)  have proof_bitCompareWithWork_matches_5 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitCompareWithWork left right).1 (OAI.EditApproximation.bitWordValue left) (OAI.EditApproximation.bitWordValue right) := by    induction left generalizing right with    | nil =>      simp only [OAI.EditApproximation.bitCompareWithWork]      induction right with      | nil => (simp [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.orderingMatches, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        simpa only [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareNilLeftWithWork bs).1 false b 0 (OAI.EditApproximation.bitWordValue bs) ih    | cons a as ih =>      cases right with      | nil =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as []).1 a false (OAI.EditApproximation.bitWordValue as) 0 (ih [])      | cons b bs =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue] using          proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as bs).1 a b (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs) (ih bs)  have proof_bitCompareWithWork_lt_16 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .lt ↔ OAI.EditApproximation.bitWordValue left < OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_bitSubtractor_value_17 (a : Bool) (b : Bool) (borrow : Bool) :      a.toNat + 2 * (OAI.EditApproximation.bitBorrow a b borrow).toNat =        b.toNat + borrow.toNat + (OAI.EditApproximation.bitDifference a b borrow).toNat := by    cases a <;> cases b <;> cases borrow <;> decide  have proof_bitSubtractionRippleEquation_18 (a : ℕ) (b : ℕ) (borrow : ℕ) (nextBorrow : ℕ) (difference : ℕ) (left : ℕ) (right : ℕ) (result : ℕ) (tail : ℕ) (htail : Eq.{1} (HAdd.hAdd.{0, 0, 0} (HAdd.hAdd.{0, 0, 0} result right) nextBorrow) (HAdd.hAdd.{0, 0, 0} left tail)) (hbit : Eq.{1} (HAdd.hAdd.{0, 0, 0} a (HMul.hMul.{0, 0, 0} 2 nextBorrow))    (HAdd.hAdd.{0, 0, 0} (HAdd.hAdd.{0, 0, 0} b borrow) difference)) :      (difference + 2 * result) + (b + 2 * right) + borrow =        (a + 2 * left) + 2 * tail := by    omega  have proof_bitSubtractWithWork_value_19 (left : List.{0} Bool) (right : List.{0} Bool) (borrow : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork left right borrow).1 + OAI.EditApproximation.bitWordValue right + borrow.toNat =        OAI.EditApproximation.bitWordValue left + 2 ^ max left.length right.length *          (OAI.EditApproximation.bitSubtractWithWork left right borrow).2.1.toNat := by    induction left generalizing right borrow with    | nil =>      induction right generalizing borrow with      | nil => (simp [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitSubtractNilLeftWithWork, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        have h := ih (OAI.EditApproximation.bitBorrow false b borrow)        have hb := proof_bitSubtractor_value_17 false b borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitSubtractNilLeftWithWork, OAI.EditApproximation.bitWordValue,          List.length_nil, List.length_cons, Nat.zero_max, pow_succ, Bool.toNat_false] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 0 b.toNat borrow.toNat (OAI.EditApproximation.bitBorrow false b borrow).toNat          (OAI.EditApproximation.bitDifference false b borrow).toNat 0 (OAI.EditApproximation.bitWordValue bs)          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractNilLeftWithWork bs (OAI.EditApproximation.bitBorrow false b borrow)).1)          (2 ^ bs.length * (OAI.EditApproximation.bitSubtractNilLeftWithWork bs (OAI.EditApproximation.bitBorrow false b borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_zero, Nat.add_zero, Nat.zero_add, Nat.mul_assoc,          Nat.mul_left_comm] using hs    | cons a as ih =>      cases right with      | nil =>        have h := ih [] (OAI.EditApproximation.bitBorrow a false borrow)        have hb := proof_bitSubtractor_value_17 a false borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitWordValue, List.length_nil, List.length_cons,          Nat.max_zero, pow_succ, Bool.toNat_false] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 a.toNat 0 borrow.toNat (OAI.EditApproximation.bitBorrow a false borrow).toNat          (OAI.EditApproximation.bitDifference a false borrow).toNat (OAI.EditApproximation.bitWordValue as) 0          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork as [] (OAI.EditApproximation.bitBorrow a false borrow)).1)          (2 ^ as.length * (OAI.EditApproximation.bitSubtractWithWork as [] (OAI.EditApproximation.bitBorrow a false borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_zero, Nat.add_zero, Nat.zero_add, Nat.mul_assoc,          Nat.mul_left_comm] using hs      | cons b bs =>        have h := ih bs (OAI.EditApproximation.bitBorrow a b borrow)        have hb := proof_bitSubtractor_value_17 a b borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitWordValue, List.length_cons, Nat.succ_max_succ,          pow_succ] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 a.toNat b.toNat borrow.toNat (OAI.EditApproximation.bitBorrow a b borrow).toNat          (OAI.EditApproximation.bitDifference a b borrow).toNat (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs)          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork as bs (OAI.EditApproximation.bitBorrow a b borrow)).1)          (2 ^ max as.length bs.length * (OAI.EditApproximation.bitSubtractWithWork as bs (OAI.EditApproximation.bitBorrow a b borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_assoc, Nat.mul_left_comm] using hs  have proof_bitWordValue_lt_pow_length_20 (bits : List.{0} Bool) : OAI.EditApproximation.bitWordValue bits < 2 ^ bits.length := by    induction bits with    | nil => (simp [OAI.EditApproximation.bitWordValue])    | cons bit bits ih =>      cases bit <;> (simp only [OAI.EditApproximation.bitWordValue, List.length_cons, pow_succ, Bool.toNat_false, Bool.toNat_true]) <;> omega  have proof_bitSubtractWithWork_length_21 (left : List.{0} Bool) (right : List.{0} Bool) (borrow : Bool) :      (OAI.EditApproximation.bitSubtractWithWork left right borrow).1.length = max left.length right.length := by    induction left generalizing right borrow with    | nil =>      simp only [OAI.EditApproximation.bitSubtractWithWork]      induction right generalizing borrow with      | nil => simp [OAI.EditApproximation.bitSubtractNilLeftWithWork]      | cons b bs ih => simp [OAI.EditApproximation.bitSubtractNilLeftWithWork, ih]    | cons a as ih =>      cases right with      | nil => simp [OAI.EditApproximation.bitSubtractWithWork, ih]      | cons b bs => simp [OAI.EditApproximation.bitSubtractWithWork, ih, Nat.succ_max_succ]  have proof_bitSubtractWithWork_sub_22 (left : List.{0} Bool) (right : List.{0} Bool) (h : LE.le.{0} (OAI.EditApproximation.bitWordValue right) (OAI.EditApproximation.bitWordValue left)) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork left right false).1 = OAI.EditApproximation.bitWordValue left - OAI.EditApproximation.bitWordValue right := by    have hvalue := proof_bitSubtractWithWork_value_19 left right false    have hlt := proof_bitWordValue_lt_pow_length_20 (OAI.EditApproximation.bitSubtractWithWork left right false).1    rw [proof_bitSubtractWithWork_length_21] at hlt    cases hb : (OAI.EditApproximation.bitSubtractWithWork left right false).2.1    · simp only [hb, Bool.toNat_false, Nat.mul_zero, Nat.add_zero] at hvalue      omega    · simp only [hb, Bool.toNat_true, Bool.toNat_false, Nat.mul_one, Nat.add_zero] at hvalue      omega  have proof_bitDivModWithWork_value_23 (divisor : List.{0} Bool) (bits : List.{0} Bool) (hd : LT.lt.{0} 0 (OAI.EditApproximation.bitWordValue divisor)) :      OAI.EditApproximation.bitWordValue bits = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).1 +        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 ∧        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 < OAI.EditApproximation.bitWordValue divisor := by    induction bits with    | nil => (simp [OAI.EditApproximation.bitDivModWithWork, OAI.EditApproximation.bitWordValue, hd])    | cons bit bits ih =>      let previous := OAI.EditApproximation.bitDivModWithWork divisor bits      let candidate := bit :: previous.2.1      have hp : OAI.EditApproximation.bitWordValue bits = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue previous.1 +          OAI.EditApproximation.bitWordValue previous.2.1 := ih.1      have hr : OAI.EditApproximation.bitWordValue previous.2.1 < OAI.EditApproximation.bitWordValue divisor := ih.2      have hc : OAI.EditApproximation.bitWordValue candidate < 2 * OAI.EditApproximation.bitWordValue divisor := by        dsimp only [candidate, OAI.EditApproximation.bitWordValue]        cases bit <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega      by_cases hlt : (OAI.EditApproximation.bitCompareWithWork candidate divisor).1 = .lt      · have hv := (proof_bitCompareWithWork_lt_16 candidate divisor).1 hlt        simp only [OAI.EditApproximation.bitDivModWithWork, show (OAI.EditApproximation.bitCompareWithWork (bit :: (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1)          divisor).1 = .lt from hlt, ↓reduceIte]        change OAI.EditApproximation.bitWordValue (bit :: bits) = OAI.EditApproximation.bitWordValue divisor *          OAI.EditApproximation.bitWordValue (false :: previous.1) + OAI.EditApproximation.bitWordValue candidate ∧ OAI.EditApproximation.bitWordValue candidate < _        constructor        · (simp only [OAI.EditApproximation.bitWordValue, Bool.toNat_false])          dsimp only [candidate, OAI.EditApproximation.bitWordValue]          nlinarith only [hp]        · exact hv      · have hv : OAI.EditApproximation.bitWordValue divisor ≤ OAI.EditApproximation.bitWordValue candidate := by          exact Nat.le_of_not_gt (fun h => hlt ((proof_bitCompareWithWork_lt_16 candidate divisor).2 h))        have hs := proof_bitSubtractWithWork_sub_22 candidate divisor hv        simp only [OAI.EditApproximation.bitDivModWithWork, show (OAI.EditApproximation.bitCompareWithWork (bit :: (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1)          divisor).1 ≠ .lt from hlt, ↓reduceIte]        change OAI.EditApproximation.bitWordValue (bit :: bits) = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue (true :: previous.1) +          OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork candidate divisor false).1 ∧          OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork candidate divisor false).1 < _        rw [hs]        constructor        · (simp only [OAI.EditApproximation.bitWordValue, Bool.toNat_true])          have he := Nat.sub_add_cancel hv          dsimp only [candidate, OAI.EditApproximation.bitWordValue] at he ⊢          nlinarith only [hp, he]        · omega  have proof_binaryNaturalDivModWithWork_spec_24 (n : ℕ) (d : ℕ) (hd : LT.lt.{0} 0 d) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalDivModWithWork n d).1 = n / d ∧        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalDivModWithWork n d).2.1 = n % d := by    have h := proof_bitDivModWithWork_value_23 d.bits n.bits (by simpa only [proof_bitWordValue_bits_15] using hd)    simp only [proof_bitWordValue_bits_15] at h    have hmod : n % d = OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork d.bits n.bits).2.1 := by      conv_lhs => rw [h.1]      simp only [Nat.add_mod, Nat.mul_mod_right, Nat.zero_add, Nat.mod_eq_of_lt h.2]    have hdiv : n / d = OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork d.bits n.bits).1 := by      conv_lhs => rw [h.1]      rw [Nat.mul_add_div hd, Nat.div_eq_of_lt h.2, Nat.add_zero]    exact ⟨hdiv.symm, hmod.symm⟩  have proof_binaryGridRoundWithWork_value_25 (spacing : ℕ) (position : ℕ) (hspacing : LT.lt.{0} 0 spacing) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryGridRoundWithWork spacing position).1 = OAI.EditApproximation.gridRound spacing position := by    simp only [OAI.EditApproximation.binaryGridRoundWithWork, proof_bitMulWithWork_value_0, proof_bitWordValue_bits_15,      (proof_binaryNaturalDivModWithWork_spec_24 position spacing hspacing).1, OAI.EditApproximation.gridRound]  have proof_binaryIntervalRoundWithWork_value_14 {n : ℕ} (spacing : ℕ) (hspacing : LT.lt.{0} 0 spacing) (q : OAI.EditApproximation.TargetInterval n) :      (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryIntervalRoundWithWork spacing q.lo q.hi).1.1,        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryIntervalRoundWithWork spacing q.lo q.hi).1.2) =        ((OAI.EditApproximation.roundInterval spacing q).lo, (OAI.EditApproximation.roundInterval spacing q).hi) := by    simp only [OAI.EditApproximation.binaryIntervalRoundWithWork, proof_binaryGridRoundWithWork_value_25 _ _ hspacing,      OAI.EditApproximation.roundInterval]  exact    let output := OAI.EditApproximation.binaryIntervalRoundWithWork spacing q.lo q.hi    let heq := proof_binaryIntervalRoundWithWork_value_14 spacing hspacing q    (⟨OAI.EditApproximation.bitWordValue output.1.1, OAI.EditApproximation.bitWordValue output.1.2,      by exact (congrArg Prod.fst heq).le.trans ((OAI.EditApproximation.roundInterval spacing q).ordered.trans        (congrArg Prod.snd heq).symm.le),      by exact (congrArg Prod.snd heq).le.trans (OAI.EditApproximation.roundInterval spacing q).valid⟩, output.2 + 1)def actionEqualWithWork {n M : ℕ} (a b : Fin M → OAI.EditApproximation.TargetInterval n) : Bool × ℕ :=  OAI.EditApproximation.allWithWork (fun i =>    let left := OAI.EditApproximation.naturalEqualWithWork (a i).lo (b i).lo    let right := OAI.EditApproximation.naturalEqualWithWork (a i).hi (b i).hi    (left.1 && right.1, left.2 + right.2 + 1)) (List.finRange M)def localRefinementRepresentatives {n : ℕ} (N P F : ℕ) (a : ℚ)    (initial : OAI.EditApproximation.TargetInterval n → ℚ) (q : OAI.EditApproximation.TargetInterval n) : List (ℕ × OAI.EditApproximation.TargetInterval n) :=  ((OAI.EditApproximation.dyadicScales N).filter fun (b : ℕ) => decide    (initial q / (16 * F) ≤ b ∧ (b : ℚ) ≤ 8 * a * initial q)).flatMap fun b =>      ((OAI.EditApproximation.localTargetStates n (OAI.EditApproximation.seedGridSpacing b P) ⌈initial q⌉₊ q).filter fun r => decide        ((b : ℚ) / (4 * a) ≤ initial r ∧ initial r ≤ 8 * F * b)).map fun r => (b, r)def sharedBandRationalAction {ny M : ℕ} (center : OAI.EditApproximation.TargetInterval ny)    (states : Fin M → OAI.EditApproximation.TargetInterval ny) : OAI.EditApproximation.PhysicalRationalAction M ny :=  ⟨center, 0, fun i => (i, states i)⟩def localGroupQueryKeys {n : ℕ} (N F exponent : ℕ) (a : ℚ)    (initial : OAI.EditApproximation.TargetInterval n → ℚ) (q : OAI.EditApproximation.TargetInterval n) : List (ℕ × (ℕ × ℕ)) :=  (OAI.EditApproximation.dyadicQueryWindow N (initial q) a F).flatMap fun (b : ℕ) =>    (OAI.EditApproximation.localTargetCells ((2 : ℚ) ^ (-(exponent : ℤ)) * b) ⌈initial q⌉₊ q).map fun cell => (b, cell)def rationalWidePrefixCost {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx)    (r : OAI.EditApproximation.TargetInterval ny) (states : Fin M → OAI.EditApproximation.TargetInterval ny)    (child : Fin M → OAI.EditApproximation.TargetInterval ny → ℚ) (j : ℕ) (p : ℚ) : ℚ :=  OAI.EditApproximation.rationalConnectionBudget r.lo ((List.ofFn states).take j)    ((OAI.EditApproximation.balancedCut parent.lo (parent.hi - parent.lo) M j : ℚ) + p) +      ∑ i, if i.val < j then child i (states i) else 0def bandRoundSpacing {ny M : ℕ} (thetaExponent b : ℕ) (band : List (Fin M → OAI.EditApproximation.TargetInterval ny))    (initial : Fin M → OAI.EditApproximation.TargetInterval ny → ℚ) (i : Fin M) : ℕ :=  2 ^ (OAI.EditApproximation.bandEnvelopeExponent b band initial i - thetaExponent).toNatdef actionMemberWithWork {n M : ℕ} (a : Fin M → OAI.EditApproximation.TargetInterval n) :    List (Fin M → OAI.EditApproximation.TargetInterval n) → Bool × ℕ  | [] => (false, 1)  | b :: rest =>    let test := OAI.EditApproximation.actionEqualWithWork a b    let tail := actionMemberWithWork a rest    (test.1 || tail.1, test.2 + tail.2 + 1)def wideEarlierInputCover {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx) (P history : ℕ)    (representatives : List (ℕ × OAI.EditApproximation.TargetInterval ny)) : Finset (Fin M × ℕ × OAI.EditApproximation.TargetInterval ny) :=  representatives.toFinset.biUnion fun br =>    Finset.univ.biUnion fun i : Fin M =>      (Finset.range history).biUnion fun t =>        ((OAI.EditApproximation.wideChildStateList parent br.2 br.1 P i).toFinset).image fun r => (i, t, r)def queryEarlierRepresentatives {n : ℕ} (N P F exponent : ℕ) (a : ℚ)    (initial : OAI.EditApproximation.TargetInterval n → ℚ) (q : OAI.EditApproximation.TargetInterval n) : List (ℕ × OAI.EditApproximation.TargetInterval n) :=  OAI.EditApproximation.localRefinementRepresentatives N P F a initial q ++  (OAI.EditApproximation.localGroupQueryKeys N F exponent a initial q).flatMap (fun key =>    (OAI.EditApproximation.cellRepresentativeStates n P F key.1 a initial ((2 : ℚ) ^ (-(exponent : ℤ))) key.2).map      fun r => (key.1, r)) ++  (OAI.EditApproximation.dyadicQueryWindow N (initial q) a F).map    fun b => (b, OAI.EditApproximation.roundInterval (OAI.EditApproximation.seedGridSpacing b P) q)def rationalWidePrefixMinimum {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx)    (r : OAI.EditApproximation.TargetInterval ny) (actions : List (Fin M → OAI.EditApproximation.TargetInterval ny)) (hnonempty : actions ≠ [])    (child : Fin M → OAI.EditApproximation.TargetInterval ny → ℚ) (j : ℕ) (p : ℚ) : ℚ :=  OAI.EditApproximation.rationalMinimum (OAI.EditApproximation.rationalWidePrefixCost parent r (actions.head hnonempty) child j p)    (actions.map fun action => OAI.EditApproximation.rationalWidePrefixCost parent r action child j p)def roundedBandAction {ny M : ℕ} (thetaExponent b : ℕ)    (band : List (Fin M → OAI.EditApproximation.TargetInterval ny))    (initial : Fin M → OAI.EditApproximation.TargetInterval ny → ℚ) (action : Fin M → OAI.EditApproximation.TargetInterval ny) :    Fin M → OAI.EditApproximation.TargetInterval ny :=  fun i => OAI.EditApproximation.roundInterval (OAI.EditApproximation.bandRoundSpacing thetaExponent b band initial i) (action i)def queryEarlierInputCover {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx)    (N P F exponent history : ℕ) (a : ℚ)    (initial : OAI.EditApproximation.TargetInterval ny → ℚ) (q : OAI.EditApproximation.TargetInterval ny) :    Finset (Fin M × ℕ × OAI.EditApproximation.TargetInterval ny) :=  OAI.EditApproximation.wideEarlierInputCover parent P history (OAI.EditApproximation.queryEarlierRepresentatives N P F exponent a initial q)def canonicalRoundedBandAction {ny M : ℕ} (thetaExponent b : ℕ)    (band : List (Fin M → OAI.EditApproximation.TargetInterval ny)) (hnonempty : band ≠ [])    (initial : Fin M → OAI.EditApproximation.TargetInterval ny → ℚ) : Fin M → OAI.EditApproximation.TargetInterval ny :=  OAI.EditApproximation.roundedBandAction thetaExponent b band initial (band.head hnonempty)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen Filterdef parameterClogWithWork (n : ℕ) : ℕ × ℕ :=  let result := OAI.EditApproximation.inputBitLengthWithWork (n - 1)  (result.1, result.2 + 2)def parameterLogWithWork (n : ℕ) : ℕ × ℕ :=  let result := OAI.EditApproximation.inputBitLengthWithWork n  (result.1 - 1, result.2 + 1)def parameterRootSearch (n : ℕ) : ℕ → ℕ × ℕ  | 0 => (0, 1)  | k + 1 => if (k + 1) * (k + 1) ≤ n then (k + 1, 3) else      let result := parameterRootSearch n k      (result.1, result.2 + 3)def parameterPowerWithWork (a : ℕ) : ℕ → ℕ × ℕ  | 0 => (1, 1)  | k + 1 => let result := parameterPowerWithWork a k      (result.1 * a, result.2 + 2)def physicalCoarseInputStorage {M J : ℕ} (source target : List ℕ)    (entry : OAI.EditApproximation.PhysicalEntry M J target.length) : ℕ :=  let interval := OAI.EditApproximation.physicalSourceInterval source.length entry.1  OAI.EditApproximation.coarsePreparedInputStorage source target interval.lo interval.hi entry.2.lo entry.2.hidef computedQueryPassWithWork (N pass : ℕ) : (OAI.EditApproximation.BinaryFraction × OAI.EditApproximation.RefinementParameterWords) × ℕ := by  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  exact    let seed := OAI.EditApproximation.scheduledSeedWordWithWork N pass    let parameters := OAI.EditApproximation.refinementParameterWordsWithWork N pass (OAI.EditApproximation.inputSmallLog N).bits      (by rw [proof_bitWordValue_bits_15]; exact Nat.two_pow_pos _)    ((seed.1, parameters.1), seed.2 + parameters.2 + 2)def storedIntegerBits (values : List ℤ) : ℕ :=  1 + (values.map fun z => Nat.size z.natAbs + 2).sumdef parameterSqrtWithWork (n : ℕ) : ℕ × ℕ := OAI.EditApproximation.parameterRootSearch n ndef computedQuerySetupWithWork (N : ℕ) :=  let parameters := OAI.EditApproximation.vectorMapWithWork (OAI.EditApproximation.computedSeedPassCount N + 1)    (fun i => OAI.EditApproximation.computedQueryPassWithWork N i.val)  let base := OAI.EditApproximation.refinementBaseWithWork (OAI.EditApproximation.inputSmallLog N).bits  ((parameters.1, base.1), parameters.2 + base.2 + 5)def integerParametersWithWork (N : ℕ) : OAI.EditApproximation.IntegerParameters × ℕ :=  let first := OAI.EditApproximation.parameterClogWithWork (N + 2)  let heightExponent := OAI.EditApproximation.parameterClogWithWork first.1  let height := OAI.EditApproximation.parameterPowerWithWork 2 heightExponent.1  let smallExponent := OAI.EditApproximation.parameterClogWithWork (max 1 heightExponent.1)  let small := OAI.EditApproximation.parameterPowerWithWork 2 smallExponent.1  let logarithm := OAI.EditApproximation.parameterLogWithWork small.1  let firstRoot := OAI.EditApproximation.parameterSqrtWithWork logarithm.1  let secondRoot := OAI.EditApproximation.parameterSqrtWithWork firstRoot.1  let branching := OAI.EditApproximation.parameterPowerWithWork 2 (heightExponent.1 / 20)  let coarseBranching := OAI.EditApproximation.parameterPowerWithWork height.1 secondRoot.1  let factor := OAI.EditApproximation.parameterPowerWithWork height.1 (secondRoot.1 + 4)  let grid := OAI.EditApproximation.parameterPowerWithWork height.1 (secondRoot.1 + 20)  let rounds := OAI.EditApproximation.parameterPowerWithWork 2 ((3 * heightExponent.1 + 3) / 4)  let spacingDenominator := OAI.EditApproximation.parameterPowerWithWork small.1 2  ({ H := height.1, ell := small.1, p := secondRoot.1, B := coarseBranching.1,     initialFactor := factor.1, M := branching.1, P := grid.1,     T := rounds.1, S := height.1 / spacingDenominator.1 },   first.2 + heightExponent.2 + height.2 + smallExponent.2 + small.2 + logarithm.2 +     firstRoot.2 + secondRoot.2 + branching.2 + coarseBranching.2 + factor.2 + grid.2 +     rounds.2 + spacingDenominator.2 + 15)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationstructure PhysicalTableRequest (M J ny : ℕ) where  pass : ℕ  copy : ℕ  node : OAI.EditApproximation.PhysicalNode M J  index : ℕ  state : OAI.EditApproximation.TargetInterval nyderiving DecidableEqdef rawRefinementCenters {n : ℕ} (N P F : ℕ) (a value : ℚ) (q : OAI.EditApproximation.TargetInterval n) :    List (OAI.EditApproximation.TargetInterval n) :=  ((OAI.EditApproximation.dyadicQueryWindow N value a F).flatMap fun b =>    OAI.EditApproximation.localTargetStates n (OAI.EditApproximation.seedGridSpacing b P) ⌈value⌉₊ q).eraseDupsdef wideWarmupInputs {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx) (P : ℕ)    (representatives : List (ℕ × OAI.EditApproximation.TargetInterval ny)) : List (Fin M × OAI.EditApproximation.TargetInterval ny) :=  (representatives.flatMap fun br => (List.finRange M).flatMap fun i =>    (OAI.EditApproximation.wideChildStateList parent br.2 br.1 P i).map fun r => (i, r)).eraseDupsdef queryMeanRead {ι : Type u_1} (count : ℕ) (reader : Fin count → OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction) :    OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction :=  .charge (count + 1) (OAI.EditApproximation.BitQuery.collect reader (List.ofFn fun i : Fin count => i)    (fun words => OAI.EditApproximation.BitQuery.compute (OAI.EditApproximation.BinaryFraction.queryMeanWithWork count words)))def physicalNodeCodeWithWork {M J : ℕ} (node : OAI.EditApproximation.PhysicalNode M J) : ℕ × ℕ :=  let path := OAI.EditApproximation.treeLayerCodeWithWork M node.1.val node.2  let power := OAI.EditApproximation.parameterPowerWithWork M J  (path.1 + power.1 * node.1.val, path.2 + power.2 + 3)def rationalParametersWithWork (ell : ℕ) : OAI.EditApproximation.RationalParameters × ℕ :=  let fourth := OAI.EditApproximation.parameterPowerWithWork ell 4  let fifth := OAI.EditApproximation.parameterPowerWithWork ell 5  let tenth := OAI.EditApproximation.parameterPowerWithWork ell 10  let twentieth := OAI.EditApproximation.parameterPowerWithWork ell 20  let fortieth := OAI.EditApproximation.parameterPowerWithWork ell 40  ({ F := ell, initialSlope := 32 * ell, coneSlope := 128 * ell,     delta := 1 / (tenth.1 : ℚ), kappa := 1 / (fourth.1 : ℚ), tau := 1 / (fourth.1 : ℚ),     theta := 1 / (fortieth.1 : ℚ), gamma := 1 / (twentieth.1 : ℚ), eta := fifth.1 },   fourth.2 + fifth.2 + tenth.2 + twentieth.2 + fortieth.2 + 20)def onlineMassWithWork (M P H : ℕ) : ℕ × ℕ :=  let width := 40 * P + 2  let square := OAI.EditApproximation.parameterPowerWithWork width 2  let dimension := H + M * square.1 + 2  let rounds := OAI.EditApproximation.parameterPowerWithWork dimension 80  (rounds.1 * (rounds.1 + 1) / 2, square.2 + rounds.2 + 9)def refinementInitialSupport {n : ℕ} (N P F exponent : ℕ) (a value : ℚ)    (q : OAI.EditApproximation.TargetInterval n) : List (OAI.EditApproximation.TargetInterval n) :=  q :: (OAI.EditApproximation.rawRefinementCenters N P F a value q ++    (OAI.EditApproximation.localGroupQueryKeys N F exponent a (fun _ => value) q).flatMap (fun key =>      OAI.EditApproximation.cellTargetStates n (OAI.EditApproximation.seedGridSpacing key.1 P)        ((2 : ℚ) ^ (-(exponent : ℤ)) * key.1) key.2) ++    (OAI.EditApproximation.dyadicQueryWindow N value a F).map (fun b => OAI.EditApproximation.roundInterval (OAI.EditApproximation.seedGridSpacing b P) q))def refinementBandInputList {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx)    (N P F exponent : ℕ) (a : ℚ) (initial : OAI.EditApproximation.TargetInterval ny → ℚ) (q : OAI.EditApproximation.TargetInterval ny) :    List (Fin M × OAI.EditApproximation.TargetInterval ny) :=  OAI.EditApproximation.wideWarmupInputs parent P (OAI.EditApproximation.queryEarlierRepresentatives N P F exponent a initial q)def previousPassRequest {M J ny : ℕ} (T S copy : ℕ)    (parent : OAI.EditApproximation.PhysicalTableRequest M J ny) (state : OAI.EditApproximation.TargetInterval ny) : OAI.EditApproximation.PhysicalTableRequest M J ny :=  ⟨parent.pass - 1, copy, parent.node, T + S, state⟩def physicalEntryCodeWithWork {M J n : ℕ} (entry : OAI.EditApproximation.PhysicalEntry M J n) : ℕ × ℕ :=  let node := OAI.EditApproximation.physicalNodeCodeWithWork entry.1  let width := n + 1  (entry.2.lo + width * entry.2.hi + width * width * node.1, node.2 + 8)def queryPhysicalBoundedWithWork {M J n : ℕ} (passes copies T S : ℕ)    (request : OAI.EditApproximation.PhysicalTableRequest M J n) : Bool × ℕ :=  let pass := OAI.EditApproximation.binaryNaturalCompareWithWork request.pass passes  let copy := OAI.EditApproximation.binaryNaturalCompareWithWork request.copy copies  let cap := OAI.EditApproximation.binaryNaturalAddWithWork T S  let index := OAI.EditApproximation.wordLEWithWork request.index.bits cap.1  (decide (pass.1 = .lt) && decide (copy.1 = .lt) && index.1,    pass.2 + copy.2 + cap.2 + index.2 + 4)def globalParameterWork (N : ℕ) : ℕ :=  (OAI.EditApproximation.integerParametersWithWork N).2 + (OAI.EditApproximation.rationalParametersWithWork (OAI.EditApproximation.inputSmallLog N)).2 +    (OAI.EditApproximation.onlineMassWithWork (OAI.EditApproximation.integerParameters N).M (OAI.EditApproximation.integerParameters N).P (OAI.EditApproximation.inputHeight N)).2def physicalLargeInputWithWork (N : ℕ) (epsilon : OAI.EditApproximation.BinaryFraction) : Bool × ℕ :=  let inspected := OAI.EditApproximation.inspectAccuracyWithWork (OAI.EditApproximation.inputHeight N) epsilon  if inspected.1.isSome = true then    let product := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat (OAI.EditApproximation.inputSmallLog N)) epsilon    let accuracy := OAI.EditApproximation.BinaryFraction.ltWithWork product.1 (OAI.EditApproximation.BinaryFraction.nat 10)    let threshold := OAI.EditApproximation.binaryNaturalCompareWithWork (OAI.EditApproximation.inputSmallLog N) (2 ^ 1000)    let mass := OAI.EditApproximation.onlineMassWithWork (OAI.EditApproximation.integerParameters N).M (OAI.EditApproximation.integerParameters N).P (OAI.EditApproximation.inputHeight N)    let width := OAI.EditApproximation.inputBitLengthWithWork mass.1    let capacity := OAI.EditApproximation.binaryNaturalCompareWithWork (OAI.EditApproximation.inputHeight N) width.1    (decide (threshold.1 ≠ .lt ∧ accuracy.1 ≠ true ∧ capacity.1 ≠ .lt),      inspected.2 + product.2 + accuracy.2 + threshold.2 + mass.2 + width.2 + capacity.2 + 10)  else (false, inspected.2 + 1)def physicalTableCodeAllocation {M J n : ℕ} (request : OAI.EditApproximation.PhysicalTableRequest M J n) : ℕ :=  2 * request.node.1.val + 2 * J + 20def queryPhysicalBoundedAllocation {M J n : ℕ} (passes copies T S : ℕ)    (request : OAI.EditApproximation.PhysicalTableRequest M J n) : ℕ :=  request.pass.bits.length + passes.bits.length + request.copy.bits.length + copies.bits.length +    OAI.EditApproximation.binaryNaturalAddAllocation T S + OAI.EditApproximation.naturalWordLEAllocation request.index.bits (OAI.EditApproximation.binaryNaturalAddWithWork T S).1def physicalTableCodeWithWork {M J n : ℕ} (copies T S : ℕ)    (request : OAI.EditApproximation.PhysicalTableRequest M J n) : ℕ × ℕ :=  let entry := OAI.EditApproximation.physicalEntryCodeWithWork (request.node, request.state)  let power := OAI.EditApproximation.parameterPowerWithWork M J  let capacity := (n + 1) * (n + 1) * (power.1 * (J + 1))  (request.index + (T + S + 1) * (request.copy + copies * (entry.1 + capacity * request.pass)),    entry.2 + power.2 + 15)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.PhysicalTableRequestvariable {M J ny : ℕ}def remainingDepth (request : OAI.EditApproximation.PhysicalTableRequest M J ny) : ℕ :=  J - request.node.1.valdef rank (T S : ℕ) (request : OAI.EditApproximation.PhysicalTableRequest M J ny) : ℕ :=  request.pass * (T + S + 1) + request.indexdef Bounded (passes copies T S : ℕ) (request : OAI.EditApproximation.PhysicalTableRequest M J ny) : Prop :=  request.pass < passes ∧ request.copy < copies ∧ request.index ≤ T + Sdef warmup (pass copy : ℕ) (node : OAI.EditApproximation.PhysicalNode M J) (j : ℕ) (state : OAI.EditApproximation.TargetInterval ny) :    OAI.EditApproximation.PhysicalTableRequest M J ny :=  ⟨pass, copy, node, j, state⟩def refinement (pass copy : ℕ) (node : OAI.EditApproximation.PhysicalNode M J) (T t : ℕ) (state : OAI.EditApproximation.TargetInterval ny) :    OAI.EditApproximation.PhysicalTableRequest M J ny :=  ⟨pass, copy, node, T + t, state⟩def sameIndexChild (request : OAI.EditApproximation.PhysicalTableRequest M J ny)    (hbelow : request.node.1.val < J) (i : Fin M) (state : OAI.EditApproximation.TargetInterval ny) :    OAI.EditApproximation.PhysicalTableRequest M J ny :=  { request with node := OAI.EditApproximation.physicalChild request.node hbelow i, state := state }def combinedRank (T S : ℕ) (request : OAI.EditApproximation.PhysicalTableRequest M J ny) : ℕ :=  request.remainingDepth + request.rank T Send OAI.EditApproximation.PhysicalTableRequestendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationdef physicalWarmupChildQuery {M J ny : ℕ} (pass copy T S t : ℕ)    (node : OAI.EditApproximation.PhysicalNode M J) (hbelow : node.1.val < J) (q : OAI.EditApproximation.TargetInterval ny)    (input : Fin M × OAI.EditApproximation.TargetInterval ny) :    OAI.EditApproximation.FiniteQuery {child : OAI.EditApproximation.PhysicalTableRequest M J ny //      child.combinedRank T S < (OAI.EditApproximation.PhysicalTableRequest.warmup pass copy node (t + 1) q).combinedRank T S} := by  have proof_combinedRank_lt_of_progress_80 {M : ℕ} {J : ℕ} {ny : ℕ} (T : ℕ) (S : ℕ) (first : OAI.EditApproximation.PhysicalTableRequest M J ny) (second : OAI.EditApproximation.PhysicalTableRequest M J ny) (hprogress : LT.lt.{0} second.remainingDepth first.remainingDepth ∧      LE.le.{0} (OAI.EditApproximation.PhysicalTableRequest.rank T S second)        (OAI.EditApproximation.PhysicalTableRequest.rank T S first) ∨    LE.le.{0} second.remainingDepth first.remainingDepth ∧      LT.lt.{0} (OAI.EditApproximation.PhysicalTableRequest.rank T S second)        (OAI.EditApproximation.PhysicalTableRequest.rank T S first)) :      OAI.EditApproximation.PhysicalTableRequest.combinedRank T S second < OAI.EditApproximation.PhysicalTableRequest.combinedRank T S first := by    unfold OAI.EditApproximation.PhysicalTableRequest.combinedRank    rcases hprogress with h | h    · exact Nat.add_lt_add_of_lt_of_le h.1 h.2    · exact Nat.add_lt_add_of_le_of_lt h.1 h.2  have proof_warmup_previous_child_progress_81 {M : ℕ} {J : ℕ} {ny : ℕ} (pass : ℕ) (copy : ℕ) (T : ℕ) (S : ℕ) (j : ℕ) (node : OAI.EditApproximation.PhysicalNode M J) (hbelow : LT.lt.{0} (↑(Sigma.fst.{0, 0} node)) J) (i : Fin M) (state : OAI.EditApproximation.TargetInterval ny) (previousState : OAI.EditApproximation.TargetInterval ny) (hj : LT.lt.{0} 0 j) :      (OAI.EditApproximation.PhysicalTableRequest.warmup pass copy (OAI.EditApproximation.physicalChild node hbelow i) (j - 1) previousState).remainingDepth <          (OAI.EditApproximation.PhysicalTableRequest.warmup pass copy node j state).remainingDepth ∧        OAI.EditApproximation.PhysicalTableRequest.rank T S (OAI.EditApproximation.PhysicalTableRequest.warmup pass copy (OAI.EditApproximation.physicalChild node hbelow i) (j - 1) previousState) <          OAI.EditApproximation.PhysicalTableRequest.rank T S (OAI.EditApproximation.PhysicalTableRequest.warmup pass copy node j state) := by    constructor    · unfold OAI.EditApproximation.PhysicalTableRequest.remainingDepth OAI.EditApproximation.PhysicalTableRequest.warmup OAI.EditApproximation.physicalChild      dsimp only      omega    · dsimp only [OAI.EditApproximation.PhysicalTableRequest.rank, OAI.EditApproximation.PhysicalTableRequest.warmup]      omega  have proof_combinedRank_warmup_child_79 {M : ℕ} {J : ℕ} {ny : ℕ} (pass : ℕ) (copy : ℕ) (T : ℕ) (S : ℕ) (j : ℕ) (node : OAI.EditApproximation.PhysicalNode M J) (hbelow : LT.lt.{0} (↑(Sigma.fst.{0, 0} node)) J) (i : Fin M) (state : OAI.EditApproximation.TargetInterval ny) (previousState : OAI.EditApproximation.TargetInterval ny) (hj : LT.lt.{0} 0 j) :      OAI.EditApproximation.PhysicalTableRequest.combinedRank T S (OAI.EditApproximation.PhysicalTableRequest.warmup pass copy (OAI.EditApproximation.physicalChild node hbelow i) (j - 1) previousState) <        OAI.EditApproximation.PhysicalTableRequest.combinedRank T S (OAI.EditApproximation.PhysicalTableRequest.warmup pass copy node j state) :=    proof_combinedRank_lt_of_progress_80 T S _ _ (Or.inr      ⟨(proof_warmup_previous_child_progress_81 pass copy T S j node hbelow i state previousState hj).1.le,        (proof_warmup_previous_child_progress_81 pass copy T S j node hbelow i state previousState hj).2⟩)  exact    .read ⟨OAI.EditApproximation.PhysicalTableRequest.warmup pass copy (OAI.EditApproximation.physicalChild node hbelow input.1) t input.2,      by simpa only [Nat.add_sub_cancel] using        proof_combinedRank_warmup_child_79 pass copy T S (t + 1)          node hbelow input.1 q input.2 (Nat.zero_lt_succ t)⟩ .donedef physicalRefinementCurrentQuery {M J ny : ℕ} (pass copy T S t : ℕ)    (node : OAI.EditApproximation.PhysicalNode M J) (hbelow : node.1.val < J) (q : OAI.EditApproximation.TargetInterval ny)    (input : Fin M × OAI.EditApproximation.TargetInterval ny) :    OAI.EditApproximation.FiniteQuery {child : OAI.EditApproximation.PhysicalTableRequest M J ny //      child.combinedRank T S < (OAI.EditApproximation.PhysicalTableRequest.refinement pass copy node T t q).combinedRank T S} := by  have proof_combinedRank_lt_of_progress_80 {M : ℕ} {J : ℕ} {ny : ℕ} (T : ℕ) (S : ℕ) (first : OAI.EditApproximation.PhysicalTableRequest M J ny) (second : OAI.EditApproximation.PhysicalTableRequest M J ny) (hprogress : LT.lt.{0} second.remainingDepth first.remainingDepth ∧      LE.le.{0} (OAI.EditApproximation.PhysicalTableRequest.rank T S second)        (OAI.EditApproximation.PhysicalTableRequest.rank T S first) ∨    LE.le.{0} second.remainingDepth first.remainingDepth ∧      LT.lt.{0} (OAI.EditApproximation.PhysicalTableRequest.rank T S second)        (OAI.EditApproximation.PhysicalTableRequest.rank T S first)) :      OAI.EditApproximation.PhysicalTableRequest.combinedRank T S second < OAI.EditApproximation.PhysicalTableRequest.combinedRank T S first := by    unfold OAI.EditApproximation.PhysicalTableRequest.combinedRank    rcases hprogress with h | h    · exact Nat.add_lt_add_of_lt_of_le h.1 h.2    · exact Nat.add_lt_add_of_le_of_lt h.1 h.2  have proof_sameIndexChild_progress_95 {M : ℕ} {J : ℕ} {ny : ℕ} (T : ℕ) (S : ℕ) (request : OAI.EditApproximation.PhysicalTableRequest M J ny) (hbelow : LT.lt.{0} (↑(Sigma.fst.{0, 0} request.node)) J) (i : Fin M) (state : OAI.EditApproximation.TargetInterval ny) :      (OAI.EditApproximation.PhysicalTableRequest.sameIndexChild request hbelow i state).remainingDepth < request.remainingDepth ∧        OAI.EditApproximation.PhysicalTableRequest.rank T S (OAI.EditApproximation.PhysicalTableRequest.sameIndexChild request hbelow i state) ≤ OAI.EditApproximation.PhysicalTableRequest.rank T S request := by    constructor    · unfold OAI.EditApproximation.PhysicalTableRequest.remainingDepth OAI.EditApproximation.PhysicalTableRequest.sameIndexChild OAI.EditApproximation.physicalChild      dsimp only      omega    · exact le_rfl  have proof_combinedRank_sameIndexChild_94 {M : ℕ} {J : ℕ} {ny : ℕ} (T : ℕ) (S : ℕ) (request : OAI.EditApproximation.PhysicalTableRequest M J ny) (hbelow : LT.lt.{0} (↑(Sigma.fst.{0, 0} request.node)) J) (i : Fin M) (state : OAI.EditApproximation.TargetInterval ny) :      OAI.EditApproximation.PhysicalTableRequest.combinedRank T S (OAI.EditApproximation.PhysicalTableRequest.sameIndexChild request hbelow i state) < OAI.EditApproximation.PhysicalTableRequest.combinedRank T S request :=    proof_combinedRank_lt_of_progress_80 T S request _ (Or.inl (proof_sameIndexChild_progress_95 T S request hbelow i state))  exact    .read ⟨OAI.EditApproximation.PhysicalTableRequest.refinement pass copy (OAI.EditApproximation.physicalChild node hbelow input.1) T t input.2,      proof_combinedRank_sameIndexChild_94 T S        (OAI.EditApproximation.PhysicalTableRequest.refinement pass copy node T t q) hbelow input.1 input.2⟩ .donedef physicalRefinementEarlierQuery {M J ny : ℕ} (pass copy T S t : ℕ)    (node : OAI.EditApproximation.PhysicalNode M J) (hbelow : node.1.val < J) (q : OAI.EditApproximation.TargetInterval ny)    (input : Fin M × ℕ × OAI.EditApproximation.TargetInterval ny) :    OAI.EditApproximation.FiniteQuery {child : OAI.EditApproximation.PhysicalTableRequest M J ny //      child.combinedRank T S < (OAI.EditApproximation.PhysicalTableRequest.refinement pass copy node T t q).combinedRank T S} := by  have proof_combinedRank_lt_of_progress_80 {M : ℕ} {J : ℕ} {ny : ℕ} (T : ℕ) (S : ℕ) (first : OAI.EditApproximation.PhysicalTableRequest M J ny) (second : OAI.EditApproximation.PhysicalTableRequest M J ny) (hprogress : LT.lt.{0} second.remainingDepth first.remainingDepth ∧      LE.le.{0} (OAI.EditApproximation.PhysicalTableRequest.rank T S second)        (OAI.EditApproximation.PhysicalTableRequest.rank T S first) ∨    LE.le.{0} second.remainingDepth first.remainingDepth ∧      LT.lt.{0} (OAI.EditApproximation.PhysicalTableRequest.rank T S second)        (OAI.EditApproximation.PhysicalTableRequest.rank T S first)) :      OAI.EditApproximation.PhysicalTableRequest.combinedRank T S second < OAI.EditApproximation.PhysicalTableRequest.combinedRank T S first := by    unfold OAI.EditApproximation.PhysicalTableRequest.combinedRank    rcases hprogress with h | h    · exact Nat.add_lt_add_of_lt_of_le h.1 h.2    · exact Nat.add_lt_add_of_le_of_lt h.1 h.2  have proof_refinement_history_child_progress_96 {M : ℕ} {J : ℕ} {ny : ℕ} (pass : ℕ) (copy : ℕ) (T : ℕ) (S : ℕ) (t : ℕ) (s : ℕ) (node : OAI.EditApproximation.PhysicalNode M J) (hbelow : LT.lt.{0} (↑(Sigma.fst.{0, 0} node)) J) (i : Fin M) (state : OAI.EditApproximation.TargetInterval ny) (previousState : OAI.EditApproximation.TargetInterval ny) (hs : LT.lt.{0} s t) :      (OAI.EditApproximation.PhysicalTableRequest.refinement pass copy (OAI.EditApproximation.physicalChild node hbelow i) T s previousState).remainingDepth <          (OAI.EditApproximation.PhysicalTableRequest.refinement pass copy node T t state).remainingDepth ∧        OAI.EditApproximation.PhysicalTableRequest.rank T S (OAI.EditApproximation.PhysicalTableRequest.refinement pass copy (OAI.EditApproximation.physicalChild node hbelow i) T s previousState) <          OAI.EditApproximation.PhysicalTableRequest.rank T S (OAI.EditApproximation.PhysicalTableRequest.refinement pass copy node T t state) := by    constructor    · unfold OAI.EditApproximation.PhysicalTableRequest.remainingDepth OAI.EditApproximation.PhysicalTableRequest.refinement OAI.EditApproximation.physicalChild      dsimp only      omega    · dsimp only [OAI.EditApproximation.PhysicalTableRequest.rank, OAI.EditApproximation.PhysicalTableRequest.refinement]      omega  exact    if hs : input.2.1 < t then      .read ⟨OAI.EditApproximation.PhysicalTableRequest.refinement pass copy (OAI.EditApproximation.physicalChild node hbelow input.1) T input.2.1 input.2.2,        proof_combinedRank_lt_of_progress_80 T S _ _ (Or.inr          ⟨(proof_refinement_history_child_progress_96 pass copy T S t input.2.1            node hbelow input.1 q input.2.2 hs).1.le,            (proof_refinement_history_child_progress_96 pass copy T S t input.2.1              node hbelow input.1 q input.2.2 hs).2⟩)⟩ .done    else .done 0def physicalRefinementWarmupRead {M J ny : ℕ} (pass copy T S t : ℕ) (ht : 0 < t)    (node : OAI.EditApproximation.PhysicalNode M J) (q : OAI.EditApproximation.TargetInterval ny)    (otherNode : OAI.EditApproximation.PhysicalNode M J) (hnode : node.1.val ≤ otherNode.1.val)    (j : ℕ) (hj : j ≤ T) (r : OAI.EditApproximation.TargetInterval ny) :    OAI.EditApproximation.FiniteQuery {child : OAI.EditApproximation.PhysicalTableRequest M J ny //      child.combinedRank T S < (OAI.EditApproximation.PhysicalTableRequest.refinement pass copy node T t q).combinedRank T S} := by  have proof_combinedRank_lt_of_progress_80 {M : ℕ} {J : ℕ} {ny : ℕ} (T : ℕ) (S : ℕ) (first : OAI.EditApproximation.PhysicalTableRequest M J ny) (second : OAI.EditApproximation.PhysicalTableRequest M J ny) (hprogress : LT.lt.{0} second.remainingDepth first.remainingDepth ∧      LE.le.{0} (OAI.EditApproximation.PhysicalTableRequest.rank T S second)        (OAI.EditApproximation.PhysicalTableRequest.rank T S first) ∨    LE.le.{0} second.remainingDepth first.remainingDepth ∧      LT.lt.{0} (OAI.EditApproximation.PhysicalTableRequest.rank T S second)        (OAI.EditApproximation.PhysicalTableRequest.rank T S first)) :      OAI.EditApproximation.PhysicalTableRequest.combinedRank T S second < OAI.EditApproximation.PhysicalTableRequest.combinedRank T S first := by    unfold OAI.EditApproximation.PhysicalTableRequest.combinedRank    rcases hprogress with h | h    · exact Nat.add_lt_add_of_lt_of_le h.1 h.2    · exact Nat.add_lt_add_of_le_of_lt h.1 h.2  exact    .read ⟨OAI.EditApproximation.PhysicalTableRequest.warmup pass copy otherNode j r, by      apply proof_combinedRank_lt_of_progress_80 T S _ _      apply Or.inr      constructor      · exact Nat.sub_le_sub_left hnode J      · change pass * (T + S + 1) + j < pass * (T + S + 1) + (T + t)        omega⟩ .donedef previousPassRead {M J ny : ℕ} (T S : ℕ)    (parent : OAI.EditApproximation.PhysicalTableRequest M J ny) (hpass : 0 < parent.pass)    (state : OAI.EditApproximation.TargetInterval ny) (copy : ℕ) :    OAI.EditApproximation.FiniteQuery {child : OAI.EditApproximation.PhysicalTableRequest M J ny //      child.combinedRank T S < parent.combinedRank T S} := by  have proof_combinedRank_lt_of_progress_80 {M : ℕ} {J : ℕ} {ny : ℕ} (T : ℕ) (S : ℕ) (first : OAI.EditApproximation.PhysicalTableRequest M J ny) (second : OAI.EditApproximation.PhysicalTableRequest M J ny) (hprogress : LT.lt.{0} second.remainingDepth first.remainingDepth ∧      LE.le.{0} (OAI.EditApproximation.PhysicalTableRequest.rank T S second)        (OAI.EditApproximation.PhysicalTableRequest.rank T S first) ∨    LE.le.{0} second.remainingDepth first.remainingDepth ∧      LT.lt.{0} (OAI.EditApproximation.PhysicalTableRequest.rank T S second)        (OAI.EditApproximation.PhysicalTableRequest.rank T S first)) :      OAI.EditApproximation.PhysicalTableRequest.combinedRank T S second < OAI.EditApproximation.PhysicalTableRequest.combinedRank T S first := by    unfold OAI.EditApproximation.PhysicalTableRequest.combinedRank    rcases hprogress with h | h    · exact Nat.add_lt_add_of_lt_of_le h.1 h.2    · exact Nat.add_lt_add_of_le_of_lt h.1 h.2  have proof_rank_lt_previous_pass_98 {M : ℕ} {J : ℕ} {ny : ℕ} (T : ℕ) (S : ℕ) (first : OAI.EditApproximation.PhysicalTableRequest M J ny) (second : OAI.EditApproximation.PhysicalTableRequest M J ny) (hpass : LT.lt.{0} second.pass first.pass) (hindex : LE.le.{0} second.index (HAdd.hAdd.{0, 0, 0} T S)) :      OAI.EditApproximation.PhysicalTableRequest.rank T S second < OAI.EditApproximation.PhysicalTableRequest.rank T S first := by    have hblock : second.pass * (T + S + 1) + second.index <        (second.pass + 1) * (T + S + 1) := by      nlinarith only [hindex]    have hnext := Nat.mul_le_mul_right (T + S + 1) (Nat.succ_le_of_lt hpass)    exact hblock.trans_le (hnext.trans (Nat.le_add_right _ _))  have proof_previousPassRequest_progress_97 {M : ℕ} {J : ℕ} {ny : ℕ} (T : ℕ) (S : ℕ) (copy : ℕ) (parent : OAI.EditApproximation.PhysicalTableRequest M J ny) (hpass : LT.lt.{0} 0 parent.pass) (state : OAI.EditApproximation.TargetInterval ny) :      (OAI.EditApproximation.previousPassRequest T S copy parent state).remainingDepth = parent.remainingDepth ∧        (OAI.EditApproximation.previousPassRequest T S copy parent state).rank T S < parent.rank T S := by    refine ⟨rfl, ?_⟩    exact proof_rank_lt_previous_pass_98 T S parent _ (by      change parent.pass - 1 < parent.pass      omega) le_rfl  exact    .read ⟨OAI.EditApproximation.previousPassRequest T S copy parent state,      proof_combinedRank_lt_of_progress_80 T S parent _ (Or.inr        ⟨(proof_previousPassRequest_progress_97 T S copy parent hpass state).1.le,          (proof_previousPassRequest_progress_97 T S copy parent hpass state).2⟩)⟩ .doneabbrev ChargedPhysicalRequest (M J ny passes copies T S : ℕ) :=  Sum (OAI.EditApproximation.PhysicalEntry M J ny)    {request : OAI.EditApproximation.PhysicalTableRequest M J ny // request.Bounded passes copies T S}def chargedPreviousPass {M J ny passes copies T S : ℕ}    (parent : {r : OAI.EditApproximation.PhysicalTableRequest M J ny // r.Bounded passes copies T S})    (state : OAI.EditApproximation.TargetInterval ny) (copy : Fin copies) :    {r : OAI.EditApproximation.PhysicalTableRequest M J ny // r.Bounded passes copies T S} :=  ⟨OAI.EditApproximation.previousPassRequest T S copy.val parent.val state,    Nat.lt_of_le_of_lt (Nat.sub_le _ _) parent.property.1, copy.isLt, le_rfl⟩def queryPhysicalTableRead {M J n : ℕ} (copies T S : ℕ)    (parent : OAI.EditApproximation.PhysicalTableRequest M J n)    (child : {r : OAI.EditApproximation.PhysicalTableRequest M J n // r.combinedRank T S < parent.combinedRank T S}) :    OAI.EditApproximation.BitQuery {r : OAI.EditApproximation.PhysicalTableRequest M J n // r.combinedRank T S < parent.combinedRank T S}      OAI.EditApproximation.BinaryFraction :=  .charge ((OAI.EditApproximation.physicalTableCodeWithWork copies T S child.val).2 + 1) (.read child .done)abbrev ComputedFamilyTableKey (source target : List ℕ) (N : ℕ) :=  OAI.EditApproximation.ChargedPhysicalRequest (OAI.EditApproximation.integerParameters N).M    (OAI.EditApproximation.intervalTreeDepth (OAI.EditApproximation.integerParameters N).M source.length) target.length    (OAI.EditApproximation.computedSeedPassCount N + 1) (OAI.EditApproximation.inputHeight N ^ 2) (OAI.EditApproximation.integerParameters N).T (OAI.EditApproximation.integerParameters N).Sdef chargedPhysicalCodeWithWork {M J n passes copies T S : ℕ} :    OAI.EditApproximation.ChargedPhysicalRequest M J n passes copies T S → ℕ × ℕ  | .inl entry => let result := OAI.EditApproximation.physicalEntryCodeWithWork entry      (2 * result.1, result.2 + 2)  | .inr request => let result := OAI.EditApproximation.physicalTableCodeWithWork copies T S request.val      (2 * result.1 + 1, result.2 + 3)def queryPhysicalWarmupRead {M J n : ℕ} (copies pass copy T S t : ℕ) (ht : 0 < t)    (node : OAI.EditApproximation.PhysicalNode M J) (q : OAI.EditApproximation.TargetInterval n)    (otherNode : OAI.EditApproximation.PhysicalNode M J) (hnode : node.1.val ≤ otherNode.1.val)    (j : ℕ) (hj : j ≤ T) (r : OAI.EditApproximation.TargetInterval n) :    OAI.EditApproximation.BitQuery {child : OAI.EditApproximation.PhysicalTableRequest M J n // child.combinedRank T S <      (OAI.EditApproximation.PhysicalTableRequest.refinement pass copy node T t q).combinedRank T S} OAI.EditApproximation.BinaryFraction := by  have proof_combinedRank_lt_of_progress_80 {M : ℕ} {J : ℕ} {ny : ℕ} (T : ℕ) (S : ℕ) (first : OAI.EditApproximation.PhysicalTableRequest M J ny) (second : OAI.EditApproximation.PhysicalTableRequest M J ny) (hprogress : LT.lt.{0} second.remainingDepth first.remainingDepth ∧      LE.le.{0} (OAI.EditApproximation.PhysicalTableRequest.rank T S second)        (OAI.EditApproximation.PhysicalTableRequest.rank T S first) ∨    LE.le.{0} second.remainingDepth first.remainingDepth ∧      LT.lt.{0} (OAI.EditApproximation.PhysicalTableRequest.rank T S second)        (OAI.EditApproximation.PhysicalTableRequest.rank T S first)) :      OAI.EditApproximation.PhysicalTableRequest.combinedRank T S second < OAI.EditApproximation.PhysicalTableRequest.combinedRank T S first := by    unfold OAI.EditApproximation.PhysicalTableRequest.combinedRank    rcases hprogress with h | h    · exact Nat.add_lt_add_of_lt_of_le h.1 h.2    · exact Nat.add_lt_add_of_le_of_lt h.1 h.2  exact    OAI.EditApproximation.queryPhysicalTableRead copies T S (OAI.EditApproximation.PhysicalTableRequest.refinement pass copy node T t q)      ⟨OAI.EditApproximation.PhysicalTableRequest.warmup pass copy otherNode j r, by        apply proof_combinedRank_lt_of_progress_80 T S _ _        apply Or.inr        constructor        · exact Nat.sub_le_sub_left hnode J        · change pass * (T + S + 1) + j < pass * (T + S + 1) + (T + t)          omega⟩def queryPhysicalCurrentRead {M J n : ℕ} (copies pass copy T S t : ℕ)    (node : OAI.EditApproximation.PhysicalNode M J) (hbelow : node.1.val < J) (q : OAI.EditApproximation.TargetInterval n)    (input : Fin M × OAI.EditApproximation.TargetInterval n) :    OAI.EditApproximation.BitQuery {child : OAI.EditApproximation.PhysicalTableRequest M J n // child.combinedRank T S <      (OAI.EditApproximation.PhysicalTableRequest.refinement pass copy node T t q).combinedRank T S} OAI.EditApproximation.BinaryFraction := by  have proof_combinedRank_lt_of_progress_80 {M : ℕ} {J : ℕ} {ny : ℕ} (T : ℕ) (S : ℕ) (first : OAI.EditApproximation.PhysicalTableRequest M J ny) (second : OAI.EditApproximation.PhysicalTableRequest M J ny) (hprogress : LT.lt.{0} second.remainingDepth first.remainingDepth ∧      LE.le.{0} (OAI.EditApproximation.PhysicalTableRequest.rank T S second)        (OAI.EditApproximation.PhysicalTableRequest.rank T S first) ∨    LE.le.{0} second.remainingDepth first.remainingDepth ∧      LT.lt.{0} (OAI.EditApproximation.PhysicalTableRequest.rank T S second)        (OAI.EditApproximation.PhysicalTableRequest.rank T S first)) :      OAI.EditApproximation.PhysicalTableRequest.combinedRank T S second < OAI.EditApproximation.PhysicalTableRequest.combinedRank T S first := by    unfold OAI.EditApproximation.PhysicalTableRequest.combinedRank    rcases hprogress with h | h    · exact Nat.add_lt_add_of_lt_of_le h.1 h.2    · exact Nat.add_lt_add_of_le_of_lt h.1 h.2  have proof_sameIndexChild_progress_95 {M : ℕ} {J : ℕ} {ny : ℕ} (T : ℕ) (S : ℕ) (request : OAI.EditApproximation.PhysicalTableRequest M J ny) (hbelow : LT.lt.{0} (↑(Sigma.fst.{0, 0} request.node)) J) (i : Fin M) (state : OAI.EditApproximation.TargetInterval ny) :      (OAI.EditApproximation.PhysicalTableRequest.sameIndexChild request hbelow i state).remainingDepth < request.remainingDepth ∧        OAI.EditApproximation.PhysicalTableRequest.rank T S (OAI.EditApproximation.PhysicalTableRequest.sameIndexChild request hbelow i state) ≤ OAI.EditApproximation.PhysicalTableRequest.rank T S request := by    constructor    · unfold OAI.EditApproximation.PhysicalTableRequest.remainingDepth OAI.EditApproximation.PhysicalTableRequest.sameIndexChild OAI.EditApproximation.physicalChild      dsimp only      omega    · exact le_rfl  have proof_combinedRank_sameIndexChild_94 {M : ℕ} {J : ℕ} {ny : ℕ} (T : ℕ) (S : ℕ) (request : OAI.EditApproximation.PhysicalTableRequest M J ny) (hbelow : LT.lt.{0} (↑(Sigma.fst.{0, 0} request.node)) J) (i : Fin M) (state : OAI.EditApproximation.TargetInterval ny) :      OAI.EditApproximation.PhysicalTableRequest.combinedRank T S (OAI.EditApproximation.PhysicalTableRequest.sameIndexChild request hbelow i state) < OAI.EditApproximation.PhysicalTableRequest.combinedRank T S request :=    proof_combinedRank_lt_of_progress_80 T S request _ (Or.inl (proof_sameIndexChild_progress_95 T S request hbelow i state))  exact    OAI.EditApproximation.queryPhysicalTableRead copies T S (OAI.EditApproximation.PhysicalTableRequest.refinement pass copy node T t q)      ⟨OAI.EditApproximation.PhysicalTableRequest.refinement pass copy (OAI.EditApproximation.physicalChild node hbelow input.1) T t input.2,        proof_combinedRank_sameIndexChild_94 T S          (OAI.EditApproximation.PhysicalTableRequest.refinement pass copy node T t q) hbelow input.1 input.2⟩def queryPhysicalEarlierRead {M J n : ℕ} (copies pass copy T S t : ℕ)    (node : OAI.EditApproximation.PhysicalNode M J) (hbelow : node.1.val < J) (q : OAI.EditApproximation.TargetInterval n)    (input : Fin M × ℕ × OAI.EditApproximation.TargetInterval n) :    OAI.EditApproximation.BitQuery {child : OAI.EditApproximation.PhysicalTableRequest M J n // child.combinedRank T S <      (OAI.EditApproximation.PhysicalTableRequest.refinement pass copy node T t q).combinedRank T S} OAI.EditApproximation.BinaryFraction := by  have proof_combinedRank_lt_of_progress_80 {M : ℕ} {J : ℕ} {ny : ℕ} (T : ℕ) (S : ℕ) (first : OAI.EditApproximation.PhysicalTableRequest M J ny) (second : OAI.EditApproximation.PhysicalTableRequest M J ny) (hprogress : LT.lt.{0} second.remainingDepth first.remainingDepth ∧      LE.le.{0} (OAI.EditApproximation.PhysicalTableRequest.rank T S second)        (OAI.EditApproximation.PhysicalTableRequest.rank T S first) ∨    LE.le.{0} second.remainingDepth first.remainingDepth ∧      LT.lt.{0} (OAI.EditApproximation.PhysicalTableRequest.rank T S second)        (OAI.EditApproximation.PhysicalTableRequest.rank T S first)) :      OAI.EditApproximation.PhysicalTableRequest.combinedRank T S second < OAI.EditApproximation.PhysicalTableRequest.combinedRank T S first := by    unfold OAI.EditApproximation.PhysicalTableRequest.combinedRank    rcases hprogress with h | h    · exact Nat.add_lt_add_of_lt_of_le h.1 h.2    · exact Nat.add_lt_add_of_le_of_lt h.1 h.2  have proof_refinement_history_child_progress_96 {M : ℕ} {J : ℕ} {ny : ℕ} (pass : ℕ) (copy : ℕ) (T : ℕ) (S : ℕ) (t : ℕ) (s : ℕ) (node : OAI.EditApproximation.PhysicalNode M J) (hbelow : LT.lt.{0} (↑(Sigma.fst.{0, 0} node)) J) (i : Fin M) (state : OAI.EditApproximation.TargetInterval ny) (previousState : OAI.EditApproximation.TargetInterval ny) (hs : LT.lt.{0} s t) :      (OAI.EditApproximation.PhysicalTableRequest.refinement pass copy (OAI.EditApproximation.physicalChild node hbelow i) T s previousState).remainingDepth <          (OAI.EditApproximation.PhysicalTableRequest.refinement pass copy node T t state).remainingDepth ∧        OAI.EditApproximation.PhysicalTableRequest.rank T S (OAI.EditApproximation.PhysicalTableRequest.refinement pass copy (OAI.EditApproximation.physicalChild node hbelow i) T s previousState) <          OAI.EditApproximation.PhysicalTableRequest.rank T S (OAI.EditApproximation.PhysicalTableRequest.refinement pass copy node T t state) := by    constructor    · unfold OAI.EditApproximation.PhysicalTableRequest.remainingDepth OAI.EditApproximation.PhysicalTableRequest.refinement OAI.EditApproximation.physicalChild      dsimp only      omega    · dsimp only [OAI.EditApproximation.PhysicalTableRequest.rank, OAI.EditApproximation.PhysicalTableRequest.refinement]      omega  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_bitOrdering_matches_4 (high : Ordering) (a : Bool) (b : Bool) (x : ℕ) (y : ℕ) (h : OAI.EditApproximation.orderingMatches high x y) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitOrdering high a b) (a.toNat + 2 * x) (b.toNat + 2 * y) := by    rcases h with ⟨rfl, h⟩ | ⟨rfl, rfl⟩ | ⟨rfl, h⟩    · exact Or.inl ⟨rfl, by cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩    · cases a <;> cases b <;> simp [OAI.EditApproximation.bitOrdering, OAI.EditApproximation.orderingMatches]    · exact Or.inr (Or.inr ⟨rfl, by        cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩)  have proof_bitCompareWithWork_matches_5 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitCompareWithWork left right).1 (OAI.EditApproximation.bitWordValue left) (OAI.EditApproximation.bitWordValue right) := by    induction left generalizing right with    | nil =>      simp only [OAI.EditApproximation.bitCompareWithWork]      induction right with      | nil => (simp [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.orderingMatches, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        simpa only [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareNilLeftWithWork bs).1 false b 0 (OAI.EditApproximation.bitWordValue bs) ih    | cons a as ih =>      cases right with      | nil =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as []).1 a false (OAI.EditApproximation.bitWordValue as) 0 (ih [])      | cons b bs =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue] using          proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as bs).1 a b (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs) (ih bs)  have proof_bitCompareWithWork_lt_16 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .lt ↔ OAI.EditApproximation.bitWordValue left < OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_binaryNaturalCompareWithWork_lt_53 (a : ℕ) (b : ℕ) :      (OAI.EditApproximation.binaryNaturalCompareWithWork a b).1 = .lt ↔ a < b := by    simpa only [OAI.EditApproximation.binaryNaturalCompareWithWork, proof_bitWordValue_bits_15] using proof_bitCompareWithWork_lt_16 a.bits b.bits  exact    .charge ((OAI.EditApproximation.binaryNaturalCompareWithWork input.2.1 t).2 + 1)      (if hs : (OAI.EditApproximation.binaryNaturalCompareWithWork input.2.1 t).1 = .lt then        OAI.EditApproximation.queryPhysicalTableRead copies T S (OAI.EditApproximation.PhysicalTableRequest.refinement pass copy node T t q)          ⟨OAI.EditApproximation.PhysicalTableRequest.refinement pass copy (OAI.EditApproximation.physicalChild node hbelow input.1) T input.2.1 input.2.2,            proof_combinedRank_lt_of_progress_80 T S _ _ (Or.inr              ⟨(proof_refinement_history_child_progress_96 pass copy T S t input.2.1                node hbelow input.1 q input.2.2 ((proof_binaryNaturalCompareWithWork_lt_53 _ _).mp hs)).1.le,                (proof_refinement_history_child_progress_96 pass copy T S t input.2.1                  node hbelow input.1 q input.2.2 ((proof_binaryNaturalCompareWithWork_lt_53 _ _).mp hs)).2⟩)⟩      else .done (OAI.EditApproximation.BinaryFraction.nat 0))def chargedPhysicalRemaining {M J n passes copies T S : ℕ} :    OAI.EditApproximation.ChargedPhysicalRequest M J n passes copies T S → ℕ  | .inl _ => 0  | .inr request => request.val.remainingDepthdef chargedPhysicalCodeAllocation {M J n passes copies T S : ℕ} :    OAI.EditApproximation.ChargedPhysicalRequest M J n passes copies T S → ℕ  | .inl entry => 2 * entry.1.1.val + J + 12  | .inr request => OAI.EditApproximation.physicalTableCodeAllocation request.val + 2def queryPhysicalMassRead {M J n : ℕ} (copies pass copy T S t : ℕ) (ht : 0 < t)    (node : OAI.EditApproximation.PhysicalNode M J) (hbelow : node.1.val < J) (q : OAI.EditApproximation.TargetInterval n)    (input : Fin M × OAI.EditApproximation.TargetInterval n) :    OAI.EditApproximation.BitQuery {child : OAI.EditApproximation.PhysicalTableRequest M J n // child.combinedRank T S <      (OAI.EditApproximation.PhysicalTableRequest.refinement pass copy node T t q).combinedRank T S} OAI.EditApproximation.BinaryFraction :=  OAI.EditApproximation.queryMeanRead T (fun j => OAI.EditApproximation.queryPhysicalWarmupRead copies pass copy T S t ht node q    (OAI.EditApproximation.physicalChild node hbelow input.1) (by change node.1.val ≤ node.1.val + 1; omega)    j.val j.isLt.le input.2)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen Finset MeasureTheory ProbabilityTheorydef integerClosedRange (lo hi : ℤ) : List ℤ :=  (List.range (hi - lo + 1).toNat).map fun i : ℕ => lo + (i : ℤ)def groupSampleCount (M Q b : ℕ) (h : ℚ) : ℕ := min M ⌈(Q : ℚ) * M * h / b⌉₊def groupScaleTrueCost {M : ℕ} (h : ℚ) (envelope value : Fin M → ℚ) : ℚ :=  ∑ i, if envelope i = h then value i else 0def selectGroupMember {ι : Type u_1} (members : List ι) (hnonempty : members ≠ [])    (estimate : ι → ℚ) : ι :=  (members.argmax fun member => -estimate member).getD (members.head hnonempty)instance coarseDrawsMeasurableSpace (B D : ℕ) [MeasurableSpace (Fin B)] :    MeasurableSpace (OAI.EditApproximation.CoarseThresholdDraws B D) := by  induction D with  | zero => exact inferInstanceAs (MeasurableSpace PUnit)  | succ D ih =>    letI := ih    exact inferInstanceAs      (MeasurableSpace ((Fin B → Fin B) × (Fin B → OAI.EditApproximation.CoarseThresholdDraws B D)))def groupDyadicScales (M b : ℕ) (F : ℚ) : List ℚ :=  (OAI.EditApproximation.integerClosedRange (Int.clog 2 ((b : ℚ) / M)) (Int.log 2 (64 * F * b))).map    fun exponent => (2 : ℚ) ^ exponentdef groupScaleEstimate {M : ℕ} (k : ℕ) (h : ℚ) (envelope value : Fin M → ℚ)    (draw : Fin k → Fin M) : ℚ :=  if k = M then OAI.EditApproximation.groupScaleTrueCost h envelope value  else (M : ℚ) / k * ∑ j, if envelope (draw j) = h then value (draw j) else 0noncomputable def coarseDrawMeasure (B : ℕ) [NeZero B]    [MeasurableSpace (Fin B)] [MeasurableSingletonClass (Fin B)] :    (D : ℕ) → Measure (OAI.EditApproximation.CoarseThresholdDraws B D)  | 0 => Measure.dirac PUnit.unit  | D + 1 =>    (Measure.pi fun _ : Fin B => (PMF.uniformOfFintype (Fin B)).toMeasure).prod      (Measure.pi fun _ : Fin B => coarseDrawMeasure B D)def groupMemberEstimate {M T : ℕ} (scales : Fin T → ℚ) (count : Fin T → ℕ)    (connection : ℚ) (envelope value : Fin M → ℚ)    (draw : ∀ scale : Fin T, Fin (count scale) → Fin M) : ℚ :=  connection + ∑ scale, OAI.EditApproximation.groupScaleEstimate (count scale) (scales scale) envelope value (draw scale)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.BinaryFractiondef groupScalesWithWork (eM eb eF : ℕ) : List OAI.EditApproximation.BinaryFraction × ℕ :=  let exponents := OAI.EditApproximation.integerClosedRange ((eb : ℤ) - eM) ((6 + eF + eb : ℕ) : ℤ)  let values := OAI.EditApproximation.arithmeticMapWithWork OAI.EditApproximation.BinaryFraction.signedPowerTwoWithWork exponents  (values.1, values.2 + exponents.length + Nat.size eM + Nat.size eb + Nat.size eF + 8)def bandPredicateReadWithWork {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx) (r : OAI.EditApproximation.TargetInterval ny)    (b : ℕ) (tau theta velocity : OAI.EditApproximation.BinaryFraction)    (actions : List (Fin M → OAI.EditApproximation.TargetInterval ny)) (hne : actions ≠ [])    (read : Fin M → OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BinaryFraction × ℕ) (states : Fin M → OAI.EditApproximation.TargetInterval ny) :    Bool × ℕ :=  let connection := OAI.EditApproximation.zeroConnectionWithWork r.lo (List.ofFn states) r.hi  let anchors := OAI.EditApproximation.allWithWork (fun i : Fin M =>    let leftAnchor := OAI.EditApproximation.translatedEndpointWithWork r.lo parent.lo (OAI.EditApproximation.sourceChild parent i).lo    let rightAnchor := OAI.EditApproximation.translatedEndpointWithWork r.lo parent.lo (OAI.EditApproximation.sourceChild parent i).hi    let radius := OAI.EditApproximation.binaryNaturalMulWithWork 6 b    let left := OAI.EditApproximation.BinaryFraction.naturalDistanceLeWithWork leftAnchor.1 (states i).lo (OAI.EditApproximation.bitWordValue radius.1)    let right := OAI.EditApproximation.BinaryFraction.naturalDistanceLeWithWork rightAnchor.1 (states i).hi (OAI.EditApproximation.bitWordValue radius.1)    (left.1 && right.1, leftAnchor.2 + rightAnchor.2 + radius.2 + left.2 + right.2 + 3)) (List.finRange M)  let tolerance := OAI.EditApproximation.BinaryFraction.bandToleranceWithWork tau theta b M  let cuts := OAI.EditApproximation.allWithWork (OAI.EditApproximation.BinaryFraction.cutGuardReadWithWork parent r actions hne read states velocity tolerance.1)    (List.finRange M)  (connection.1 && anchors.1 && cuts.1, connection.2 + anchors.2 + tolerance.2 + cuts.2 + 4)def indexedGroupScales (raw : List OAI.EditApproximation.BinaryFraction) (M b : ℕ) (F : ℚ)    (h : raw.map OAI.EditApproximation.BinaryFraction.value = OAI.EditApproximation.groupDyadicScales M b F) :    Fin (OAI.EditApproximation.groupDyadicScales M b F).length → OAI.EditApproximation.BinaryFraction :=  fun i => raw.get ⟨i.val, by    have hlen := congrArg List.length h    simp only [List.length_map] at hlen    omega⟩def queryOnlineKeysWithWork {n : ℕ} (N P F : ℕ) (hP : 0 < P)    (a value : OAI.EditApproximation.BinaryFraction) (q : OAI.EditApproximation.TargetInterval n) : List (ℕ × OAI.EditApproximation.TargetInterval n) × ℕ := by  have proof_bitOrdering_matches_4 (high : Ordering) (a : Bool) (b : Bool) (x : ℕ) (y : ℕ) (h : OAI.EditApproximation.orderingMatches high x y) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitOrdering high a b) (a.toNat + 2 * x) (b.toNat + 2 * y) := by    rcases h with ⟨rfl, h⟩ | ⟨rfl, rfl⟩ | ⟨rfl, h⟩    · exact Or.inl ⟨rfl, by cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩    · cases a <;> cases b <;> simp [OAI.EditApproximation.bitOrdering, OAI.EditApproximation.orderingMatches]    · exact Or.inr (Or.inr ⟨rfl, by        cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩)  have proof_bitCompareWithWork_matches_5 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitCompareWithWork left right).1 (OAI.EditApproximation.bitWordValue left) (OAI.EditApproximation.bitWordValue right) := by    induction left generalizing right with    | nil =>      simp only [OAI.EditApproximation.bitCompareWithWork]      induction right with      | nil => (simp [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.orderingMatches, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        simpa only [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareNilLeftWithWork bs).1 false b 0 (OAI.EditApproximation.bitWordValue bs) ih    | cons a as ih =>      cases right with      | nil =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as []).1 a false (OAI.EditApproximation.bitWordValue as) 0 (ih [])      | cons b bs =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue] using          proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as bs).1 a b (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs) (ih bs)  have proof_bitCompareWithWork_lt_16 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .lt ↔ OAI.EditApproximation.bitWordValue left < OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_bitSubtractor_value_17 (a : Bool) (b : Bool) (borrow : Bool) :      a.toNat + 2 * (OAI.EditApproximation.bitBorrow a b borrow).toNat =        b.toNat + borrow.toNat + (OAI.EditApproximation.bitDifference a b borrow).toNat := by    cases a <;> cases b <;> cases borrow <;> decide  have proof_bitSubtractionRippleEquation_18 (a : ℕ) (b : ℕ) (borrow : ℕ) (nextBorrow : ℕ) (difference : ℕ) (left : ℕ) (right : ℕ) (result : ℕ) (tail : ℕ) (htail : Eq.{1} (HAdd.hAdd.{0, 0, 0} (HAdd.hAdd.{0, 0, 0} result right) nextBorrow) (HAdd.hAdd.{0, 0, 0} left tail)) (hbit : Eq.{1} (HAdd.hAdd.{0, 0, 0} a (HMul.hMul.{0, 0, 0} 2 nextBorrow))    (HAdd.hAdd.{0, 0, 0} (HAdd.hAdd.{0, 0, 0} b borrow) difference)) :      (difference + 2 * result) + (b + 2 * right) + borrow =        (a + 2 * left) + 2 * tail := by    omega  have proof_bitSubtractWithWork_value_19 (left : List.{0} Bool) (right : List.{0} Bool) (borrow : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork left right borrow).1 + OAI.EditApproximation.bitWordValue right + borrow.toNat =        OAI.EditApproximation.bitWordValue left + 2 ^ max left.length right.length *          (OAI.EditApproximation.bitSubtractWithWork left right borrow).2.1.toNat := by    induction left generalizing right borrow with    | nil =>      induction right generalizing borrow with      | nil => (simp [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitSubtractNilLeftWithWork, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        have h := ih (OAI.EditApproximation.bitBorrow false b borrow)        have hb := proof_bitSubtractor_value_17 false b borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitSubtractNilLeftWithWork, OAI.EditApproximation.bitWordValue,          List.length_nil, List.length_cons, Nat.zero_max, pow_succ, Bool.toNat_false] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 0 b.toNat borrow.toNat (OAI.EditApproximation.bitBorrow false b borrow).toNat          (OAI.EditApproximation.bitDifference false b borrow).toNat 0 (OAI.EditApproximation.bitWordValue bs)          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractNilLeftWithWork bs (OAI.EditApproximation.bitBorrow false b borrow)).1)          (2 ^ bs.length * (OAI.EditApproximation.bitSubtractNilLeftWithWork bs (OAI.EditApproximation.bitBorrow false b borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_zero, Nat.add_zero, Nat.zero_add, Nat.mul_assoc,          Nat.mul_left_comm] using hs    | cons a as ih =>      cases right with      | nil =>        have h := ih [] (OAI.EditApproximation.bitBorrow a false borrow)        have hb := proof_bitSubtractor_value_17 a false borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitWordValue, List.length_nil, List.length_cons,          Nat.max_zero, pow_succ, Bool.toNat_false] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 a.toNat 0 borrow.toNat (OAI.EditApproximation.bitBorrow a false borrow).toNat          (OAI.EditApproximation.bitDifference a false borrow).toNat (OAI.EditApproximation.bitWordValue as) 0          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork as [] (OAI.EditApproximation.bitBorrow a false borrow)).1)          (2 ^ as.length * (OAI.EditApproximation.bitSubtractWithWork as [] (OAI.EditApproximation.bitBorrow a false borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_zero, Nat.add_zero, Nat.zero_add, Nat.mul_assoc,          Nat.mul_left_comm] using hs      | cons b bs =>        have h := ih bs (OAI.EditApproximation.bitBorrow a b borrow)        have hb := proof_bitSubtractor_value_17 a b borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitWordValue, List.length_cons, Nat.succ_max_succ,          pow_succ] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 a.toNat b.toNat borrow.toNat (OAI.EditApproximation.bitBorrow a b borrow).toNat          (OAI.EditApproximation.bitDifference a b borrow).toNat (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs)          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork as bs (OAI.EditApproximation.bitBorrow a b borrow)).1)          (2 ^ max as.length bs.length * (OAI.EditApproximation.bitSubtractWithWork as bs (OAI.EditApproximation.bitBorrow a b borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_assoc, Nat.mul_left_comm] using hs  have proof_bitWordValue_lt_pow_length_20 (bits : List.{0} Bool) : OAI.EditApproximation.bitWordValue bits < 2 ^ bits.length := by    induction bits with    | nil => (simp [OAI.EditApproximation.bitWordValue])    | cons bit bits ih =>      cases bit <;> (simp only [OAI.EditApproximation.bitWordValue, List.length_cons, pow_succ, Bool.toNat_false, Bool.toNat_true]) <;> omega  have proof_bitSubtractWithWork_length_21 (left : List.{0} Bool) (right : List.{0} Bool) (borrow : Bool) :      (OAI.EditApproximation.bitSubtractWithWork left right borrow).1.length = max left.length right.length := by    induction left generalizing right borrow with    | nil =>      simp only [OAI.EditApproximation.bitSubtractWithWork]      induction right generalizing borrow with      | nil => simp [OAI.EditApproximation.bitSubtractNilLeftWithWork]      | cons b bs ih => simp [OAI.EditApproximation.bitSubtractNilLeftWithWork, ih]    | cons a as ih =>      cases right with      | nil => simp [OAI.EditApproximation.bitSubtractWithWork, ih]      | cons b bs => simp [OAI.EditApproximation.bitSubtractWithWork, ih, Nat.succ_max_succ]  have proof_bitSubtractWithWork_sub_22 (left : List.{0} Bool) (right : List.{0} Bool) (h : LE.le.{0} (OAI.EditApproximation.bitWordValue right) (OAI.EditApproximation.bitWordValue left)) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork left right false).1 = OAI.EditApproximation.bitWordValue left - OAI.EditApproximation.bitWordValue right := by    have hvalue := proof_bitSubtractWithWork_value_19 left right false    have hlt := proof_bitWordValue_lt_pow_length_20 (OAI.EditApproximation.bitSubtractWithWork left right false).1    rw [proof_bitSubtractWithWork_length_21] at hlt    cases hb : (OAI.EditApproximation.bitSubtractWithWork left right false).2.1    · simp only [hb, Bool.toNat_false, Nat.mul_zero, Nat.add_zero] at hvalue      omega    · simp only [hb, Bool.toNat_true, Bool.toNat_false, Nat.mul_one, Nat.add_zero] at hvalue      omega  have proof_bitDivModWithWork_value_23 (divisor : List.{0} Bool) (bits : List.{0} Bool) (hd : LT.lt.{0} 0 (OAI.EditApproximation.bitWordValue divisor)) :      OAI.EditApproximation.bitWordValue bits = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).1 +        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 ∧        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 < OAI.EditApproximation.bitWordValue divisor := by    induction bits with    | nil => (simp [OAI.EditApproximation.bitDivModWithWork, OAI.EditApproximation.bitWordValue, hd])    | cons bit bits ih =>      let previous := OAI.EditApproximation.bitDivModWithWork divisor bits      let candidate := bit :: previous.2.1      have hp : OAI.EditApproximation.bitWordValue bits = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue previous.1 +          OAI.EditApproximation.bitWordValue previous.2.1 := ih.1      have hr : OAI.EditApproximation.bitWordValue previous.2.1 < OAI.EditApproximation.bitWordValue divisor := ih.2      have hc : OAI.EditApproximation.bitWordValue candidate < 2 * OAI.EditApproximation.bitWordValue divisor := by        dsimp only [candidate, OAI.EditApproximation.bitWordValue]        cases bit <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega      by_cases hlt : (OAI.EditApproximation.bitCompareWithWork candidate divisor).1 = .lt      · have hv := (proof_bitCompareWithWork_lt_16 candidate divisor).1 hlt        simp only [OAI.EditApproximation.bitDivModWithWork, show (OAI.EditApproximation.bitCompareWithWork (bit :: (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1)          divisor).1 = .lt from hlt, ↓reduceIte]        change OAI.EditApproximation.bitWordValue (bit :: bits) = OAI.EditApproximation.bitWordValue divisor *          OAI.EditApproximation.bitWordValue (false :: previous.1) + OAI.EditApproximation.bitWordValue candidate ∧ OAI.EditApproximation.bitWordValue candidate < _        constructor        · (simp only [OAI.EditApproximation.bitWordValue, Bool.toNat_false])          dsimp only [candidate, OAI.EditApproximation.bitWordValue]          nlinarith only [hp]        · exact hv      · have hv : OAI.EditApproximation.bitWordValue divisor ≤ OAI.EditApproximation.bitWordValue candidate := by          exact Nat.le_of_not_gt (fun h => hlt ((proof_bitCompareWithWork_lt_16 candidate divisor).2 h))        have hs := proof_bitSubtractWithWork_sub_22 candidate divisor hv        simp only [OAI.EditApproximation.bitDivModWithWork, show (OAI.EditApproximation.bitCompareWithWork (bit :: (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1)          divisor).1 ≠ .lt from hlt, ↓reduceIte]        change OAI.EditApproximation.bitWordValue (bit :: bits) = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue (true :: previous.1) +          OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork candidate divisor false).1 ∧          OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork candidate divisor false).1 < _        rw [hs]        constructor        · (simp only [OAI.EditApproximation.bitWordValue, Bool.toNat_true])          have he := Nat.sub_add_cancel hv          dsimp only [candidate, OAI.EditApproximation.bitWordValue] at he ⊢          nlinarith only [hp, he]        · omega  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_binaryNaturalDivModWithWork_spec_24 (n : ℕ) (d : ℕ) (hd : LT.lt.{0} 0 d) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalDivModWithWork n d).1 = n / d ∧        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalDivModWithWork n d).2.1 = n % d := by    have h := proof_bitDivModWithWork_value_23 d.bits n.bits (by simpa only [proof_bitWordValue_bits_15] using hd)    simp only [proof_bitWordValue_bits_15] at h    have hmod : n % d = OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork d.bits n.bits).2.1 := by      conv_lhs => rw [h.1]      simp only [Nat.add_mod, Nat.mul_mod_right, Nat.zero_add, Nat.mod_eq_of_lt h.2]    have hdiv : n / d = OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork d.bits n.bits).1 := by      conv_lhs => rw [h.1]      rw [Nat.mul_add_div hd, Nat.div_eq_of_lt h.2, Nat.add_zero]    exact ⟨hdiv.symm, hmod.symm⟩  have proof_wordLEWithWork_value_26 (a : List.{0} Bool) (b : List.{0} Bool) :      (OAI.EditApproximation.wordLEWithWork a b).1 = true ↔ OAI.EditApproximation.bitWordValue a ≤ OAI.EditApproximation.bitWordValue b := by    simp only [OAI.EditApproximation.wordLEWithWork, Bool.not_eq_true', decide_eq_false_iff_not,      proof_bitCompareWithWork_lt_16, not_lt]  have proof_seedGridSpacingWithWork_value_86 (b : ℕ) (P : ℕ) (hP : LT.lt.{0} 0 P) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.seedGridSpacingWithWork b P).1 = OAI.EditApproximation.seedGridSpacing b P := by    have hv := (proof_binaryNaturalDivModWithWork_spec_24 b P hP).1    unfold OAI.EditApproximation.seedGridSpacingWithWork OAI.EditApproximation.seedGridSpacing    dsimp only    split_ifs with ht    · have hq : b / P ≤ 1 := by        have h := (proof_wordLEWithWork_value_26 _ _).mp ht        change OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalDivModWithWork b P).1 ≤ 1 at h        rwa [hv] at h      rw [max_eq_left hq]      rfl    · have hq : 1 ≤ b / P := by        have h := mt (proof_wordLEWithWork_value_26 _ _).mpr ht        change ¬ OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalDivModWithWork b P).1 ≤ 1 at h        rw [hv] at h        exact Nat.le_of_lt (Nat.lt_of_not_ge h)      rw [max_eq_right hq]      exact hv  have proof_seedGridSpacingWithWork_pos_85 (b : ℕ) (P : ℕ) (hP : LT.lt.{0} 0 P) :      0 < OAI.EditApproximation.bitWordValue (OAI.EditApproximation.seedGridSpacingWithWork b P).1 := by    rw [proof_seedGridSpacingWithWork_value_86 b P hP]    unfold OAI.EditApproximation.seedGridSpacing    omega  exact    let scales := OAI.EditApproximation.BinaryFraction.queryScalesWithWork N F a value    let keys := OAI.EditApproximation.arithmeticMapWithWork (fun b =>      let spacing := OAI.EditApproximation.seedGridSpacingWithWork b P      let center := OAI.EditApproximation.roundStateWithWork (OAI.EditApproximation.bitWordValue spacing.1) (proof_seedGridSpacingWithWork_pos_85 b P hP) q      ((b, center.1), spacing.2 + center.2 + 2)) scales.1    (keys.1, scales.2 + keys.2 + 1)def groupScalesAllocation (eM eb eF : ℕ) : ℕ :=  let exponents := OAI.EditApproximation.integerClosedRange ((eb : ℤ) - eM) ((6 + eF + eb : ℕ) : ℤ)  OAI.EditApproximation.arithmeticMapAllocation OAI.EditApproximation.BinaryFraction.signedPowerTwoAllocation exponents + exponents.length +    Nat.size eM + Nat.size eb + Nat.size eFdef bandFromActionsReadWithWork {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx)    (r : OAI.EditApproximation.TargetInterval ny) (b : ℕ) (tau theta velocity : OAI.EditApproximation.BinaryFraction)    (read : Fin M → OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BinaryFraction × ℕ)    (actions : List (Fin M → OAI.EditApproximation.TargetInterval ny)) (hne : actions ≠ []) :    List (Fin M → OAI.EditApproximation.TargetInterval ny) × ℕ :=  let margin := OAI.EditApproximation.BinaryFraction.subWithWork OAI.EditApproximation.BinaryFraction.one tau  let guard := OAI.EditApproximation.BinaryFraction.leWithWork velocity.absolute margin.1  if guard.1 then    let filtered := OAI.EditApproximation.filterWithWork      (OAI.EditApproximation.BinaryFraction.bandPredicateReadWithWork parent r b tau theta velocity actions hne read) actions    (filtered.1, margin.2 + guard.2 + filtered.2 + 2)  else ([], margin.2 + guard.2 + 1)def queryInitialSupportWithWork {n : ℕ} (N P F exponent : ℕ) (hP : 0 < P)    (a value : OAI.EditApproximation.BinaryFraction) (q : OAI.EditApproximation.TargetInterval n) : List (OAI.EditApproximation.TargetInterval n) × ℕ :=  let raw := OAI.EditApproximation.BinaryFraction.queryRawCentersWithWork N P F a value q  let groups := OAI.EditApproximation.BinaryFraction.queryGroupKeysWithWork N F exponent a value q  let cells := OAI.EditApproximation.arithmeticFlatMapWithWork (fun key =>    let spacing := OAI.EditApproximation.seedGridSpacingWithWork key.1 P    let side := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.inversePowerTwo exponent) (OAI.EditApproximation.BinaryFraction.nat key.1)    let states := OAI.EditApproximation.BinaryFraction.cellStatesWithWork n (OAI.EditApproximation.bitWordValue spacing.1) side.1 key.2    (states.1, spacing.2 + side.2 + states.2 + exponent + 3)) groups.1  let online := OAI.EditApproximation.BinaryFraction.queryOnlineKeysWithWork N P F hP a value q  let onlineStates := OAI.EditApproximation.arithmeticMapWithWork (fun key => (key.2, 1)) online.1  (q :: (raw.1 ++ cells.1 ++ onlineStates.1),    raw.2 + groups.2 + cells.2 + online.2 + onlineStates.2 + 2 * raw.1.length + cells.1.length + 5)def queryEarlierRepresentativesWithWork {n : ℕ} (N P F exponent : ℕ) (hP : 0 < P)    (a : OAI.EditApproximation.BinaryFraction) (initial : OAI.EditApproximation.TargetInterval n → OAI.EditApproximation.BinaryFraction × ℕ)    (q : OAI.EditApproximation.TargetInterval n) : List (ℕ × OAI.EditApproximation.TargetInterval n) × ℕ :=  let query := initial q  let reps := OAI.EditApproximation.BinaryFraction.localRepresentativeReadWithWork N P F a initial q  let groups := OAI.EditApproximation.BinaryFraction.queryGroupKeysWithWork N F exponent a query.1 q  let cells := OAI.EditApproximation.arithmeticFlatMapWithWork (fun key =>    let centers := OAI.EditApproximation.BinaryFraction.cellCentersReadWithWork P F key.1 a (OAI.EditApproximation.BinaryFraction.inversePowerTwo exponent) initial key.2    let labeled := OAI.EditApproximation.arithmeticMapWithWork (fun r => ((key.1, r), 1)) centers.1    (labeled.1, centers.2 + labeled.2 + 1)) groups.1  let online := OAI.EditApproximation.BinaryFraction.queryOnlineKeysWithWork N P F hP a query.1 q  (reps.1 ++ cells.1 ++ online.1,    query.2 + reps.2 + groups.2 + cells.2 + online.2 + 2 * reps.1.length + cells.1.length + 4)def bandFromActionsReadAllocation {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx)    (r : OAI.EditApproximation.TargetInterval ny) (b : ℕ) (tau theta velocity : OAI.EditApproximation.BinaryFraction)    (read : Fin M → OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BinaryFraction × ℕ)    (allocation : Fin M → OAI.EditApproximation.TargetInterval ny → ℕ)    (actions : List (Fin M → OAI.EditApproximation.TargetInterval ny)) (hne : actions ≠ []) : ℕ :=  let margin := (OAI.EditApproximation.BinaryFraction.subWithWork OAI.EditApproximation.BinaryFraction.one tau).1  OAI.EditApproximation.BinaryFraction.subAllocation OAI.EditApproximation.BinaryFraction.one tau + OAI.EditApproximation.BinaryFraction.leAllocation velocity.absolute margin +    if (OAI.EditApproximation.BinaryFraction.leWithWork velocity.absolute margin).1 then      OAI.EditApproximation.filterAllocation (OAI.EditApproximation.BinaryFraction.bandPredicateReadWithWork parent r b tau theta velocity actions hne read)        (OAI.EditApproximation.BinaryFraction.bandPredicateReadAllocation parent r b tau theta velocity actions hne read allocation) actions    else 0def queryInitialSupportAllocation {n : ℕ} (N P F exponent : ℕ) (hP : 0 < P)    (a value : OAI.EditApproximation.BinaryFraction) (q : OAI.EditApproximation.TargetInterval n) : ℕ :=  let raw := (OAI.EditApproximation.BinaryFraction.queryRawCentersWithWork N P F a value q).1  let groups := (OAI.EditApproximation.BinaryFraction.queryGroupKeysWithWork N F exponent a value q).1  let build := fun key =>    let spacing := OAI.EditApproximation.seedGridSpacingWithWork key.1 P    let side := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.inversePowerTwo exponent) (OAI.EditApproximation.BinaryFraction.nat key.1)    let states := OAI.EditApproximation.BinaryFraction.cellStatesWithWork n (OAI.EditApproximation.bitWordValue spacing.1) side.1 key.2    (states.1, spacing.2 + side.2 + states.2 + exponent + 3)  let cells := (OAI.EditApproximation.arithmeticFlatMapWithWork build groups).1  let online := (OAI.EditApproximation.BinaryFraction.queryOnlineKeysWithWork N P F hP a value q).1  OAI.EditApproximation.BinaryFraction.queryRawCentersAllocation N P F a value q + OAI.EditApproximation.BinaryFraction.queryGroupKeysAllocation N F exponent a value q +    OAI.EditApproximation.arithmeticFlatMapAllocation build (OAI.EditApproximation.BinaryFraction.initialCellAllocation n P exponent) groups +    OAI.EditApproximation.BinaryFraction.queryOnlineKeysAllocation N P F hP a value q + OAI.EditApproximation.arithmeticMapAllocation (fun _ => 1) online +    2 * raw.length + cells.length + 1def queryBandInputsWithWork {nx ny : ℕ} (M : ℕ) (parent : OAI.EditApproximation.TargetInterval nx)    (N P F exponent : ℕ) (hP : 0 < P) (a : OAI.EditApproximation.BinaryFraction)    (initial : OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BinaryFraction × ℕ) (q : OAI.EditApproximation.TargetInterval ny) :    List (Fin M × OAI.EditApproximation.TargetInterval ny) × ℕ :=  let representatives := OAI.EditApproximation.BinaryFraction.queryEarlierRepresentativesWithWork N P F exponent hP a initial q  let inputs := OAI.EditApproximation.BinaryFraction.queryWideInputsWithWork M parent P representatives.1  (inputs.1, representatives.2 + inputs.2 + 1)def queryEarlierInputsWithWork {nx ny : ℕ} (M : ℕ) (parent : OAI.EditApproximation.TargetInterval nx)    (N P F exponent history : ℕ) (hP : 0 < P) (a : OAI.EditApproximation.BinaryFraction)    (initial : OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BinaryFraction × ℕ) (q : OAI.EditApproximation.TargetInterval ny) :    List (Fin M × ℕ × OAI.EditApproximation.TargetInterval ny) × ℕ :=  let representatives := OAI.EditApproximation.BinaryFraction.queryEarlierRepresentativesWithWork N P F exponent hP a initial q  let raw := OAI.EditApproximation.BinaryFraction.queryRawHistoryInputsWithWork M parent P history representatives.1  let ordered := OAI.EditApproximation.queryOrderedHistoryInputsWithWork raw.1  (ordered.1, representatives.2 + raw.2 + ordered.2 + 2)def queryEarlierInputsAllocation {nx ny : ℕ} (M : ℕ) (parent : OAI.EditApproximation.TargetInterval nx)    (N P F exponent history : ℕ) (hP : 0 < P) (a : OAI.EditApproximation.BinaryFraction)    (initial : OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BinaryFraction × ℕ) (allocation : OAI.EditApproximation.TargetInterval ny → ℕ)    (q : OAI.EditApproximation.TargetInterval ny) : ℕ :=  let reps := (OAI.EditApproximation.BinaryFraction.queryEarlierRepresentativesWithWork N P F exponent hP a initial q).1  OAI.EditApproximation.BinaryFraction.queryEarlierRepresentativesAllocation N P F exponent hP a initial allocation q +    OAI.EditApproximation.BinaryFraction.queryRawHistoryInputsAllocation M parent P history reps +    OAI.EditApproximation.queryOrderedHistoryInputsAllocation (OAI.EditApproximation.BinaryFraction.queryRawHistoryInputsWithWork M parent P history reps).1def queryBandInputsAllocation {nx ny : ℕ} (M : ℕ) (parent : OAI.EditApproximation.TargetInterval nx)    (N P F exponent : ℕ) (hP : 0 < P) (a : OAI.EditApproximation.BinaryFraction)    (initial : OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BinaryFraction × ℕ) (allocation : OAI.EditApproximation.TargetInterval ny → ℕ)    (q : OAI.EditApproximation.TargetInterval ny) : ℕ :=  OAI.EditApproximation.BinaryFraction.queryEarlierRepresentativesAllocation N P F exponent hP a initial allocation q +    OAI.EditApproximation.BinaryFraction.queryWideInputsAllocation M parent P (OAI.EditApproximation.BinaryFraction.queryEarlierRepresentativesWithWork N P F exponent hP a initial q).1end OAI.EditApproximation.BinaryFractionendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.FiniteQuerydef run {ι : Type u_1} {κ : Type u_2} (ask : ι → OAI.EditApproximation.BinaryMemo ℚ → OAI.EditApproximation.RecursiveMemoResult κ) :    OAI.EditApproximation.FiniteQuery ι → OAI.EditApproximation.BinaryMemo ℚ → OAI.EditApproximation.RecursiveMemoResult κ  | .done result, memory => ⟨result, memory, [], 0, 0⟩  | .read key next, memory =>    let first := ask key memory    let rest := run ask (next first.value) first.memory    ⟨rest.value, rest.memory, first.freshKeys ++ rest.freshKeys,      first.dictionaryVisits + rest.dictionaryVisits, first.requests + rest.requests⟩def bind {ι : Type u_1} : OAI.EditApproximation.FiniteQuery ι → (ℚ → OAI.EditApproximation.FiniteQuery ι) → OAI.EditApproximation.FiniteQuery ι  | .done result, next => next result  | .read key continuation, next => .read key (fun result => bind (continuation result) next)def mapKeys {ι : Type u_1} {κ : Type u_2} (f : ι → κ) : OAI.EditApproximation.FiniteQuery ι → OAI.EditApproximation.FiniteQuery κ  | .done result => .done result  | .read key next => .read (f key) (fun answer => mapKeys f (next answer))def restrict {ι : Type u_1} (P : ι → Prop) [DecidablePred P] : OAI.EditApproximation.FiniteQuery ι → OAI.EditApproximation.FiniteQuery {key // P key}  | .done result => .done result  | .read key next => if h : P key then      .read ⟨key, h⟩ (fun answer => restrict P (next answer))    else restrict P (next 0)def requestWork {ι : Type u_1} {κ : Type u_2} (ask : ι → OAI.EditApproximation.BinaryMemo ℚ → OAI.EditApproximation.RecursiveMemoResult κ)    (cost : ι → OAI.EditApproximation.BinaryMemo ℚ → ℕ) : OAI.EditApproximation.FiniteQuery ι → OAI.EditApproximation.BinaryMemo ℚ → ℕ  | .done _, _ => 0  | .read key next, memory =>      let first := ask key memory      cost key memory + requestWork ask cost (next first.value) first.memorydef collect {ι : Type u_1} {κ : Type u_2} (reader : κ → OAI.EditApproximation.FiniteQuery ι) :    List κ → (List ℚ → OAI.EditApproximation.FiniteQuery ι) → OAI.EditApproximation.FiniteQuery ι  | [], next => next []  | key :: keys, next => OAI.EditApproximation.FiniteQuery.bind (reader key) fun result =>      collect reader keys (fun results => next (result :: results))end OAI.EditApproximation.FiniteQueryendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationdef physicalInitialQuery {ι : Type u_1} {α : Type u_2} [DecidableEq α] {M J : ℕ}    (source target : List α) (N P F : ℕ) (A : ℚ)    (seedRead : OAI.EditApproximation.PhysicalEntry M J target.length → OAI.EditApproximation.FiniteQuery ι)    (state : OAI.EditApproximation.PhysicalEntry M J target.length) : OAI.EditApproximation.FiniteQuery ι :=  let piece := OAI.EditApproximation.physicalSource source state.1  if piece.length ≤ 1 then .done (OAI.EditApproximation.shortSourceCost piece (OAI.EditApproximation.substring target state.2.lo state.2.hi))  else OAI.EditApproximation.FiniteQuery.bind (seedRead state) fun answer =>    let value := ⌈answer⌉₊    let keys := OAI.EditApproximation.rawInitialConeCenters N P A value state.2    OAI.EditApproximation.FiniteQuery.collect (fun q => seedRead (state.1, q)) keys fun answers =>      let localTable := fun q => if q = state.2 then value        else ⌈OAI.EditApproximation.finiteAnswerTable keys answers q⌉₊      .done (OAI.EditApproximation.localInitialConeTable piece target localTable N P F A (OAI.EditApproximation.refinementFactor A F) state.2)def queryInitialGather {ι : Type u_1} {β : Type u_2} {n : ℕ} (N P F exponent : ℕ) (hP : 0 < P)    (a : OAI.EditApproximation.BinaryFraction) (q : OAI.EditApproximation.TargetInterval n)    (reader : OAI.EditApproximation.TargetInterval n → OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction)    (next : List (OAI.EditApproximation.TargetInterval n) → List OAI.EditApproximation.BinaryFraction → OAI.EditApproximation.BitQuery ι β) : OAI.EditApproximation.BitQuery ι β :=  (reader q).bind fun value =>    (OAI.EditApproximation.BitQuery.compute (OAI.EditApproximation.BinaryFraction.queryInitialSupportWithWork N P F exponent hP a value q)).bind      fun keys => OAI.EditApproximation.BitQuery.collect reader keys (next keys)def queryBandGather {ι : Type u_1} {β : Type u_2} {nx ny : ℕ} (M : ℕ) (parent : OAI.EditApproximation.TargetInterval nx)    (N P F exponent : ℕ) (hP : 0 < P) (a : OAI.EditApproximation.BinaryFraction)    (initial : OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BinaryFraction × ℕ) (q : OAI.EditApproximation.TargetInterval ny)    (massReader initialReader : (Fin M × OAI.EditApproximation.TargetInterval ny) → OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction)    (next : List (Fin M × OAI.EditApproximation.TargetInterval ny) → List OAI.EditApproximation.BinaryFraction → List OAI.EditApproximation.BinaryFraction →      OAI.EditApproximation.BitQuery ι β) : OAI.EditApproximation.BitQuery ι β :=  (OAI.EditApproximation.BitQuery.compute (OAI.EditApproximation.BinaryFraction.queryBandInputsWithWork M parent N P F exponent hP a initial q)).bind    fun keys => OAI.EditApproximation.BitQuery.collect massReader keys fun mass =>      OAI.EditApproximation.BitQuery.collect initialReader keys (next keys mass)def physicalRefinementMassQuery {M J ny : ℕ} (pass copy T S t : ℕ) (ht : 0 < t)    (node : OAI.EditApproximation.PhysicalNode M J) (hbelow : node.1.val < J) (q : OAI.EditApproximation.TargetInterval ny)    (input : Fin M × OAI.EditApproximation.TargetInterval ny) :    OAI.EditApproximation.FiniteQuery {child : OAI.EditApproximation.PhysicalTableRequest M J ny //      child.combinedRank T S < (OAI.EditApproximation.PhysicalTableRequest.refinement pass copy node T t q).combinedRank T S} :=  OAI.EditApproximation.FiniteQuery.collect (fun j : Fin T => OAI.EditApproximation.physicalRefinementWarmupRead pass copy T S t ht node q    (OAI.EditApproximation.physicalChild node hbelow input.1) (by change node.1.val ≤ node.1.val + 1; omega)    j.val (Nat.le_of_lt j.isLt) input.2) (List.ofFn fun j : Fin T => j)    (fun values => .done (values.sum / T))def physicalMedianSeedQuery {M J ny : ℕ} (N T S copies multiplier : ℕ)    (parent : OAI.EditApproximation.PhysicalTableRequest M J ny) (hpass : 0 < parent.pass) (state : OAI.EditApproximation.TargetInterval ny) :    OAI.EditApproximation.FiniteQuery {child : OAI.EditApproximation.PhysicalTableRequest M J ny //      child.combinedRank T S < parent.combinedRank T S} :=  OAI.EditApproximation.FiniteQuery.collect (fun copy : Fin copies => OAI.EditApproximation.previousPassRead T S parent hpass state copy.val)    (List.finRange copies) fun values =>      .done (min N (OAI.EditApproximation.upperMedian (values.map fun value => ⌈(multiplier : ℚ) * value⌉₊)) : ℕ)def globalSeedRead {M J ny : ℕ} (N T S copies : ℕ) (multiplier : ℕ → ℕ)    (initial : OAI.EditApproximation.PhysicalEntry M J ny → ℕ) (parent : OAI.EditApproximation.PhysicalTableRequest M J ny)    (state : OAI.EditApproximation.PhysicalEntry M J ny) :    OAI.EditApproximation.FiniteQuery {child : OAI.EditApproximation.PhysicalTableRequest M J ny //      child.combinedRank T S < parent.combinedRank T S} :=  if state.1 = parent.node then    if hp : parent.pass = 0 then .done (initial state : ℚ)    else OAI.EditApproximation.physicalMedianSeedQuery N T S copies (multiplier (parent.pass - 1)) parent      (Nat.pos_of_ne_zero hp) state.2  else .done 0end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.UnreducedRationaldef value (a : OAI.EditApproximation.UnreducedRational) : ℚ := (a.num : ℚ) / a.dendef zero : OAI.EditApproximation.UnreducedRational := ⟨0, 1, by decide⟩def mul (a b : OAI.EditApproximation.UnreducedRational) : OAI.EditApproximation.UnreducedRational :=  ⟨a.num * b.num, a.den * b.den, Nat.mul_pos a.den_pos b.den_pos⟩def lt (a b : OAI.EditApproximation.UnreducedRational) : Bool := decide (a.num * b.den < b.num * a.den)def inv (a : OAI.EditApproximation.UnreducedRational) : OAI.EditApproximation.UnreducedRational :=  if h : a.num = 0 then OAI.EditApproximation.UnreducedRational.zero else    ⟨a.num.sign * a.den, a.num.natAbs, Int.natAbs_pos.mpr h⟩def div (a b : OAI.EditApproximation.UnreducedRational) : OAI.EditApproximation.UnreducedRational := a.mul b.invend OAI.EditApproximation.UnreducedRationalendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen Finset EditDistortioninductive CoarseSourceTree (B : ℕ) (α : Type u) : ℕ → Type u  | leaf (letter : Option α) : CoarseSourceTree B α 0  | branch {D : ℕ} (children : Fin B → CoarseSourceTree B α D) : CoarseSourceTree B α (D + 1)def coarseTargetFrame {α : Type u} (k : ℕ) (target : List α) : List (Option α) :=  (List.replicate k none ++ target.map some) ++ List.replicate k nonedef coarseRootShift (k : ℕ) : Fin (2 * k + 1) := ⟨k, by omega⟩def endpointActionConnection {n M : ℕ} (q : OAI.EditApproximation.TargetInterval n)    (states : Fin M → OAI.EditApproximation.TargetInterval n) : ℕ :=  OAI.EditApproximation.connectionBudget q.lo (List.ofFn states) q.hidef coarseSourceTreeOfList (B : ℕ) {α : Type u} :    (D : ℕ) → List α → OAI.EditApproximation.CoarseSourceTree B α D  | 0, source => .leaf source.head?  | D + 1, source => .branch (fun i =>      coarseSourceTreeOfList B D ((source.drop (i.val * B ^ D)).take (B ^ D)))end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.BinaryFractionopen Finsetdef groupIndexWithWork {M : ℕ} (h : OAI.EditApproximation.BinaryFraction) (envelope values : Vector OAI.EditApproximation.BinaryFraction M)    (indices : List (Fin M)) : OAI.EditApproximation.BinaryFraction × ℕ :=  let terms := OAI.EditApproximation.BinaryFraction.groupTermsWithWork h envelope values indices  let total := OAI.EditApproximation.BinaryFraction.sumListWithWork terms.1  (total.1, terms.2 + total.2 + 1)def endpointDistanceWithWork {n : ℕ} (q r : OAI.EditApproximation.TargetInterval n) : OAI.EditApproximation.BinaryFraction × ℕ :=  let left := OAI.EditApproximation.BinaryFraction.distanceWithWork (OAI.EditApproximation.BinaryFraction.nat q.lo) (OAI.EditApproximation.BinaryFraction.nat r.lo)  let right := OAI.EditApproximation.BinaryFraction.distanceWithWork (OAI.EditApproximation.BinaryFraction.nat q.hi) (OAI.EditApproximation.BinaryFraction.nat r.hi)  let result := OAI.EditApproximation.BinaryFraction.canonicalAddWithWork left.1 right.1  (result.1, left.2 + right.2 + result.2 + Nat.size q.lo + Nat.size q.hi +    Nat.size r.lo + Nat.size r.hi + 3)def endpointConnectionWithWork {n M : ℕ} (r : OAI.EditApproximation.TargetInterval n)    (states : Fin M → OAI.EditApproximation.TargetInterval n) : OAI.EditApproximation.BinaryFraction × ℕ :=  let result := OAI.EditApproximation.BinaryFraction.connectionWithWork (OAI.EditApproximation.BinaryFraction.nat r.lo) (OAI.EditApproximation.BinaryFraction.nat r.hi) (List.ofFn states)  (result.1, result.2 + Nat.size r.lo + Nat.size r.hi + M + 2)def stateGapWithWork {n : ℕ} (sourceLength : ℕ) (r : OAI.EditApproximation.TargetInterval n) : OAI.EditApproximation.BinaryFraction × ℕ :=  let targetLength := OAI.EditApproximation.BinaryFraction.subWithWork (OAI.EditApproximation.BinaryFraction.nat r.hi) (OAI.EditApproximation.BinaryFraction.nat r.lo)  let result := OAI.EditApproximation.BinaryFraction.subWithWork targetLength.1 (OAI.EditApproximation.BinaryFraction.nat sourceLength)  (result.1, targetLength.2 + result.2 + Nat.size r.hi + Nat.size r.lo + Nat.size sourceLength + 2)end OAI.EditApproximation.BinaryFractionendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.BinaryFractiondef groupScaleSourceWithWork {M : ℕ} (k : ℕ) (h : OAI.EditApproximation.BinaryFraction)    (envelope values : Vector OAI.EditApproximation.BinaryFraction M) (draw : Fin k → Fin M × ℕ) : OAI.EditApproximation.BinaryFraction × ℕ :=  let indices := if k = M then (List.finRange M, 0) else OAI.EditApproximation.arithmeticMapWithWork draw (List.finRange k)  let subtotal := OAI.EditApproximation.BinaryFraction.groupIndexWithWork h envelope values indices.1  let factor := if k = M then (OAI.EditApproximation.BinaryFraction.one, 1) else OAI.EditApproximation.BinaryFraction.divWithWork (OAI.EditApproximation.BinaryFraction.nat M) (OAI.EditApproximation.BinaryFraction.nat k)  let result := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork factor.1 subtotal.1  (result.1, indices.2 + subtotal.2 + factor.2 + result.2 + Nat.size M + Nat.size k + 3)def endpointScoreReadWithWork {n M : ℕ} (r : OAI.EditApproximation.TargetInterval n)    (read : Fin M → OAI.EditApproximation.TargetInterval n → OAI.EditApproximation.BinaryFraction × ℕ) (states : Fin M → OAI.EditApproximation.TargetInterval n) :    OAI.EditApproximation.BinaryFraction × ℕ :=  let words := OAI.EditApproximation.arithmeticMapWithWork (fun i => read i (states i)) (List.finRange M)  let connection := OAI.EditApproximation.BinaryFraction.endpointConnectionWithWork r states  let children := OAI.EditApproximation.BinaryFraction.sumListWithWork words.1  let result := OAI.EditApproximation.BinaryFraction.canonicalAddWithWork connection.1 children.1  (result.1, words.2 + connection.2 + children.2 + result.2 + 2)def initialConeWithWork {n : ℕ} (sourceLength : ℕ) (U : OAI.EditApproximation.TargetInterval n → ℕ)    (a L : OAI.EditApproximation.BinaryFraction) (query center : OAI.EditApproximation.TargetInterval n) : OAI.EditApproximation.BinaryFraction × ℕ :=  let gap := OAI.EditApproximation.BinaryFraction.stateGapWithWork sourceLength center  let seed := OAI.EditApproximation.BinaryFraction.scaledSeedWithWork (U center) a gap.1  let distance := OAI.EditApproximation.BinaryFraction.endpointDistanceWithWork query center  let spatial := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork L distance.1  let result := OAI.EditApproximation.BinaryFraction.canonicalAddWithWork seed.1 spatial.1  (result.1, gap.2 + seed.2 + distance.2 + spatial.2 + result.2 + 4)def endpointActionWithWork {ny M : ℕ} (center : OAI.EditApproximation.TargetInterval ny)    (states : Fin M → OAI.EditApproximation.TargetInterval ny) :    OAI.EditApproximation.BinaryBellmanAction (OAI.EditApproximation.TargetInterval ny) (Fin M × OAI.EditApproximation.TargetInterval ny) M × ℕ :=  let connection := OAI.EditApproximation.BinaryFraction.endpointConnectionWithWork center states  (⟨center, connection.1, fun i => (i, states i)⟩, connection.2 + M + 1)def endpointScoreReadAllocation {n M : ℕ} (r : OAI.EditApproximation.TargetInterval n)    (read : Fin M → OAI.EditApproximation.TargetInterval n → OAI.EditApproximation.BinaryFraction × ℕ)    (footprint : Fin M → OAI.EditApproximation.TargetInterval n → ℕ) (states : Fin M → OAI.EditApproximation.TargetInterval n) : ℕ :=  let words := (OAI.EditApproximation.arithmeticMapWithWork (fun i => read i (states i)) (List.finRange M)).1  OAI.EditApproximation.arithmeticMapAllocation (fun i => footprint i (states i)) (List.finRange M) +    OAI.EditApproximation.BinaryFraction.endpointConnectionAllocation r states + OAI.EditApproximation.BinaryFraction.sumListAllocation words +    OAI.EditApproximation.BinaryFraction.canonicalAddAllocation (OAI.EditApproximation.BinaryFraction.endpointConnectionWithWork r states).1 (OAI.EditApproximation.BinaryFraction.sumListWithWork words).1 + 0def initialConeAllocation {n : ℕ} (sourceLength U : ℕ) (a L : OAI.EditApproximation.BinaryFraction)    (query center : OAI.EditApproximation.TargetInterval n) : ℕ :=  let gap := (OAI.EditApproximation.BinaryFraction.stateGapWithWork sourceLength center).1  let seed := (OAI.EditApproximation.BinaryFraction.scaledSeedWithWork U a gap).1  let distance := (OAI.EditApproximation.BinaryFraction.endpointDistanceWithWork query center).1  let spatial := (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork L distance).1  OAI.EditApproximation.BinaryFraction.stateGapAllocation sourceLength center + OAI.EditApproximation.BinaryFraction.scaledSeedAllocation U a gap +    OAI.EditApproximation.BinaryFraction.endpointDistanceAllocation query center + OAI.EditApproximation.BinaryFraction.canonicalMulAllocation L distance + OAI.EditApproximation.BinaryFraction.canonicalAddAllocation seed spatialdef groupScaleSourceAllocation {M : ℕ} (k : ℕ) (h : OAI.EditApproximation.BinaryFraction)    (envelope values : Vector OAI.EditApproximation.BinaryFraction M) (draw : Fin k → Fin M × ℕ)    (allocation : Fin k → ℕ) : ℕ :=  let indices := if k = M then (List.finRange M, 0) else OAI.EditApproximation.arithmeticMapWithWork draw (List.finRange k)  let factor := if k = M then (OAI.EditApproximation.BinaryFraction.one, 1) else OAI.EditApproximation.BinaryFraction.divWithWork (OAI.EditApproximation.BinaryFraction.nat M) (OAI.EditApproximation.BinaryFraction.nat k)  (if k = M then 0 else OAI.EditApproximation.arithmeticMapAllocation allocation (List.finRange k)) +    OAI.EditApproximation.BinaryFraction.groupIndexAllocation h envelope values indices.1 +    (if k = M then 0 else OAI.EditApproximation.BinaryFraction.divAllocation (OAI.EditApproximation.BinaryFraction.nat M) (OAI.EditApproximation.BinaryFraction.nat k)) +    OAI.EditApproximation.BinaryFraction.canonicalMulAllocation factor.1 (OAI.EditApproximation.BinaryFraction.groupIndexWithWork h envelope values indices.1).1 +    Nat.size M + Nat.size kdef gapGuardAllocation {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx)    (envelope : Vector OAI.EditApproximation.BinaryFraction M) (rounded : Vector (OAI.EditApproximation.TargetInterval ny) M) (i : Fin M) : ℕ :=  let sourceLength := (OAI.EditApproximation.binaryNaturalSubtractWithWork (OAI.EditApproximation.sourceChild parent i).hi (OAI.EditApproximation.sourceChild parent i).lo).1  let gap := (OAI.EditApproximation.BinaryFraction.stateGapWithWork (OAI.EditApproximation.bitWordValue sourceLength) (rounded.get i)).1  let bound := (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat 2) (envelope.get i)).1  OAI.EditApproximation.bitSubtractAllocation (OAI.EditApproximation.sourceChild parent i).hi.bits (OAI.EditApproximation.sourceChild parent i).lo.bits false +    OAI.EditApproximation.BinaryFraction.stateGapAllocation (OAI.EditApproximation.bitWordValue sourceLength) (rounded.get i) +    OAI.EditApproximation.BinaryFraction.canonicalMulAllocation (OAI.EditApproximation.BinaryFraction.nat 2) (envelope.get i) + OAI.EditApproximation.BinaryFraction.leAllocation gap.absolute bounddef wideMinimumReadWithWork {n M : ℕ} (r : OAI.EditApproximation.TargetInterval n)    (read : Fin M → OAI.EditApproximation.TargetInterval n → OAI.EditApproximation.BinaryFraction × ℕ)    (actions : List (Fin M → OAI.EditApproximation.TargetInterval n)) (hne : actions ≠ []) : OAI.EditApproximation.BinaryFraction × ℕ :=  let fallback := OAI.EditApproximation.BinaryFraction.endpointScoreReadWithWork r read (actions.head hne)  let scores := OAI.EditApproximation.arithmeticMapWithWork (OAI.EditApproximation.BinaryFraction.endpointScoreReadWithWork r read) actions  let result := OAI.EditApproximation.BinaryFraction.minimumWithWork fallback.1 scores.1  (result.1, fallback.2 + scores.2 + result.2 + 2)def groupMemberSourceWithWork {M T : ℕ} (scales : Fin T → OAI.EditApproximation.BinaryFraction) (count : Fin T → ℕ)    (connection : OAI.EditApproximation.BinaryFraction) (envelope values : Vector OAI.EditApproximation.BinaryFraction M)    (draw : ∀ s : Fin T, Fin (count s) → Fin M × ℕ) : OAI.EditApproximation.BinaryFraction × ℕ :=  let terms := OAI.EditApproximation.arithmeticMapWithWork (fun s => OAI.EditApproximation.BinaryFraction.groupScaleSourceWithWork (count s) (scales s)    envelope values (draw s)) (List.finRange T)  let subtotal := OAI.EditApproximation.BinaryFraction.sumListWithWork terms.1  let result := OAI.EditApproximation.BinaryFraction.canonicalAddWithWork connection subtotal.1  (result.1, terms.2 + subtotal.2 + result.2 + 1)def wideActionsFromRepresentativesWithWork {nx ny : ℕ} (M : ℕ)    (parent : OAI.EditApproximation.TargetInterval nx) (representatives : List (ℕ × OAI.EditApproximation.TargetInterval ny)) (P : ℕ) :    List (OAI.EditApproximation.BinaryBellmanAction (OAI.EditApproximation.TargetInterval ny) (Fin M × OAI.EditApproximation.TargetInterval ny) M) × ℕ :=  OAI.EditApproximation.arithmeticFlatMapWithWork (fun br =>    let grids := OAI.EditApproximation.wideActionGridWithWork M parent br.2 br.1 P    let actions := OAI.EditApproximation.arithmeticMapWithWork (fun states => OAI.EditApproximation.BinaryFraction.endpointActionWithWork br.2 states.get) grids.1    (actions.1, grids.2 + actions.2 + 1)) representativesdef initialConeReadWithWork {n : ℕ} (sourceLength : ℕ)    (read : OAI.EditApproximation.TargetInterval n → List Bool × ℕ) (a L : OAI.EditApproximation.BinaryFraction)    (query center : OAI.EditApproximation.TargetInterval n) : OAI.EditApproximation.BinaryFraction × ℕ :=  let seed := read center  let result := OAI.EditApproximation.BinaryFraction.initialConeWithWork sourceLength (fun _ => OAI.EditApproximation.bitWordValue seed.1) a L query center  (result.1, seed.2 + result.2)def wideMinimumReadAllocation {n M : ℕ} (r : OAI.EditApproximation.TargetInterval n)    (read : Fin M → OAI.EditApproximation.TargetInterval n → OAI.EditApproximation.BinaryFraction × ℕ)    (footprint : Fin M → OAI.EditApproximation.TargetInterval n → ℕ)    (actions : List (Fin M → OAI.EditApproximation.TargetInterval n)) (hne : actions ≠ []) : ℕ :=  let fallback := (OAI.EditApproximation.BinaryFraction.endpointScoreReadWithWork r read (actions.head hne)).1  let scores := (OAI.EditApproximation.arithmeticMapWithWork (OAI.EditApproximation.BinaryFraction.endpointScoreReadWithWork r read) actions).1  OAI.EditApproximation.BinaryFraction.endpointScoreReadAllocation r read footprint (actions.head hne) +    OAI.EditApproximation.arithmeticMapAllocation (OAI.EditApproximation.BinaryFraction.endpointScoreReadAllocation r read footprint) actions +    OAI.EditApproximation.BinaryFraction.minimumAllocation fallback scores + 0def groupMemberSourceAllocation {M T : ℕ} (scales : Fin T → OAI.EditApproximation.BinaryFraction) (count : Fin T → ℕ)    (connection : OAI.EditApproximation.BinaryFraction) (envelope values : Vector OAI.EditApproximation.BinaryFraction M)    (draw : ∀ s : Fin T, Fin (count s) → Fin M × ℕ)    (allocation : ∀ s : Fin T, Fin (count s) → ℕ) : ℕ :=  let terms := (OAI.EditApproximation.arithmeticMapWithWork (fun s => OAI.EditApproximation.BinaryFraction.groupScaleSourceWithWork (count s) (scales s)    envelope values (draw s)) (List.finRange T)).1  OAI.EditApproximation.arithmeticMapAllocation (fun s => OAI.EditApproximation.BinaryFraction.groupScaleSourceAllocation (count s) (scales s) envelope values (draw s) (allocation s)) (List.finRange T) +    OAI.EditApproximation.BinaryFraction.sumListAllocation terms + OAI.EditApproximation.BinaryFraction.canonicalAddAllocation connection (OAI.EditApproximation.BinaryFraction.sumListWithWork terms).1def wideActionsFromRepresentativesAllocation {nx ny : ℕ} (M : ℕ) (parent : OAI.EditApproximation.TargetInterval nx)    (representatives : List (ℕ × OAI.EditApproximation.TargetInterval ny)) (P : ℕ) : ℕ :=  OAI.EditApproximation.arithmeticFlatMapAllocation (fun br =>    let grids := OAI.EditApproximation.wideActionGridWithWork M parent br.2 br.1 P    let actions := OAI.EditApproximation.arithmeticMapWithWork (fun states => OAI.EditApproximation.BinaryFraction.endpointActionWithWork br.2 states.get) grids.1    (actions.1, grids.2 + actions.2 + 1))    (fun br => OAI.EditApproximation.wideActionGridAllocation M parent br.2 br.1 P +      OAI.EditApproximation.arithmeticMapAllocation (fun states => OAI.EditApproximation.BinaryFraction.endpointActionAllocation br.2 states.get)        (OAI.EditApproximation.wideActionGridWithWork M parent br.2 br.1 P).1) representativesdef representativeFromActionsReadWithWork {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx)    (r : OAI.EditApproximation.TargetInterval ny) (sourceLength b : ℕ) (tau theta : OAI.EditApproximation.BinaryFraction)    (read : Fin M → OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BinaryFraction × ℕ)    (actions : List (Fin M → OAI.EditApproximation.TargetInterval ny)) : List (Fin M → OAI.EditApproximation.TargetInterval ny) × ℕ :=  if hne : actions = [] then ([], 1) else    let Z := OAI.EditApproximation.BinaryFraction.wideMinimumReadWithWork r read actions hne    let positive := OAI.EditApproximation.BinaryFraction.ltWithWork OAI.EditApproximation.BinaryFraction.zero Z.1    if positive.1 then      let gap := OAI.EditApproximation.BinaryFraction.stateGapWithWork sourceLength r      let velocity := OAI.EditApproximation.BinaryFraction.divWithWork gap.1 Z.1      let result := OAI.EditApproximation.BinaryFraction.bandFromActionsReadWithWork parent r b tau theta velocity.1 read actions hne      (result.1, Z.2 + positive.2 + gap.2 + velocity.2 + result.2 + 3)    else ([], Z.2 + positive.2 + 2)def physicalContinuationReadWithWork {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx)    (representatives : List (ℕ × OAI.EditApproximation.TargetInterval ny)) (P F : ℕ)    (delta fallback : OAI.EditApproximation.BinaryFraction)    (old current : Fin M × OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BinaryFraction × ℕ)    (groups online : List (OAI.EditApproximation.BinaryBellmanAction (OAI.EditApproximation.TargetInterval ny) (Fin M × OAI.EditApproximation.TargetInterval ny) M))    (query : OAI.EditApproximation.TargetInterval ny) : OAI.EditApproximation.BinaryFraction × ℕ :=  let wide := OAI.EditApproximation.BinaryFraction.wideActionsFromRepresentativesWithWork M parent representatives P  let L := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat 128) (OAI.EditApproximation.BinaryFraction.nat F)  let result := OAI.EditApproximation.BinaryFraction.localContinuationReadWithWork OAI.EditApproximation.BinaryFraction.endpointDistanceWithWork L.1 delta fallback    old current query wide.1 groups online  (result.1, wide.2 + L.2 + result.2 + 1)def initialMinimumReadWithWork {n : ℕ} (sourceLength : ℕ)    (read : OAI.EditApproximation.TargetInterval n → List Bool × ℕ) (N F : ℕ) (a : OAI.EditApproximation.BinaryFraction)    (query : OAI.EditApproximation.TargetInterval n) (centers : List (OAI.EditApproximation.TargetInterval n)) : OAI.EditApproximation.BinaryFraction × ℕ :=  let queryWord := read query  let zeroTest := OAI.EditApproximation.naturalEqualWithWork (OAI.EditApproximation.bitWordValue queryWord.1) 0  if zeroTest.1 then (OAI.EditApproximation.BinaryFraction.zero, queryWord.2 + zeroTest.2 + 1) else    let L := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat 32) (OAI.EditApproximation.BinaryFraction.nat F)    let coefficient := OAI.EditApproximation.BinaryFraction.canonicalAddWithWork L.1 OAI.EditApproximation.BinaryFraction.one    let fallback := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork coefficient.1 (OAI.EditApproximation.BinaryFraction.nat N)    let scores := OAI.EditApproximation.arithmeticMapWithWork (OAI.EditApproximation.BinaryFraction.initialConeReadWithWork sourceLength read a L.1 query) centers    let result := OAI.EditApproximation.BinaryFraction.minimumWithWork fallback.1 scores.1    (result.1, queryWord.2 + zeroTest.2 + L.2 + coefficient.2 + fallback.2 + scores.2 + result.2 +      Nat.size F + Nat.size N + 6)def localWarmupReadKernelWithWork {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx)    (N P F : ℕ) (a : OAI.EditApproximation.BinaryFraction) (initial : OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BinaryFraction × ℕ)    (child : Fin M × OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BinaryFraction × ℕ) (query : OAI.EditApproximation.TargetInterval ny) :    OAI.EditApproximation.BinaryFraction × ℕ :=  let fallback := initial query  let representatives := OAI.EditApproximation.BinaryFraction.localRepresentativeReadWithWork N P F a initial query  let actions := OAI.EditApproximation.BinaryFraction.wideActionsFromRepresentativesWithWork M parent representatives.1 P  let L := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat 128) (OAI.EditApproximation.BinaryFraction.nat F)  let result := OAI.EditApproximation.BinaryFraction.bellmanReadWithWork OAI.EditApproximation.BinaryFraction.endpointDistanceWithWork L.1 fallback.1 child query actions.1  (result.1, fallback.2 + representatives.2 + actions.2 + L.2 + result.2 + 3)def representativeFromActionsReadAllocation {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx)    (r : OAI.EditApproximation.TargetInterval ny) (sourceLength b : ℕ) (tau theta : OAI.EditApproximation.BinaryFraction)    (read : Fin M → OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BinaryFraction × ℕ)    (allocation : Fin M → OAI.EditApproximation.TargetInterval ny → ℕ)    (actions : List (Fin M → OAI.EditApproximation.TargetInterval ny)) : ℕ :=  if hne : actions = [] then 0 else    let Z := (OAI.EditApproximation.BinaryFraction.wideMinimumReadWithWork r read actions hne).1    OAI.EditApproximation.BinaryFraction.wideMinimumReadAllocation r read allocation actions hne + OAI.EditApproximation.BinaryFraction.ltAllocation OAI.EditApproximation.BinaryFraction.zero Z +      if (OAI.EditApproximation.BinaryFraction.ltWithWork OAI.EditApproximation.BinaryFraction.zero Z).1 then        OAI.EditApproximation.BinaryFraction.stateGapAllocation sourceLength r + OAI.EditApproximation.BinaryFraction.divAllocation (OAI.EditApproximation.BinaryFraction.stateGapWithWork sourceLength r).1 Z +          OAI.EditApproximation.BinaryFraction.bandFromActionsReadAllocation parent r b tau theta            (OAI.EditApproximation.BinaryFraction.divWithWork (OAI.EditApproximation.BinaryFraction.stateGapWithWork sourceLength r).1 Z).1 read allocation actions hne      else 0def physicalContinuationReadAllocation {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx)    (representatives : List (ℕ × OAI.EditApproximation.TargetInterval ny)) (P F : ℕ) (delta fallback : OAI.EditApproximation.BinaryFraction)    (old current : Fin M × OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BinaryFraction × ℕ)    (oldAllocation currentAllocation : Fin M × OAI.EditApproximation.TargetInterval ny → ℕ)    (groups online : List (OAI.EditApproximation.BinaryBellmanAction (OAI.EditApproximation.TargetInterval ny) (Fin M × OAI.EditApproximation.TargetInterval ny) M))    (query : OAI.EditApproximation.TargetInterval ny) : ℕ :=  OAI.EditApproximation.BinaryFraction.wideActionsFromRepresentativesAllocation M parent representatives P + OAI.EditApproximation.BinaryFraction.canonicalMulAllocation (OAI.EditApproximation.BinaryFraction.nat 128) (OAI.EditApproximation.BinaryFraction.nat F) +    OAI.EditApproximation.BinaryFraction.localContinuationReadAllocation OAI.EditApproximation.BinaryFraction.endpointDistanceWithWork OAI.EditApproximation.BinaryFraction.endpointDistanceAllocation      (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat 128) (OAI.EditApproximation.BinaryFraction.nat F)).1 delta fallback old current oldAllocation currentAllocation query      (OAI.EditApproximation.BinaryFraction.wideActionsFromRepresentativesWithWork M parent representatives P).1 groups onlinedef localWarmupReadAllocation {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx)    (N P F : ℕ) (a : OAI.EditApproximation.BinaryFraction) (initial : OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BinaryFraction × ℕ)    (initialAllocation : OAI.EditApproximation.TargetInterval ny → ℕ) (child : Fin M × OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BinaryFraction × ℕ)    (childAllocation : Fin M × OAI.EditApproximation.TargetInterval ny → ℕ) (query : OAI.EditApproximation.TargetInterval ny) : ℕ :=  let representatives := (OAI.EditApproximation.BinaryFraction.localRepresentativeReadWithWork N P F a initial query).1  let actions := (OAI.EditApproximation.BinaryFraction.wideActionsFromRepresentativesWithWork M parent representatives P).1  initialAllocation query + OAI.EditApproximation.BinaryFraction.localRepresentativeReadAllocation N P F a initial initialAllocation query +    OAI.EditApproximation.BinaryFraction.wideActionsFromRepresentativesAllocation M parent representatives P + OAI.EditApproximation.BinaryFraction.canonicalMulAllocation (OAI.EditApproximation.BinaryFraction.nat 128) (OAI.EditApproximation.BinaryFraction.nat F) +    OAI.EditApproximation.BinaryFraction.bellmanReadAllocation OAI.EditApproximation.BinaryFraction.endpointDistanceWithWork OAI.EditApproximation.BinaryFraction.endpointDistanceAllocation      (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat 128) (OAI.EditApproximation.BinaryFraction.nat F)).1 (initial query).1 child childAllocation query actionsdef preparedRepresentativeReadWithWork {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx)    (center : OAI.EditApproximation.TargetInterval ny) (sourceLength b P : ℕ) (tau theta : OAI.EditApproximation.BinaryFraction)    (read : Fin M → OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BinaryFraction × ℕ) : List (Fin M → OAI.EditApproximation.TargetInterval ny) × ℕ :=  let wide := OAI.EditApproximation.wideActionGridWithWork M parent center b P  let result := OAI.EditApproximation.BinaryFraction.representativeFromActionsReadWithWork parent center sourceLength b tau theta read    (wide.1.map Vector.get)  (result.1, wide.2 + result.2 + wide.1.length + 1)def initialProgramReadWithWork {n : ℕ} (sourceLength N P F : ℕ) (A a : OAI.EditApproximation.BinaryFraction)    (read : OAI.EditApproximation.TargetInterval n → List Bool × ℕ) (query : OAI.EditApproximation.TargetInterval n) : OAI.EditApproximation.BinaryFraction × ℕ :=  let centers := OAI.EditApproximation.BinaryFraction.initialCentersReadWithWork N P A read query  let result := OAI.EditApproximation.BinaryFraction.initialMinimumReadWithWork sourceLength read N F a query centers.1  (result.1, centers.2 + result.2 + 1)def preparedRepresentativeReadAllocation {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx)    (center : OAI.EditApproximation.TargetInterval ny) (sourceLength b P : ℕ) (tau theta : OAI.EditApproximation.BinaryFraction)    (read : Fin M → OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BinaryFraction × ℕ)    (allocation : Fin M → OAI.EditApproximation.TargetInterval ny → ℕ) : ℕ :=  let wide := (OAI.EditApproximation.wideActionGridWithWork M parent center b P).1  OAI.EditApproximation.wideActionGridAllocation M parent center b P + wide.length +    OAI.EditApproximation.BinaryFraction.representativeFromActionsReadAllocation parent center sourceLength b tau theta read allocation (wide.map Vector.get)def queryRefinementFinishAllocation {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx) (N P F : ℕ)    (a delta : OAI.EditApproximation.BinaryFraction) (initial : OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BinaryFraction × ℕ)    (initialAllocation : OAI.EditApproximation.TargetInterval ny → ℕ) (t : ℕ)    (earlierKeys : List (Fin M × ℕ × OAI.EditApproximation.TargetInterval ny)) (earlierWords : List OAI.EditApproximation.BinaryFraction)    (groups online : List (OAI.EditApproximation.BinaryBellmanAction (OAI.EditApproximation.TargetInterval ny) (Fin M × OAI.EditApproximation.TargetInterval ny) M))    (currentKeys : List (Fin M × OAI.EditApproximation.TargetInterval ny)) (currentWords : List OAI.EditApproximation.BinaryFraction)    (query : OAI.EditApproximation.TargetInterval ny) : ℕ :=  initialAllocation query + OAI.EditApproximation.BinaryFraction.localRepresentativeReadAllocation N P F a initial initialAllocation query +    OAI.EditApproximation.BinaryFraction.physicalContinuationReadAllocation parent (OAI.EditApproximation.BinaryFraction.localRepresentativeReadWithWork N P F a initial query).1 P F delta (initial query).1      (OAI.EditApproximation.BinaryFraction.queryHistoryReadWithWork earlierKeys earlierWords (t - 1))      (fun input => OAI.EditApproximation.BinaryFraction.queryChildReadWithWork currentKeys currentWords input.1 input.2)      (OAI.EditApproximation.BinaryFraction.queryHistoryReadAllocation earlierKeys earlierWords (t - 1))      (fun input => OAI.EditApproximation.BinaryFraction.queryChildReadAllocation currentKeys currentWords input.1 input.2) groups online querydef queryOnlineRangeWithWork {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx)    (P exponent H : ℕ) (tau : OAI.EditApproximation.BinaryFraction)    (child : Fin M → OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BinaryFraction × ℕ)    (key : ℕ × OAI.EditApproximation.TargetInterval ny) : ℕ × ℕ :=  let width := OAI.EditApproximation.saturatingSubtractWithWork parent.hi parent.lo  let band := OAI.EditApproximation.BinaryFraction.preparedRepresentativeReadWithWork parent key.2 (OAI.EditApproximation.bitWordValue width.1) key.1 P    tau (OAI.EditApproximation.BinaryFraction.inversePowerTwo exponent) child  let setup := OAI.EditApproximation.BinaryFraction.onlineIndexSetupWithWork H band.1  let power := OAI.EditApproximation.bitPowerWithWork setup.1.bits 80  let mass := OAI.EditApproximation.triangularMassWithWork (OAI.EditApproximation.bitWordValue power.1)  (OAI.EditApproximation.bitWordValue mass.1, width.2 + band.2 + setup.2 + power.2 + mass.2 + 4)def cachedInitialProgramReadWithWork {n : ℕ} (sourceLength N P F : ℕ) (A a : OAI.EditApproximation.BinaryFraction)    (read : OAI.EditApproximation.TargetInterval n → List Bool × ℕ) (query : OAI.EditApproximation.TargetInterval n) : OAI.EditApproximation.BinaryFraction × ℕ :=  OAI.EditApproximation.BinaryFraction.finishCachedWithWork (OAI.EditApproximation.BinaryFraction.initialProgramReadWithWork sourceLength N P F A a read query)    [true] (by decide) 0def queryOnlineRangeAllocation {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx)    (P exponent H : ℕ) (tau : OAI.EditApproximation.BinaryFraction)    (child : Fin M → OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BinaryFraction × ℕ)    (allocation : Fin M → OAI.EditApproximation.TargetInterval ny → ℕ) (key : ℕ × OAI.EditApproximation.TargetInterval ny) : ℕ :=  let width := (OAI.EditApproximation.saturatingSubtractWithWork parent.hi parent.lo).1  let band := (OAI.EditApproximation.BinaryFraction.preparedRepresentativeReadWithWork parent key.2 (OAI.EditApproximation.bitWordValue width) key.1 P    tau (OAI.EditApproximation.BinaryFraction.inversePowerTwo exponent) child).1  let setup := (OAI.EditApproximation.BinaryFraction.onlineIndexSetupWithWork H band).1  let power := (OAI.EditApproximation.bitPowerWithWork setup.bits 80).1  OAI.EditApproximation.saturatingSubtractAllocation parent.hi parent.lo +    OAI.EditApproximation.BinaryFraction.preparedRepresentativeReadAllocation parent key.2 (OAI.EditApproximation.bitWordValue width) key.1 P      tau (OAI.EditApproximation.BinaryFraction.inversePowerTwo exponent) child allocation + OAI.EditApproximation.BinaryFraction.onlineIndexSetupAllocation H band +    OAI.EditApproximation.bitPowerAllocation setup.bits 80 + OAI.EditApproximation.triangularMassAllocation (OAI.EditApproximation.bitWordValue power)end OAI.EditApproximation.BinaryFractionendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.PositionCountsdef count : OAI.EditApproximation.PositionCounts → ℕ  | .empty => 0  | .node n _ _ => ndef left : OAI.EditApproximation.PositionCounts → OAI.EditApproximation.PositionCounts  | .empty => .empty  | .node _ l _ => ldef right : OAI.EditApproximation.PositionCounts → OAI.EditApproximation.PositionCounts  | .empty => .empty  | .node _ _ r => rdef storageBits : OAI.EditApproximation.PositionCounts → ℕ  | .empty => 0  | .node n l r => Nat.size n + 3 + l.storageBits + r.storageBitsdef add (tree : OAI.EditApproximation.PositionCounts) : ℕ → ℕ → OAI.EditApproximation.PositionCounts  | 0, _ => .node (tree.count + 1) tree.left tree.right  | d + 1, i =>    if i < 2 ^ d then      .node (tree.count + 1) (tree.left.add d i) tree.right    else .node (tree.count + 1) tree.left (tree.right.add d (i - 2 ^ d))def addWithWork (tree : OAI.EditApproximation.PositionCounts) : ℕ → ℕ → OAI.EditApproximation.PositionCounts × ℕ  | 0, _ => (.node (tree.count + 1) tree.left tree.right, 1)  | d + 1, i =>    if i < 2 ^ d then      let result := tree.left.addWithWork d i      (.node (tree.count + 1) result.1 tree.right, result.2 + 2)    else      let result := tree.right.addWithWork d (i - 2 ^ d)      (.node (tree.count + 1) tree.left result.1, result.2 + 2)def prefixWithWork (tree : OAI.EditApproximation.PositionCounts) : ℕ → ℕ → ℕ × ℕ  | 0, t => (if t = 0 then 0 else tree.count, 1)  | d + 1, t =>    if t ≤ 2 ^ d then      let result := tree.left.prefixWithWork d t      (result.1, result.2 + 2)    else      let result := tree.right.prefixWithWork d (t - 2 ^ d)      (tree.left.count + result.1, result.2 + 2)end OAI.EditApproximation.PositionCountsendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.BitQuery.Footprintdef bind {ι : Type u_1} {α : Type u_2} {β : Type u_3} {program : OAI.EditApproximation.BitQuery ι α} (heap : OAI.EditApproximation.BitQuery.Footprint program)    (next : α → OAI.EditApproximation.BitQuery ι β) (allocation : ∀ value, OAI.EditApproximation.BitQuery.Footprint (next value)) :    OAI.EditApproximation.BitQuery.Footprint (program.bind next) :=  match heap with  | .done result => allocation result  | .read key continuation stored => .read key _ (fun word => (stored word).bind next allocation)  | .charge localCells tail => .charge localCells (tail.bind next allocation)def compute {ι : Type u_1} {β : Type u_2} (execution : β × ℕ) (allocation : ℕ) :    OAI.EditApproximation.BitQuery.Footprint (OAI.EditApproximation.BitQuery.compute (ι := ι) execution) :=  .charge allocation (.done execution.1)def chargeOf {ι : Type u_1} {β : Type u_2} {steps : ℕ} {program : OAI.EditApproximation.BitQuery ι β} (allocation : ℕ)    (tail : OAI.EditApproximation.BitQuery.Footprint program) : OAI.EditApproximation.BitQuery.Footprint (.charge steps program) :=  .charge allocation taildef runCells {ι : Type u_1} {κ : Type u_2}    (ask : ι → OAI.EditApproximation.BinaryMemo OAI.EditApproximation.BinaryFraction → OAI.EditApproximation.BitRecursiveMemoResult κ)    (childCells : ι → OAI.EditApproximation.BinaryMemo OAI.EditApproximation.BinaryFraction → ℕ)    {program : OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction} : OAI.EditApproximation.BitQuery.Footprint program → OAI.EditApproximation.BinaryMemo OAI.EditApproximation.BinaryFraction → ℕ  | .done _, _ => 0  | .read key _ continuation, memory =>    let first := ask key memory    3 + childCells key memory + (continuation first.value).runCells ask childCells first.memory  | .charge cells next, memory => cells + next.runCells ask childCells memorydef computeOf {ι : Type u_1} {β : Type u_2} (execution : β × ℕ) (allocation : ℕ) :    OAI.EditApproximation.BitQuery.Footprint (OAI.EditApproximation.BitQuery.compute (ι := ι) execution) :=  OAI.EditApproximation.BitQuery.Footprint.compute execution allocationdef collect {ι : Type u_1} {κ : Type u_2} {β : Type u_3} (reader : κ → OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction)    (allocation : ∀ key, OAI.EditApproximation.BitQuery.Footprint (reader key)) :    (inputs : List κ) → (next : List OAI.EditApproximation.BinaryFraction → OAI.EditApproximation.BitQuery ι β) →      (∀ words, OAI.EditApproximation.BitQuery.Footprint (next words)) → OAI.EditApproximation.BitQuery.Footprint (OAI.EditApproximation.BitQuery.collect reader inputs next)  | [], _, continuation => continuation []  | key :: rest, next, continuation =>    (allocation key).bind _ fun word => .charge 1      (collect reader allocation rest (fun words => next (word :: words))        (fun words => continuation (word :: words)))def mapKeysWithWork {ι : Type u_1} {κ : Type u_2} {β : Type u_3} (f : ι → κ × ℕ) (allocation : ι → ℕ)    {program : OAI.EditApproximation.BitQuery ι β} (heap : OAI.EditApproximation.BitQuery.Footprint program) : OAI.EditApproximation.BitQuery.Footprint (program.mapKeysWithWork f) :=  match heap with  | .done result => .done result  | .read key next continuation =>    OAI.EditApproximation.BitQuery.Footprint.chargeOf (allocation key)      (.read (f key).1 _ (fun word => (continuation word).mapKeysWithWork f allocation))  | .charge localCells next => .charge localCells (next.mapKeysWithWork f allocation)def restrictWithWork {ι : Type u_1} (P : ι → Prop)    (test : ι → Bool × ℕ) (htest : ∀ key, (test key).1 = true ↔ P key)    (allocation : ι → ℕ)    {program : OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction} (heap : OAI.EditApproximation.BitQuery.Footprint program) :    OAI.EditApproximation.BitQuery.Footprint (program.restrictWithWork P test htest) :=  match heap with  | .done result => .done result  | .charge localCells next => .charge localCells (next.restrictWithWork P test htest allocation)  | .read key next continuation =>    OAI.EditApproximation.BitQuery.Footprint.chargeOf (allocation key)      (by        split        · exact .read _ _ (fun word => (continuation word).restrictWithWork P test htest allocation)        · exact (continuation (OAI.EditApproximation.BinaryFraction.nat 0)).restrictWithWork P test htest allocation)def normalize {ι : Type u_1} {program : OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction} (heap : OAI.EditApproximation.BitQuery.Footprint program)    (base : List Bool) (hbase : 0 < OAI.EditApproximation.bitWordValue base) (remaining : ℕ) :    OAI.EditApproximation.BitQuery.Footprint (program.normalize base hbase remaining) :=  heap.bind _ fun word => OAI.EditApproximation.BitQuery.Footprint.computeOf (OAI.EditApproximation.BinaryFraction.finishCachedWithWork (word, 0) base hbase remaining)    (OAI.EditApproximation.BinaryFraction.finishCachedAllocation (word, 0) 0 base hbase remaining)end OAI.EditApproximation.BitQuery.Footprintendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationdef bandActionPredicate {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx)    (r : OAI.EditApproximation.TargetInterval ny) (b : ℕ) (tau theta velocity : ℚ)    (actions : List (Fin M → OAI.EditApproximation.TargetInterval ny)) (hnonempty : actions ≠ [])    (child : Fin M → OAI.EditApproximation.TargetInterval ny → ℚ) (states : Fin M → OAI.EditApproximation.TargetInterval ny) : Prop :=  OAI.EditApproximation.endpointActionConnection r states = 0 ∧    (∀ i, Nat.dist (r.lo + ((OAI.EditApproximation.sourceChild parent i).lo - parent.lo)) (states i).lo ≤ 6 * b ∧      Nat.dist (r.lo + ((OAI.EditApproximation.sourceChild parent i).hi - parent.lo)) (states i).hi ≤ 6 * b) ∧    ∀ j : Fin M, 0 < j.val →      |bandCutShift parent states j - ((r.lo : ℚ) - parent.lo) - velocity *        OAI.EditApproximation.rationalWidePrefixMinimum parent r actions hnonempty child j.val (OAI.EditApproximation.bandCutShift parent states j)| ≤          tau * theta * b / Mdef queryOnlineSourceGather {ι : Type u_1} {β : Type u_2} {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx)    (N P F exponent H : ℕ) (hP : 0 < P) (tau a : OAI.EditApproximation.BinaryFraction)    (initial : OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BinaryFraction × ℕ)    (child : Fin M → OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BinaryFraction × ℕ) (q : OAI.EditApproximation.TargetInterval ny)    (reader : (ℕ × OAI.EditApproximation.TargetInterval ny) → ℕ → OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction)    (next : List (ℕ × OAI.EditApproximation.TargetInterval ny) → List OAI.EditApproximation.BinaryFraction → OAI.EditApproximation.BitQuery ι β) : OAI.EditApproximation.BitQuery ι β :=  let query := initial q  .charge query.2 ((OAI.EditApproximation.BitQuery.compute (OAI.EditApproximation.BinaryFraction.queryOnlineKeysWithWork N P F hP a query.1 q)).bind    fun keys => OAI.EditApproximation.BitQuery.collect (fun key =>      (OAI.EditApproximation.BitQuery.compute (OAI.EditApproximation.BinaryFraction.queryOnlineRangeWithWork parent P exponent H tau child key)).bind        (reader key)) keys (next keys))def coarseLabelChildren {B d : ℕ} {α : Type u_1} (Q lam allowance : ℚ)    (work : OAI.EditApproximation.CoarseSourceTree B α d → OAI.EditApproximation.CoarseThresholdDraws B d → ℚ → ℕ) :    List (OAI.EditApproximation.CoarseSourceTree B α d × Fin B × OAI.EditApproximation.CoarseThresholdDraws B d) → ℕ  | [] => 0  | (child, draw, below) :: rest =>    work child below (lam * OAI.EditApproximation.coarseChildThreshold B Q allowance draw) +      coarseLabelChildren Q lam allowance work restinstance bandActionPredicateDecidable {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx)    (r : OAI.EditApproximation.TargetInterval ny) (b : ℕ) (tau theta velocity : ℚ)    (actions : List (Fin M → OAI.EditApproximation.TargetInterval ny)) (hnonempty : actions ≠ [])    (child : Fin M → OAI.EditApproximation.TargetInterval ny → ℚ) (states : Fin M → OAI.EditApproximation.TargetInterval ny) :    Decidable (OAI.EditApproximation.bandActionPredicate parent r b tau theta velocity actions hnonempty child states) := by  unfold OAI.EditApproximation.bandActionPredicate  infer_instancedef computedBandActions {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx)    (r : OAI.EditApproximation.TargetInterval ny) (b P : ℕ) (tau theta velocity : ℚ)    (child : Fin M → OAI.EditApproximation.TargetInterval ny → ℚ) : List (Fin M → OAI.EditApproximation.TargetInterval ny) :=  let actions := OAI.EditApproximation.wideActionList M parent r b P  if h : actions = [] then [] else    if |velocity| ≤ 1 - tau then      actions.filter (fun states => decide (OAI.EditApproximation.bandActionPredicate parent r b tau theta velocity actions h child states))    else []end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen Finsetdef rationalEndpointActionValue {ny M : ℕ} (r : OAI.EditApproximation.TargetInterval ny)    (states : Fin M → OAI.EditApproximation.TargetInterval ny) (child : Fin M → OAI.EditApproximation.TargetInterval ny → ℚ) : ℚ :=  OAI.EditApproximation.endpointActionConnection r states + ∑ i, child i (states i)def rationalActualWideActions {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx)    (representatives : List (ℕ × OAI.EditApproximation.TargetInterval ny)) (P : ℕ) :    List (OAI.EditApproximation.RationalBellmanAction (OAI.EditApproximation.TargetInterval ny) (Fin M × OAI.EditApproximation.TargetInterval ny) M) :=  representatives.flatMap fun br => (OAI.EditApproximation.wideActionList M parent br.2 br.1 P).map fun states =>    ⟨br.2, OAI.EditApproximation.endpointActionConnection br.2 states, fun i => (i, states i)⟩def groupQueriedChildLabels (M Q b : ℕ) (h : ℚ)    (draw : Fin (OAI.EditApproximation.groupSampleCount M Q b h) → Fin M) : Finset (Fin M) :=  if OAI.EditApproximation.groupSampleCount M Q b h = M then univ else univ.image drawdef rationalWideActionMinimum {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx)    (r : OAI.EditApproximation.TargetInterval ny) (b P : ℕ) (hnonempty : OAI.EditApproximation.wideActionList M parent r b P ≠ [])    (child : Fin M → OAI.EditApproximation.TargetInterval ny → ℚ) : ℚ :=  OAI.EditApproximation.rationalMinimum (OAI.EditApproximation.rationalEndpointActionValue r ((OAI.EditApproximation.wideActionList M parent r b P).head hnonempty) child)    ((OAI.EditApproximation.wideActionList M parent r b P).map fun states => OAI.EditApproximation.rationalEndpointActionValue r states child)def groupCurrentInputCover {α : Type u_1} (source target : List α) {M : ℕ}    (parent : OAI.EditApproximation.TargetInterval source.length) (b exponent Q : ℕ) (cell : ℕ × ℕ) (h : ℚ)    (draw : Fin (OAI.EditApproximation.groupSampleCount M Q b h) → Fin M) : Finset (Fin M × OAI.EditApproximation.TargetInterval target.length) :=  (OAI.EditApproximation.groupQueriedChildLabels M Q b h draw).biUnion fun i =>    (OAI.EditApproximation.groupRoundedStateList source target parent b exponent cell i h).toFinset.image fun r => (i, r)def representativeBandActions {α : Type u_1} (source target : List α)    {M : ℕ} (parent : OAI.EditApproximation.TargetInterval source.length) (r : OAI.EditApproximation.TargetInterval target.length)    (b P : ℕ) (tau theta : ℚ) (child : Fin M → OAI.EditApproximation.TargetInterval target.length → ℚ) :    List (Fin M → OAI.EditApproximation.TargetInterval target.length) :=  if h : OAI.EditApproximation.wideActionList M parent r b P = [] then [] else    let Z := OAI.EditApproximation.rationalWideActionMinimum parent r b P h child    if 0 < Z then      OAI.EditApproximation.computedBandActions parent r b P tau theta        (OAI.EditApproximation.rationalStateGap (OAI.EditApproximation.substring source parent.lo parent.hi) target r / Z) child    else []structure UnskippedBand {α : Type u_1} (source target : List α) {M : ℕ}    (parent : OAI.EditApproximation.TargetInterval source.length) (b P thetaExponent : ℕ)    (tau F : ℚ) (child initial : Fin M → OAI.EditApproximation.TargetInterval target.length → ℚ) where  center : OAI.EditApproximation.TargetInterval target.length  nonempty : OAI.EditApproximation.representativeBandActions source target parent center b P tau    ((2 : ℚ) ^ (-(thetaExponent : ℤ))) child ≠ []  sum_guard : (∑ i, OAI.EditApproximation.bandChildEnvelope b (OAI.EditApproximation.representativeBandActions source target parent center b P tau    ((2 : ℚ) ^ (-(thetaExponent : ℤ))) child) initial i) ≤ 64 * F * b  wide_guard : OAI.EditApproximation.canonicalRoundedBandAction thetaExponent b    (OAI.EditApproximation.representativeBandActions source target parent center b P tau      ((2 : ℚ) ^ (-(thetaExponent : ℤ))) child) nonempty initial ∈ OAI.EditApproximation.wideActionList M parent center b P  imbalance_guard : ∀ i, |rationalStateGap    (OAI.EditApproximation.substring source (OAI.EditApproximation.sourceChild parent i).lo (OAI.EditApproximation.sourceChild parent i).hi) target    (OAI.EditApproximation.canonicalRoundedBandAction thetaExponent b      (OAI.EditApproximation.representativeBandActions source target parent center b P tau        ((2 : ℚ) ^ (-(thetaExponent : ℤ))) child) nonempty initial i)| ≤      2 * OAI.EditApproximation.bandChildEnvelope b (OAI.EditApproximation.representativeBandActions source target parent center b P tau        ((2 : ℚ) ^ (-(thetaExponent : ℤ))) child) initial idef keyedOnlineBandG {α : Type u_1} (source target : List α) {M : ℕ}    (parent : OAI.EditApproximation.TargetInterval source.length) (P exponent H b : ℕ) (tau : ℚ)    (child : Fin M → OAI.EditApproximation.TargetInterval target.length → ℚ) (r : OAI.EditApproximation.TargetInterval target.length) : ℕ :=  H + (OAI.EditApproximation.bandCoordinates (OAI.EditApproximation.representativeBandActions source target parent r b P tau    ((2 : ℚ) ^ (-(exponent : ℤ))) child).toFinset).card + 2def testUnskippedBand {α : Type u_1} (source target : List α) {M : ℕ}    (parent : OAI.EditApproximation.TargetInterval source.length) (b P thetaExponent : ℕ)    (tau F : ℚ) (child initial : Fin M → OAI.EditApproximation.TargetInterval target.length → ℚ)    (center : OAI.EditApproximation.TargetInterval target.length) :    Option (OAI.EditApproximation.UnskippedBand source target parent b P thetaExponent tau F child initial) :=  let band := OAI.EditApproximation.representativeBandActions source target parent center b P tau    ((2 : ℚ) ^ (-(thetaExponent : ℤ))) child  if hband : band = [] then none else    if hsum : (∑ i, OAI.EditApproximation.bandChildEnvelope b band initial i) ≤ 64 * F * b then      let rounded := OAI.EditApproximation.canonicalRoundedBandAction thetaExponent b band hband initial      if hwide : rounded ∈ OAI.EditApproximation.wideActionList M parent center b P then        if hgap : ∀ i, |rationalStateGap            (OAI.EditApproximation.substring source (OAI.EditApproximation.sourceChild parent i).lo (OAI.EditApproximation.sourceChild parent i).hi) target (rounded i)| ≤              2 * OAI.EditApproximation.bandChildEnvelope b band initial i then          some ⟨center, hband, hsum, hwide, hgap⟩        else none      else none    else nonedef unskippedBandList {α : Type u_1} (source target : List α) {M : ℕ}    (parent : OAI.EditApproximation.TargetInterval source.length) (b P thetaExponent : ℕ)    (tau F : ℚ) (child initial : Fin M → OAI.EditApproximation.TargetInterval target.length → ℚ)    (centers : List (OAI.EditApproximation.TargetInterval target.length)) :    List (OAI.EditApproximation.UnskippedBand source target parent b P thetaExponent tau F child initial) :=  centers.filterMap (OAI.EditApproximation.testUnskippedBand source target parent b P thetaExponent tau F child initial)def keyedOnlineCandidate {α : Type u_1} (source target : List α) {M : ℕ}    (parent : OAI.EditApproximation.TargetInterval source.length) (P F exponent H b : ℕ) (tau eta kappa : ℚ)    (child initial : Fin M → OAI.EditApproximation.TargetInterval target.length → ℚ)    (children : OAI.EditApproximation.PhysicalChildTables M target.length) (t : ℕ)    (r : OAI.EditApproximation.TargetInterval target.length) (integer : ℕ) :    Option (OAI.EditApproximation.PhysicalRationalAction M target.length) := by  have proof_optimizerTriangularMass_succ_66 (K : ℕ) :      OAI.EditApproximation.optimizerTriangularMass (K + 1) = OAI.EditApproximation.optimizerTriangularMass K + (K + 1) := by    unfold OAI.EditApproximation.optimizerTriangularMass    rw [sum_range_succ]  have proof_optimizerTriangularMass_twice_67 (K : ℕ) :      2 * OAI.EditApproximation.optimizerTriangularMass K = K * (K + 1) := by    induction K with    | zero => simp [OAI.EditApproximation.optimizerTriangularMass]    | succ K ih =>      rw [proof_optimizerTriangularMass_succ_66]      nlinarith  have proof_optimizerTriangularMass_positive_77 (K : ℕ) (hK : LT.lt.{0} 0 K) :      0 < OAI.EditApproximation.optimizerTriangularMass K := by    have hproduct : 0 < K * (K + 1) := Nat.mul_pos hK (by omega)    rw [← proof_optimizerTriangularMass_twice_67 K] at hproduct    omega  have proof_keyedOnlineBandG_positive_78 {α : Type u_1} (source : List.{u_1} α) (target : List.{u_1} α) {M : ℕ} (parent : OAI.EditApproximation.TargetInterval (List.length.{u_1} source)) (P : ℕ) (exponent : ℕ) (H : ℕ) (b : ℕ) (tau : ℚ) (child : Fin M → OAI.EditApproximation.TargetInterval (List.length.{u_1} target) → ℚ) (r : OAI.EditApproximation.TargetInterval (List.length.{u_1} target)) :      0 < OAI.EditApproximation.keyedOnlineBandG source target parent P exponent H b tau child r := by    unfold OAI.EditApproximation.keyedOnlineBandG    omega  exact    let band := OAI.EditApproximation.representativeBandActions source target parent r b P tau      ((2 : ℚ) ^ (-(exponent : ℤ))) child    let envelope := OAI.EditApproximation.bandChildEnvelope b band initial    let G := OAI.EditApproximation.keyedOnlineBandG source target parent P exponent H b tau child r    let K := G ^ 80    let accepted := OAI.EditApproximation.boundedOnlineInteger (OAI.EditApproximation.optimizerTriangularMass K)      (proof_optimizerTriangularMass_positive_77 _        (pow_pos (proof_keyedOnlineBandG_positive_78 source target parent P exponent H b tau child r) 80)) integer    if hband : band = [] then none else      match OAI.EditApproximation.testUnskippedBand source target parent b P exponent tau F child initial r with      | none => none      | some _ => some (OAI.EditApproximation.sharedBandRationalAction r          (OAI.EditApproximation.finiteOptimizerActionDraw band hband envelope            (OAI.EditApproximation.rationalOnlineLinear eta kappa              (OAI.EditApproximation.childGain envelope (fun s coordinate => children coordinate.1 s coordinate.2))              (OAI.EditApproximation.childDecrement envelope (fun s coordinate => children coordinate.1 s coordinate.2)) t)            G K accepted))def cellUnskippedBands {α : Type u_1} (source target : List α) {M : ℕ}    (parent : OAI.EditApproximation.TargetInterval source.length) (b P F thetaExponent : ℕ) (tau a : ℚ)    (parentInitial : OAI.EditApproximation.TargetInterval target.length → ℚ)    (child initial : Fin M → OAI.EditApproximation.TargetInterval target.length → ℚ) (cell : ℕ × ℕ) :=  OAI.EditApproximation.unskippedBandList source target parent b P thetaExponent tau F child initial    (OAI.EditApproximation.cellRepresentativeStates target.length P F b a parentInitial      ((2 : ℚ) ^ (-(thetaExponent : ℤ))) cell)def localOnlineCandidates {α : Type u_1} (source target : List α) {M : ℕ}    (parent : OAI.EditApproximation.TargetInterval source.length) (N P F exponent H : ℕ) (tau a eta kappa : ℚ)    (parentInitial : OAI.EditApproximation.TargetInterval target.length → ℚ)    (child initial : Fin M → OAI.EditApproximation.TargetInterval target.length → ℚ)    (children : OAI.EditApproximation.PhysicalChildTables M target.length) (t : ℕ)    (integer : ℕ → OAI.EditApproximation.TargetInterval target.length → ℕ)    (q : OAI.EditApproximation.TargetInterval target.length) : List (OAI.EditApproximation.PhysicalRationalAction M target.length) :=  (OAI.EditApproximation.dyadicQueryWindow N (parentInitial q) a F).filterMap fun b =>    let r := OAI.EditApproximation.roundInterval (OAI.EditApproximation.seedGridSpacing b P) q    if (b : ℚ) / (4 * a) ≤ parentInitial r ∧ parentInitial r ≤ 8 * F * b then      OAI.EditApproximation.keyedOnlineCandidate source target parent P F exponent H b tau eta kappa        child initial children t r (integer b r)    else noneend OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.BinaryMemovariable {α : Type u_1}def value : OAI.EditApproximation.BinaryMemo α → Option α  | .empty => none  | .node v _ _ => vdef left : OAI.EditApproximation.BinaryMemo α → OAI.EditApproximation.BinaryMemo α  | .empty => .empty  | .node _ l _ => ldef right : OAI.EditApproximation.BinaryMemo α → OAI.EditApproximation.BinaryMemo α  | .empty => .empty  | .node _ _ r => rdef lookup (tree : OAI.EditApproximation.BinaryMemo α) : List Bool → Option α  | [] => tree.value  | false :: rest => tree.left.lookup rest  | true :: rest => tree.right.lookup restdef insert (tree : OAI.EditApproximation.BinaryMemo α) : List Bool → α → OAI.EditApproximation.BinaryMemo α  | [], a => .node (some a) tree.left tree.right  | false :: rest, a => .node tree.value (tree.left.insert rest a) tree.right  | true :: rest, a => .node tree.value tree.left (tree.right.insert rest a)def lookupCosted (tree : OAI.EditApproximation.BinaryMemo α) : List Bool → Option α × ℕ  | [] => (tree.value, 1)  | false :: rest =>    let result := tree.left.lookupCosted rest    (result.1, result.2 + 1)  | true :: rest =>    let result := tree.right.lookupCosted rest    (result.1, result.2 + 1)def insertCosted (tree : OAI.EditApproximation.BinaryMemo α) : List Bool → α → OAI.EditApproximation.BinaryMemo α × ℕ  | [], a => (.node (some a) tree.left tree.right, 1)  | false :: rest, a =>    let result := tree.left.insertCosted rest a    (.node tree.value result.1 tree.right, result.2 + 1)  | true :: rest, a =>    let result := tree.right.insertCosted rest a    (.node tree.value tree.left result.1, result.2 + 1)end OAI.EditApproximation.BinaryMemoendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationdef rankedMemoEvaluate {κ : Type u_1} (rank : κ → ℕ)    (program : (key : κ) → OAI.EditApproximation.FiniteQuery {child : κ // rank child < rank key})    (bits : ℕ) (encode : κ → ℕ) (key : κ) (memory : OAI.EditApproximation.BinaryMemo ℚ) : OAI.EditApproximation.RecursiveMemoResult κ :=  let found := memory.lookupCosted (OAI.EditApproximation.binaryMemoKey bits (encode key))  match found.1 with  | some result => ⟨result, memory, [], found.2, 1⟩  | none =>    let result := OAI.EditApproximation.FiniteQuery.run (fun child previous =>      rankedMemoEvaluate rank program bits encode child.val previous) (program key) memory    let stored := result.memory.insertCosted (OAI.EditApproximation.binaryMemoKey bits (encode key)) result.value    ⟨result.value, stored.1, key :: result.freshKeys,      found.2 + result.dictionaryVisits + stored.2, result.requests + 1⟩termination_by rank keydecreasing_by exact child.propertydef localWarmupStepQuery {ι : Type u_1} {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx)    (N P F : ℕ) (a : ℚ) (initialRead : OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.FiniteQuery ι)    (childRead : Fin M × OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.FiniteQuery ι) (q : OAI.EditApproximation.TargetInterval ny) :    OAI.EditApproximation.FiniteQuery ι :=  OAI.EditApproximation.FiniteQuery.bind (initialRead q) fun value =>    let centers := OAI.EditApproximation.rawRefinementCenters N P F a value q    OAI.EditApproximation.FiniteQuery.collect initialRead centers fun answers =>      let initial := fun r => if r = q then value else OAI.EditApproximation.finiteAnswerTable centers answers r      let representatives := OAI.EditApproximation.localRefinementRepresentatives N P F a initial q      let inputs := OAI.EditApproximation.wideWarmupInputs (M := M) parent P representatives      OAI.EditApproximation.FiniteQuery.collect childRead inputs fun values =>        .done (OAI.EditApproximation.rationalBellman initial (fun q r => OAI.EditApproximation.targetEndpointDistance q r) (128 * F)          (OAI.EditApproximation.rationalActualWideActions parent representatives P) (OAI.EditApproximation.finiteAnswerTable inputs values) q)def keyedOnlineSourceRange {α : Type u_1} (source target : List α) {M : ℕ}    (parent : OAI.EditApproximation.TargetInterval source.length) (P exponent H : ℕ) (tau : ℚ)    (child : Fin M → OAI.EditApproximation.TargetInterval target.length → ℚ) (key : ℕ × OAI.EditApproximation.TargetInterval target.length) : ℕ :=  OAI.EditApproximation.optimizerTriangularMass (OAI.EditApproximation.keyedOnlineBandG source target parent P exponent H key.1 tau child key.2 ^ 80)def occurrenceBuild (symbolBits positionBits : ℕ) : List (ℕ × ℕ) → OAI.EditApproximation.BinaryMemo OAI.EditApproximation.PositionCounts  | [] => .empty  | e :: es =>    let table := occurrenceBuild symbolBits positionBits es    let key := OAI.EditApproximation.binaryMemoKey symbolBits e.1    let old := (table.lookup key).getD .empty    table.insert key (old.add positionBits e.2)def occurrenceBuildWithWork (symbolBits positionBits : ℕ) :    List (ℕ × ℕ) → OAI.EditApproximation.BinaryMemo OAI.EditApproximation.PositionCounts × ℕ  | [] => (.empty, 0)  | e :: es =>    let previous := occurrenceBuildWithWork symbolBits positionBits es    let key := OAI.EditApproximation.binaryMemoKey symbolBits e.1    let found := previous.1.lookupCosted key    let inserted := (found.1.getD .empty).addWithWork positionBits e.2    let updated := previous.1.insertCosted key inserted.1    (updated.1, previous.2 + symbolBits + found.2 + inserted.2 + updated.2 + 2)def occurrenceQueryWithWork (table : OAI.EditApproximation.BinaryMemo OAI.EditApproximation.PositionCounts)    (symbolBits positionBits a lo hi : ℕ) : Bool × ℕ :=  let key := OAI.EditApproximation.binaryMemoKey symbolBits a  let found := table.lookupCosted key  let tree := found.1.getD .empty  let first := tree.prefixWithWork positionBits lo  let last := tree.prefixWithWork positionBits hi  (decide (first.1 < last.1), symbolBits + found.2 + first.2 + last.2 + 2)def rankedBitMemoEvaluate {κ : Type u_1} (rank : κ → ℕ)    (program : (key : κ) → OAI.EditApproximation.BitQuery {child : κ // rank child < rank key} OAI.EditApproximation.BinaryFraction)    (bits : ℕ) (encode : κ → ℕ) (key : κ) (memory : OAI.EditApproximation.BinaryMemo OAI.EditApproximation.BinaryFraction) :    OAI.EditApproximation.BitRecursiveMemoResult κ :=  let found := memory.lookupCosted (OAI.EditApproximation.binaryMemoKey bits (encode key))  match found.1 with  | some result => ⟨result, memory, [], found.2, 1, 0⟩  | none =>    let result := OAI.EditApproximation.BitQuery.runMemo (fun child previous =>      rankedBitMemoEvaluate rank program bits encode child.val previous) (program key) memory    let stored := result.memory.insertCosted (OAI.EditApproximation.binaryMemoKey bits (encode key)) result.value    ⟨result.value, stored.1, key :: result.freshKeys,      found.2 + result.dictionaryVisits + stored.2, result.requests + 1, result.localWork⟩termination_by rank keydecreasing_by exact child.propertydef physicalWarmupStepQuery {ι : Type u_1} {α : Type u_2} [DecidableEq α] {M J : ℕ}    (source target : List α) (N P F : ℕ) (A : ℚ)    (seedRead : OAI.EditApproximation.PhysicalEntry M J target.length → OAI.EditApproximation.FiniteQuery ι)    (childRead : Fin M × OAI.EditApproximation.TargetInterval target.length → OAI.EditApproximation.FiniteQuery ι)    (node : OAI.EditApproximation.PhysicalNode M J) (q : OAI.EditApproximation.TargetInterval target.length) : OAI.EditApproximation.FiniteQuery ι :=  OAI.EditApproximation.localWarmupStepQuery (OAI.EditApproximation.physicalSourceInterval source.length node) N P F (OAI.EditApproximation.refinementFactor A F)    (fun r => OAI.EditApproximation.physicalInitialQuery source target N P F A seedRead (node, r)) childRead qdef indexedSingletonCostWithWork (table : OAI.EditApproximation.BinaryMemo OAI.EditApproximation.PositionCounts)    (symbolBits positionBits a lo hi : ℕ) : ℕ × ℕ :=  if lo = hi then (1, 1) else    let query := OAI.EditApproximation.occurrenceQueryWithWork table symbolBits positionBits a lo hi    (hi - lo - if query.1 = true then 1 else 0, query.2 + 4)def integerOccurrenceIndex (source target : List ℤ) : OAI.EditApproximation.BinaryMemo OAI.EditApproximation.PositionCounts :=  OAI.EditApproximation.occurrenceBuild (OAI.EditApproximation.integerInputSymbolBits source target) (OAI.EditApproximation.integerInputPositionBits target)    (target.map OAI.EditApproximation.integerSymbolCode).zipIdxdef integerOccurrenceBuildWithWork (source target : List ℤ) : OAI.EditApproximation.BinaryMemo OAI.EditApproximation.PositionCounts × ℕ :=  OAI.EditApproximation.occurrenceBuildWithWork (OAI.EditApproximation.integerInputSymbolBits source target) (OAI.EditApproximation.integerInputPositionBits target)    (target.map OAI.EditApproximation.integerSymbolCode).zipIdxdef rankedMemoAddressWork {κ : Type u_1} (rank : κ → ℕ)    (program : (key : κ) → OAI.EditApproximation.FiniteQuery {child : κ // rank child < rank key})    (bits : ℕ) (encode cost : κ → ℕ) (key : κ) (memory : OAI.EditApproximation.BinaryMemo ℚ) : ℕ :=  match (memory.lookupCosted (OAI.EditApproximation.binaryMemoKey bits (encode key))).1 with  | some _ => cost key  | none => cost key + OAI.EditApproximation.FiniteQuery.requestWork      (fun child previous => OAI.EditApproximation.rankedMemoEvaluate rank program bits encode child.val previous)      (fun child previous => rankedMemoAddressWork rank program bits encode cost child.val previous)      (program key) memory + cost keytermination_by rank keydecreasing_by exact child.propertydef rankedMemoKernelWork {κ : Type u_1} (rank : κ → ℕ)    (program : (key : κ) → OAI.EditApproximation.FiniteQuery {child : κ // rank child < rank key})    (bits : ℕ) (encode cost : κ → ℕ) (key : κ) (memory : OAI.EditApproximation.BinaryMemo ℚ) : ℕ :=  match (memory.lookupCosted (OAI.EditApproximation.binaryMemoKey bits (encode key))).1 with  | some _ => 0  | none => cost key + OAI.EditApproximation.FiniteQuery.requestWork      (fun child previous => OAI.EditApproximation.rankedMemoEvaluate rank program bits encode child.val previous)      (fun child previous => rankedMemoKernelWork rank program bits encode cost child.val previous)      (program key) memorytermination_by rank keydecreasing_by exact child.propertydef physicalWarmupRequestQuery {α : Type u_1} [DecidableEq α] {M J : ℕ}    (source target : List α) (N P F : ℕ) (A : ℚ)    (pass copy T S j : ℕ) (node : OAI.EditApproximation.PhysicalNode M J) (q : OAI.EditApproximation.TargetInterval target.length)    (seedRead : OAI.EditApproximation.PhysicalEntry M J target.length →      OAI.EditApproximation.FiniteQuery {child : OAI.EditApproximation.PhysicalTableRequest M J target.length //        child.combinedRank T S < (OAI.EditApproximation.PhysicalTableRequest.warmup pass copy node j q).combinedRank T S}) :    OAI.EditApproximation.FiniteQuery {child : OAI.EditApproximation.PhysicalTableRequest M J target.length //      child.combinedRank T S < (OAI.EditApproximation.PhysicalTableRequest.warmup pass copy node j q).combinedRank T S} :=  match j with  | 0 => OAI.EditApproximation.physicalInitialQuery source target N P F A seedRead (node, q)  | t + 1 =>    if hbelow : node.1.val < J then      if (OAI.EditApproximation.physicalSourceInterval source.length node).hi -          (OAI.EditApproximation.physicalSourceInterval source.length node).lo ≤ 1 then        OAI.EditApproximation.physicalInitialQuery source target N P F A seedRead (node, q)      else OAI.EditApproximation.physicalWarmupStepQuery source target N P F A seedRead        (OAI.EditApproximation.physicalWarmupChildQuery pass copy T S t node hbelow q) node q    else OAI.EditApproximation.physicalInitialQuery source target N P F A seedRead (node, q)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen MeasureTheory ProbabilityTheoryabbrev PhysicalLocalOnlineKey (M J N n : ℕ) :=  OAI.EditApproximation.PhysicalInternalNode M J × Fin (OAI.EditApproximation.dyadicScales N).length × OAI.EditApproximation.TargetInterval nabbrev ClampedPhysicalSeed (M J ny N : ℕ) := OAI.EditApproximation.PhysicalEntry M J ny → Fin (N + 1)def finalTargetState (n : ℕ) : OAI.EditApproximation.TargetInterval n := ⟨0, n, Nat.zero_le _, le_rfl⟩abbrev PhysicalCommonKey (M J N n exponent B : ℕ) :=  Sum (OAI.EditApproximation.CommonRangeKey (OAI.EditApproximation.PhysicalLocalOnlineKey M J N n) B)    (OAI.EditApproximation.PhysicalLocalGroupKey M J N n exponent)def clampedSeedNat {M J ny N : ℕ} (seed : OAI.EditApproximation.ClampedPhysicalSeed M J ny N)    (state : OAI.EditApproximation.PhysicalEntry M J ny) : ℕ := (seed state).valend OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen Finsetdef triangularChoiceWithWork (K : ℕ) : Fin (OAI.EditApproximation.optimizerTriangularMass K) → Fin K × ℕ:= by  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_bitOrdering_matches_4 (high : Ordering) (a : Bool) (b : Bool) (x : ℕ) (y : ℕ) (h : OAI.EditApproximation.orderingMatches high x y) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitOrdering high a b) (a.toNat + 2 * x) (b.toNat + 2 * y) := by    rcases h with ⟨rfl, h⟩ | ⟨rfl, rfl⟩ | ⟨rfl, h⟩    · exact Or.inl ⟨rfl, by cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩    · cases a <;> cases b <;> simp [OAI.EditApproximation.bitOrdering, OAI.EditApproximation.orderingMatches]    · exact Or.inr (Or.inr ⟨rfl, by        cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩)  have proof_bitCompareWithWork_matches_5 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitCompareWithWork left right).1 (OAI.EditApproximation.bitWordValue left) (OAI.EditApproximation.bitWordValue right) := by    induction left generalizing right with    | nil =>      simp only [OAI.EditApproximation.bitCompareWithWork]      induction right with      | nil => (simp [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.orderingMatches, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        simpa only [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareNilLeftWithWork bs).1 false b 0 (OAI.EditApproximation.bitWordValue bs) ih    | cons a as ih =>      cases right with      | nil =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as []).1 a false (OAI.EditApproximation.bitWordValue as) 0 (ih [])      | cons b bs =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue] using          proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as bs).1 a b (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs) (ih bs)  have proof_bitCompareWithWork_lt_16 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .lt ↔ OAI.EditApproximation.bitWordValue left < OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_binaryNaturalCompareWithWork_lt_53 (a : ℕ) (b : ℕ) :      (OAI.EditApproximation.binaryNaturalCompareWithWork a b).1 = .lt ↔ a < b := by    simpa only [OAI.EditApproximation.binaryNaturalCompareWithWork, proof_bitWordValue_bits_15] using proof_bitCompareWithWork_lt_16 a.bits b.bits  have proof_bitAdder_value_1 (a : Bool) (b : Bool) (carry : Bool) :      (OAI.EditApproximation.bitSum a b carry).toNat + 2 * (OAI.EditApproximation.bitCarry a b carry).toNat =        a.toNat + b.toNat + carry.toNat := by    cases a <;> cases b <;> cases carry <;> decide  have proof_bitAddWithWork_value_2 (left : List.{0} Bool) (right : List.{0} Bool) (carry : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitAddWithWork left right carry).1 =        OAI.EditApproximation.bitWordValue left + OAI.EditApproximation.bitWordValue right + carry.toNat := by    induction left generalizing right carry with    | nil =>      simp only [OAI.EditApproximation.bitAddWithWork]      induction right generalizing carry with      | nil => cases carry <;> simp [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue]      | cons b bs ih =>        simp only [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 false b carry        simp only [Bool.toNat_false] at h        omega    | cons a as ih =>      cases right with      | nil =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a false carry        simp only [Bool.toNat_false] at h        omega      | cons b bs =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a b carry        omega  have proof_binaryNaturalAddWithWork_value_52 (a : ℕ) (b : ℕ) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalAddWithWork a b).1 = a + b := by    simp [OAI.EditApproximation.binaryNaturalAddWithWork, proof_bitAddWithWork_value_2, proof_bitWordValue_bits_15]  have proof_bitMulWithWork_value_0 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitMulWithWork left right).1 = OAI.EditApproximation.bitWordValue left * OAI.EditApproximation.bitWordValue right := by    induction left with    | nil => simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue]    | cons bit bits ih =>      cases bit <;> simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue, proof_bitAddWithWork_value_2, ih] <;> ring  have proof_binaryNaturalMulWithWork_value_55 (a : ℕ) (b : ℕ) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalMulWithWork a b).1 = a * b := by    simp [OAI.EditApproximation.binaryNaturalMulWithWork, proof_bitMulWithWork_value_0, proof_bitWordValue_bits_15]  have proof_bitSubtractor_value_17 (a : Bool) (b : Bool) (borrow : Bool) :      a.toNat + 2 * (OAI.EditApproximation.bitBorrow a b borrow).toNat =        b.toNat + borrow.toNat + (OAI.EditApproximation.bitDifference a b borrow).toNat := by    cases a <;> cases b <;> cases borrow <;> decide  have proof_bitSubtractionRippleEquation_18 (a : ℕ) (b : ℕ) (borrow : ℕ) (nextBorrow : ℕ) (difference : ℕ) (left : ℕ) (right : ℕ) (result : ℕ) (tail : ℕ) (htail : Eq.{1} (HAdd.hAdd.{0, 0, 0} (HAdd.hAdd.{0, 0, 0} result right) nextBorrow) (HAdd.hAdd.{0, 0, 0} left tail)) (hbit : Eq.{1} (HAdd.hAdd.{0, 0, 0} a (HMul.hMul.{0, 0, 0} 2 nextBorrow))    (HAdd.hAdd.{0, 0, 0} (HAdd.hAdd.{0, 0, 0} b borrow) difference)) :      (difference + 2 * result) + (b + 2 * right) + borrow =        (a + 2 * left) + 2 * tail := by    omega  have proof_bitSubtractWithWork_value_19 (left : List.{0} Bool) (right : List.{0} Bool) (borrow : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork left right borrow).1 + OAI.EditApproximation.bitWordValue right + borrow.toNat =        OAI.EditApproximation.bitWordValue left + 2 ^ max left.length right.length *          (OAI.EditApproximation.bitSubtractWithWork left right borrow).2.1.toNat := by    induction left generalizing right borrow with    | nil =>      induction right generalizing borrow with      | nil => (simp [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitSubtractNilLeftWithWork, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        have h := ih (OAI.EditApproximation.bitBorrow false b borrow)        have hb := proof_bitSubtractor_value_17 false b borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitSubtractNilLeftWithWork, OAI.EditApproximation.bitWordValue,          List.length_nil, List.length_cons, Nat.zero_max, pow_succ, Bool.toNat_false] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 0 b.toNat borrow.toNat (OAI.EditApproximation.bitBorrow false b borrow).toNat          (OAI.EditApproximation.bitDifference false b borrow).toNat 0 (OAI.EditApproximation.bitWordValue bs)          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractNilLeftWithWork bs (OAI.EditApproximation.bitBorrow false b borrow)).1)          (2 ^ bs.length * (OAI.EditApproximation.bitSubtractNilLeftWithWork bs (OAI.EditApproximation.bitBorrow false b borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_zero, Nat.add_zero, Nat.zero_add, Nat.mul_assoc,          Nat.mul_left_comm] using hs    | cons a as ih =>      cases right with      | nil =>        have h := ih [] (OAI.EditApproximation.bitBorrow a false borrow)        have hb := proof_bitSubtractor_value_17 a false borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitWordValue, List.length_nil, List.length_cons,          Nat.max_zero, pow_succ, Bool.toNat_false] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 a.toNat 0 borrow.toNat (OAI.EditApproximation.bitBorrow a false borrow).toNat          (OAI.EditApproximation.bitDifference a false borrow).toNat (OAI.EditApproximation.bitWordValue as) 0          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork as [] (OAI.EditApproximation.bitBorrow a false borrow)).1)          (2 ^ as.length * (OAI.EditApproximation.bitSubtractWithWork as [] (OAI.EditApproximation.bitBorrow a false borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_zero, Nat.add_zero, Nat.zero_add, Nat.mul_assoc,          Nat.mul_left_comm] using hs      | cons b bs =>        have h := ih bs (OAI.EditApproximation.bitBorrow a b borrow)        have hb := proof_bitSubtractor_value_17 a b borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitWordValue, List.length_cons, Nat.succ_max_succ,          pow_succ] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 a.toNat b.toNat borrow.toNat (OAI.EditApproximation.bitBorrow a b borrow).toNat          (OAI.EditApproximation.bitDifference a b borrow).toNat (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs)          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork as bs (OAI.EditApproximation.bitBorrow a b borrow)).1)          (2 ^ max as.length bs.length * (OAI.EditApproximation.bitSubtractWithWork as bs (OAI.EditApproximation.bitBorrow a b borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_assoc, Nat.mul_left_comm] using hs  have proof_bitWordValue_lt_pow_length_20 (bits : List.{0} Bool) : OAI.EditApproximation.bitWordValue bits < 2 ^ bits.length := by    induction bits with    | nil => (simp [OAI.EditApproximation.bitWordValue])    | cons bit bits ih =>      cases bit <;> (simp only [OAI.EditApproximation.bitWordValue, List.length_cons, pow_succ, Bool.toNat_false, Bool.toNat_true]) <;> omega  have proof_bitSubtractWithWork_length_21 (left : List.{0} Bool) (right : List.{0} Bool) (borrow : Bool) :      (OAI.EditApproximation.bitSubtractWithWork left right borrow).1.length = max left.length right.length := by    induction left generalizing right borrow with    | nil =>      simp only [OAI.EditApproximation.bitSubtractWithWork]      induction right generalizing borrow with      | nil => simp [OAI.EditApproximation.bitSubtractNilLeftWithWork]      | cons b bs ih => simp [OAI.EditApproximation.bitSubtractNilLeftWithWork, ih]    | cons a as ih =>      cases right with      | nil => simp [OAI.EditApproximation.bitSubtractWithWork, ih]      | cons b bs => simp [OAI.EditApproximation.bitSubtractWithWork, ih, Nat.succ_max_succ]  have proof_bitSubtractWithWork_sub_22 (left : List.{0} Bool) (right : List.{0} Bool) (h : LE.le.{0} (OAI.EditApproximation.bitWordValue right) (OAI.EditApproximation.bitWordValue left)) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork left right false).1 = OAI.EditApproximation.bitWordValue left - OAI.EditApproximation.bitWordValue right := by    have hvalue := proof_bitSubtractWithWork_value_19 left right false    have hlt := proof_bitWordValue_lt_pow_length_20 (OAI.EditApproximation.bitSubtractWithWork left right false).1    rw [proof_bitSubtractWithWork_length_21] at hlt    cases hb : (OAI.EditApproximation.bitSubtractWithWork left right false).2.1    · simp only [hb, Bool.toNat_false, Nat.mul_zero, Nat.add_zero] at hvalue      omega    · simp only [hb, Bool.toNat_true, Bool.toNat_false, Nat.mul_one, Nat.add_zero] at hvalue      omega  have proof_bitDivModWithWork_value_23 (divisor : List.{0} Bool) (bits : List.{0} Bool) (hd : LT.lt.{0} 0 (OAI.EditApproximation.bitWordValue divisor)) :      OAI.EditApproximation.bitWordValue bits = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).1 +        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 ∧        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 < OAI.EditApproximation.bitWordValue divisor := by    induction bits with    | nil => (simp [OAI.EditApproximation.bitDivModWithWork, OAI.EditApproximation.bitWordValue, hd])    | cons bit bits ih =>      let previous := OAI.EditApproximation.bitDivModWithWork divisor bits      let candidate := bit :: previous.2.1      have hp : OAI.EditApproximation.bitWordValue bits = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue previous.1 +          OAI.EditApproximation.bitWordValue previous.2.1 := ih.1      have hr : OAI.EditApproximation.bitWordValue previous.2.1 < OAI.EditApproximation.bitWordValue divisor := ih.2      have hc : OAI.EditApproximation.bitWordValue candidate < 2 * OAI.EditApproximation.bitWordValue divisor := by        dsimp only [candidate, OAI.EditApproximation.bitWordValue]        cases bit <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega      by_cases hlt : (OAI.EditApproximation.bitCompareWithWork candidate divisor).1 = .lt      · have hv := (proof_bitCompareWithWork_lt_16 candidate divisor).1 hlt        simp only [OAI.EditApproximation.bitDivModWithWork, show (OAI.EditApproximation.bitCompareWithWork (bit :: (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1)          divisor).1 = .lt from hlt, ↓reduceIte]        change OAI.EditApproximation.bitWordValue (bit :: bits) = OAI.EditApproximation.bitWordValue divisor *          OAI.EditApproximation.bitWordValue (false :: previous.1) + OAI.EditApproximation.bitWordValue candidate ∧ OAI.EditApproximation.bitWordValue candidate < _        constructor        · (simp only [OAI.EditApproximation.bitWordValue, Bool.toNat_false])          dsimp only [candidate, OAI.EditApproximation.bitWordValue]          nlinarith only [hp]        · exact hv      · have hv : OAI.EditApproximation.bitWordValue divisor ≤ OAI.EditApproximation.bitWordValue candidate := by          exact Nat.le_of_not_gt (fun h => hlt ((proof_bitCompareWithWork_lt_16 candidate divisor).2 h))        have hs := proof_bitSubtractWithWork_sub_22 candidate divisor hv        simp only [OAI.EditApproximation.bitDivModWithWork, show (OAI.EditApproximation.bitCompareWithWork (bit :: (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1)          divisor).1 ≠ .lt from hlt, ↓reduceIte]        change OAI.EditApproximation.bitWordValue (bit :: bits) = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue (true :: previous.1) +          OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork candidate divisor false).1 ∧          OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork candidate divisor false).1 < _        rw [hs]        constructor        · (simp only [OAI.EditApproximation.bitWordValue, Bool.toNat_true])          have he := Nat.sub_add_cancel hv          dsimp only [candidate, OAI.EditApproximation.bitWordValue] at he ⊢          nlinarith only [hp, he]        · omega  have proof_binaryNaturalDivModWithWork_spec_24 (n : ℕ) (d : ℕ) (hd : LT.lt.{0} 0 d) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalDivModWithWork n d).1 = n / d ∧        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalDivModWithWork n d).2.1 = n % d := by    have h := proof_bitDivModWithWork_value_23 d.bits n.bits (by simpa only [proof_bitWordValue_bits_15] using hd)    simp only [proof_bitWordValue_bits_15] at h    have hmod : n % d = OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork d.bits n.bits).2.1 := by      conv_lhs => rw [h.1]      simp only [Nat.add_mod, Nat.mul_mod_right, Nat.zero_add, Nat.mod_eq_of_lt h.2]    have hdiv : n / d = OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork d.bits n.bits).1 := by      conv_lhs => rw [h.1]      rw [Nat.mul_add_div hd, Nat.div_eq_of_lt h.2, Nat.add_zero]    exact ⟨hdiv.symm, hmod.symm⟩  have proof_optimizerTriangularMass_succ_66 (K : ℕ) :      OAI.EditApproximation.optimizerTriangularMass (K + 1) = OAI.EditApproximation.optimizerTriangularMass K + (K + 1) := by    unfold OAI.EditApproximation.optimizerTriangularMass    rw [sum_range_succ]  have proof_optimizerTriangularMass_twice_67 (K : ℕ) :      2 * OAI.EditApproximation.optimizerTriangularMass K = K * (K + 1) := by    induction K with    | zero => simp [OAI.EditApproximation.optimizerTriangularMass]    | succ K ih =>      rw [proof_optimizerTriangularMass_succ_66]      nlinarith  have proof_triangularMassWithWork_value_65 (K : ℕ) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.triangularMassWithWork K).1 = OAI.EditApproximation.optimizerTriangularMass K := by    simp only [OAI.EditApproximation.triangularMassWithWork, proof_binaryNaturalAddWithWork_value_52, proof_binaryNaturalMulWithWork_value_55,      (proof_binaryNaturalDivModWithWork_spec_24 _ 2 (by decide)).1]    rw [← proof_optimizerTriangularMass_twice_67 K, Nat.mul_div_cancel_left _ (by decide : 0 < 2)]  exact fun integer => match K, integer with    | 0, integer => Fin.elim0 integer    | K + 1, integer =>      let threshold := OAI.EditApproximation.triangularMassWithWork K      let test := OAI.EditApproximation.binaryNaturalCompareWithWork integer.val (OAI.EditApproximation.bitWordValue threshold.1)      if h : test.1 = .lt then        let hsmall : integer.val < OAI.EditApproximation.optimizerTriangularMass K := by          have ht := (proof_binaryNaturalCompareWithWork_lt_53 _ _).mp h          simpa only [threshold, proof_triangularMassWithWork_value_65] using ht        let chosen := triangularChoiceWithWork K ⟨integer.val, hsmall⟩        (chosen.1.castSucc, threshold.2 + test.2 + chosen.2 + 2)      else (⟨K, by omega⟩, threshold.2 + test.2 + 1)def triangularChoiceAllocation (K : ℕ) : Fin (OAI.EditApproximation.optimizerTriangularMass K) → ℕ:= by  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_bitOrdering_matches_4 (high : Ordering) (a : Bool) (b : Bool) (x : ℕ) (y : ℕ) (h : OAI.EditApproximation.orderingMatches high x y) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitOrdering high a b) (a.toNat + 2 * x) (b.toNat + 2 * y) := by    rcases h with ⟨rfl, h⟩ | ⟨rfl, rfl⟩ | ⟨rfl, h⟩    · exact Or.inl ⟨rfl, by cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩    · cases a <;> cases b <;> simp [OAI.EditApproximation.bitOrdering, OAI.EditApproximation.orderingMatches]    · exact Or.inr (Or.inr ⟨rfl, by        cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩)  have proof_bitCompareWithWork_matches_5 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitCompareWithWork left right).1 (OAI.EditApproximation.bitWordValue left) (OAI.EditApproximation.bitWordValue right) := by    induction left generalizing right with    | nil =>      simp only [OAI.EditApproximation.bitCompareWithWork]      induction right with      | nil => (simp [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.orderingMatches, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        simpa only [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareNilLeftWithWork bs).1 false b 0 (OAI.EditApproximation.bitWordValue bs) ih    | cons a as ih =>      cases right with      | nil =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as []).1 a false (OAI.EditApproximation.bitWordValue as) 0 (ih [])      | cons b bs =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue] using          proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as bs).1 a b (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs) (ih bs)  have proof_bitCompareWithWork_lt_16 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .lt ↔ OAI.EditApproximation.bitWordValue left < OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_binaryNaturalCompareWithWork_lt_53 (a : ℕ) (b : ℕ) :      (OAI.EditApproximation.binaryNaturalCompareWithWork a b).1 = .lt ↔ a < b := by    simpa only [OAI.EditApproximation.binaryNaturalCompareWithWork, proof_bitWordValue_bits_15] using proof_bitCompareWithWork_lt_16 a.bits b.bits  have proof_bitAdder_value_1 (a : Bool) (b : Bool) (carry : Bool) :      (OAI.EditApproximation.bitSum a b carry).toNat + 2 * (OAI.EditApproximation.bitCarry a b carry).toNat =        a.toNat + b.toNat + carry.toNat := by    cases a <;> cases b <;> cases carry <;> decide  have proof_bitAddWithWork_value_2 (left : List.{0} Bool) (right : List.{0} Bool) (carry : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitAddWithWork left right carry).1 =        OAI.EditApproximation.bitWordValue left + OAI.EditApproximation.bitWordValue right + carry.toNat := by    induction left generalizing right carry with    | nil =>      simp only [OAI.EditApproximation.bitAddWithWork]      induction right generalizing carry with      | nil => cases carry <;> simp [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue]      | cons b bs ih =>        simp only [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 false b carry        simp only [Bool.toNat_false] at h        omega    | cons a as ih =>      cases right with      | nil =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a false carry        simp only [Bool.toNat_false] at h        omega      | cons b bs =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a b carry        omega  have proof_binaryNaturalAddWithWork_value_52 (a : ℕ) (b : ℕ) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalAddWithWork a b).1 = a + b := by    simp [OAI.EditApproximation.binaryNaturalAddWithWork, proof_bitAddWithWork_value_2, proof_bitWordValue_bits_15]  have proof_bitMulWithWork_value_0 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitMulWithWork left right).1 = OAI.EditApproximation.bitWordValue left * OAI.EditApproximation.bitWordValue right := by    induction left with    | nil => simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue]    | cons bit bits ih =>      cases bit <;> simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue, proof_bitAddWithWork_value_2, ih] <;> ring  have proof_binaryNaturalMulWithWork_value_55 (a : ℕ) (b : ℕ) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalMulWithWork a b).1 = a * b := by    simp [OAI.EditApproximation.binaryNaturalMulWithWork, proof_bitMulWithWork_value_0, proof_bitWordValue_bits_15]  have proof_bitSubtractor_value_17 (a : Bool) (b : Bool) (borrow : Bool) :      a.toNat + 2 * (OAI.EditApproximation.bitBorrow a b borrow).toNat =        b.toNat + borrow.toNat + (OAI.EditApproximation.bitDifference a b borrow).toNat := by    cases a <;> cases b <;> cases borrow <;> decide  have proof_bitSubtractionRippleEquation_18 (a : ℕ) (b : ℕ) (borrow : ℕ) (nextBorrow : ℕ) (difference : ℕ) (left : ℕ) (right : ℕ) (result : ℕ) (tail : ℕ) (htail : Eq.{1} (HAdd.hAdd.{0, 0, 0} (HAdd.hAdd.{0, 0, 0} result right) nextBorrow) (HAdd.hAdd.{0, 0, 0} left tail)) (hbit : Eq.{1} (HAdd.hAdd.{0, 0, 0} a (HMul.hMul.{0, 0, 0} 2 nextBorrow))    (HAdd.hAdd.{0, 0, 0} (HAdd.hAdd.{0, 0, 0} b borrow) difference)) :      (difference + 2 * result) + (b + 2 * right) + borrow =        (a + 2 * left) + 2 * tail := by    omega  have proof_bitSubtractWithWork_value_19 (left : List.{0} Bool) (right : List.{0} Bool) (borrow : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork left right borrow).1 + OAI.EditApproximation.bitWordValue right + borrow.toNat =        OAI.EditApproximation.bitWordValue left + 2 ^ max left.length right.length *          (OAI.EditApproximation.bitSubtractWithWork left right borrow).2.1.toNat := by    induction left generalizing right borrow with    | nil =>      induction right generalizing borrow with      | nil => (simp [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitSubtractNilLeftWithWork, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        have h := ih (OAI.EditApproximation.bitBorrow false b borrow)        have hb := proof_bitSubtractor_value_17 false b borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitSubtractNilLeftWithWork, OAI.EditApproximation.bitWordValue,          List.length_nil, List.length_cons, Nat.zero_max, pow_succ, Bool.toNat_false] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 0 b.toNat borrow.toNat (OAI.EditApproximation.bitBorrow false b borrow).toNat          (OAI.EditApproximation.bitDifference false b borrow).toNat 0 (OAI.EditApproximation.bitWordValue bs)          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractNilLeftWithWork bs (OAI.EditApproximation.bitBorrow false b borrow)).1)          (2 ^ bs.length * (OAI.EditApproximation.bitSubtractNilLeftWithWork bs (OAI.EditApproximation.bitBorrow false b borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_zero, Nat.add_zero, Nat.zero_add, Nat.mul_assoc,          Nat.mul_left_comm] using hs    | cons a as ih =>      cases right with      | nil =>        have h := ih [] (OAI.EditApproximation.bitBorrow a false borrow)        have hb := proof_bitSubtractor_value_17 a false borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitWordValue, List.length_nil, List.length_cons,          Nat.max_zero, pow_succ, Bool.toNat_false] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 a.toNat 0 borrow.toNat (OAI.EditApproximation.bitBorrow a false borrow).toNat          (OAI.EditApproximation.bitDifference a false borrow).toNat (OAI.EditApproximation.bitWordValue as) 0          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork as [] (OAI.EditApproximation.bitBorrow a false borrow)).1)          (2 ^ as.length * (OAI.EditApproximation.bitSubtractWithWork as [] (OAI.EditApproximation.bitBorrow a false borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_zero, Nat.add_zero, Nat.zero_add, Nat.mul_assoc,          Nat.mul_left_comm] using hs      | cons b bs =>        have h := ih bs (OAI.EditApproximation.bitBorrow a b borrow)        have hb := proof_bitSubtractor_value_17 a b borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitWordValue, List.length_cons, Nat.succ_max_succ,          pow_succ] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 a.toNat b.toNat borrow.toNat (OAI.EditApproximation.bitBorrow a b borrow).toNat          (OAI.EditApproximation.bitDifference a b borrow).toNat (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs)          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork as bs (OAI.EditApproximation.bitBorrow a b borrow)).1)          (2 ^ max as.length bs.length * (OAI.EditApproximation.bitSubtractWithWork as bs (OAI.EditApproximation.bitBorrow a b borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_assoc, Nat.mul_left_comm] using hs  have proof_bitWordValue_lt_pow_length_20 (bits : List.{0} Bool) : OAI.EditApproximation.bitWordValue bits < 2 ^ bits.length := by    induction bits with    | nil => (simp [OAI.EditApproximation.bitWordValue])    | cons bit bits ih =>      cases bit <;> (simp only [OAI.EditApproximation.bitWordValue, List.length_cons, pow_succ, Bool.toNat_false, Bool.toNat_true]) <;> omega  have proof_bitSubtractWithWork_length_21 (left : List.{0} Bool) (right : List.{0} Bool) (borrow : Bool) :      (OAI.EditApproximation.bitSubtractWithWork left right borrow).1.length = max left.length right.length := by    induction left generalizing right borrow with    | nil =>      simp only [OAI.EditApproximation.bitSubtractWithWork]      induction right generalizing borrow with      | nil => simp [OAI.EditApproximation.bitSubtractNilLeftWithWork]      | cons b bs ih => simp [OAI.EditApproximation.bitSubtractNilLeftWithWork, ih]    | cons a as ih =>      cases right with      | nil => simp [OAI.EditApproximation.bitSubtractWithWork, ih]      | cons b bs => simp [OAI.EditApproximation.bitSubtractWithWork, ih, Nat.succ_max_succ]  have proof_bitSubtractWithWork_sub_22 (left : List.{0} Bool) (right : List.{0} Bool) (h : LE.le.{0} (OAI.EditApproximation.bitWordValue right) (OAI.EditApproximation.bitWordValue left)) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork left right false).1 = OAI.EditApproximation.bitWordValue left - OAI.EditApproximation.bitWordValue right := by    have hvalue := proof_bitSubtractWithWork_value_19 left right false    have hlt := proof_bitWordValue_lt_pow_length_20 (OAI.EditApproximation.bitSubtractWithWork left right false).1    rw [proof_bitSubtractWithWork_length_21] at hlt    cases hb : (OAI.EditApproximation.bitSubtractWithWork left right false).2.1    · simp only [hb, Bool.toNat_false, Nat.mul_zero, Nat.add_zero] at hvalue      omega    · simp only [hb, Bool.toNat_true, Bool.toNat_false, Nat.mul_one, Nat.add_zero] at hvalue      omega  have proof_bitDivModWithWork_value_23 (divisor : List.{0} Bool) (bits : List.{0} Bool) (hd : LT.lt.{0} 0 (OAI.EditApproximation.bitWordValue divisor)) :      OAI.EditApproximation.bitWordValue bits = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).1 +        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 ∧        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 < OAI.EditApproximation.bitWordValue divisor := by    induction bits with    | nil => (simp [OAI.EditApproximation.bitDivModWithWork, OAI.EditApproximation.bitWordValue, hd])    | cons bit bits ih =>      let previous := OAI.EditApproximation.bitDivModWithWork divisor bits      let candidate := bit :: previous.2.1      have hp : OAI.EditApproximation.bitWordValue bits = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue previous.1 +          OAI.EditApproximation.bitWordValue previous.2.1 := ih.1      have hr : OAI.EditApproximation.bitWordValue previous.2.1 < OAI.EditApproximation.bitWordValue divisor := ih.2      have hc : OAI.EditApproximation.bitWordValue candidate < 2 * OAI.EditApproximation.bitWordValue divisor := by        dsimp only [candidate, OAI.EditApproximation.bitWordValue]        cases bit <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega      by_cases hlt : (OAI.EditApproximation.bitCompareWithWork candidate divisor).1 = .lt      · have hv := (proof_bitCompareWithWork_lt_16 candidate divisor).1 hlt        simp only [OAI.EditApproximation.bitDivModWithWork, show (OAI.EditApproximation.bitCompareWithWork (bit :: (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1)          divisor).1 = .lt from hlt, ↓reduceIte]        change OAI.EditApproximation.bitWordValue (bit :: bits) = OAI.EditApproximation.bitWordValue divisor *          OAI.EditApproximation.bitWordValue (false :: previous.1) + OAI.EditApproximation.bitWordValue candidate ∧ OAI.EditApproximation.bitWordValue candidate < _        constructor        · (simp only [OAI.EditApproximation.bitWordValue, Bool.toNat_false])          dsimp only [candidate, OAI.EditApproximation.bitWordValue]          nlinarith only [hp]        · exact hv      · have hv : OAI.EditApproximation.bitWordValue divisor ≤ OAI.EditApproximation.bitWordValue candidate := by          exact Nat.le_of_not_gt (fun h => hlt ((proof_bitCompareWithWork_lt_16 candidate divisor).2 h))        have hs := proof_bitSubtractWithWork_sub_22 candidate divisor hv        simp only [OAI.EditApproximation.bitDivModWithWork, show (OAI.EditApproximation.bitCompareWithWork (bit :: (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1)          divisor).1 ≠ .lt from hlt, ↓reduceIte]        change OAI.EditApproximation.bitWordValue (bit :: bits) = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue (true :: previous.1) +          OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork candidate divisor false).1 ∧          OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork candidate divisor false).1 < _        rw [hs]        constructor        · (simp only [OAI.EditApproximation.bitWordValue, Bool.toNat_true])          have he := Nat.sub_add_cancel hv          dsimp only [candidate, OAI.EditApproximation.bitWordValue] at he ⊢          nlinarith only [hp, he]        · omega  have proof_binaryNaturalDivModWithWork_spec_24 (n : ℕ) (d : ℕ) (hd : LT.lt.{0} 0 d) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalDivModWithWork n d).1 = n / d ∧        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalDivModWithWork n d).2.1 = n % d := by    have h := proof_bitDivModWithWork_value_23 d.bits n.bits (by simpa only [proof_bitWordValue_bits_15] using hd)    simp only [proof_bitWordValue_bits_15] at h    have hmod : n % d = OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork d.bits n.bits).2.1 := by      conv_lhs => rw [h.1]      simp only [Nat.add_mod, Nat.mul_mod_right, Nat.zero_add, Nat.mod_eq_of_lt h.2]    have hdiv : n / d = OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork d.bits n.bits).1 := by      conv_lhs => rw [h.1]      rw [Nat.mul_add_div hd, Nat.div_eq_of_lt h.2, Nat.add_zero]    exact ⟨hdiv.symm, hmod.symm⟩  have proof_optimizerTriangularMass_succ_66 (K : ℕ) :      OAI.EditApproximation.optimizerTriangularMass (K + 1) = OAI.EditApproximation.optimizerTriangularMass K + (K + 1) := by    unfold OAI.EditApproximation.optimizerTriangularMass    rw [sum_range_succ]  have proof_optimizerTriangularMass_twice_67 (K : ℕ) :      2 * OAI.EditApproximation.optimizerTriangularMass K = K * (K + 1) := by    induction K with    | zero => simp [OAI.EditApproximation.optimizerTriangularMass]    | succ K ih =>      rw [proof_optimizerTriangularMass_succ_66]      nlinarith  have proof_triangularMassWithWork_value_65 (K : ℕ) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.triangularMassWithWork K).1 = OAI.EditApproximation.optimizerTriangularMass K := by    simp only [OAI.EditApproximation.triangularMassWithWork, proof_binaryNaturalAddWithWork_value_52, proof_binaryNaturalMulWithWork_value_55,      (proof_binaryNaturalDivModWithWork_spec_24 _ 2 (by decide)).1]    rw [← proof_optimizerTriangularMass_twice_67 K, Nat.mul_div_cancel_left _ (by decide : 0 < 2)]  exact fun integer => match K, integer with    | 0, integer => Fin.elim0 integer    | K + 1, integer =>      let threshold := OAI.EditApproximation.triangularMassWithWork K      let test := OAI.EditApproximation.binaryNaturalCompareWithWork integer.val (OAI.EditApproximation.bitWordValue threshold.1)      let localCells := OAI.EditApproximation.triangularMassAllocation K + integer.val.bits.length +        (OAI.EditApproximation.bitWordValue threshold.1).bits.length      if h : test.1 = .lt then        let hsmall : integer.val < OAI.EditApproximation.optimizerTriangularMass K := by          have ht := (proof_binaryNaturalCompareWithWork_lt_53 _ _).mp h          simpa only [threshold, proof_triangularMassWithWork_value_65] using ht        localCells + triangularChoiceAllocation K ⟨integer.val, hsmall⟩      else localCellsend OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.BinaryFractionopen Finsetdef coordinateVectorWithWork {M n : ℕ} (band : List (Fin M → OAI.EditApproximation.TargetInterval n)) :    Vector (Fin M × OAI.EditApproximation.TargetInterval n) (OAI.EditApproximation.listedBandCoordinates band).length × ℕ := by  have proof_arithmeticFlatMapWithWork_value_69 {α : Type 0} {β : Type 0} (f : α → Prod.{0, 0} (List.{0} β) ℕ) (values : List.{0} α) :      (OAI.EditApproximation.arithmeticFlatMapWithWork f values).1 = values.flatMap (fun a => (f a).1) := by    induction values with    | nil => rfl    | cons a rest ih => simp only [OAI.EditApproximation.arithmeticFlatMapWithWork, ih, List.flatMap_cons]  have proof_arithmeticMapWithWork_value_70 {α : Type 0} {β : Type 0} (f : α → Prod.{0, 0} β ℕ) (values : List.{0} α) :      (OAI.EditApproximation.arithmeticMapWithWork f values).1 = values.map (fun a => (f a).1) := by    induction values with    | nil => rfl    | cons a rest ih => simp only [OAI.EditApproximation.arithmeticMapWithWork, ih, List.map_cons]  have proof_memberByWithWork_value_71 {α : Type 0} (equal : α → α → Prod.{0, 0} Bool ℕ) (heq : ∀ (a b : α), Eq.{1} (equal a b).1 Bool.true ↔ Eq.{0 + 1} a b) (a : α) (xs : List.{0} α) :      (OAI.EditApproximation.memberByWithWork equal a xs).1 = true ↔ a ∈ xs := by    induction xs with    | nil => simp only [OAI.EditApproximation.memberByWithWork, Bool.false_eq_true, List.not_mem_nil]    | cons b xs ih => simp only [OAI.EditApproximation.memberByWithWork, Bool.or_eq_true, heq, ih, List.mem_cons]  have proof_dedupByWithWork_value_72 {α : Type 0} [instLocal1 : DecidableEq.{0 + 1} α] (equal : α → α → Prod.{0, 0} Bool ℕ) (heq : ∀ (a b : α), Eq.{1} (equal a b).1 Bool.true ↔ Eq.{0 + 1} a b) (xs : List.{0} α) :      (OAI.EditApproximation.dedupByWithWork equal xs).1 = xs.dedup := by    induction xs with    | nil => rfl    | cons a rest ih =>      have hm := proof_memberByWithWork_value_71 equal heq a rest      have ht : (OAI.EditApproximation.memberByWithWork equal a rest).1 = decide (a ∈ rest) :=        Bool.eq_iff_iff.mpr (by simpa only [decide_eq_true_eq] using hm)      simp only [OAI.EditApproximation.dedupByWithWork, ht, ih, List.dedup_cons, decide_eq_true_eq]  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_bitOrdering_matches_4 (high : Ordering) (a : Bool) (b : Bool) (x : ℕ) (y : ℕ) (h : OAI.EditApproximation.orderingMatches high x y) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitOrdering high a b) (a.toNat + 2 * x) (b.toNat + 2 * y) := by    rcases h with ⟨rfl, h⟩ | ⟨rfl, rfl⟩ | ⟨rfl, h⟩    · exact Or.inl ⟨rfl, by cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩    · cases a <;> cases b <;> simp [OAI.EditApproximation.bitOrdering, OAI.EditApproximation.orderingMatches]    · exact Or.inr (Or.inr ⟨rfl, by        cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩)  have proof_bitCompareWithWork_matches_5 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitCompareWithWork left right).1 (OAI.EditApproximation.bitWordValue left) (OAI.EditApproximation.bitWordValue right) := by    induction left generalizing right with    | nil =>      simp only [OAI.EditApproximation.bitCompareWithWork]      induction right with      | nil => (simp [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.orderingMatches, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        simpa only [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareNilLeftWithWork bs).1 false b 0 (OAI.EditApproximation.bitWordValue bs) ih    | cons a as ih =>      cases right with      | nil =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as []).1 a false (OAI.EditApproximation.bitWordValue as) 0 (ih [])      | cons b bs =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue] using          proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as bs).1 a b (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs) (ih bs)  have proof_bitCompareWithWork_eq_3 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .eq ↔ OAI.EditApproximation.bitWordValue left = OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_binaryNaturalCompareWithWork_eq_73 (a : ℕ) (b : ℕ) :      (OAI.EditApproximation.binaryNaturalCompareWithWork a b).1 = .eq ↔ a = b := by    simpa only [OAI.EditApproximation.binaryNaturalCompareWithWork, proof_bitWordValue_bits_15] using proof_bitCompareWithWork_eq_3 a.bits b.bits  have proof_naturalEqualWithWork_value_74 (a : ℕ) (b : ℕ) :      (OAI.EditApproximation.naturalEqualWithWork a b).1 = true ↔ a = b := by    simp only [OAI.EditApproximation.naturalEqualWithWork, decide_eq_true_eq, proof_binaryNaturalCompareWithWork_eq_73]  have proof_coordinateEqualWithWork_value_75 {M : ℕ} {n : ℕ} (a : Prod.{0, 0} (Fin M) (OAI.EditApproximation.TargetInterval n)) (b : Prod.{0, 0} (Fin M) (OAI.EditApproximation.TargetInterval n)) :      (OAI.EditApproximation.coordinateEqualWithWork a b).1 = true ↔ a = b := by    simp only [OAI.EditApproximation.coordinateEqualWithWork, Bool.and_eq_true, proof_naturalEqualWithWork_value_74]    constructor    · rintro ⟨⟨hc, hl⟩, hh⟩      have hi : a.1 = b.1 := Fin.ext hc      have hq : a.2 = b.2 := by        rcases a with ⟨i, q⟩        rcases b with ⟨j, r⟩        cases q        cases r        cases hl        cases hh        rfl      exact Prod.ext hi hq    · intro h      subst b      exact ⟨⟨rfl, rfl⟩, rfl⟩  have proof_bandCoordinatesWithWork_value_68 {M : ℕ} {n : ℕ} (band : List.{0} (Fin M → OAI.EditApproximation.TargetInterval n)) :      (OAI.EditApproximation.BinaryFraction.bandCoordinatesWithWork band).1 = OAI.EditApproximation.listedBandCoordinates band := by    simp only [OAI.EditApproximation.BinaryFraction.bandCoordinatesWithWork, proof_dedupByWithWork_value_72 _ proof_coordinateEqualWithWork_value_75,      proof_arithmeticFlatMapWithWork_value_69, proof_arithmeticMapWithWork_value_70, OAI.EditApproximation.listedBandCoordinates,      List.ofFn_eq_map]  exact    let coordinates := OAI.EditApproximation.BinaryFraction.bandCoordinatesWithWork band    (Vector.ofFn (fun i => coordinates.1.get ⟨i.val, by      rw [proof_bandCoordinatesWithWork_value_68]      exact i.isLt⟩), coordinates.2 + coordinates.1.length + 1)def reduceOnlineIntegerWithWork (K : ℕ) (hK : 0 < K) (integer : ℕ) :    Fin (OAI.EditApproximation.optimizerTriangularMass K) × ℕ := by  have proof_bitOrdering_matches_4 (high : Ordering) (a : Bool) (b : Bool) (x : ℕ) (y : ℕ) (h : OAI.EditApproximation.orderingMatches high x y) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitOrdering high a b) (a.toNat + 2 * x) (b.toNat + 2 * y) := by    rcases h with ⟨rfl, h⟩ | ⟨rfl, rfl⟩ | ⟨rfl, h⟩    · exact Or.inl ⟨rfl, by cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩    · cases a <;> cases b <;> simp [OAI.EditApproximation.bitOrdering, OAI.EditApproximation.orderingMatches]    · exact Or.inr (Or.inr ⟨rfl, by        cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩)  have proof_bitCompareWithWork_matches_5 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitCompareWithWork left right).1 (OAI.EditApproximation.bitWordValue left) (OAI.EditApproximation.bitWordValue right) := by    induction left generalizing right with    | nil =>      simp only [OAI.EditApproximation.bitCompareWithWork]      induction right with      | nil => (simp [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.orderingMatches, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        simpa only [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareNilLeftWithWork bs).1 false b 0 (OAI.EditApproximation.bitWordValue bs) ih    | cons a as ih =>      cases right with      | nil =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as []).1 a false (OAI.EditApproximation.bitWordValue as) 0 (ih [])      | cons b bs =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue] using          proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as bs).1 a b (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs) (ih bs)  have proof_bitCompareWithWork_lt_16 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .lt ↔ OAI.EditApproximation.bitWordValue left < OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_bitSubtractor_value_17 (a : Bool) (b : Bool) (borrow : Bool) :      a.toNat + 2 * (OAI.EditApproximation.bitBorrow a b borrow).toNat =        b.toNat + borrow.toNat + (OAI.EditApproximation.bitDifference a b borrow).toNat := by    cases a <;> cases b <;> cases borrow <;> decide  have proof_bitSubtractionRippleEquation_18 (a : ℕ) (b : ℕ) (borrow : ℕ) (nextBorrow : ℕ) (difference : ℕ) (left : ℕ) (right : ℕ) (result : ℕ) (tail : ℕ) (htail : Eq.{1} (HAdd.hAdd.{0, 0, 0} (HAdd.hAdd.{0, 0, 0} result right) nextBorrow) (HAdd.hAdd.{0, 0, 0} left tail)) (hbit : Eq.{1} (HAdd.hAdd.{0, 0, 0} a (HMul.hMul.{0, 0, 0} 2 nextBorrow))    (HAdd.hAdd.{0, 0, 0} (HAdd.hAdd.{0, 0, 0} b borrow) difference)) :      (difference + 2 * result) + (b + 2 * right) + borrow =        (a + 2 * left) + 2 * tail := by    omega  have proof_bitSubtractWithWork_value_19 (left : List.{0} Bool) (right : List.{0} Bool) (borrow : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork left right borrow).1 + OAI.EditApproximation.bitWordValue right + borrow.toNat =        OAI.EditApproximation.bitWordValue left + 2 ^ max left.length right.length *          (OAI.EditApproximation.bitSubtractWithWork left right borrow).2.1.toNat := by    induction left generalizing right borrow with    | nil =>      induction right generalizing borrow with      | nil => (simp [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitSubtractNilLeftWithWork, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        have h := ih (OAI.EditApproximation.bitBorrow false b borrow)        have hb := proof_bitSubtractor_value_17 false b borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitSubtractNilLeftWithWork, OAI.EditApproximation.bitWordValue,          List.length_nil, List.length_cons, Nat.zero_max, pow_succ, Bool.toNat_false] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 0 b.toNat borrow.toNat (OAI.EditApproximation.bitBorrow false b borrow).toNat          (OAI.EditApproximation.bitDifference false b borrow).toNat 0 (OAI.EditApproximation.bitWordValue bs)          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractNilLeftWithWork bs (OAI.EditApproximation.bitBorrow false b borrow)).1)          (2 ^ bs.length * (OAI.EditApproximation.bitSubtractNilLeftWithWork bs (OAI.EditApproximation.bitBorrow false b borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_zero, Nat.add_zero, Nat.zero_add, Nat.mul_assoc,          Nat.mul_left_comm] using hs    | cons a as ih =>      cases right with      | nil =>        have h := ih [] (OAI.EditApproximation.bitBorrow a false borrow)        have hb := proof_bitSubtractor_value_17 a false borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitWordValue, List.length_nil, List.length_cons,          Nat.max_zero, pow_succ, Bool.toNat_false] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 a.toNat 0 borrow.toNat (OAI.EditApproximation.bitBorrow a false borrow).toNat          (OAI.EditApproximation.bitDifference a false borrow).toNat (OAI.EditApproximation.bitWordValue as) 0          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork as [] (OAI.EditApproximation.bitBorrow a false borrow)).1)          (2 ^ as.length * (OAI.EditApproximation.bitSubtractWithWork as [] (OAI.EditApproximation.bitBorrow a false borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_zero, Nat.add_zero, Nat.zero_add, Nat.mul_assoc,          Nat.mul_left_comm] using hs      | cons b bs =>        have h := ih bs (OAI.EditApproximation.bitBorrow a b borrow)        have hb := proof_bitSubtractor_value_17 a b borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitWordValue, List.length_cons, Nat.succ_max_succ,          pow_succ] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 a.toNat b.toNat borrow.toNat (OAI.EditApproximation.bitBorrow a b borrow).toNat          (OAI.EditApproximation.bitDifference a b borrow).toNat (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs)          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork as bs (OAI.EditApproximation.bitBorrow a b borrow)).1)          (2 ^ max as.length bs.length * (OAI.EditApproximation.bitSubtractWithWork as bs (OAI.EditApproximation.bitBorrow a b borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_assoc, Nat.mul_left_comm] using hs  have proof_bitWordValue_lt_pow_length_20 (bits : List.{0} Bool) : OAI.EditApproximation.bitWordValue bits < 2 ^ bits.length := by    induction bits with    | nil => (simp [OAI.EditApproximation.bitWordValue])    | cons bit bits ih =>      cases bit <;> (simp only [OAI.EditApproximation.bitWordValue, List.length_cons, pow_succ, Bool.toNat_false, Bool.toNat_true]) <;> omega  have proof_bitSubtractWithWork_length_21 (left : List.{0} Bool) (right : List.{0} Bool) (borrow : Bool) :      (OAI.EditApproximation.bitSubtractWithWork left right borrow).1.length = max left.length right.length := by    induction left generalizing right borrow with    | nil =>      simp only [OAI.EditApproximation.bitSubtractWithWork]      induction right generalizing borrow with      | nil => simp [OAI.EditApproximation.bitSubtractNilLeftWithWork]      | cons b bs ih => simp [OAI.EditApproximation.bitSubtractNilLeftWithWork, ih]    | cons a as ih =>      cases right with      | nil => simp [OAI.EditApproximation.bitSubtractWithWork, ih]      | cons b bs => simp [OAI.EditApproximation.bitSubtractWithWork, ih, Nat.succ_max_succ]  have proof_bitSubtractWithWork_sub_22 (left : List.{0} Bool) (right : List.{0} Bool) (h : LE.le.{0} (OAI.EditApproximation.bitWordValue right) (OAI.EditApproximation.bitWordValue left)) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork left right false).1 = OAI.EditApproximation.bitWordValue left - OAI.EditApproximation.bitWordValue right := by    have hvalue := proof_bitSubtractWithWork_value_19 left right false    have hlt := proof_bitWordValue_lt_pow_length_20 (OAI.EditApproximation.bitSubtractWithWork left right false).1    rw [proof_bitSubtractWithWork_length_21] at hlt    cases hb : (OAI.EditApproximation.bitSubtractWithWork left right false).2.1    · simp only [hb, Bool.toNat_false, Nat.mul_zero, Nat.add_zero] at hvalue      omega    · simp only [hb, Bool.toNat_true, Bool.toNat_false, Nat.mul_one, Nat.add_zero] at hvalue      omega  have proof_bitDivModWithWork_value_23 (divisor : List.{0} Bool) (bits : List.{0} Bool) (hd : LT.lt.{0} 0 (OAI.EditApproximation.bitWordValue divisor)) :      OAI.EditApproximation.bitWordValue bits = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).1 +        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 ∧        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 < OAI.EditApproximation.bitWordValue divisor := by    induction bits with    | nil => (simp [OAI.EditApproximation.bitDivModWithWork, OAI.EditApproximation.bitWordValue, hd])    | cons bit bits ih =>      let previous := OAI.EditApproximation.bitDivModWithWork divisor bits      let candidate := bit :: previous.2.1      have hp : OAI.EditApproximation.bitWordValue bits = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue previous.1 +          OAI.EditApproximation.bitWordValue previous.2.1 := ih.1      have hr : OAI.EditApproximation.bitWordValue previous.2.1 < OAI.EditApproximation.bitWordValue divisor := ih.2      have hc : OAI.EditApproximation.bitWordValue candidate < 2 * OAI.EditApproximation.bitWordValue divisor := by        dsimp only [candidate, OAI.EditApproximation.bitWordValue]        cases bit <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega      by_cases hlt : (OAI.EditApproximation.bitCompareWithWork candidate divisor).1 = .lt      · have hv := (proof_bitCompareWithWork_lt_16 candidate divisor).1 hlt        simp only [OAI.EditApproximation.bitDivModWithWork, show (OAI.EditApproximation.bitCompareWithWork (bit :: (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1)          divisor).1 = .lt from hlt, ↓reduceIte]        change OAI.EditApproximation.bitWordValue (bit :: bits) = OAI.EditApproximation.bitWordValue divisor *          OAI.EditApproximation.bitWordValue (false :: previous.1) + OAI.EditApproximation.bitWordValue candidate ∧ OAI.EditApproximation.bitWordValue candidate < _        constructor        · (simp only [OAI.EditApproximation.bitWordValue, Bool.toNat_false])          dsimp only [candidate, OAI.EditApproximation.bitWordValue]          nlinarith only [hp]        · exact hv      · have hv : OAI.EditApproximation.bitWordValue divisor ≤ OAI.EditApproximation.bitWordValue candidate := by          exact Nat.le_of_not_gt (fun h => hlt ((proof_bitCompareWithWork_lt_16 candidate divisor).2 h))        have hs := proof_bitSubtractWithWork_sub_22 candidate divisor hv        simp only [OAI.EditApproximation.bitDivModWithWork, show (OAI.EditApproximation.bitCompareWithWork (bit :: (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1)          divisor).1 ≠ .lt from hlt, ↓reduceIte]        change OAI.EditApproximation.bitWordValue (bit :: bits) = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue (true :: previous.1) +          OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork candidate divisor false).1 ∧          OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork candidate divisor false).1 < _        rw [hs]        constructor        · (simp only [OAI.EditApproximation.bitWordValue, Bool.toNat_true])          have he := Nat.sub_add_cancel hv          dsimp only [candidate, OAI.EditApproximation.bitWordValue] at he ⊢          nlinarith only [hp, he]        · omega  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_binaryNaturalDivModWithWork_spec_24 (n : ℕ) (d : ℕ) (hd : LT.lt.{0} 0 d) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalDivModWithWork n d).1 = n / d ∧        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalDivModWithWork n d).2.1 = n % d := by    have h := proof_bitDivModWithWork_value_23 d.bits n.bits (by simpa only [proof_bitWordValue_bits_15] using hd)    simp only [proof_bitWordValue_bits_15] at h    have hmod : n % d = OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork d.bits n.bits).2.1 := by      conv_lhs => rw [h.1]      simp only [Nat.add_mod, Nat.mul_mod_right, Nat.zero_add, Nat.mod_eq_of_lt h.2]    have hdiv : n / d = OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork d.bits n.bits).1 := by      conv_lhs => rw [h.1]      rw [Nat.mul_add_div hd, Nat.div_eq_of_lt h.2, Nat.add_zero]    exact ⟨hdiv.symm, hmod.symm⟩  have proof_bitAdder_value_1 (a : Bool) (b : Bool) (carry : Bool) :      (OAI.EditApproximation.bitSum a b carry).toNat + 2 * (OAI.EditApproximation.bitCarry a b carry).toNat =        a.toNat + b.toNat + carry.toNat := by    cases a <;> cases b <;> cases carry <;> decide  have proof_bitAddWithWork_value_2 (left : List.{0} Bool) (right : List.{0} Bool) (carry : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitAddWithWork left right carry).1 =        OAI.EditApproximation.bitWordValue left + OAI.EditApproximation.bitWordValue right + carry.toNat := by    induction left generalizing right carry with    | nil =>      simp only [OAI.EditApproximation.bitAddWithWork]      induction right generalizing carry with      | nil => cases carry <;> simp [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue]      | cons b bs ih =>        simp only [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 false b carry        simp only [Bool.toNat_false] at h        omega    | cons a as ih =>      cases right with      | nil =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a false carry        simp only [Bool.toNat_false] at h        omega      | cons b bs =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a b carry        omega  have proof_binaryNaturalAddWithWork_value_52 (a : ℕ) (b : ℕ) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalAddWithWork a b).1 = a + b := by    simp [OAI.EditApproximation.binaryNaturalAddWithWork, proof_bitAddWithWork_value_2, proof_bitWordValue_bits_15]  have proof_bitMulWithWork_value_0 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitMulWithWork left right).1 = OAI.EditApproximation.bitWordValue left * OAI.EditApproximation.bitWordValue right := by    induction left with    | nil => simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue]    | cons bit bits ih =>      cases bit <;> simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue, proof_bitAddWithWork_value_2, ih] <;> ring  have proof_binaryNaturalMulWithWork_value_55 (a : ℕ) (b : ℕ) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalMulWithWork a b).1 = a * b := by    simp [OAI.EditApproximation.binaryNaturalMulWithWork, proof_bitMulWithWork_value_0, proof_bitWordValue_bits_15]  have proof_optimizerTriangularMass_succ_66 (K : ℕ) :      OAI.EditApproximation.optimizerTriangularMass (K + 1) = OAI.EditApproximation.optimizerTriangularMass K + (K + 1) := by    unfold OAI.EditApproximation.optimizerTriangularMass    rw [sum_range_succ]  have proof_optimizerTriangularMass_twice_67 (K : ℕ) :      2 * OAI.EditApproximation.optimizerTriangularMass K = K * (K + 1) := by    induction K with    | zero => simp [OAI.EditApproximation.optimizerTriangularMass]    | succ K ih =>      rw [proof_optimizerTriangularMass_succ_66]      nlinarith  have proof_triangularMassWithWork_value_65 (K : ℕ) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.triangularMassWithWork K).1 = OAI.EditApproximation.optimizerTriangularMass K := by    simp only [OAI.EditApproximation.triangularMassWithWork, proof_binaryNaturalAddWithWork_value_52, proof_binaryNaturalMulWithWork_value_55,      (proof_binaryNaturalDivModWithWork_spec_24 _ 2 (by decide)).1]    rw [← proof_optimizerTriangularMass_twice_67 K, Nat.mul_div_cancel_left _ (by decide : 0 < 2)]  have proof_optimizerTriangularMass_positive_77 (K : ℕ) (hK : LT.lt.{0} 0 K) :      0 < OAI.EditApproximation.optimizerTriangularMass K := by    have hproduct : 0 < K * (K + 1) := Nat.mul_pos hK (by omega)    rw [← proof_optimizerTriangularMass_twice_67 K] at hproduct    omega  exact    let mass := OAI.EditApproximation.triangularMassWithWork K    let divided := OAI.EditApproximation.binaryNaturalDivModWithWork integer (OAI.EditApproximation.bitWordValue mass.1)    (⟨OAI.EditApproximation.bitWordValue divided.2.1, by      rw [(proof_binaryNaturalDivModWithWork_spec_24 integer (OAI.EditApproximation.bitWordValue mass.1)        (by rw [proof_triangularMassWithWork_value_65]; exact proof_optimizerTriangularMass_positive_77 K hK)).2]      rw [proof_triangularMassWithWork_value_65]      exact Nat.mod_lt _ (proof_optimizerTriangularMass_positive_77 K hK)⟩,      mass.2 + divided.2.2 + Nat.size integer + 2)end OAI.EditApproximation.BinaryFractionendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.BinaryFractiondef countedPreparedActionReadWithWork {M n : ℕ} (mass : Vector OAI.EditApproximation.BinaryFraction M)    (read : ℕ → Fin M × OAI.EditApproximation.TargetInterval n → OAI.EditApproximation.BinaryFraction × ℕ)    (eta kappa : OAI.EditApproximation.BinaryFraction) (band : List (Fin M → OAI.EditApproximation.TargetInterval n)) (G j t : ℕ) :    Option (Fin M → OAI.EditApproximation.TargetInterval n) × ℕ :=  let coordinates := OAI.EditApproximation.BinaryFraction.coordinateVectorWithWork band  let vertices := OAI.EditApproximation.BinaryFraction.countedBandVerticesWithWork coordinates.1 mass band  let linear := OAI.EditApproximation.vectorMapWithWork _ fun i =>    OAI.EditApproximation.BinaryFraction.onlineLinearReadWithWork (fun child => mass.get child) read eta kappa t (coordinates.1.get i)  let selected := OAI.EditApproximation.BinaryFraction.selectionWithWork vertices.1 linear.1 G j  (selected.1, coordinates.2 + vertices.2 + linear.2 + selected.2 + 3)def countedPreparedActionKernelAllocation {M n : ℕ} (mass : Vector OAI.EditApproximation.BinaryFraction M)    (read : ℕ → Fin M × OAI.EditApproximation.TargetInterval n → OAI.EditApproximation.BinaryFraction × ℕ)    (footprint : ℕ → Fin M × OAI.EditApproximation.TargetInterval n → ℕ)    (eta kappa : OAI.EditApproximation.BinaryFraction) (band : List (Fin M → OAI.EditApproximation.TargetInterval n)) (G j t : ℕ) : ℕ :=  let coordinates := (OAI.EditApproximation.BinaryFraction.coordinateVectorWithWork band).1  let vertices := (OAI.EditApproximation.BinaryFraction.countedBandVerticesWithWork coordinates mass band).1  let linear := (OAI.EditApproximation.vectorMapWithWork _ fun i =>    OAI.EditApproximation.BinaryFraction.onlineLinearReadWithWork (fun child => mass.get child) read eta kappa t (coordinates.get i)).1  OAI.EditApproximation.BinaryFraction.countedBandVerticesAllocation coordinates mass band +    OAI.EditApproximation.vectorMapAllocation _ (fun i => OAI.EditApproximation.BinaryFraction.onlineLinearReadAllocation (fun child => mass.get child)      read footprint eta kappa t (coordinates.get i)) + OAI.EditApproximation.BinaryFraction.selectionAllocation vertices linear G jdef countedBandActionReadWithWork {M n : ℕ} (b : ℕ)    (initial : Fin M → OAI.EditApproximation.TargetInterval n → OAI.EditApproximation.BinaryFraction × ℕ)    (read : ℕ → Fin M × OAI.EditApproximation.TargetInterval n → OAI.EditApproximation.BinaryFraction × ℕ)    (eta kappa : OAI.EditApproximation.BinaryFraction) (band : List (Fin M → OAI.EditApproximation.TargetInterval n)) (G j t : ℕ) :    Option (Fin M → OAI.EditApproximation.TargetInterval n) × ℕ :=  let mass := OAI.EditApproximation.BinaryFraction.envelopeVectorReadWithWork b band initial  let selected := OAI.EditApproximation.BinaryFraction.countedPreparedActionReadWithWork mass.1 read eta kappa band G j t  (selected.1, mass.2 + selected.2 + 1)def countedPreparedActionAllocation {M n : ℕ} (mass : Vector OAI.EditApproximation.BinaryFraction M)    (read : ℕ → Fin M × OAI.EditApproximation.TargetInterval n → OAI.EditApproximation.BinaryFraction × ℕ)    (footprint : ℕ → Fin M × OAI.EditApproximation.TargetInterval n → ℕ)    (eta kappa : OAI.EditApproximation.BinaryFraction) (band : List (Fin M → OAI.EditApproximation.TargetInterval n)) (G j t : ℕ) : ℕ :=  OAI.EditApproximation.BinaryFraction.coordinateVectorAllocation band + OAI.EditApproximation.BinaryFraction.countedPreparedActionKernelAllocation mass read footprint eta kappa band G j tdef countedSampledOnlineReadWithWork {n M : ℕ} (center : OAI.EditApproximation.TargetInterval n) (b : ℕ)    (initial : Fin M → OAI.EditApproximation.TargetInterval n → OAI.EditApproximation.BinaryFraction × ℕ)    (read : ℕ → Fin M × OAI.EditApproximation.TargetInterval n → OAI.EditApproximation.BinaryFraction × ℕ)    (eta kappa : OAI.EditApproximation.BinaryFraction) (band : List (Fin M → OAI.EditApproximation.TargetInterval n)) (hne : band ≠ [])    (G K t : ℕ) (integer : Fin (OAI.EditApproximation.optimizerTriangularMass K)) :    OAI.EditApproximation.BinaryBellmanAction (OAI.EditApproximation.TargetInterval n) (Fin M × OAI.EditApproximation.TargetInterval n) M × ℕ :=  let chosen := OAI.EditApproximation.triangularChoiceWithWork K integer  let selected := OAI.EditApproximation.BinaryFraction.countedBandActionReadWithWork b initial read eta kappa band G chosen.1.val t  let states := selected.1.getD (band.head hne)  (⟨center, OAI.EditApproximation.BinaryFraction.zero, fun i => (i, states i)⟩, chosen.2 + selected.2 + M + 2)def countedBandActionAllocation {M n : ℕ} (b : ℕ)    (initial : Fin M → OAI.EditApproximation.TargetInterval n → OAI.EditApproximation.BinaryFraction × ℕ)    (initialAllocation : Fin M → OAI.EditApproximation.TargetInterval n → ℕ)    (read : ℕ → Fin M × OAI.EditApproximation.TargetInterval n → OAI.EditApproximation.BinaryFraction × ℕ)    (footprint : ℕ → Fin M × OAI.EditApproximation.TargetInterval n → ℕ)    (eta kappa : OAI.EditApproximation.BinaryFraction) (band : List (Fin M → OAI.EditApproximation.TargetInterval n)) (G j t : ℕ) : ℕ :=  OAI.EditApproximation.BinaryFraction.envelopeVectorReadAllocation b band initial initialAllocation +    OAI.EditApproximation.BinaryFraction.countedPreparedActionAllocation (OAI.EditApproximation.BinaryFraction.envelopeVectorReadWithWork b band initial).1      read footprint eta kappa band G j tdef countedSampledOnlineAllocation {n M : ℕ} (_center : OAI.EditApproximation.TargetInterval n) (b : ℕ)    (initial : Fin M → OAI.EditApproximation.TargetInterval n → OAI.EditApproximation.BinaryFraction × ℕ)    (initialAllocation : Fin M → OAI.EditApproximation.TargetInterval n → ℕ)    (read : ℕ → Fin M × OAI.EditApproximation.TargetInterval n → OAI.EditApproximation.BinaryFraction × ℕ)    (readAllocation : ℕ → Fin M × OAI.EditApproximation.TargetInterval n → ℕ)    (eta kappa : OAI.EditApproximation.BinaryFraction) (band : List (Fin M → OAI.EditApproximation.TargetInterval n)) (_hne : band ≠ [])    (G K t : ℕ) (integer : Fin (OAI.EditApproximation.optimizerTriangularMass K)) : ℕ :=  let chosen := (OAI.EditApproximation.triangularChoiceWithWork K integer).1  OAI.EditApproximation.triangularChoiceAllocation K integer +    OAI.EditApproximation.BinaryFraction.countedBandActionAllocation b initial initialAllocation read readAllocation eta kappa band G chosen.val t + M + 1end OAI.EditApproximation.BinaryFractionendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.SourceRankedvariable {σ : Type u_1} {κ : Type u_2}def rank (tableRank : κ → ℕ) : Sum σ κ → ℕ  | .inl _ => 0  | .inr key => tableRank key + 1def keyCode (sourceCode : σ → ℕ) (tableCode : κ → ℕ) : Sum σ κ → ℕ  | .inl source => 2 * sourceCode source  | .inr table => 2 * tableCode table + 1def child (tableRank : κ → ℕ) (parent : κ) :    Sum σ {key : κ // tableRank key < tableRank parent} →      {key : Sum σ κ // OAI.EditApproximation.SourceRanked.rank tableRank key < OAI.EditApproximation.SourceRanked.rank (σ := σ) tableRank (.inr parent)}  | .inl source => ⟨.inl source, Nat.zero_lt_succ _⟩  | .inr table => ⟨.inr table.val, Nat.add_lt_add_right table.property 1⟩def body (tableRank : κ → ℕ)    (tableBody : (parent : κ) → OAI.EditApproximation.FiniteQuery (Sum σ {key : κ // tableRank key < tableRank parent}))    (sourceValue : σ → ℚ) (key : Sum σ κ) :    OAI.EditApproximation.FiniteQuery {next : Sum σ κ // OAI.EditApproximation.SourceRanked.rank tableRank next < OAI.EditApproximation.SourceRanked.rank tableRank key} :=  match key with  | .inl source => .done (sourceValue source)  | .inr table => OAI.EditApproximation.FiniteQuery.mapKeys (OAI.EditApproximation.SourceRanked.child tableRank table) (tableBody table)def bitBody (tableRank : κ → ℕ)    (tableBody : (parent : κ) → OAI.EditApproximation.BitQuery (Sum σ {key : κ // tableRank key < tableRank parent}) OAI.EditApproximation.BinaryFraction)    (sourceValue : σ → OAI.EditApproximation.BinaryFraction × ℕ) (key : Sum σ κ) :    OAI.EditApproximation.BitQuery {next : Sum σ κ // OAI.EditApproximation.SourceRanked.rank tableRank next < OAI.EditApproximation.SourceRanked.rank tableRank key} OAI.EditApproximation.BinaryFraction :=  match key with  | .inl source => OAI.EditApproximation.BitQuery.compute (sourceValue source)  | .inr table => OAI.EditApproximation.BitQuery.mapKeysWithWork (fun key => (OAI.EditApproximation.SourceRanked.child tableRank table key, 1)) (tableBody table)end OAI.EditApproximation.SourceRankedendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.ChargedPhysicalRequestdef depth {M J ny passes copies T S : ℕ} : OAI.EditApproximation.ChargedPhysicalRequest M J ny passes copies T S → ℕ  | .inl entry => J - entry.1.1.val  | .inr request => request.val.remainingDepthdef index {M J ny passes copies T S : ℕ} : OAI.EditApproximation.ChargedPhysicalRequest M J ny passes copies T S → ℕ  | .inl _ => 0  | .inr request => request.val.rank T S + 1def rank {M J ny passes copies T S : ℕ}    (request : OAI.EditApproximation.ChargedPhysicalRequest M J ny passes copies T S) : ℕ :=  request.depth + request.indexend OAI.EditApproximation.ChargedPhysicalRequestendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationdef chargedPreviousRead {M J ny passes copies T S : ℕ}    (parent : {r : OAI.EditApproximation.PhysicalTableRequest M J ny // r.Bounded passes copies T S})    (hpass : 0 < parent.val.pass) (state : OAI.EditApproximation.TargetInterval ny) (copy : Fin copies) :    OAI.EditApproximation.FiniteQuery {child : OAI.EditApproximation.ChargedPhysicalRequest M J ny passes copies T S //      child.rank < OAI.EditApproximation.ChargedPhysicalRequest.rank (Sum.inr parent)} := by  have proof_table_rank_lt_99 {M : ℕ} {J : ℕ} {ny : ℕ} {passes : ℕ} {copies : ℕ} {T : ℕ} {S : ℕ} (parent : Subtype.{1} fun request => OAI.EditApproximation.PhysicalTableRequest.Bounded (M := M) (J := J) (ny := ny) passes copies T S request) (child : Subtype.{1} fun request => OAI.EditApproximation.PhysicalTableRequest.Bounded (M := M) (J := J) (ny := ny) passes copies T S request) (h : LT.lt.{0} (OAI.EditApproximation.PhysicalTableRequest.combinedRank T S child.val)    (OAI.EditApproximation.PhysicalTableRequest.combinedRank T S parent.val)) :      OAI.EditApproximation.ChargedPhysicalRequest.rank (Sum.inr child : OAI.EditApproximation.ChargedPhysicalRequest M J ny passes copies T S) < OAI.EditApproximation.ChargedPhysicalRequest.rank (Sum.inr parent) := by    simpa only [OAI.EditApproximation.ChargedPhysicalRequest.rank, OAI.EditApproximation.ChargedPhysicalRequest.depth, OAI.EditApproximation.ChargedPhysicalRequest.index, ← Nat.add_assoc, OAI.EditApproximation.PhysicalTableRequest.combinedRank] using      Nat.add_lt_add_right h 1  have proof_combinedRank_lt_of_progress_80 {M : ℕ} {J : ℕ} {ny : ℕ} (T : ℕ) (S : ℕ) (first : OAI.EditApproximation.PhysicalTableRequest M J ny) (second : OAI.EditApproximation.PhysicalTableRequest M J ny) (hprogress : LT.lt.{0} second.remainingDepth first.remainingDepth ∧      LE.le.{0} (OAI.EditApproximation.PhysicalTableRequest.rank T S second)        (OAI.EditApproximation.PhysicalTableRequest.rank T S first) ∨    LE.le.{0} second.remainingDepth first.remainingDepth ∧      LT.lt.{0} (OAI.EditApproximation.PhysicalTableRequest.rank T S second)        (OAI.EditApproximation.PhysicalTableRequest.rank T S first)) :      OAI.EditApproximation.PhysicalTableRequest.combinedRank T S second < OAI.EditApproximation.PhysicalTableRequest.combinedRank T S first := by    unfold OAI.EditApproximation.PhysicalTableRequest.combinedRank    rcases hprogress with h | h    · exact Nat.add_lt_add_of_lt_of_le h.1 h.2    · exact Nat.add_lt_add_of_le_of_lt h.1 h.2  have proof_rank_lt_previous_pass_98 {M : ℕ} {J : ℕ} {ny : ℕ} (T : ℕ) (S : ℕ) (first : OAI.EditApproximation.PhysicalTableRequest M J ny) (second : OAI.EditApproximation.PhysicalTableRequest M J ny) (hpass : LT.lt.{0} second.pass first.pass) (hindex : LE.le.{0} second.index (HAdd.hAdd.{0, 0, 0} T S)) :      OAI.EditApproximation.PhysicalTableRequest.rank T S second < OAI.EditApproximation.PhysicalTableRequest.rank T S first := by    have hblock : second.pass * (T + S + 1) + second.index <        (second.pass + 1) * (T + S + 1) := by      nlinarith only [hindex]    have hnext := Nat.mul_le_mul_right (T + S + 1) (Nat.succ_le_of_lt hpass)    exact hblock.trans_le (hnext.trans (Nat.le_add_right _ _))  have proof_previousPassRequest_progress_97 {M : ℕ} {J : ℕ} {ny : ℕ} (T : ℕ) (S : ℕ) (copy : ℕ) (parent : OAI.EditApproximation.PhysicalTableRequest M J ny) (hpass : LT.lt.{0} 0 parent.pass) (state : OAI.EditApproximation.TargetInterval ny) :      (OAI.EditApproximation.previousPassRequest T S copy parent state).remainingDepth = parent.remainingDepth ∧        (OAI.EditApproximation.previousPassRequest T S copy parent state).rank T S < parent.rank T S := by    refine ⟨rfl, ?_⟩    exact proof_rank_lt_previous_pass_98 T S parent _ (by      change parent.pass - 1 < parent.pass      omega) le_rfl  exact    .read ⟨Sum.inr (OAI.EditApproximation.chargedPreviousPass parent state copy), by      apply proof_table_rank_lt_99      apply proof_combinedRank_lt_of_progress_80 T S parent.val _      exact Or.inr ⟨(proof_previousPassRequest_progress_97 T S copy.val parent.val hpass state).1.le,        (proof_previousPassRequest_progress_97 T S copy.val parent.val hpass state).2⟩⟩ .donedef chargedWarmupChild {M J ny passes copies T S : ℕ}    (parent : {r : OAI.EditApproximation.PhysicalTableRequest M J ny // r.Bounded passes copies T S})    (hbelow : parent.val.node.1.val < J) (hindex : 0 < parent.val.index)    (input : Fin M × OAI.EditApproximation.TargetInterval ny) :    OAI.EditApproximation.FiniteQuery {child : OAI.EditApproximation.ChargedPhysicalRequest M J ny passes copies T S //      child.rank < OAI.EditApproximation.ChargedPhysicalRequest.rank (Sum.inr parent)} := by  have proof_table_rank_lt_99 {M : ℕ} {J : ℕ} {ny : ℕ} {passes : ℕ} {copies : ℕ} {T : ℕ} {S : ℕ} (parent : Subtype.{1} fun request => OAI.EditApproximation.PhysicalTableRequest.Bounded (M := M) (J := J) (ny := ny) passes copies T S request) (child : Subtype.{1} fun request => OAI.EditApproximation.PhysicalTableRequest.Bounded (M := M) (J := J) (ny := ny) passes copies T S request) (h : LT.lt.{0} (OAI.EditApproximation.PhysicalTableRequest.combinedRank T S child.val)    (OAI.EditApproximation.PhysicalTableRequest.combinedRank T S parent.val)) :      OAI.EditApproximation.ChargedPhysicalRequest.rank (Sum.inr child : OAI.EditApproximation.ChargedPhysicalRequest M J ny passes copies T S) < OAI.EditApproximation.ChargedPhysicalRequest.rank (Sum.inr parent) := by    simpa only [OAI.EditApproximation.ChargedPhysicalRequest.rank, OAI.EditApproximation.ChargedPhysicalRequest.depth, OAI.EditApproximation.ChargedPhysicalRequest.index, ← Nat.add_assoc, OAI.EditApproximation.PhysicalTableRequest.combinedRank] using      Nat.add_lt_add_right h 1  have proof_combinedRank_lt_of_progress_80 {M : ℕ} {J : ℕ} {ny : ℕ} (T : ℕ) (S : ℕ) (first : OAI.EditApproximation.PhysicalTableRequest M J ny) (second : OAI.EditApproximation.PhysicalTableRequest M J ny) (hprogress : LT.lt.{0} second.remainingDepth first.remainingDepth ∧      LE.le.{0} (OAI.EditApproximation.PhysicalTableRequest.rank T S second)        (OAI.EditApproximation.PhysicalTableRequest.rank T S first) ∨    LE.le.{0} second.remainingDepth first.remainingDepth ∧      LT.lt.{0} (OAI.EditApproximation.PhysicalTableRequest.rank T S second)        (OAI.EditApproximation.PhysicalTableRequest.rank T S first)) :      OAI.EditApproximation.PhysicalTableRequest.combinedRank T S second < OAI.EditApproximation.PhysicalTableRequest.combinedRank T S first := by    unfold OAI.EditApproximation.PhysicalTableRequest.combinedRank    rcases hprogress with h | h    · exact Nat.add_lt_add_of_lt_of_le h.1 h.2    · exact Nat.add_lt_add_of_le_of_lt h.1 h.2  have proof_warmup_previous_child_progress_81 {M : ℕ} {J : ℕ} {ny : ℕ} (pass : ℕ) (copy : ℕ) (T : ℕ) (S : ℕ) (j : ℕ) (node : OAI.EditApproximation.PhysicalNode M J) (hbelow : LT.lt.{0} (↑(Sigma.fst.{0, 0} node)) J) (i : Fin M) (state : OAI.EditApproximation.TargetInterval ny) (previousState : OAI.EditApproximation.TargetInterval ny) (hj : LT.lt.{0} 0 j) :      (OAI.EditApproximation.PhysicalTableRequest.warmup pass copy (OAI.EditApproximation.physicalChild node hbelow i) (j - 1) previousState).remainingDepth <          (OAI.EditApproximation.PhysicalTableRequest.warmup pass copy node j state).remainingDepth ∧        OAI.EditApproximation.PhysicalTableRequest.rank T S (OAI.EditApproximation.PhysicalTableRequest.warmup pass copy (OAI.EditApproximation.physicalChild node hbelow i) (j - 1) previousState) <          OAI.EditApproximation.PhysicalTableRequest.rank T S (OAI.EditApproximation.PhysicalTableRequest.warmup pass copy node j state) := by    constructor    · unfold OAI.EditApproximation.PhysicalTableRequest.remainingDepth OAI.EditApproximation.PhysicalTableRequest.warmup OAI.EditApproximation.physicalChild      dsimp only      omega    · dsimp only [OAI.EditApproximation.PhysicalTableRequest.rank, OAI.EditApproximation.PhysicalTableRequest.warmup]      omega  have proof_combinedRank_warmup_child_79 {M : ℕ} {J : ℕ} {ny : ℕ} (pass : ℕ) (copy : ℕ) (T : ℕ) (S : ℕ) (j : ℕ) (node : OAI.EditApproximation.PhysicalNode M J) (hbelow : LT.lt.{0} (↑(Sigma.fst.{0, 0} node)) J) (i : Fin M) (state : OAI.EditApproximation.TargetInterval ny) (previousState : OAI.EditApproximation.TargetInterval ny) (hj : LT.lt.{0} 0 j) :      OAI.EditApproximation.PhysicalTableRequest.combinedRank T S (OAI.EditApproximation.PhysicalTableRequest.warmup pass copy (OAI.EditApproximation.physicalChild node hbelow i) (j - 1) previousState) <        OAI.EditApproximation.PhysicalTableRequest.combinedRank T S (OAI.EditApproximation.PhysicalTableRequest.warmup pass copy node j state) :=    proof_combinedRank_lt_of_progress_80 T S _ _ (Or.inr      ⟨(proof_warmup_previous_child_progress_81 pass copy T S j node hbelow i state previousState hj).1.le,        (proof_warmup_previous_child_progress_81 pass copy T S j node hbelow i state previousState hj).2⟩)  exact    .read ⟨Sum.inr ⟨OAI.EditApproximation.PhysicalTableRequest.warmup parent.val.pass parent.val.copy        (OAI.EditApproximation.physicalChild parent.val.node hbelow input.1) (parent.val.index - 1) input.2,        parent.property.1, parent.property.2.1,        (Nat.sub_le _ _).trans parent.property.2.2⟩, by      apply proof_table_rank_lt_99      exact proof_combinedRank_warmup_child_79 parent.val.pass parent.val.copy T S        parent.val.index parent.val.node hbelow input.1 parent.val.state input.2 hindex⟩ .donedef chargedSeedQuery {M J ny passes copies T S : ℕ} (N : ℕ) (multiplier : ℕ → ℕ)    (parent : {r : OAI.EditApproximation.PhysicalTableRequest M J ny // r.Bounded passes copies T S})    (state : OAI.EditApproximation.PhysicalEntry M J ny) :    OAI.EditApproximation.FiniteQuery {child : OAI.EditApproximation.ChargedPhysicalRequest M J ny passes copies T S //      child.rank < OAI.EditApproximation.ChargedPhysicalRequest.rank (Sum.inr parent)} := by  have proof_coarse_rank_lt_100 {M : ℕ} {J : ℕ} {ny : ℕ} {passes : ℕ} {copies : ℕ} {T : ℕ} {S : ℕ} (entry : OAI.EditApproximation.PhysicalEntry M J ny) (request : Subtype.{1} fun request => OAI.EditApproximation.PhysicalTableRequest.Bounded (M := M) (J := J) (ny := ny) passes copies T S request) (hnode : Eq.{1} entry.1 request.val.node) :      OAI.EditApproximation.ChargedPhysicalRequest.rank (Sum.inl entry : OAI.EditApproximation.ChargedPhysicalRequest M J ny passes copies T S) < OAI.EditApproximation.ChargedPhysicalRequest.rank (Sum.inr request) := by    change J - entry.1.1.val + 0 < request.val.remainingDepth + (request.val.rank T S + 1)    rw [hnode]    unfold OAI.EditApproximation.PhysicalTableRequest.remainingDepth    omega  exact    if hn : state.1 = parent.val.node then      if hp : parent.val.pass = 0 then        .read ⟨Sum.inl state, proof_coarse_rank_lt_100 state parent hn⟩ .done      else OAI.EditApproximation.FiniteQuery.collect (OAI.EditApproximation.chargedPreviousRead parent (Nat.pos_of_ne_zero hp) state.2)        (List.finRange copies) fun values =>          .done (min N (OAI.EditApproximation.upperMedian (values.map fun value =>            ⌈(multiplier (parent.val.pass - 1) : ℚ) * value⌉₊)) : ℕ)    else .done 0def chargedWarmupQuery {α : Type u_1} [DecidableEq α] {M J passes copies T S : ℕ}    (source target : List α) (N P F : ℕ) (factor : ℕ → ℚ) (multiplier : ℕ → ℕ)    (parent : {r : OAI.EditApproximation.PhysicalTableRequest M J target.length // r.Bounded passes copies T S}) :    OAI.EditApproximation.FiniteQuery {child : OAI.EditApproximation.ChargedPhysicalRequest M J target.length passes copies T S //      child.rank < OAI.EditApproximation.ChargedPhysicalRequest.rank (Sum.inr parent)} :=  if hz : parent.val.index = 0 then    OAI.EditApproximation.physicalInitialQuery source target N P F (factor parent.val.pass)      (OAI.EditApproximation.chargedSeedQuery N multiplier parent) (parent.val.node, parent.val.state)  else if hbelow : parent.val.node.1.val < J then    if (OAI.EditApproximation.physicalSourceInterval source.length parent.val.node).hi -        (OAI.EditApproximation.physicalSourceInterval source.length parent.val.node).lo ≤ 1 then      OAI.EditApproximation.physicalInitialQuery source target N P F (factor parent.val.pass)        (OAI.EditApproximation.chargedSeedQuery N multiplier parent) (parent.val.node, parent.val.state)    else OAI.EditApproximation.physicalWarmupStepQuery source target N P F (factor parent.val.pass)      (OAI.EditApproximation.chargedSeedQuery N multiplier parent)      (OAI.EditApproximation.chargedWarmupChild parent hbelow (Nat.pos_of_ne_zero hz)) parent.val.node parent.val.state  else OAI.EditApproximation.physicalInitialQuery source target N P F (factor parent.val.pass)    (OAI.EditApproximation.chargedSeedQuery N multiplier parent) (parent.val.node, parent.val.state)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen EditDistortion Finset MeasureTheory ProbabilityTheoryabbrev coarseEntryWidth {α : Type u} (x y : List α) : ℕ := max x.length y.lengthabbrev CoarseGuessIndex (n : ℕ) := Fin (Nat.clog 2 n + 1)def coarseGuess (n : ℕ) (i : OAI.EditApproximation.CoarseGuessIndex n) : ℕ := 2 ^ i.valdef coarseEntryTree (B D : ℕ) {α : Type u} (x y : List α) : OAI.EditApproximation.CoarseSourceTree B (Option α) D :=  OAI.EditApproximation.coarseSourceTreeOfList B D (OAI.EditApproximation.coarsePadTo (OAI.EditApproximation.coarseEntryWidth x y) x)noncomputable def coarseInitialMeasure (B D n : ℕ) [NeZero B]    [MeasurableSpace (Fin B)] [MeasurableSingletonClass (Fin B)] :    Measure (OAI.EditApproximation.CoarseGuessIndex n → OAI.EditApproximation.CoarseThresholdDraws B D) :=  Measure.pi fun _ => OAI.EditApproximation.coarseDrawMeasure B Dend OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen Finset MeasureTheory ProbabilityTheorydef coarseActiveChildrenWork {B D : ℕ} {α : Type u}    (Q lam allowance : ℚ)    (work : OAI.EditApproximation.CoarseSourceTree B α D → OAI.EditApproximation.CoarseThresholdDraws B D → ℚ → ℕ) :    List (OAI.EditApproximation.CoarseSourceTree B α D × Fin B × OAI.EditApproximation.CoarseThresholdDraws B D) → ℕ  | [] => 0  | (child, draw, below) :: rest =>    work child below (lam * OAI.EditApproximation.coarseChildThreshold B Q allowance draw) +      coarseActiveChildrenWork Q lam allowance work restabbrev CoarseFullSeedDraws (B : ℕ) {I : Type u_1} {α : Type u_2} (depth : I → ℕ) (x y : I → List α) :=  ∀ i, OAI.EditApproximation.CoarseGuessIndex (OAI.EditApproximation.coarseEntryWidth (x i) (y i)) → OAI.EditApproximation.CoarseThresholdDraws B (depth i)noncomputable def coarseFullSeedMeasure (B : ℕ) [NeZero B]    {I : Type u_1} {α : Type u_2} [Fintype I] (depth : I → ℕ) (x y : I → List α)    [MeasurableSpace (Fin B)] [MeasurableSingletonClass (Fin B)] :    Measure (OAI.EditApproximation.CoarseFullSeedDraws B depth x y) :=  Measure.pi fun i => OAI.EditApproximation.coarseInitialMeasure B (depth i) (OAI.EditApproximation.coarseEntryWidth (x i) (y i))end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen MeasureTheory ProbabilityTheoryvariable {ι : Type u_1} [Fintype ι] (range : ι → ℕ) [∀ i, NeZero (range i)]noncomputable def rejectionAcceptedLaw : Measure (∀ i, Fin (range i)) :=  Measure.pi fun i => (PMF.uniformOfFintype (Fin (range i))).toMeasureabbrev RejectionRuntimeArray := (ι → ℕ) × (∀ i, Fin (range i))end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.BinaryMemodef fractionStorage : OAI.EditApproximation.BinaryMemo OAI.EditApproximation.BinaryFraction → ℕ  | .empty => 0  | .node value left right =>    3 + (value.map fun word => word.numerator.bits.length + word.denominator.length + 1).getD 0 +      left.fractionStorage + right.fractionStoragedef valueStorage {α : Type u_1} (bits : α → ℕ) : OAI.EditApproximation.BinaryMemo α → ℕ  | .empty => 0  | .node value l r => 3 + (value.map bits).getD 0 + valueStorage bits l + valueStorage bits rend OAI.EditApproximation.BinaryMemoendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen Filterdef indexedLeafWithWork (table : OAI.EditApproximation.BinaryMemo OAI.EditApproximation.PositionCounts) (symbolBits positionBits : ℕ)    (symbol : Option ℕ) (lo hi : ℕ) : ℕ × ℕ :=  match symbol with  | none => (hi - lo, 2)  | some a => OAI.EditApproximation.indexedSingletonCostWithWork table symbolBits positionBits a lo hidef integerOccurrenceStorage (source target : List ℤ) : ℕ :=  OAI.EditApproximation.BinaryMemo.valueStorage OAI.EditApproximation.PositionCounts.storageBits (OAI.EditApproximation.integerOccurrenceIndex source target)def integerStoredDataSpace (source target : List ℤ) : ℕ :=  OAI.EditApproximation.storedIntegerBits source + OAI.EditApproximation.storedIntegerBits target +    OAI.EditApproximation.storedNaturalBits (source.map OAI.EditApproximation.integerSymbolCode) + OAI.EditApproximation.storedNaturalBits (target.map OAI.EditApproximation.integerSymbolCode) +    OAI.EditApproximation.integerOccurrenceStorage source targetend OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationdef binaryIndexedLeafWithWork (table : OAI.EditApproximation.BinaryMemo OAI.EditApproximation.PositionCounts) (symbolBits positionBits : ℕ)    (symbol : Option ℕ) (lo hi : ℕ) : OAI.EditApproximation.BinaryFraction × ℕ :=  let result := OAI.EditApproximation.indexedLeafWithWork table symbolBits positionBits symbol lo hi  (OAI.EditApproximation.BinaryFraction.nat result.1, result.2 + Nat.size result.1 + 2)def binaryIndexedLeafAllocation (table : OAI.EditApproximation.BinaryMemo OAI.EditApproximation.PositionCounts) (symbolBits positionBits : ℕ)    (symbol : Option ℕ) (lo hi : ℕ) : ℕ :=  OAI.EditApproximation.indexedLeafAllocation symbolBits positionBits symbol lo hi +    Nat.size (OAI.EditApproximation.indexedLeafWithWork table symbolBits positionBits symbol lo hi).1 + 2def queryIndexedSliceWithWork (source : List ℕ) (interval : OAI.EditApproximation.TargetInterval source.length)    (targetLength : ℕ) (q : OAI.EditApproximation.TargetInterval targetLength)    (occurrence : OAI.EditApproximation.BinaryMemo OAI.EditApproximation.PositionCounts) (symbolBits positionBits : ℕ) : OAI.EditApproximation.BinaryFraction × ℕ :=  let symbol := OAI.EditApproximation.querySliceHeadWithWork source interval  let result := OAI.EditApproximation.binaryIndexedLeafWithWork occurrence symbolBits positionBits symbol.1 q.lo q.hi  (result.1, symbol.2 + result.2 + 1)def queryIndexedSliceAllocation (source : List ℕ) (interval : OAI.EditApproximation.TargetInterval source.length)    (targetLength : ℕ) (q : OAI.EditApproximation.TargetInterval targetLength)    (occurrence : OAI.EditApproximation.BinaryMemo OAI.EditApproximation.PositionCounts) (symbolBits positionBits : ℕ) : ℕ :=  interval.lo.bits.length + interval.hi.bits.length + 1 +    OAI.EditApproximation.binaryIndexedLeafAllocation occurrence symbolBits positionBits (OAI.EditApproximation.querySliceHeadWithWork source interval).1 q.lo q.hiend OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.BinaryFractionvariable {n : ℕ} (read : TargetInterval n → List Bool × ℕ) (allocation : TargetInterval n → ℕ)def initialGridReadAllocation (P : ℕ) (A : OAI.EditApproximation.BinaryFraction) (radius : ℕ) (q : OAI.EditApproximation.TargetInterval n) (b : ℕ) : ℕ :=  let spacing := (OAI.EditApproximation.seedGridSpacingWithWork b P).1  let points := (OAI.EditApproximation.gridStateBoxWithWork n (OAI.EditApproximation.bitWordValue spacing) radius q.lo q.hi).1  OAI.EditApproximation.seedGridSpacingAllocation b P + OAI.EditApproximation.gridStateBoxAllocation n (OAI.EditApproximation.bitWordValue spacing) radius q.lo q.hi +    OAI.EditApproximation.filterAllocation (fun r => ((OAI.EditApproximation.BinaryFraction.initialCenterGuardWithWork b (OAI.EditApproximation.bitWordValue (read r).1) A).1,      (OAI.EditApproximation.BinaryFraction.initialCenterGuardWithWork b (OAI.EditApproximation.bitWordValue (read r).1) A).2 + (read r).2))      (fun r => OAI.EditApproximation.BinaryFraction.initialCenterGuardAllocation b (OAI.EditApproximation.bitWordValue (read r).1) A + allocation r) pointsdef initialConeReadAllocation (sourceLength : ℕ) (a L : OAI.EditApproximation.BinaryFraction) (query center : OAI.EditApproximation.TargetInterval n) : ℕ :=  allocation center + OAI.EditApproximation.BinaryFraction.initialConeAllocation sourceLength (OAI.EditApproximation.bitWordValue (read center).1) a L query centerdef initialCentersReadAllocation (N P : ℕ) (A : OAI.EditApproximation.BinaryFraction) (q : OAI.EditApproximation.TargetInterval n) : ℕ :=  let Uq := OAI.EditApproximation.bitWordValue (read q).1  let scales := (OAI.EditApproximation.dyadicScalesWithWork N).1  let active := (OAI.EditApproximation.filterWithWork (fun b => OAI.EditApproximation.BinaryFraction.initialScaleGuardWithWork Uq b A) scales).1  allocation q + OAI.EditApproximation.dyadicScalesAllocation N +    OAI.EditApproximation.filterAllocation (fun b => OAI.EditApproximation.BinaryFraction.initialScaleGuardWithWork Uq b A) (fun b => OAI.EditApproximation.BinaryFraction.initialScaleGuardAllocation Uq b A) scales +    OAI.EditApproximation.arithmeticFlatMapAllocation (OAI.EditApproximation.BinaryFraction.initialGridReadWithWork P A read Uq q)      (OAI.EditApproximation.BinaryFraction.initialGridReadAllocation read allocation P A Uq q) activedef initialMinimumReadAllocation (sourceLength N F : ℕ) (a : OAI.EditApproximation.BinaryFraction)    (query : OAI.EditApproximation.TargetInterval n) (centers : List (OAI.EditApproximation.TargetInterval n)) : ℕ :=  let Uq := OAI.EditApproximation.bitWordValue (read query).1  allocation query + OAI.EditApproximation.naturalEqualAllocation Uq 0 +    if (OAI.EditApproximation.naturalEqualWithWork Uq 0).1 then 0 else      let L := (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat 32) (OAI.EditApproximation.BinaryFraction.nat F)).1      let coefficient := (OAI.EditApproximation.BinaryFraction.canonicalAddWithWork L OAI.EditApproximation.BinaryFraction.one).1      let fallback := (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork coefficient (OAI.EditApproximation.BinaryFraction.nat N)).1      let scores := (OAI.EditApproximation.arithmeticMapWithWork (OAI.EditApproximation.BinaryFraction.initialConeReadWithWork sourceLength read a L query) centers).1      OAI.EditApproximation.BinaryFraction.canonicalMulAllocation (OAI.EditApproximation.BinaryFraction.nat 32) (OAI.EditApproximation.BinaryFraction.nat F) + OAI.EditApproximation.BinaryFraction.canonicalAddAllocation L OAI.EditApproximation.BinaryFraction.one +        OAI.EditApproximation.BinaryFraction.canonicalMulAllocation coefficient (OAI.EditApproximation.BinaryFraction.nat N) +        OAI.EditApproximation.arithmeticMapAllocation (OAI.EditApproximation.BinaryFraction.initialConeReadAllocation read allocation sourceLength a L query) centers +        OAI.EditApproximation.BinaryFraction.minimumAllocation fallback scores + Nat.size F + Nat.size Ndef initialProgramReadAllocation (sourceLength N P F : ℕ) (A a : OAI.EditApproximation.BinaryFraction) (query : OAI.EditApproximation.TargetInterval n) : ℕ :=  OAI.EditApproximation.BinaryFraction.initialCentersReadAllocation read allocation N P A query + OAI.EditApproximation.BinaryFraction.initialMinimumReadAllocation read allocation sourceLength N F a    query (OAI.EditApproximation.BinaryFraction.initialCentersReadWithWork N P A read query).1def cachedInitialProgramReadAllocation (sourceLength N P F : ℕ) (A a : OAI.EditApproximation.BinaryFraction) (query : OAI.EditApproximation.TargetInterval n) : ℕ :=  OAI.EditApproximation.BinaryFraction.finishCachedAllocation (OAI.EditApproximation.BinaryFraction.initialProgramReadWithWork sourceLength N P F A a read query)    (OAI.EditApproximation.BinaryFraction.initialProgramReadAllocation read allocation sourceLength N P F A a query) [true] (by decide) 0end OAI.EditApproximation.BinaryFractionendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.BinaryFractionopen BinaryFractiondef onlineParametersAllocation (word : List Bool) : ℕ :=  OAI.EditApproximation.bitPowerAllocation word 5 + OAI.EditApproximation.bitPowerAllocation word 4 + 2def refinementDecrementAllocation (word : List Bool) : ℕ := OAI.EditApproximation.bitPowerAllocation word 10 + 1end OAI.EditApproximation.BinaryFractionendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen BinaryFractiondef scheduledRefinementAllocation (N pass : ℕ) : ℕ :=  if pass < OAI.EditApproximation.computedSeedPassCount N then    OAI.EditApproximation.BinaryFraction.signedPowerTwoAllocation ((OAI.EditApproximation.dyadicSeedExponent (OAI.EditApproximation.smallLogExponent N)      (OAI.EditApproximation.computedSeedInitialExponent N) pass - OAI.EditApproximation.smallLogExponent N : ℕ) : ℤ) + 2  else 2def refinementBaseAllocation (word : List Bool) : ℕ :=  let power := OAI.EditApproximation.bitPowerWithWork word 10  let increment := OAI.EditApproximation.bitAddWithWork power.1 [true] false  OAI.EditApproximation.bitPowerAllocation word 10 + OAI.EditApproximation.bitAddAllocation power.1 [true] false +    OAI.EditApproximation.trimBitWordAllocation increment.1 + 2def refinementParameterAllocation (N pass : ℕ) (word : List Bool) : ℕ :=  OAI.EditApproximation.BinaryFraction.onlineParametersAllocation word + OAI.EditApproximation.scheduledRefinementAllocation N pass +    OAI.EditApproximation.BinaryFraction.refinementDecrementAllocation word + 5def computedQueryPassAllocation (N pass : ℕ) : ℕ :=  OAI.EditApproximation.BinaryFraction.signedPowerTwoAllocation ((OAI.EditApproximation.dyadicSeedExponent (OAI.EditApproximation.smallLogExponent N) (OAI.EditApproximation.computedSeedInitialExponent N) pass : ℕ) : ℤ) +    OAI.EditApproximation.refinementParameterAllocation N pass (OAI.EditApproximation.inputSmallLog N).bits + 2def computedQuerySetupAllocation (N : ℕ) : ℕ :=  OAI.EditApproximation.vectorMapAllocation (OAI.EditApproximation.computedSeedPassCount N + 1) (fun i => OAI.EditApproximation.computedQueryPassAllocation N i.val) +    OAI.EditApproximation.refinementBaseAllocation (OAI.EditApproximation.inputSmallLog N).bits + 5end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.UnreducedRationalopen Finsetdef nat (n : ℕ) : OAI.EditApproximation.UnreducedRational := ⟨n, 1, by decide⟩end OAI.EditApproximation.UnreducedRationalendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.BinaryFractionopen Finsetdef countedGroupMemberSourceWithWork {M T : ℕ} (Q b : ℕ) (scales : Fin T → OAI.EditApproximation.BinaryFraction)    (connection : OAI.EditApproximation.BinaryFraction) (envelope values : Vector OAI.EditApproximation.BinaryFraction M)    (draw : ∀ t, Fin (OAI.EditApproximation.groupSampleCount M Q b (scales t).value) → Fin M × ℕ) : OAI.EditApproximation.BinaryFraction × ℕ := by  have proof_vectorMapWithWork_value_27 {α : Type 0} (d : ℕ) (f : Fin d → Prod.{0, 0} α ℕ) (i : Fin d) :      (OAI.EditApproximation.vectorMapWithWork d f).1.get i = (f i).1 := by    change (Vector.ofFn f |>.map Prod.fst)[i.val] = _    simp only [Vector.getElem_map, Vector.getElem_ofFn]  have proof_bitOrdering_matches_4 (high : Ordering) (a : Bool) (b : Bool) (x : ℕ) (y : ℕ) (h : OAI.EditApproximation.orderingMatches high x y) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitOrdering high a b) (a.toNat + 2 * x) (b.toNat + 2 * y) := by    rcases h with ⟨rfl, h⟩ | ⟨rfl, rfl⟩ | ⟨rfl, h⟩    · exact Or.inl ⟨rfl, by cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩    · cases a <;> cases b <;> simp [OAI.EditApproximation.bitOrdering, OAI.EditApproximation.orderingMatches]    · exact Or.inr (Or.inr ⟨rfl, by        cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩)  have proof_bitCompareWithWork_matches_5 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitCompareWithWork left right).1 (OAI.EditApproximation.bitWordValue left) (OAI.EditApproximation.bitWordValue right) := by    induction left generalizing right with    | nil =>      simp only [OAI.EditApproximation.bitCompareWithWork]      induction right with      | nil => (simp [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.orderingMatches, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        simpa only [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareNilLeftWithWork bs).1 false b 0 (OAI.EditApproximation.bitWordValue bs) ih    | cons a as ih =>      cases right with      | nil =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as []).1 a false (OAI.EditApproximation.bitWordValue as) 0 (ih [])      | cons b bs =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue] using          proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as bs).1 a b (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs) (ih bs)  have proof_bitCompareWithWork_lt_16 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .lt ↔ OAI.EditApproximation.bitWordValue left < OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_wordLEWithWork_value_26 (a : List.{0} Bool) (b : List.{0} Bool) :      (OAI.EditApproximation.wordLEWithWork a b).1 = true ↔ OAI.EditApproximation.bitWordValue a ≤ OAI.EditApproximation.bitWordValue b := by    simp only [OAI.EditApproximation.wordLEWithWork, Bool.not_eq_true', decide_eq_false_iff_not,      proof_bitCompareWithWork_lt_16, not_lt]  have proof_wordMinWithWork_value_29 (a : List.{0} Bool) (b : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.wordMinWithWork a b).1 = min (OAI.EditApproximation.bitWordValue a) (OAI.EditApproximation.bitWordValue b) := by    unfold OAI.EditApproximation.wordMinWithWork    dsimp only    split_ifs with h    · exact (min_eq_left ((proof_wordLEWithWork_value_26 a b).mp h)).symm    · exact (min_eq_right (le_of_not_ge (fun hle => h ((proof_wordLEWithWork_value_26 a b).mpr hle)))).symm  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_bitSubtractor_value_17 (a : Bool) (b : Bool) (borrow : Bool) :      a.toNat + 2 * (OAI.EditApproximation.bitBorrow a b borrow).toNat =        b.toNat + borrow.toNat + (OAI.EditApproximation.bitDifference a b borrow).toNat := by    cases a <;> cases b <;> cases borrow <;> decide  have proof_bitSubtractionRippleEquation_18 (a : ℕ) (b : ℕ) (borrow : ℕ) (nextBorrow : ℕ) (difference : ℕ) (left : ℕ) (right : ℕ) (result : ℕ) (tail : ℕ) (htail : Eq.{1} (HAdd.hAdd.{0, 0, 0} (HAdd.hAdd.{0, 0, 0} result right) nextBorrow) (HAdd.hAdd.{0, 0, 0} left tail)) (hbit : Eq.{1} (HAdd.hAdd.{0, 0, 0} a (HMul.hMul.{0, 0, 0} 2 nextBorrow))    (HAdd.hAdd.{0, 0, 0} (HAdd.hAdd.{0, 0, 0} b borrow) difference)) :      (difference + 2 * result) + (b + 2 * right) + borrow =        (a + 2 * left) + 2 * tail := by    omega  have proof_bitSubtractWithWork_value_19 (left : List.{0} Bool) (right : List.{0} Bool) (borrow : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork left right borrow).1 + OAI.EditApproximation.bitWordValue right + borrow.toNat =        OAI.EditApproximation.bitWordValue left + 2 ^ max left.length right.length *          (OAI.EditApproximation.bitSubtractWithWork left right borrow).2.1.toNat := by    induction left generalizing right borrow with    | nil =>      induction right generalizing borrow with      | nil => (simp [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitSubtractNilLeftWithWork, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        have h := ih (OAI.EditApproximation.bitBorrow false b borrow)        have hb := proof_bitSubtractor_value_17 false b borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitSubtractNilLeftWithWork, OAI.EditApproximation.bitWordValue,          List.length_nil, List.length_cons, Nat.zero_max, pow_succ, Bool.toNat_false] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 0 b.toNat borrow.toNat (OAI.EditApproximation.bitBorrow false b borrow).toNat          (OAI.EditApproximation.bitDifference false b borrow).toNat 0 (OAI.EditApproximation.bitWordValue bs)          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractNilLeftWithWork bs (OAI.EditApproximation.bitBorrow false b borrow)).1)          (2 ^ bs.length * (OAI.EditApproximation.bitSubtractNilLeftWithWork bs (OAI.EditApproximation.bitBorrow false b borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_zero, Nat.add_zero, Nat.zero_add, Nat.mul_assoc,          Nat.mul_left_comm] using hs    | cons a as ih =>      cases right with      | nil =>        have h := ih [] (OAI.EditApproximation.bitBorrow a false borrow)        have hb := proof_bitSubtractor_value_17 a false borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitWordValue, List.length_nil, List.length_cons,          Nat.max_zero, pow_succ, Bool.toNat_false] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 a.toNat 0 borrow.toNat (OAI.EditApproximation.bitBorrow a false borrow).toNat          (OAI.EditApproximation.bitDifference a false borrow).toNat (OAI.EditApproximation.bitWordValue as) 0          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork as [] (OAI.EditApproximation.bitBorrow a false borrow)).1)          (2 ^ as.length * (OAI.EditApproximation.bitSubtractWithWork as [] (OAI.EditApproximation.bitBorrow a false borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_zero, Nat.add_zero, Nat.zero_add, Nat.mul_assoc,          Nat.mul_left_comm] using hs      | cons b bs =>        have h := ih bs (OAI.EditApproximation.bitBorrow a b borrow)        have hb := proof_bitSubtractor_value_17 a b borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitWordValue, List.length_cons, Nat.succ_max_succ,          pow_succ] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 a.toNat b.toNat borrow.toNat (OAI.EditApproximation.bitBorrow a b borrow).toNat          (OAI.EditApproximation.bitDifference a b borrow).toNat (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs)          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork as bs (OAI.EditApproximation.bitBorrow a b borrow)).1)          (2 ^ max as.length bs.length * (OAI.EditApproximation.bitSubtractWithWork as bs (OAI.EditApproximation.bitBorrow a b borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_assoc, Nat.mul_left_comm] using hs  have proof_bitWordValue_lt_pow_length_20 (bits : List.{0} Bool) : OAI.EditApproximation.bitWordValue bits < 2 ^ bits.length := by    induction bits with    | nil => (simp [OAI.EditApproximation.bitWordValue])    | cons bit bits ih =>      cases bit <;> (simp only [OAI.EditApproximation.bitWordValue, List.length_cons, pow_succ, Bool.toNat_false, Bool.toNat_true]) <;> omega  have proof_bitSubtractWithWork_length_21 (left : List.{0} Bool) (right : List.{0} Bool) (borrow : Bool) :      (OAI.EditApproximation.bitSubtractWithWork left right borrow).1.length = max left.length right.length := by    induction left generalizing right borrow with    | nil =>      simp only [OAI.EditApproximation.bitSubtractWithWork]      induction right generalizing borrow with      | nil => simp [OAI.EditApproximation.bitSubtractNilLeftWithWork]      | cons b bs ih => simp [OAI.EditApproximation.bitSubtractNilLeftWithWork, ih]    | cons a as ih =>      cases right with      | nil => simp [OAI.EditApproximation.bitSubtractWithWork, ih]      | cons b bs => simp [OAI.EditApproximation.bitSubtractWithWork, ih, Nat.succ_max_succ]  have proof_bitSubtractWithWork_sub_22 (left : List.{0} Bool) (right : List.{0} Bool) (h : LE.le.{0} (OAI.EditApproximation.bitWordValue right) (OAI.EditApproximation.bitWordValue left)) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork left right false).1 = OAI.EditApproximation.bitWordValue left - OAI.EditApproximation.bitWordValue right := by    have hvalue := proof_bitSubtractWithWork_value_19 left right false    have hlt := proof_bitWordValue_lt_pow_length_20 (OAI.EditApproximation.bitSubtractWithWork left right false).1    rw [proof_bitSubtractWithWork_length_21] at hlt    cases hb : (OAI.EditApproximation.bitSubtractWithWork left right false).2.1    · simp only [hb, Bool.toNat_false, Nat.mul_zero, Nat.add_zero] at hvalue      omega    · simp only [hb, Bool.toNat_true, Bool.toNat_false, Nat.mul_one, Nat.add_zero] at hvalue      omega  have proof_bitDivModWithWork_value_23 (divisor : List.{0} Bool) (bits : List.{0} Bool) (hd : LT.lt.{0} 0 (OAI.EditApproximation.bitWordValue divisor)) :      OAI.EditApproximation.bitWordValue bits = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).1 +        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 ∧        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 < OAI.EditApproximation.bitWordValue divisor := by    induction bits with    | nil => (simp [OAI.EditApproximation.bitDivModWithWork, OAI.EditApproximation.bitWordValue, hd])    | cons bit bits ih =>      let previous := OAI.EditApproximation.bitDivModWithWork divisor bits      let candidate := bit :: previous.2.1      have hp : OAI.EditApproximation.bitWordValue bits = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue previous.1 +          OAI.EditApproximation.bitWordValue previous.2.1 := ih.1      have hr : OAI.EditApproximation.bitWordValue previous.2.1 < OAI.EditApproximation.bitWordValue divisor := ih.2      have hc : OAI.EditApproximation.bitWordValue candidate < 2 * OAI.EditApproximation.bitWordValue divisor := by        dsimp only [candidate, OAI.EditApproximation.bitWordValue]        cases bit <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega      by_cases hlt : (OAI.EditApproximation.bitCompareWithWork candidate divisor).1 = .lt      · have hv := (proof_bitCompareWithWork_lt_16 candidate divisor).1 hlt        simp only [OAI.EditApproximation.bitDivModWithWork, show (OAI.EditApproximation.bitCompareWithWork (bit :: (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1)          divisor).1 = .lt from hlt, ↓reduceIte]        change OAI.EditApproximation.bitWordValue (bit :: bits) = OAI.EditApproximation.bitWordValue divisor *          OAI.EditApproximation.bitWordValue (false :: previous.1) + OAI.EditApproximation.bitWordValue candidate ∧ OAI.EditApproximation.bitWordValue candidate < _        constructor        · (simp only [OAI.EditApproximation.bitWordValue, Bool.toNat_false])          dsimp only [candidate, OAI.EditApproximation.bitWordValue]          nlinarith only [hp]        · exact hv      · have hv : OAI.EditApproximation.bitWordValue divisor ≤ OAI.EditApproximation.bitWordValue candidate := by          exact Nat.le_of_not_gt (fun h => hlt ((proof_bitCompareWithWork_lt_16 candidate divisor).2 h))        have hs := proof_bitSubtractWithWork_sub_22 candidate divisor hv        simp only [OAI.EditApproximation.bitDivModWithWork, show (OAI.EditApproximation.bitCompareWithWork (bit :: (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1)          divisor).1 ≠ .lt from hlt, ↓reduceIte]        change OAI.EditApproximation.bitWordValue (bit :: bits) = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue (true :: previous.1) +          OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork candidate divisor false).1 ∧          OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork candidate divisor false).1 < _        rw [hs]        constructor        · (simp only [OAI.EditApproximation.bitWordValue, Bool.toNat_true])          have he := Nat.sub_add_cancel hv          dsimp only [candidate, OAI.EditApproximation.bitWordValue] at he ⊢          nlinarith only [hp, he]        · omega  have proof_bitCompareWithWork_eq_3 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .eq ↔ OAI.EditApproximation.bitWordValue left = OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_bitAdder_value_1 (a : Bool) (b : Bool) (carry : Bool) :      (OAI.EditApproximation.bitSum a b carry).toNat + 2 * (OAI.EditApproximation.bitCarry a b carry).toNat =        a.toNat + b.toNat + carry.toNat := by    cases a <;> cases b <;> cases carry <;> decide  have proof_bitAddWithWork_value_2 (left : List.{0} Bool) (right : List.{0} Bool) (carry : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitAddWithWork left right carry).1 =        OAI.EditApproximation.bitWordValue left + OAI.EditApproximation.bitWordValue right + carry.toNat := by    induction left generalizing right carry with    | nil =>      simp only [OAI.EditApproximation.bitAddWithWork]      induction right generalizing carry with      | nil => cases carry <;> simp [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue]      | cons b bs ih =>        simp only [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 false b carry        simp only [Bool.toNat_false] at h        omega    | cons a as ih =>      cases right with      | nil =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a false carry        simp only [Bool.toNat_false] at h        omega      | cons b bs =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a b carry        omega  have proof_bitCeilDivWithWork_value_30 (divisor : List.{0} Bool) (bits : List.{0} Bool) (hd : LT.lt.{0} 0 (OAI.EditApproximation.bitWordValue divisor)) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitCeilDivWithWork divisor bits).1 =        ⌈((OAI.EditApproximation.bitWordValue bits : ℚ) / OAI.EditApproximation.bitWordValue divisor)⌉₊ := by    let q := OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).1    let r := OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1    have h := proof_bitDivModWithWork_value_23 divisor bits hd    have heq : OAI.EditApproximation.bitWordValue bits = OAI.EditApproximation.bitWordValue divisor * q + r := h.1    have hr : r < OAI.EditApproximation.bitWordValue divisor := h.2    have hdQ : (0 : ℚ) < OAI.EditApproximation.bitWordValue divisor := by exact_mod_cast hd    unfold OAI.EditApproximation.bitCeilDivWithWork    dsimp only    split_ifs with hz    · have hr0 : r = 0 := by        exact (proof_bitCompareWithWork_eq_3 (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 []).1 hz      have hratio : (OAI.EditApproximation.bitWordValue bits : ℚ) / OAI.EditApproximation.bitWordValue divisor = (q : ℚ) := by        apply (div_eq_iff hdQ.ne').mpr        exact_mod_cast (show OAI.EditApproximation.bitWordValue bits = q * OAI.EditApproximation.bitWordValue divisor by nlinarith only [heq, hr0])      rw [hratio]      exact (Nat.ceil_natCast q).symm    · have hr0 : r ≠ 0 := by        intro hzero        exact hz ((proof_bitCompareWithWork_eq_3 (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 []).2 hzero)      rw [proof_bitAddWithWork_value_2]      change q + 1 + 0 = _      simp only [Nat.add_zero]      symm      apply (Nat.ceil_eq_iff (by omega : q + 1 ≠ 0)).mpr      constructor      · simp only [Nat.add_sub_cancel]        rw [lt_div_iff₀ hdQ]        exact_mod_cast (show q * OAI.EditApproximation.bitWordValue divisor < OAI.EditApproximation.bitWordValue bits by          nlinarith only [heq, Nat.pos_of_ne_zero hr0])      · rw [div_le_iff₀ hdQ]        push_cast        exact_mod_cast (show OAI.EditApproximation.bitWordValue bits ≤ (q + 1) * OAI.EditApproximation.bitWordValue divisor by nlinarith only [heq, hr])  have proof_naturalCeilingWithWork_value_31 (a : OAI.EditApproximation.BinaryFraction) :      OAI.EditApproximation.bitWordValue (a.naturalCeilingWithWork).1 = ⌈a.value⌉₊ := by    cases hs : a.numerator.negative    · simpa only [OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork, hs, Bool.false_eq_true, ↓reduceIte,        OAI.EditApproximation.BinaryFraction.value, OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, Int.cast_natCast] using        proof_bitCeilDivWithWork_value_30 a.denominator a.numerator.bits a.denominator_pos    · have hn : a.value ≤ 0 := by        (simp only [OAI.EditApproximation.BinaryFraction.value, OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, hs, ↓reduceIte, Int.cast_neg, Int.cast_natCast])        exact div_nonpos_of_nonpos_of_nonneg (neg_nonpos.mpr (Nat.cast_nonneg _)) (Nat.cast_nonneg _)      (simp only [OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork, hs, ↓reduceIte, OAI.EditApproximation.bitWordValue])      exact (Nat.ceil_eq_zero.mpr hn).symm  have proof_representation_value_32 (a : OAI.EditApproximation.BinaryFraction) : a.representation.value = a.value := rfl  have proof_eq_of_num_den_33 {a : OAI.EditApproximation.UnreducedRational} {b : OAI.EditApproximation.UnreducedRational} (hnum : Eq.{1} a.num b.num) (hden : Eq.{1} a.den b.den) : a = b := by    cases a    cases b    cases hnum    cases hden    rfl  have proof_trimBitWordWithWork_value_6 (bits : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.trimBitWordWithWork bits).1 = OAI.EditApproximation.bitWordValue bits := by    induction bits with    | nil => rfl    | cons bit bits ih =>      simp only [OAI.EditApproximation.trimBitWordWithWork]      split_ifs with h      · have ht : OAI.EditApproximation.bitWordValue bits = 0 := by rw [← ih, h.1]; rfl        simp [h.2, OAI.EditApproximation.bitWordValue, ht]      · (simp only [OAI.EditApproximation.bitWordValue, ih])  have proof_canonicalizeWithWork_representation_34 (a : OAI.EditApproximation.BinaryFraction) :      (OAI.EditApproximation.BinaryFraction.canonicalizeWithWork a).1.representation = a.representation := by    apply proof_eq_of_num_den_33    · (simp only [OAI.EditApproximation.BinaryFraction.canonicalizeWithWork, OAI.EditApproximation.BinaryFraction.representation, OAI.EditApproximation.SignedBinary.value, proof_trimBitWordWithWork_value_6])    · exact proof_trimBitWordWithWork_value_6 a.denominator  have proof_bitMulWithWork_value_0 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitMulWithWork left right).1 = OAI.EditApproximation.bitWordValue left * OAI.EditApproximation.bitWordValue right := by    induction left with    | nil => simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue]    | cons bit bits ih =>      cases bit <;> simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue, proof_bitAddWithWork_value_2, ih] <;> ring  have proof_mulWithWork_value_35 (a : OAI.EditApproximation.SignedBinary) (b : OAI.EditApproximation.SignedBinary) :      (a.mulWithWork b).1.value = a.value * b.value := by    simp only [OAI.EditApproximation.SignedBinary.mulWithWork, OAI.EditApproximation.SignedBinary.value, proof_bitMulWithWork_value_0]    cases a.negative <;> cases b.negative <;> simp [OAI.EditApproximation.signedMagnitude]  have proof_mulWithWork_representation_36 (a : OAI.EditApproximation.BinaryFraction) (b : OAI.EditApproximation.BinaryFraction) :      (a.mulWithWork b).1.representation = a.representation.mul b.representation := by    apply proof_eq_of_num_den_33    · exact proof_mulWithWork_value_35 a.numerator b.numerator    · exact proof_bitMulWithWork_value_0 a.denominator b.denominator  have proof_canonicalMulWithWork_representation_37 (a : OAI.EditApproximation.BinaryFraction) (b : OAI.EditApproximation.BinaryFraction) :      (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork a b).1.representation = a.representation.mul b.representation := by    rw [OAI.EditApproximation.BinaryFraction.canonicalMulWithWork, proof_canonicalizeWithWork_representation_34, proof_mulWithWork_representation_36]  have proof_zero_representation_38 : OAI.EditApproximation.BinaryFraction.zero.representation = OAI.EditApproximation.UnreducedRational.zero := by    apply proof_eq_of_num_den_33 <;> rfl  have proof_invWithWork_representation_39 (a : OAI.EditApproximation.BinaryFraction) :      (a.invWithWork).1.representation = a.representation.inv := by    unfold OAI.EditApproximation.BinaryFraction.invWithWork    dsimp only    split_ifs with h    · have hz : OAI.EditApproximation.bitWordValue a.numerator.bits = 0 := by        simpa only [OAI.EditApproximation.bitWordValue] using (proof_bitCompareWithWork_eq_3 a.numerator.bits []).1 h      have hv : a.numerator.value = 0 := by (simp [OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, hz])      (simp only [OAI.EditApproximation.UnreducedRational.inv, OAI.EditApproximation.BinaryFraction.representation, hv, ↓reduceDIte])      exact proof_zero_representation_38    · have hn : OAI.EditApproximation.bitWordValue a.numerator.bits ≠ 0 := by        intro hz        exact h ((proof_bitCompareWithWork_eq_3 a.numerator.bits []).2 (by simpa [OAI.EditApproximation.bitWordValue] using hz))      have hv : a.numerator.value ≠ 0 := by        cases hs : a.numerator.negative <;> (simp [OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, hs, hn])      (simp only [OAI.EditApproximation.UnreducedRational.inv, OAI.EditApproximation.BinaryFraction.representation, hv, ↓reduceDIte])      apply proof_eq_of_num_den_33      · cases hs : a.numerator.negative <;>          simp [OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, hs, Int.sign_natCast_of_ne_zero hn]      · cases hs : a.numerator.negative <;> (simp [OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, hs])  have proof_divWithWork_representation_40 (a : OAI.EditApproximation.BinaryFraction) (b : OAI.EditApproximation.BinaryFraction) :      (a.divWithWork b).1.representation = a.representation.div b.representation := by    (simp only [OAI.EditApproximation.BinaryFraction.divWithWork, proof_canonicalMulWithWork_representation_37, proof_invWithWork_representation_39,      OAI.EditApproximation.UnreducedRational.div])  have proof_value_mul_41 (a : OAI.EditApproximation.UnreducedRational) (b : OAI.EditApproximation.UnreducedRational) : (a.mul b).value = a.value * b.value := by    simp [OAI.EditApproximation.UnreducedRational.mul, OAI.EditApproximation.UnreducedRational.value, mul_div_mul_comm]  have proof_value_inv_42 (a : OAI.EditApproximation.UnreducedRational) : a.inv.value = a.value⁻¹ := by    by_cases h : a.num = 0    · simp [OAI.EditApproximation.UnreducedRational.inv, h, OAI.EditApproximation.UnreducedRational.value, OAI.EditApproximation.UnreducedRational.zero]    · have hn : (a.num.natAbs : ℚ) ≠ 0 := by exact_mod_cast (Int.natAbs_pos.mpr h).ne'      have hd : (a.den : ℚ) ≠ 0 := by exact_mod_cast a.den_pos.ne'      have hsign : ((a.num.sign : ℤ) : ℚ) * a.num = (a.num.natAbs : ℚ) := by        simpa only [Int.cast_mul, Int.cast_natCast] using          congrArg (fun z : ℤ => (z : ℚ)) (Int.sign_mul_self_eq_natAbs a.num)      simp only [OAI.EditApproximation.UnreducedRational.inv, h, ↓reduceDIte, OAI.EditApproximation.UnreducedRational.value]      push_cast      apply eq_inv_of_mul_eq_one_left      field_simp [hn, hd]      exact hsign  have proof_value_div_43 (a : OAI.EditApproximation.UnreducedRational) (b : OAI.EditApproximation.UnreducedRational) : (a.div b).value = a.value / b.value := by    simp [proof_value_mul_41, proof_value_inv_42, OAI.EditApproximation.UnreducedRational.div, div_eq_mul_inv]  have proof_divWithWork_value_44 (a : OAI.EditApproximation.BinaryFraction) (b : OAI.EditApproximation.BinaryFraction) :      (OAI.EditApproximation.BinaryFraction.divWithWork a b).1.value = a.value / b.value := by    rw [← proof_representation_value_32, proof_divWithWork_representation_40,      proof_value_div_43, proof_representation_value_32, proof_representation_value_32]  have proof_canonicalMulWithWork_value_45 (a : OAI.EditApproximation.BinaryFraction) (b : OAI.EditApproximation.BinaryFraction) :      (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork a b).1.value = a.value * b.value := by    rw [← proof_representation_value_32, proof_canonicalMulWithWork_representation_37,      proof_value_mul_41, proof_representation_value_32, proof_representation_value_32]  have proof_value_ofInt_46 (a : ℤ) : (OAI.EditApproximation.SignedBinary.ofInt a).value = a := by    by_cases h : a < 0    · simpa only [OAI.EditApproximation.SignedBinary.ofInt, OAI.EditApproximation.SignedBinary.value, proof_bitWordValue_bits_15, OAI.EditApproximation.signedMagnitude, h, decide_true,        ↓reduceIte] using (Int.eq_neg_natAbs_of_nonpos (le_of_lt h)).symm    · simpa only [OAI.EditApproximation.SignedBinary.ofInt, OAI.EditApproximation.SignedBinary.value, proof_bitWordValue_bits_15, OAI.EditApproximation.signedMagnitude, h, decide_false,        Bool.false_eq_true, ↓reduceIte] using (Int.eq_natAbs_of_nonneg (le_of_not_gt h)).symm  have proof_nat_representation_47 (n : ℕ) : (OAI.EditApproximation.BinaryFraction.nat n).representation = OAI.EditApproximation.UnreducedRational.nat n := by    apply proof_eq_of_num_den_33    · change (OAI.EditApproximation.SignedBinary.ofInt (n : ℤ)).value = (n : ℤ)      exact proof_value_ofInt_46 _    · rfl  have proof_value_nat_48 (n : ℕ) : (OAI.EditApproximation.UnreducedRational.nat n).value = n := by (simp [OAI.EditApproximation.UnreducedRational.nat, OAI.EditApproximation.UnreducedRational.value])  have proof_nat_value_49 (n : ℕ) : (OAI.EditApproximation.BinaryFraction.nat n).value = (n : ℚ) := by    rw [← proof_representation_value_32, proof_nat_representation_47, proof_value_nat_48]  have proof_groupSampleCountWithWork_value_28 (M : ℕ) (Q : ℕ) (b : ℕ) (h : OAI.EditApproximation.BinaryFraction) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.BinaryFraction.groupSampleCountWithWork M Q b h).1 = OAI.EditApproximation.groupSampleCount M Q b h.value := by    simp only [OAI.EditApproximation.BinaryFraction.groupSampleCountWithWork, proof_wordMinWithWork_value_29, proof_bitWordValue_bits_15,      proof_naturalCeilingWithWork_value_31, proof_divWithWork_value_44, proof_canonicalMulWithWork_value_45,      proof_nat_value_49, OAI.EditApproximation.groupSampleCount]  exact    let counts := OAI.EditApproximation.vectorMapWithWork T fun t => OAI.EditApproximation.BinaryFraction.groupSampleCountWithWork M Q b (scales t)    let count := fun t => OAI.EditApproximation.bitWordValue (counts.1.get t)    let heq : ∀ t, count t = OAI.EditApproximation.groupSampleCount M Q b (scales t).value := by      intro t      simp only [count, counts, proof_vectorMapWithWork_value_27, proof_groupSampleCountWithWork_value_28]    let result := OAI.EditApproximation.BinaryFraction.groupMemberSourceWithWork scales count connection envelope values      (fun t j => draw t (Fin.cast (heq t) j))    (result.1, counts.2 + result.2 + 1)def roundedBandReadWithWork {n M : ℕ} (exponent b : ℕ)    (band : List (Fin M → OAI.EditApproximation.TargetInterval n)) (hne : band ≠ [])    (read : Fin M → OAI.EditApproximation.TargetInterval n → OAI.EditApproximation.BinaryFraction × ℕ) : Vector (OAI.EditApproximation.TargetInterval n) M × ℕ := by  have proof_bitOrdering_matches_4 (high : Ordering) (a : Bool) (b : Bool) (x : ℕ) (y : ℕ) (h : OAI.EditApproximation.orderingMatches high x y) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitOrdering high a b) (a.toNat + 2 * x) (b.toNat + 2 * y) := by    rcases h with ⟨rfl, h⟩ | ⟨rfl, rfl⟩ | ⟨rfl, h⟩    · exact Or.inl ⟨rfl, by cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩    · cases a <;> cases b <;> simp [OAI.EditApproximation.bitOrdering, OAI.EditApproximation.orderingMatches]    · exact Or.inr (Or.inr ⟨rfl, by        cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩)  have proof_bitCompareWithWork_matches_5 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitCompareWithWork left right).1 (OAI.EditApproximation.bitWordValue left) (OAI.EditApproximation.bitWordValue right) := by    induction left generalizing right with    | nil =>      simp only [OAI.EditApproximation.bitCompareWithWork]      induction right with      | nil => (simp [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.orderingMatches, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        simpa only [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareNilLeftWithWork bs).1 false b 0 (OAI.EditApproximation.bitWordValue bs) ih    | cons a as ih =>      cases right with      | nil =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as []).1 a false (OAI.EditApproximation.bitWordValue as) 0 (ih [])      | cons b bs =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue] using          proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as bs).1 a b (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs) (ih bs)  have proof_bitCompareWithWork_lt_16 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .lt ↔ OAI.EditApproximation.bitWordValue left < OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_bitSubtractor_value_17 (a : Bool) (b : Bool) (borrow : Bool) :      a.toNat + 2 * (OAI.EditApproximation.bitBorrow a b borrow).toNat =        b.toNat + borrow.toNat + (OAI.EditApproximation.bitDifference a b borrow).toNat := by    cases a <;> cases b <;> cases borrow <;> decide  have proof_bitSubtractionRippleEquation_18 (a : ℕ) (b : ℕ) (borrow : ℕ) (nextBorrow : ℕ) (difference : ℕ) (left : ℕ) (right : ℕ) (result : ℕ) (tail : ℕ) (htail : Eq.{1} (HAdd.hAdd.{0, 0, 0} (HAdd.hAdd.{0, 0, 0} result right) nextBorrow) (HAdd.hAdd.{0, 0, 0} left tail)) (hbit : Eq.{1} (HAdd.hAdd.{0, 0, 0} a (HMul.hMul.{0, 0, 0} 2 nextBorrow))    (HAdd.hAdd.{0, 0, 0} (HAdd.hAdd.{0, 0, 0} b borrow) difference)) :      (difference + 2 * result) + (b + 2 * right) + borrow =        (a + 2 * left) + 2 * tail := by    omega  have proof_bitSubtractWithWork_value_19 (left : List.{0} Bool) (right : List.{0} Bool) (borrow : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork left right borrow).1 + OAI.EditApproximation.bitWordValue right + borrow.toNat =        OAI.EditApproximation.bitWordValue left + 2 ^ max left.length right.length *          (OAI.EditApproximation.bitSubtractWithWork left right borrow).2.1.toNat := by    induction left generalizing right borrow with    | nil =>      induction right generalizing borrow with      | nil => (simp [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitSubtractNilLeftWithWork, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        have h := ih (OAI.EditApproximation.bitBorrow false b borrow)        have hb := proof_bitSubtractor_value_17 false b borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitSubtractNilLeftWithWork, OAI.EditApproximation.bitWordValue,          List.length_nil, List.length_cons, Nat.zero_max, pow_succ, Bool.toNat_false] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 0 b.toNat borrow.toNat (OAI.EditApproximation.bitBorrow false b borrow).toNat          (OAI.EditApproximation.bitDifference false b borrow).toNat 0 (OAI.EditApproximation.bitWordValue bs)          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractNilLeftWithWork bs (OAI.EditApproximation.bitBorrow false b borrow)).1)          (2 ^ bs.length * (OAI.EditApproximation.bitSubtractNilLeftWithWork bs (OAI.EditApproximation.bitBorrow false b borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_zero, Nat.add_zero, Nat.zero_add, Nat.mul_assoc,          Nat.mul_left_comm] using hs    | cons a as ih =>      cases right with      | nil =>        have h := ih [] (OAI.EditApproximation.bitBorrow a false borrow)        have hb := proof_bitSubtractor_value_17 a false borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitWordValue, List.length_nil, List.length_cons,          Nat.max_zero, pow_succ, Bool.toNat_false] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 a.toNat 0 borrow.toNat (OAI.EditApproximation.bitBorrow a false borrow).toNat          (OAI.EditApproximation.bitDifference a false borrow).toNat (OAI.EditApproximation.bitWordValue as) 0          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork as [] (OAI.EditApproximation.bitBorrow a false borrow)).1)          (2 ^ as.length * (OAI.EditApproximation.bitSubtractWithWork as [] (OAI.EditApproximation.bitBorrow a false borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_zero, Nat.add_zero, Nat.zero_add, Nat.mul_assoc,          Nat.mul_left_comm] using hs      | cons b bs =>        have h := ih bs (OAI.EditApproximation.bitBorrow a b borrow)        have hb := proof_bitSubtractor_value_17 a b borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitWordValue, List.length_cons, Nat.succ_max_succ,          pow_succ] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 a.toNat b.toNat borrow.toNat (OAI.EditApproximation.bitBorrow a b borrow).toNat          (OAI.EditApproximation.bitDifference a b borrow).toNat (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs)          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork as bs (OAI.EditApproximation.bitBorrow a b borrow)).1)          (2 ^ max as.length bs.length * (OAI.EditApproximation.bitSubtractWithWork as bs (OAI.EditApproximation.bitBorrow a b borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_assoc, Nat.mul_left_comm] using hs  have proof_bitWordValue_lt_pow_length_20 (bits : List.{0} Bool) : OAI.EditApproximation.bitWordValue bits < 2 ^ bits.length := by    induction bits with    | nil => (simp [OAI.EditApproximation.bitWordValue])    | cons bit bits ih =>      cases bit <;> (simp only [OAI.EditApproximation.bitWordValue, List.length_cons, pow_succ, Bool.toNat_false, Bool.toNat_true]) <;> omega  have proof_bitSubtractWithWork_length_21 (left : List.{0} Bool) (right : List.{0} Bool) (borrow : Bool) :      (OAI.EditApproximation.bitSubtractWithWork left right borrow).1.length = max left.length right.length := by    induction left generalizing right borrow with    | nil =>      simp only [OAI.EditApproximation.bitSubtractWithWork]      induction right generalizing borrow with      | nil => simp [OAI.EditApproximation.bitSubtractNilLeftWithWork]      | cons b bs ih => simp [OAI.EditApproximation.bitSubtractNilLeftWithWork, ih]    | cons a as ih =>      cases right with      | nil => simp [OAI.EditApproximation.bitSubtractWithWork, ih]      | cons b bs => simp [OAI.EditApproximation.bitSubtractWithWork, ih, Nat.succ_max_succ]  have proof_bitSubtractWithWork_sub_22 (left : List.{0} Bool) (right : List.{0} Bool) (h : LE.le.{0} (OAI.EditApproximation.bitWordValue right) (OAI.EditApproximation.bitWordValue left)) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork left right false).1 = OAI.EditApproximation.bitWordValue left - OAI.EditApproximation.bitWordValue right := by    have hvalue := proof_bitSubtractWithWork_value_19 left right false    have hlt := proof_bitWordValue_lt_pow_length_20 (OAI.EditApproximation.bitSubtractWithWork left right false).1    rw [proof_bitSubtractWithWork_length_21] at hlt    cases hb : (OAI.EditApproximation.bitSubtractWithWork left right false).2.1    · simp only [hb, Bool.toNat_false, Nat.mul_zero, Nat.add_zero] at hvalue      omega    · simp only [hb, Bool.toNat_true, Bool.toNat_false, Nat.mul_one, Nat.add_zero] at hvalue      omega  have proof_bitDivModWithWork_value_23 (divisor : List.{0} Bool) (bits : List.{0} Bool) (hd : LT.lt.{0} 0 (OAI.EditApproximation.bitWordValue divisor)) :      OAI.EditApproximation.bitWordValue bits = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).1 +        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 ∧        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 < OAI.EditApproximation.bitWordValue divisor := by    induction bits with    | nil => (simp [OAI.EditApproximation.bitDivModWithWork, OAI.EditApproximation.bitWordValue, hd])    | cons bit bits ih =>      let previous := OAI.EditApproximation.bitDivModWithWork divisor bits      let candidate := bit :: previous.2.1      have hp : OAI.EditApproximation.bitWordValue bits = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue previous.1 +          OAI.EditApproximation.bitWordValue previous.2.1 := ih.1      have hr : OAI.EditApproximation.bitWordValue previous.2.1 < OAI.EditApproximation.bitWordValue divisor := ih.2      have hc : OAI.EditApproximation.bitWordValue candidate < 2 * OAI.EditApproximation.bitWordValue divisor := by        dsimp only [candidate, OAI.EditApproximation.bitWordValue]        cases bit <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega      by_cases hlt : (OAI.EditApproximation.bitCompareWithWork candidate divisor).1 = .lt      · have hv := (proof_bitCompareWithWork_lt_16 candidate divisor).1 hlt        simp only [OAI.EditApproximation.bitDivModWithWork, show (OAI.EditApproximation.bitCompareWithWork (bit :: (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1)          divisor).1 = .lt from hlt, ↓reduceIte]        change OAI.EditApproximation.bitWordValue (bit :: bits) = OAI.EditApproximation.bitWordValue divisor *          OAI.EditApproximation.bitWordValue (false :: previous.1) + OAI.EditApproximation.bitWordValue candidate ∧ OAI.EditApproximation.bitWordValue candidate < _        constructor        · (simp only [OAI.EditApproximation.bitWordValue, Bool.toNat_false])          dsimp only [candidate, OAI.EditApproximation.bitWordValue]          nlinarith only [hp]        · exact hv      · have hv : OAI.EditApproximation.bitWordValue divisor ≤ OAI.EditApproximation.bitWordValue candidate := by          exact Nat.le_of_not_gt (fun h => hlt ((proof_bitCompareWithWork_lt_16 candidate divisor).2 h))        have hs := proof_bitSubtractWithWork_sub_22 candidate divisor hv        simp only [OAI.EditApproximation.bitDivModWithWork, show (OAI.EditApproximation.bitCompareWithWork (bit :: (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1)          divisor).1 ≠ .lt from hlt, ↓reduceIte]        change OAI.EditApproximation.bitWordValue (bit :: bits) = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue (true :: previous.1) +          OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork candidate divisor false).1 ∧          OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork candidate divisor false).1 < _        rw [hs]        constructor        · (simp only [OAI.EditApproximation.bitWordValue, Bool.toNat_true])          have he := Nat.sub_add_cancel hv          dsimp only [candidate, OAI.EditApproximation.bitWordValue] at he ⊢          nlinarith only [hp, he]        · omega  have proof_bitCompareWithWork_eq_3 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .eq ↔ OAI.EditApproximation.bitWordValue left = OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_bitAdder_value_1 (a : Bool) (b : Bool) (carry : Bool) :      (OAI.EditApproximation.bitSum a b carry).toNat + 2 * (OAI.EditApproximation.bitCarry a b carry).toNat =        a.toNat + b.toNat + carry.toNat := by    cases a <;> cases b <;> cases carry <;> decide  have proof_bitAddWithWork_value_2 (left : List.{0} Bool) (right : List.{0} Bool) (carry : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitAddWithWork left right carry).1 =        OAI.EditApproximation.bitWordValue left + OAI.EditApproximation.bitWordValue right + carry.toNat := by    induction left generalizing right carry with    | nil =>      simp only [OAI.EditApproximation.bitAddWithWork]      induction right generalizing carry with      | nil => cases carry <;> simp [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue]      | cons b bs ih =>        simp only [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 false b carry        simp only [Bool.toNat_false] at h        omega    | cons a as ih =>      cases right with      | nil =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a false carry        simp only [Bool.toNat_false] at h        omega      | cons b bs =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a b carry        omega  have proof_bitCeilDivWithWork_value_30 (divisor : List.{0} Bool) (bits : List.{0} Bool) (hd : LT.lt.{0} 0 (OAI.EditApproximation.bitWordValue divisor)) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitCeilDivWithWork divisor bits).1 =        ⌈((OAI.EditApproximation.bitWordValue bits : ℚ) / OAI.EditApproximation.bitWordValue divisor)⌉₊ := by    let q := OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).1    let r := OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1    have h := proof_bitDivModWithWork_value_23 divisor bits hd    have heq : OAI.EditApproximation.bitWordValue bits = OAI.EditApproximation.bitWordValue divisor * q + r := h.1    have hr : r < OAI.EditApproximation.bitWordValue divisor := h.2    have hdQ : (0 : ℚ) < OAI.EditApproximation.bitWordValue divisor := by exact_mod_cast hd    unfold OAI.EditApproximation.bitCeilDivWithWork    dsimp only    split_ifs with hz    · have hr0 : r = 0 := by        exact (proof_bitCompareWithWork_eq_3 (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 []).1 hz      have hratio : (OAI.EditApproximation.bitWordValue bits : ℚ) / OAI.EditApproximation.bitWordValue divisor = (q : ℚ) := by        apply (div_eq_iff hdQ.ne').mpr        exact_mod_cast (show OAI.EditApproximation.bitWordValue bits = q * OAI.EditApproximation.bitWordValue divisor by nlinarith only [heq, hr0])      rw [hratio]      exact (Nat.ceil_natCast q).symm    · have hr0 : r ≠ 0 := by        intro hzero        exact hz ((proof_bitCompareWithWork_eq_3 (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 []).2 hzero)      rw [proof_bitAddWithWork_value_2]      change q + 1 + 0 = _      simp only [Nat.add_zero]      symm      apply (Nat.ceil_eq_iff (by omega : q + 1 ≠ 0)).mpr      constructor      · simp only [Nat.add_sub_cancel]        rw [lt_div_iff₀ hdQ]        exact_mod_cast (show q * OAI.EditApproximation.bitWordValue divisor < OAI.EditApproximation.bitWordValue bits by          nlinarith only [heq, Nat.pos_of_ne_zero hr0])      · rw [div_le_iff₀ hdQ]        push_cast        exact_mod_cast (show OAI.EditApproximation.bitWordValue bits ≤ (q + 1) * OAI.EditApproximation.bitWordValue divisor by nlinarith only [heq, hr])  have proof_naturalCeilingWithWork_value_31 (a : OAI.EditApproximation.BinaryFraction) :      OAI.EditApproximation.bitWordValue (a.naturalCeilingWithWork).1 = ⌈a.value⌉₊ := by    cases hs : a.numerator.negative    · simpa only [OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork, hs, Bool.false_eq_true, ↓reduceIte,        OAI.EditApproximation.BinaryFraction.value, OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, Int.cast_natCast] using        proof_bitCeilDivWithWork_value_30 a.denominator a.numerator.bits a.denominator_pos    · have hn : a.value ≤ 0 := by        (simp only [OAI.EditApproximation.BinaryFraction.value, OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, hs, ↓reduceIte, Int.cast_neg, Int.cast_natCast])        exact div_nonpos_of_nonpos_of_nonneg (neg_nonpos.mpr (Nat.cast_nonneg _)) (Nat.cast_nonneg _)      (simp only [OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork, hs, ↓reduceIte, OAI.EditApproximation.bitWordValue])      exact (Nat.ceil_eq_zero.mpr hn).symm  have proof_lt_eq_true_57 (a : OAI.EditApproximation.UnreducedRational) (b : OAI.EditApproximation.UnreducedRational) : a.lt b = true ↔ a.value < b.value := by    simp only [OAI.EditApproximation.UnreducedRational.lt, decide_eq_true_eq, OAI.EditApproximation.UnreducedRational.value]    rw [div_lt_div_iff₀ (by exact_mod_cast a.den_pos : (0 : ℚ) < a.den)      (by exact_mod_cast b.den_pos : (0 : ℚ) < b.den)]    exact_mod_cast (Iff.rfl : a.num * (b.den : ℤ) < b.num * (a.den : ℤ) ↔ _)  have proof_nonzeroWithWork_value_58 (bits : List.{0} Bool) :      (OAI.EditApproximation.SignedBinary.nonzeroWithWork bits).1 = true ↔ OAI.EditApproximation.bitWordValue bits ≠ 0 := by    (simp [OAI.EditApproximation.SignedBinary.nonzeroWithWork, proof_bitCompareWithWork_eq_3, OAI.EditApproximation.bitWordValue])  have proof_ltWithWork_value_59 (a : OAI.EditApproximation.SignedBinary) (b : OAI.EditApproximation.SignedBinary) :      (a.ltWithWork b).1 = true ↔ a.value < b.value := by    cases ha : a.negative <;> cases hb : b.negative    · (simp [OAI.EditApproximation.SignedBinary.ltWithWork, ha, hb, OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, proof_bitCompareWithWork_lt_16])    · (simp [OAI.EditApproximation.SignedBinary.ltWithWork, ha, hb, OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude])    · (simp only [OAI.EditApproximation.SignedBinary.ltWithWork, ha, hb, ↓reduceIte, Bool.false_eq_true,        Bool.or_eq_true, proof_nonzeroWithWork_value_58, OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude])      omega    · (simp [OAI.EditApproximation.SignedBinary.ltWithWork, ha, hb, OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, proof_bitCompareWithWork_lt_16])  have proof_bitMulWithWork_value_0 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitMulWithWork left right).1 = OAI.EditApproximation.bitWordValue left * OAI.EditApproximation.bitWordValue right := by    induction left with    | nil => simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue]    | cons bit bits ih =>      cases bit <;> simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue, proof_bitAddWithWork_value_2, ih] <;> ring  have proof_mulWithWork_value_35 (a : OAI.EditApproximation.SignedBinary) (b : OAI.EditApproximation.SignedBinary) :      (a.mulWithWork b).1.value = a.value * b.value := by    simp only [OAI.EditApproximation.SignedBinary.mulWithWork, OAI.EditApproximation.SignedBinary.value, proof_bitMulWithWork_value_0]    cases a.negative <;> cases b.negative <;> simp [OAI.EditApproximation.signedMagnitude]  have proof_denominatorInteger_value_60 (a : OAI.EditApproximation.BinaryFraction) :      a.denominatorInteger.value = (OAI.EditApproximation.bitWordValue a.denominator : ℤ) := rfl  have proof_representation_value_32 (a : OAI.EditApproximation.BinaryFraction) : a.representation.value = a.value := rfl  have proof_ltWithWork_representation_61 (a : OAI.EditApproximation.BinaryFraction) (b : OAI.EditApproximation.BinaryFraction) :      (a.ltWithWork b).1 = a.representation.lt b.representation := by    apply Bool.eq_iff_iff.mpr    rw [proof_lt_eq_true_57]    simp only [OAI.EditApproximation.BinaryFraction.ltWithWork, proof_ltWithWork_value_59, proof_mulWithWork_value_35,      proof_denominatorInteger_value_60, proof_representation_value_32]    unfold OAI.EditApproximation.BinaryFraction.value    rw [div_lt_div_iff₀ (by exact_mod_cast a.denominator_pos : (0 : ℚ) < bitWordValue a.denominator)      (by exact_mod_cast b.denominator_pos : (0 : ℚ) < bitWordValue b.denominator)]    exact_mod_cast (Iff.rfl :      a.numerator.value * (OAI.EditApproximation.bitWordValue b.denominator : ℤ) <        b.numerator.value * (OAI.EditApproximation.bitWordValue a.denominator : ℤ) ↔ _)  have proof_ltWithWork_value_62 (a : OAI.EditApproximation.BinaryFraction) (b : OAI.EditApproximation.BinaryFraction) :      (a.ltWithWork b).1 = true ↔ a.value < b.value := by    rw [proof_ltWithWork_representation_61, proof_lt_eq_true_57]    rfl  have proof_maxWithWork_value_63 (a : OAI.EditApproximation.BinaryFraction) (b : OAI.EditApproximation.BinaryFraction) :      (OAI.EditApproximation.BinaryFraction.maxWithWork a b).1.value = max a.value b.value := by    by_cases h : a.value < b.value    · simp only [OAI.EditApproximation.BinaryFraction.maxWithWork, (proof_ltWithWork_value_62 a b).mpr h, ↓reduceIte, max_eq_right h.le]    · have hb : (a.ltWithWork b).1 = false := Bool.eq_false_iff.mpr (fun hh => h ((proof_ltWithWork_value_62 a b).mp hh))      simp only [OAI.EditApproximation.BinaryFraction.maxWithWork, hb, Bool.false_eq_true, ↓reduceIte, max_eq_left (le_of_not_gt h)]  have proof_eq_of_num_den_33 {a : OAI.EditApproximation.UnreducedRational} {b : OAI.EditApproximation.UnreducedRational} (hnum : Eq.{1} a.num b.num) (hden : Eq.{1} a.den b.den) : a = b := by    cases a    cases b    cases hnum    cases hden    rfl  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_value_ofInt_46 (a : ℤ) : (OAI.EditApproximation.SignedBinary.ofInt a).value = a := by    by_cases h : a < 0    · simpa only [OAI.EditApproximation.SignedBinary.ofInt, OAI.EditApproximation.SignedBinary.value, proof_bitWordValue_bits_15, OAI.EditApproximation.signedMagnitude, h, decide_true,        ↓reduceIte] using (Int.eq_neg_natAbs_of_nonpos (le_of_lt h)).symm    · simpa only [OAI.EditApproximation.SignedBinary.ofInt, OAI.EditApproximation.SignedBinary.value, proof_bitWordValue_bits_15, OAI.EditApproximation.signedMagnitude, h, decide_false,        Bool.false_eq_true, ↓reduceIte] using (Int.eq_natAbs_of_nonneg (le_of_not_gt h)).symm  have proof_nat_representation_47 (n : ℕ) : (OAI.EditApproximation.BinaryFraction.nat n).representation = OAI.EditApproximation.UnreducedRational.nat n := by    apply proof_eq_of_num_den_33    · change (OAI.EditApproximation.SignedBinary.ofInt (n : ℤ)).value = (n : ℤ)      exact proof_value_ofInt_46 _    · rfl  have proof_value_nat_48 (n : ℕ) : (OAI.EditApproximation.UnreducedRational.nat n).value = n := by (simp [OAI.EditApproximation.UnreducedRational.nat, OAI.EditApproximation.UnreducedRational.value])  have proof_nat_value_49 (n : ℕ) : (OAI.EditApproximation.BinaryFraction.nat n).value = (n : ℚ) := by    rw [← proof_representation_value_32, proof_nat_representation_47, proof_value_nat_48]  have proof_trimBitWordWithWork_value_6 (bits : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.trimBitWordWithWork bits).1 = OAI.EditApproximation.bitWordValue bits := by    induction bits with    | nil => rfl    | cons bit bits ih =>      simp only [OAI.EditApproximation.trimBitWordWithWork]      split_ifs with h      · have ht : OAI.EditApproximation.bitWordValue bits = 0 := by rw [← ih, h.1]; rfl        simp [h.2, OAI.EditApproximation.bitWordValue, ht]      · (simp only [OAI.EditApproximation.bitWordValue, ih])  have proof_canonicalizeWithWork_representation_34 (a : OAI.EditApproximation.BinaryFraction) :      (OAI.EditApproximation.BinaryFraction.canonicalizeWithWork a).1.representation = a.representation := by    apply proof_eq_of_num_den_33    · (simp only [OAI.EditApproximation.BinaryFraction.canonicalizeWithWork, OAI.EditApproximation.BinaryFraction.representation, OAI.EditApproximation.SignedBinary.value, proof_trimBitWordWithWork_value_6])    · exact proof_trimBitWordWithWork_value_6 a.denominator  have proof_mulWithWork_representation_36 (a : OAI.EditApproximation.BinaryFraction) (b : OAI.EditApproximation.BinaryFraction) :      (a.mulWithWork b).1.representation = a.representation.mul b.representation := by    apply proof_eq_of_num_den_33    · exact proof_mulWithWork_value_35 a.numerator b.numerator    · exact proof_bitMulWithWork_value_0 a.denominator b.denominator  have proof_canonicalMulWithWork_representation_37 (a : OAI.EditApproximation.BinaryFraction) (b : OAI.EditApproximation.BinaryFraction) :      (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork a b).1.representation = a.representation.mul b.representation := by    rw [OAI.EditApproximation.BinaryFraction.canonicalMulWithWork, proof_canonicalizeWithWork_representation_34, proof_mulWithWork_representation_36]  have proof_value_mul_41 (a : OAI.EditApproximation.UnreducedRational) (b : OAI.EditApproximation.UnreducedRational) : (a.mul b).value = a.value * b.value := by    simp [OAI.EditApproximation.UnreducedRational.mul, OAI.EditApproximation.UnreducedRational.value, mul_div_mul_comm]  have proof_canonicalMulWithWork_value_45 (a : OAI.EditApproximation.BinaryFraction) (b : OAI.EditApproximation.BinaryFraction) :      (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork a b).1.value = a.value * b.value := by    rw [← proof_representation_value_32, proof_canonicalMulWithWork_representation_37,      proof_value_mul_41, proof_representation_value_32, proof_representation_value_32]  have proof_roundedSpacingWithWork_value_64 (theta : OAI.EditApproximation.BinaryFraction) (envelope : OAI.EditApproximation.BinaryFraction) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.BinaryFraction.roundedSpacingWithWork theta envelope).1 = ⌈max 1 (theta.value * envelope.value)⌉₊ := by    simp only [OAI.EditApproximation.BinaryFraction.roundedSpacingWithWork, proof_naturalCeilingWithWork_value_31, proof_maxWithWork_value_63,      proof_canonicalMulWithWork_value_45, OAI.EditApproximation.BinaryFraction.one, proof_nat_value_49, Nat.cast_one]  have proof_roundedSpacingWithWork_pos_56 (theta : OAI.EditApproximation.BinaryFraction) (envelope : OAI.EditApproximation.BinaryFraction) :      0 < OAI.EditApproximation.bitWordValue (OAI.EditApproximation.BinaryFraction.roundedSpacingWithWork theta envelope).1 := by    rw [proof_roundedSpacingWithWork_value_64, Nat.ceil_pos]    exact lt_of_lt_of_le (by norm_num : (0 : ℚ) < 1) (le_max_left _ _)  exact    OAI.EditApproximation.vectorMapWithWork M fun i =>      let envelope := OAI.EditApproximation.BinaryFraction.bandEnvelopeReadWithWork b band read i      let spacing := OAI.EditApproximation.BinaryFraction.roundedSpacingWithWork (OAI.EditApproximation.BinaryFraction.inversePowerTwo exponent) envelope.1      let rounded := OAI.EditApproximation.roundStateWithWork (OAI.EditApproximation.bitWordValue spacing.1)        (proof_roundedSpacingWithWork_pos_56 _ _) (band.head hne i)      (rounded.1, envelope.2 + spacing.2 + rounded.2 + exponent + 3)def queryGroupLabelsWithWork (M Q b : ℕ) (h : OAI.EditApproximation.BinaryFraction)    (draw : Fin (OAI.EditApproximation.groupSampleCount M Q b h.value) → Fin M × ℕ) : List (Fin M) × ℕ := by  have proof_bitOrdering_matches_4 (high : Ordering) (a : Bool) (b : Bool) (x : ℕ) (y : ℕ) (h : OAI.EditApproximation.orderingMatches high x y) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitOrdering high a b) (a.toNat + 2 * x) (b.toNat + 2 * y) := by    rcases h with ⟨rfl, h⟩ | ⟨rfl, rfl⟩ | ⟨rfl, h⟩    · exact Or.inl ⟨rfl, by cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩    · cases a <;> cases b <;> simp [OAI.EditApproximation.bitOrdering, OAI.EditApproximation.orderingMatches]    · exact Or.inr (Or.inr ⟨rfl, by        cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩)  have proof_bitCompareWithWork_matches_5 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitCompareWithWork left right).1 (OAI.EditApproximation.bitWordValue left) (OAI.EditApproximation.bitWordValue right) := by    induction left generalizing right with    | nil =>      simp only [OAI.EditApproximation.bitCompareWithWork]      induction right with      | nil => (simp [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.orderingMatches, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        simpa only [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareNilLeftWithWork bs).1 false b 0 (OAI.EditApproximation.bitWordValue bs) ih    | cons a as ih =>      cases right with      | nil =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as []).1 a false (OAI.EditApproximation.bitWordValue as) 0 (ih [])      | cons b bs =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue] using          proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as bs).1 a b (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs) (ih bs)  have proof_bitCompareWithWork_lt_16 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .lt ↔ OAI.EditApproximation.bitWordValue left < OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_wordLEWithWork_value_26 (a : List.{0} Bool) (b : List.{0} Bool) :      (OAI.EditApproximation.wordLEWithWork a b).1 = true ↔ OAI.EditApproximation.bitWordValue a ≤ OAI.EditApproximation.bitWordValue b := by    simp only [OAI.EditApproximation.wordLEWithWork, Bool.not_eq_true', decide_eq_false_iff_not,      proof_bitCompareWithWork_lt_16, not_lt]  have proof_wordMinWithWork_value_29 (a : List.{0} Bool) (b : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.wordMinWithWork a b).1 = min (OAI.EditApproximation.bitWordValue a) (OAI.EditApproximation.bitWordValue b) := by    unfold OAI.EditApproximation.wordMinWithWork    dsimp only    split_ifs with h    · exact (min_eq_left ((proof_wordLEWithWork_value_26 a b).mp h)).symm    · exact (min_eq_right (le_of_not_ge (fun hle => h ((proof_wordLEWithWork_value_26 a b).mpr hle)))).symm  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_bitSubtractor_value_17 (a : Bool) (b : Bool) (borrow : Bool) :      a.toNat + 2 * (OAI.EditApproximation.bitBorrow a b borrow).toNat =        b.toNat + borrow.toNat + (OAI.EditApproximation.bitDifference a b borrow).toNat := by    cases a <;> cases b <;> cases borrow <;> decide  have proof_bitSubtractionRippleEquation_18 (a : ℕ) (b : ℕ) (borrow : ℕ) (nextBorrow : ℕ) (difference : ℕ) (left : ℕ) (right : ℕ) (result : ℕ) (tail : ℕ) (htail : Eq.{1} (HAdd.hAdd.{0, 0, 0} (HAdd.hAdd.{0, 0, 0} result right) nextBorrow) (HAdd.hAdd.{0, 0, 0} left tail)) (hbit : Eq.{1} (HAdd.hAdd.{0, 0, 0} a (HMul.hMul.{0, 0, 0} 2 nextBorrow))    (HAdd.hAdd.{0, 0, 0} (HAdd.hAdd.{0, 0, 0} b borrow) difference)) :      (difference + 2 * result) + (b + 2 * right) + borrow =        (a + 2 * left) + 2 * tail := by    omega  have proof_bitSubtractWithWork_value_19 (left : List.{0} Bool) (right : List.{0} Bool) (borrow : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork left right borrow).1 + OAI.EditApproximation.bitWordValue right + borrow.toNat =        OAI.EditApproximation.bitWordValue left + 2 ^ max left.length right.length *          (OAI.EditApproximation.bitSubtractWithWork left right borrow).2.1.toNat := by    induction left generalizing right borrow with    | nil =>      induction right generalizing borrow with      | nil => (simp [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitSubtractNilLeftWithWork, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        have h := ih (OAI.EditApproximation.bitBorrow false b borrow)        have hb := proof_bitSubtractor_value_17 false b borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitSubtractNilLeftWithWork, OAI.EditApproximation.bitWordValue,          List.length_nil, List.length_cons, Nat.zero_max, pow_succ, Bool.toNat_false] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 0 b.toNat borrow.toNat (OAI.EditApproximation.bitBorrow false b borrow).toNat          (OAI.EditApproximation.bitDifference false b borrow).toNat 0 (OAI.EditApproximation.bitWordValue bs)          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractNilLeftWithWork bs (OAI.EditApproximation.bitBorrow false b borrow)).1)          (2 ^ bs.length * (OAI.EditApproximation.bitSubtractNilLeftWithWork bs (OAI.EditApproximation.bitBorrow false b borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_zero, Nat.add_zero, Nat.zero_add, Nat.mul_assoc,          Nat.mul_left_comm] using hs    | cons a as ih =>      cases right with      | nil =>        have h := ih [] (OAI.EditApproximation.bitBorrow a false borrow)        have hb := proof_bitSubtractor_value_17 a false borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitWordValue, List.length_nil, List.length_cons,          Nat.max_zero, pow_succ, Bool.toNat_false] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 a.toNat 0 borrow.toNat (OAI.EditApproximation.bitBorrow a false borrow).toNat          (OAI.EditApproximation.bitDifference a false borrow).toNat (OAI.EditApproximation.bitWordValue as) 0          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork as [] (OAI.EditApproximation.bitBorrow a false borrow)).1)          (2 ^ as.length * (OAI.EditApproximation.bitSubtractWithWork as [] (OAI.EditApproximation.bitBorrow a false borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_zero, Nat.add_zero, Nat.zero_add, Nat.mul_assoc,          Nat.mul_left_comm] using hs      | cons b bs =>        have h := ih bs (OAI.EditApproximation.bitBorrow a b borrow)        have hb := proof_bitSubtractor_value_17 a b borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitWordValue, List.length_cons, Nat.succ_max_succ,          pow_succ] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 a.toNat b.toNat borrow.toNat (OAI.EditApproximation.bitBorrow a b borrow).toNat          (OAI.EditApproximation.bitDifference a b borrow).toNat (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs)          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork as bs (OAI.EditApproximation.bitBorrow a b borrow)).1)          (2 ^ max as.length bs.length * (OAI.EditApproximation.bitSubtractWithWork as bs (OAI.EditApproximation.bitBorrow a b borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_assoc, Nat.mul_left_comm] using hs  have proof_bitWordValue_lt_pow_length_20 (bits : List.{0} Bool) : OAI.EditApproximation.bitWordValue bits < 2 ^ bits.length := by    induction bits with    | nil => (simp [OAI.EditApproximation.bitWordValue])    | cons bit bits ih =>      cases bit <;> (simp only [OAI.EditApproximation.bitWordValue, List.length_cons, pow_succ, Bool.toNat_false, Bool.toNat_true]) <;> omega  have proof_bitSubtractWithWork_length_21 (left : List.{0} Bool) (right : List.{0} Bool) (borrow : Bool) :      (OAI.EditApproximation.bitSubtractWithWork left right borrow).1.length = max left.length right.length := by    induction left generalizing right borrow with    | nil =>      simp only [OAI.EditApproximation.bitSubtractWithWork]      induction right generalizing borrow with      | nil => simp [OAI.EditApproximation.bitSubtractNilLeftWithWork]      | cons b bs ih => simp [OAI.EditApproximation.bitSubtractNilLeftWithWork, ih]    | cons a as ih =>      cases right with      | nil => simp [OAI.EditApproximation.bitSubtractWithWork, ih]      | cons b bs => simp [OAI.EditApproximation.bitSubtractWithWork, ih, Nat.succ_max_succ]  have proof_bitSubtractWithWork_sub_22 (left : List.{0} Bool) (right : List.{0} Bool) (h : LE.le.{0} (OAI.EditApproximation.bitWordValue right) (OAI.EditApproximation.bitWordValue left)) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork left right false).1 = OAI.EditApproximation.bitWordValue left - OAI.EditApproximation.bitWordValue right := by    have hvalue := proof_bitSubtractWithWork_value_19 left right false    have hlt := proof_bitWordValue_lt_pow_length_20 (OAI.EditApproximation.bitSubtractWithWork left right false).1    rw [proof_bitSubtractWithWork_length_21] at hlt    cases hb : (OAI.EditApproximation.bitSubtractWithWork left right false).2.1    · simp only [hb, Bool.toNat_false, Nat.mul_zero, Nat.add_zero] at hvalue      omega    · simp only [hb, Bool.toNat_true, Bool.toNat_false, Nat.mul_one, Nat.add_zero] at hvalue      omega  have proof_bitDivModWithWork_value_23 (divisor : List.{0} Bool) (bits : List.{0} Bool) (hd : LT.lt.{0} 0 (OAI.EditApproximation.bitWordValue divisor)) :      OAI.EditApproximation.bitWordValue bits = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).1 +        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 ∧        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 < OAI.EditApproximation.bitWordValue divisor := by    induction bits with    | nil => (simp [OAI.EditApproximation.bitDivModWithWork, OAI.EditApproximation.bitWordValue, hd])    | cons bit bits ih =>      let previous := OAI.EditApproximation.bitDivModWithWork divisor bits      let candidate := bit :: previous.2.1      have hp : OAI.EditApproximation.bitWordValue bits = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue previous.1 +          OAI.EditApproximation.bitWordValue previous.2.1 := ih.1      have hr : OAI.EditApproximation.bitWordValue previous.2.1 < OAI.EditApproximation.bitWordValue divisor := ih.2      have hc : OAI.EditApproximation.bitWordValue candidate < 2 * OAI.EditApproximation.bitWordValue divisor := by        dsimp only [candidate, OAI.EditApproximation.bitWordValue]        cases bit <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega      by_cases hlt : (OAI.EditApproximation.bitCompareWithWork candidate divisor).1 = .lt      · have hv := (proof_bitCompareWithWork_lt_16 candidate divisor).1 hlt        simp only [OAI.EditApproximation.bitDivModWithWork, show (OAI.EditApproximation.bitCompareWithWork (bit :: (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1)          divisor).1 = .lt from hlt, ↓reduceIte]        change OAI.EditApproximation.bitWordValue (bit :: bits) = OAI.EditApproximation.bitWordValue divisor *          OAI.EditApproximation.bitWordValue (false :: previous.1) + OAI.EditApproximation.bitWordValue candidate ∧ OAI.EditApproximation.bitWordValue candidate < _        constructor        · (simp only [OAI.EditApproximation.bitWordValue, Bool.toNat_false])          dsimp only [candidate, OAI.EditApproximation.bitWordValue]          nlinarith only [hp]        · exact hv      · have hv : OAI.EditApproximation.bitWordValue divisor ≤ OAI.EditApproximation.bitWordValue candidate := by          exact Nat.le_of_not_gt (fun h => hlt ((proof_bitCompareWithWork_lt_16 candidate divisor).2 h))        have hs := proof_bitSubtractWithWork_sub_22 candidate divisor hv        simp only [OAI.EditApproximation.bitDivModWithWork, show (OAI.EditApproximation.bitCompareWithWork (bit :: (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1)          divisor).1 ≠ .lt from hlt, ↓reduceIte]        change OAI.EditApproximation.bitWordValue (bit :: bits) = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue (true :: previous.1) +          OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork candidate divisor false).1 ∧          OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork candidate divisor false).1 < _        rw [hs]        constructor        · (simp only [OAI.EditApproximation.bitWordValue, Bool.toNat_true])          have he := Nat.sub_add_cancel hv          dsimp only [candidate, OAI.EditApproximation.bitWordValue] at he ⊢          nlinarith only [hp, he]        · omega  have proof_bitCompareWithWork_eq_3 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .eq ↔ OAI.EditApproximation.bitWordValue left = OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_bitAdder_value_1 (a : Bool) (b : Bool) (carry : Bool) :      (OAI.EditApproximation.bitSum a b carry).toNat + 2 * (OAI.EditApproximation.bitCarry a b carry).toNat =        a.toNat + b.toNat + carry.toNat := by    cases a <;> cases b <;> cases carry <;> decide  have proof_bitAddWithWork_value_2 (left : List.{0} Bool) (right : List.{0} Bool) (carry : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitAddWithWork left right carry).1 =        OAI.EditApproximation.bitWordValue left + OAI.EditApproximation.bitWordValue right + carry.toNat := by    induction left generalizing right carry with    | nil =>      simp only [OAI.EditApproximation.bitAddWithWork]      induction right generalizing carry with      | nil => cases carry <;> simp [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue]      | cons b bs ih =>        simp only [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 false b carry        simp only [Bool.toNat_false] at h        omega    | cons a as ih =>      cases right with      | nil =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a false carry        simp only [Bool.toNat_false] at h        omega      | cons b bs =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a b carry        omega  have proof_bitCeilDivWithWork_value_30 (divisor : List.{0} Bool) (bits : List.{0} Bool) (hd : LT.lt.{0} 0 (OAI.EditApproximation.bitWordValue divisor)) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitCeilDivWithWork divisor bits).1 =        ⌈((OAI.EditApproximation.bitWordValue bits : ℚ) / OAI.EditApproximation.bitWordValue divisor)⌉₊ := by    let q := OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).1    let r := OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1    have h := proof_bitDivModWithWork_value_23 divisor bits hd    have heq : OAI.EditApproximation.bitWordValue bits = OAI.EditApproximation.bitWordValue divisor * q + r := h.1    have hr : r < OAI.EditApproximation.bitWordValue divisor := h.2    have hdQ : (0 : ℚ) < OAI.EditApproximation.bitWordValue divisor := by exact_mod_cast hd    unfold OAI.EditApproximation.bitCeilDivWithWork    dsimp only    split_ifs with hz    · have hr0 : r = 0 := by        exact (proof_bitCompareWithWork_eq_3 (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 []).1 hz      have hratio : (OAI.EditApproximation.bitWordValue bits : ℚ) / OAI.EditApproximation.bitWordValue divisor = (q : ℚ) := by        apply (div_eq_iff hdQ.ne').mpr        exact_mod_cast (show OAI.EditApproximation.bitWordValue bits = q * OAI.EditApproximation.bitWordValue divisor by nlinarith only [heq, hr0])      rw [hratio]      exact (Nat.ceil_natCast q).symm    · have hr0 : r ≠ 0 := by        intro hzero        exact hz ((proof_bitCompareWithWork_eq_3 (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 []).2 hzero)      rw [proof_bitAddWithWork_value_2]      change q + 1 + 0 = _      simp only [Nat.add_zero]      symm      apply (Nat.ceil_eq_iff (by omega : q + 1 ≠ 0)).mpr      constructor      · simp only [Nat.add_sub_cancel]        rw [lt_div_iff₀ hdQ]        exact_mod_cast (show q * OAI.EditApproximation.bitWordValue divisor < OAI.EditApproximation.bitWordValue bits by          nlinarith only [heq, Nat.pos_of_ne_zero hr0])      · rw [div_le_iff₀ hdQ]        push_cast        exact_mod_cast (show OAI.EditApproximation.bitWordValue bits ≤ (q + 1) * OAI.EditApproximation.bitWordValue divisor by nlinarith only [heq, hr])  have proof_naturalCeilingWithWork_value_31 (a : OAI.EditApproximation.BinaryFraction) :      OAI.EditApproximation.bitWordValue (a.naturalCeilingWithWork).1 = ⌈a.value⌉₊ := by    cases hs : a.numerator.negative    · simpa only [OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork, hs, Bool.false_eq_true, ↓reduceIte,        OAI.EditApproximation.BinaryFraction.value, OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, Int.cast_natCast] using        proof_bitCeilDivWithWork_value_30 a.denominator a.numerator.bits a.denominator_pos    · have hn : a.value ≤ 0 := by        (simp only [OAI.EditApproximation.BinaryFraction.value, OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, hs, ↓reduceIte, Int.cast_neg, Int.cast_natCast])        exact div_nonpos_of_nonpos_of_nonneg (neg_nonpos.mpr (Nat.cast_nonneg _)) (Nat.cast_nonneg _)      (simp only [OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork, hs, ↓reduceIte, OAI.EditApproximation.bitWordValue])      exact (Nat.ceil_eq_zero.mpr hn).symm  have proof_representation_value_32 (a : OAI.EditApproximation.BinaryFraction) : a.representation.value = a.value := rfl  have proof_eq_of_num_den_33 {a : OAI.EditApproximation.UnreducedRational} {b : OAI.EditApproximation.UnreducedRational} (hnum : Eq.{1} a.num b.num) (hden : Eq.{1} a.den b.den) : a = b := by    cases a    cases b    cases hnum    cases hden    rfl  have proof_trimBitWordWithWork_value_6 (bits : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.trimBitWordWithWork bits).1 = OAI.EditApproximation.bitWordValue bits := by    induction bits with    | nil => rfl    | cons bit bits ih =>      simp only [OAI.EditApproximation.trimBitWordWithWork]      split_ifs with h      · have ht : OAI.EditApproximation.bitWordValue bits = 0 := by rw [← ih, h.1]; rfl        simp [h.2, OAI.EditApproximation.bitWordValue, ht]      · (simp only [OAI.EditApproximation.bitWordValue, ih])  have proof_canonicalizeWithWork_representation_34 (a : OAI.EditApproximation.BinaryFraction) :      (OAI.EditApproximation.BinaryFraction.canonicalizeWithWork a).1.representation = a.representation := by    apply proof_eq_of_num_den_33    · (simp only [OAI.EditApproximation.BinaryFraction.canonicalizeWithWork, OAI.EditApproximation.BinaryFraction.representation, OAI.EditApproximation.SignedBinary.value, proof_trimBitWordWithWork_value_6])    · exact proof_trimBitWordWithWork_value_6 a.denominator  have proof_bitMulWithWork_value_0 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitMulWithWork left right).1 = OAI.EditApproximation.bitWordValue left * OAI.EditApproximation.bitWordValue right := by    induction left with    | nil => simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue]    | cons bit bits ih =>      cases bit <;> simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue, proof_bitAddWithWork_value_2, ih] <;> ring  have proof_mulWithWork_value_35 (a : OAI.EditApproximation.SignedBinary) (b : OAI.EditApproximation.SignedBinary) :      (a.mulWithWork b).1.value = a.value * b.value := by    simp only [OAI.EditApproximation.SignedBinary.mulWithWork, OAI.EditApproximation.SignedBinary.value, proof_bitMulWithWork_value_0]    cases a.negative <;> cases b.negative <;> simp [OAI.EditApproximation.signedMagnitude]  have proof_mulWithWork_representation_36 (a : OAI.EditApproximation.BinaryFraction) (b : OAI.EditApproximation.BinaryFraction) :      (a.mulWithWork b).1.representation = a.representation.mul b.representation := by    apply proof_eq_of_num_den_33    · exact proof_mulWithWork_value_35 a.numerator b.numerator    · exact proof_bitMulWithWork_value_0 a.denominator b.denominator  have proof_canonicalMulWithWork_representation_37 (a : OAI.EditApproximation.BinaryFraction) (b : OAI.EditApproximation.BinaryFraction) :      (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork a b).1.representation = a.representation.mul b.representation := by    rw [OAI.EditApproximation.BinaryFraction.canonicalMulWithWork, proof_canonicalizeWithWork_representation_34, proof_mulWithWork_representation_36]  have proof_zero_representation_38 : OAI.EditApproximation.BinaryFraction.zero.representation = OAI.EditApproximation.UnreducedRational.zero := by    apply proof_eq_of_num_den_33 <;> rfl  have proof_invWithWork_representation_39 (a : OAI.EditApproximation.BinaryFraction) :      (a.invWithWork).1.representation = a.representation.inv := by    unfold OAI.EditApproximation.BinaryFraction.invWithWork    dsimp only    split_ifs with h    · have hz : OAI.EditApproximation.bitWordValue a.numerator.bits = 0 := by        simpa only [OAI.EditApproximation.bitWordValue] using (proof_bitCompareWithWork_eq_3 a.numerator.bits []).1 h      have hv : a.numerator.value = 0 := by (simp [OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, hz])      (simp only [OAI.EditApproximation.UnreducedRational.inv, OAI.EditApproximation.BinaryFraction.representation, hv, ↓reduceDIte])      exact proof_zero_representation_38    · have hn : OAI.EditApproximation.bitWordValue a.numerator.bits ≠ 0 := by        intro hz        exact h ((proof_bitCompareWithWork_eq_3 a.numerator.bits []).2 (by simpa [OAI.EditApproximation.bitWordValue] using hz))      have hv : a.numerator.value ≠ 0 := by        cases hs : a.numerator.negative <;> (simp [OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, hs, hn])      (simp only [OAI.EditApproximation.UnreducedRational.inv, OAI.EditApproximation.BinaryFraction.representation, hv, ↓reduceDIte])      apply proof_eq_of_num_den_33      · cases hs : a.numerator.negative <;>          simp [OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, hs, Int.sign_natCast_of_ne_zero hn]      · cases hs : a.numerator.negative <;> (simp [OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, hs])  have proof_divWithWork_representation_40 (a : OAI.EditApproximation.BinaryFraction) (b : OAI.EditApproximation.BinaryFraction) :      (a.divWithWork b).1.representation = a.representation.div b.representation := by    (simp only [OAI.EditApproximation.BinaryFraction.divWithWork, proof_canonicalMulWithWork_representation_37, proof_invWithWork_representation_39,      OAI.EditApproximation.UnreducedRational.div])  have proof_value_mul_41 (a : OAI.EditApproximation.UnreducedRational) (b : OAI.EditApproximation.UnreducedRational) : (a.mul b).value = a.value * b.value := by    simp [OAI.EditApproximation.UnreducedRational.mul, OAI.EditApproximation.UnreducedRational.value, mul_div_mul_comm]  have proof_value_inv_42 (a : OAI.EditApproximation.UnreducedRational) : a.inv.value = a.value⁻¹ := by    by_cases h : a.num = 0    · simp [OAI.EditApproximation.UnreducedRational.inv, h, OAI.EditApproximation.UnreducedRational.value, OAI.EditApproximation.UnreducedRational.zero]    · have hn : (a.num.natAbs : ℚ) ≠ 0 := by exact_mod_cast (Int.natAbs_pos.mpr h).ne'      have hd : (a.den : ℚ) ≠ 0 := by exact_mod_cast a.den_pos.ne'      have hsign : ((a.num.sign : ℤ) : ℚ) * a.num = (a.num.natAbs : ℚ) := by        simpa only [Int.cast_mul, Int.cast_natCast] using          congrArg (fun z : ℤ => (z : ℚ)) (Int.sign_mul_self_eq_natAbs a.num)      simp only [OAI.EditApproximation.UnreducedRational.inv, h, ↓reduceDIte, OAI.EditApproximation.UnreducedRational.value]      push_cast      apply eq_inv_of_mul_eq_one_left      field_simp [hn, hd]      exact hsign  have proof_value_div_43 (a : OAI.EditApproximation.UnreducedRational) (b : OAI.EditApproximation.UnreducedRational) : (a.div b).value = a.value / b.value := by    simp [proof_value_mul_41, proof_value_inv_42, OAI.EditApproximation.UnreducedRational.div, div_eq_mul_inv]  have proof_divWithWork_value_44 (a : OAI.EditApproximation.BinaryFraction) (b : OAI.EditApproximation.BinaryFraction) :      (OAI.EditApproximation.BinaryFraction.divWithWork a b).1.value = a.value / b.value := by    rw [← proof_representation_value_32, proof_divWithWork_representation_40,      proof_value_div_43, proof_representation_value_32, proof_representation_value_32]  have proof_canonicalMulWithWork_value_45 (a : OAI.EditApproximation.BinaryFraction) (b : OAI.EditApproximation.BinaryFraction) :      (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork a b).1.value = a.value * b.value := by    rw [← proof_representation_value_32, proof_canonicalMulWithWork_representation_37,      proof_value_mul_41, proof_representation_value_32, proof_representation_value_32]  have proof_value_ofInt_46 (a : ℤ) : (OAI.EditApproximation.SignedBinary.ofInt a).value = a := by    by_cases h : a < 0    · simpa only [OAI.EditApproximation.SignedBinary.ofInt, OAI.EditApproximation.SignedBinary.value, proof_bitWordValue_bits_15, OAI.EditApproximation.signedMagnitude, h, decide_true,        ↓reduceIte] using (Int.eq_neg_natAbs_of_nonpos (le_of_lt h)).symm    · simpa only [OAI.EditApproximation.SignedBinary.ofInt, OAI.EditApproximation.SignedBinary.value, proof_bitWordValue_bits_15, OAI.EditApproximation.signedMagnitude, h, decide_false,        Bool.false_eq_true, ↓reduceIte] using (Int.eq_natAbs_of_nonneg (le_of_not_gt h)).symm  have proof_nat_representation_47 (n : ℕ) : (OAI.EditApproximation.BinaryFraction.nat n).representation = OAI.EditApproximation.UnreducedRational.nat n := by    apply proof_eq_of_num_den_33    · change (OAI.EditApproximation.SignedBinary.ofInt (n : ℤ)).value = (n : ℤ)      exact proof_value_ofInt_46 _    · rfl  have proof_value_nat_48 (n : ℕ) : (OAI.EditApproximation.UnreducedRational.nat n).value = n := by (simp [OAI.EditApproximation.UnreducedRational.nat, OAI.EditApproximation.UnreducedRational.value])  have proof_nat_value_49 (n : ℕ) : (OAI.EditApproximation.BinaryFraction.nat n).value = (n : ℚ) := by    rw [← proof_representation_value_32, proof_nat_representation_47, proof_value_nat_48]  have proof_groupSampleCountWithWork_value_28 (M : ℕ) (Q : ℕ) (b : ℕ) (h : OAI.EditApproximation.BinaryFraction) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.BinaryFraction.groupSampleCountWithWork M Q b h).1 = OAI.EditApproximation.groupSampleCount M Q b h.value := by    simp only [OAI.EditApproximation.BinaryFraction.groupSampleCountWithWork, proof_wordMinWithWork_value_29, proof_bitWordValue_bits_15,      proof_naturalCeilingWithWork_value_31, proof_divWithWork_value_44, proof_canonicalMulWithWork_value_45,      proof_nat_value_49, OAI.EditApproximation.groupSampleCount]  exact    let count := OAI.EditApproximation.BinaryFraction.groupSampleCountWithWork M Q b h    let test := OAI.EditApproximation.naturalEqualWithWork (OAI.EditApproximation.bitWordValue count.1) M    if test.1 then (List.finRange M, count.2 + test.2 + M + 2)    else      let indices := OAI.EditApproximation.queryFinRange (OAI.EditApproximation.bitWordValue count.1) (OAI.EditApproximation.groupSampleCount M Q b h.value)        (proof_groupSampleCountWithWork_value_28 M Q b h)      let labels := OAI.EditApproximation.arithmeticMapWithWork draw indices      (labels.1, count.2 + test.2 + labels.2 + indices.length + 2)def queryGroupLabelsAllocation (M Q b : ℕ) (h : OAI.EditApproximation.BinaryFraction)    (_draw : Fin (OAI.EditApproximation.groupSampleCount M Q b h.value) → Fin M × ℕ)    (allocation : Fin (OAI.EditApproximation.groupSampleCount M Q b h.value) → ℕ) : ℕ := by  have proof_bitOrdering_matches_4 (high : Ordering) (a : Bool) (b : Bool) (x : ℕ) (y : ℕ) (h : OAI.EditApproximation.orderingMatches high x y) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitOrdering high a b) (a.toNat + 2 * x) (b.toNat + 2 * y) := by    rcases h with ⟨rfl, h⟩ | ⟨rfl, rfl⟩ | ⟨rfl, h⟩    · exact Or.inl ⟨rfl, by cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩    · cases a <;> cases b <;> simp [OAI.EditApproximation.bitOrdering, OAI.EditApproximation.orderingMatches]    · exact Or.inr (Or.inr ⟨rfl, by        cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩)  have proof_bitCompareWithWork_matches_5 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitCompareWithWork left right).1 (OAI.EditApproximation.bitWordValue left) (OAI.EditApproximation.bitWordValue right) := by    induction left generalizing right with    | nil =>      simp only [OAI.EditApproximation.bitCompareWithWork]      induction right with      | nil => (simp [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.orderingMatches, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        simpa only [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareNilLeftWithWork bs).1 false b 0 (OAI.EditApproximation.bitWordValue bs) ih    | cons a as ih =>      cases right with      | nil =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as []).1 a false (OAI.EditApproximation.bitWordValue as) 0 (ih [])      | cons b bs =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue] using          proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as bs).1 a b (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs) (ih bs)  have proof_bitCompareWithWork_lt_16 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .lt ↔ OAI.EditApproximation.bitWordValue left < OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_wordLEWithWork_value_26 (a : List.{0} Bool) (b : List.{0} Bool) :      (OAI.EditApproximation.wordLEWithWork a b).1 = true ↔ OAI.EditApproximation.bitWordValue a ≤ OAI.EditApproximation.bitWordValue b := by    simp only [OAI.EditApproximation.wordLEWithWork, Bool.not_eq_true', decide_eq_false_iff_not,      proof_bitCompareWithWork_lt_16, not_lt]  have proof_wordMinWithWork_value_29 (a : List.{0} Bool) (b : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.wordMinWithWork a b).1 = min (OAI.EditApproximation.bitWordValue a) (OAI.EditApproximation.bitWordValue b) := by    unfold OAI.EditApproximation.wordMinWithWork    dsimp only    split_ifs with h    · exact (min_eq_left ((proof_wordLEWithWork_value_26 a b).mp h)).symm    · exact (min_eq_right (le_of_not_ge (fun hle => h ((proof_wordLEWithWork_value_26 a b).mpr hle)))).symm  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_bitSubtractor_value_17 (a : Bool) (b : Bool) (borrow : Bool) :      a.toNat + 2 * (OAI.EditApproximation.bitBorrow a b borrow).toNat =        b.toNat + borrow.toNat + (OAI.EditApproximation.bitDifference a b borrow).toNat := by    cases a <;> cases b <;> cases borrow <;> decide  have proof_bitSubtractionRippleEquation_18 (a : ℕ) (b : ℕ) (borrow : ℕ) (nextBorrow : ℕ) (difference : ℕ) (left : ℕ) (right : ℕ) (result : ℕ) (tail : ℕ) (htail : Eq.{1} (HAdd.hAdd.{0, 0, 0} (HAdd.hAdd.{0, 0, 0} result right) nextBorrow) (HAdd.hAdd.{0, 0, 0} left tail)) (hbit : Eq.{1} (HAdd.hAdd.{0, 0, 0} a (HMul.hMul.{0, 0, 0} 2 nextBorrow))    (HAdd.hAdd.{0, 0, 0} (HAdd.hAdd.{0, 0, 0} b borrow) difference)) :      (difference + 2 * result) + (b + 2 * right) + borrow =        (a + 2 * left) + 2 * tail := by    omega  have proof_bitSubtractWithWork_value_19 (left : List.{0} Bool) (right : List.{0} Bool) (borrow : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork left right borrow).1 + OAI.EditApproximation.bitWordValue right + borrow.toNat =        OAI.EditApproximation.bitWordValue left + 2 ^ max left.length right.length *          (OAI.EditApproximation.bitSubtractWithWork left right borrow).2.1.toNat := by    induction left generalizing right borrow with    | nil =>      induction right generalizing borrow with      | nil => (simp [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitSubtractNilLeftWithWork, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        have h := ih (OAI.EditApproximation.bitBorrow false b borrow)        have hb := proof_bitSubtractor_value_17 false b borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitSubtractNilLeftWithWork, OAI.EditApproximation.bitWordValue,          List.length_nil, List.length_cons, Nat.zero_max, pow_succ, Bool.toNat_false] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 0 b.toNat borrow.toNat (OAI.EditApproximation.bitBorrow false b borrow).toNat          (OAI.EditApproximation.bitDifference false b borrow).toNat 0 (OAI.EditApproximation.bitWordValue bs)          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractNilLeftWithWork bs (OAI.EditApproximation.bitBorrow false b borrow)).1)          (2 ^ bs.length * (OAI.EditApproximation.bitSubtractNilLeftWithWork bs (OAI.EditApproximation.bitBorrow false b borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_zero, Nat.add_zero, Nat.zero_add, Nat.mul_assoc,          Nat.mul_left_comm] using hs    | cons a as ih =>      cases right with      | nil =>        have h := ih [] (OAI.EditApproximation.bitBorrow a false borrow)        have hb := proof_bitSubtractor_value_17 a false borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitWordValue, List.length_nil, List.length_cons,          Nat.max_zero, pow_succ, Bool.toNat_false] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 a.toNat 0 borrow.toNat (OAI.EditApproximation.bitBorrow a false borrow).toNat          (OAI.EditApproximation.bitDifference a false borrow).toNat (OAI.EditApproximation.bitWordValue as) 0          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork as [] (OAI.EditApproximation.bitBorrow a false borrow)).1)          (2 ^ as.length * (OAI.EditApproximation.bitSubtractWithWork as [] (OAI.EditApproximation.bitBorrow a false borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_zero, Nat.add_zero, Nat.zero_add, Nat.mul_assoc,          Nat.mul_left_comm] using hs      | cons b bs =>        have h := ih bs (OAI.EditApproximation.bitBorrow a b borrow)        have hb := proof_bitSubtractor_value_17 a b borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitWordValue, List.length_cons, Nat.succ_max_succ,          pow_succ] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 a.toNat b.toNat borrow.toNat (OAI.EditApproximation.bitBorrow a b borrow).toNat          (OAI.EditApproximation.bitDifference a b borrow).toNat (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs)          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork as bs (OAI.EditApproximation.bitBorrow a b borrow)).1)          (2 ^ max as.length bs.length * (OAI.EditApproximation.bitSubtractWithWork as bs (OAI.EditApproximation.bitBorrow a b borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_assoc, Nat.mul_left_comm] using hs  have proof_bitWordValue_lt_pow_length_20 (bits : List.{0} Bool) : OAI.EditApproximation.bitWordValue bits < 2 ^ bits.length := by    induction bits with    | nil => (simp [OAI.EditApproximation.bitWordValue])    | cons bit bits ih =>      cases bit <;> (simp only [OAI.EditApproximation.bitWordValue, List.length_cons, pow_succ, Bool.toNat_false, Bool.toNat_true]) <;> omega  have proof_bitSubtractWithWork_length_21 (left : List.{0} Bool) (right : List.{0} Bool) (borrow : Bool) :      (OAI.EditApproximation.bitSubtractWithWork left right borrow).1.length = max left.length right.length := by    induction left generalizing right borrow with    | nil =>      simp only [OAI.EditApproximation.bitSubtractWithWork]      induction right generalizing borrow with      | nil => simp [OAI.EditApproximation.bitSubtractNilLeftWithWork]      | cons b bs ih => simp [OAI.EditApproximation.bitSubtractNilLeftWithWork, ih]    | cons a as ih =>      cases right with      | nil => simp [OAI.EditApproximation.bitSubtractWithWork, ih]      | cons b bs => simp [OAI.EditApproximation.bitSubtractWithWork, ih, Nat.succ_max_succ]  have proof_bitSubtractWithWork_sub_22 (left : List.{0} Bool) (right : List.{0} Bool) (h : LE.le.{0} (OAI.EditApproximation.bitWordValue right) (OAI.EditApproximation.bitWordValue left)) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork left right false).1 = OAI.EditApproximation.bitWordValue left - OAI.EditApproximation.bitWordValue right := by    have hvalue := proof_bitSubtractWithWork_value_19 left right false    have hlt := proof_bitWordValue_lt_pow_length_20 (OAI.EditApproximation.bitSubtractWithWork left right false).1    rw [proof_bitSubtractWithWork_length_21] at hlt    cases hb : (OAI.EditApproximation.bitSubtractWithWork left right false).2.1    · simp only [hb, Bool.toNat_false, Nat.mul_zero, Nat.add_zero] at hvalue      omega    · simp only [hb, Bool.toNat_true, Bool.toNat_false, Nat.mul_one, Nat.add_zero] at hvalue      omega  have proof_bitDivModWithWork_value_23 (divisor : List.{0} Bool) (bits : List.{0} Bool) (hd : LT.lt.{0} 0 (OAI.EditApproximation.bitWordValue divisor)) :      OAI.EditApproximation.bitWordValue bits = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).1 +        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 ∧        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 < OAI.EditApproximation.bitWordValue divisor := by    induction bits with    | nil => (simp [OAI.EditApproximation.bitDivModWithWork, OAI.EditApproximation.bitWordValue, hd])    | cons bit bits ih =>      let previous := OAI.EditApproximation.bitDivModWithWork divisor bits      let candidate := bit :: previous.2.1      have hp : OAI.EditApproximation.bitWordValue bits = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue previous.1 +          OAI.EditApproximation.bitWordValue previous.2.1 := ih.1      have hr : OAI.EditApproximation.bitWordValue previous.2.1 < OAI.EditApproximation.bitWordValue divisor := ih.2      have hc : OAI.EditApproximation.bitWordValue candidate < 2 * OAI.EditApproximation.bitWordValue divisor := by        dsimp only [candidate, OAI.EditApproximation.bitWordValue]        cases bit <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega      by_cases hlt : (OAI.EditApproximation.bitCompareWithWork candidate divisor).1 = .lt      · have hv := (proof_bitCompareWithWork_lt_16 candidate divisor).1 hlt        simp only [OAI.EditApproximation.bitDivModWithWork, show (OAI.EditApproximation.bitCompareWithWork (bit :: (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1)          divisor).1 = .lt from hlt, ↓reduceIte]        change OAI.EditApproximation.bitWordValue (bit :: bits) = OAI.EditApproximation.bitWordValue divisor *          OAI.EditApproximation.bitWordValue (false :: previous.1) + OAI.EditApproximation.bitWordValue candidate ∧ OAI.EditApproximation.bitWordValue candidate < _        constructor        · (simp only [OAI.EditApproximation.bitWordValue, Bool.toNat_false])          dsimp only [candidate, OAI.EditApproximation.bitWordValue]          nlinarith only [hp]        · exact hv      · have hv : OAI.EditApproximation.bitWordValue divisor ≤ OAI.EditApproximation.bitWordValue candidate := by          exact Nat.le_of_not_gt (fun h => hlt ((proof_bitCompareWithWork_lt_16 candidate divisor).2 h))        have hs := proof_bitSubtractWithWork_sub_22 candidate divisor hv        simp only [OAI.EditApproximation.bitDivModWithWork, show (OAI.EditApproximation.bitCompareWithWork (bit :: (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1)          divisor).1 ≠ .lt from hlt, ↓reduceIte]        change OAI.EditApproximation.bitWordValue (bit :: bits) = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue (true :: previous.1) +          OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork candidate divisor false).1 ∧          OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork candidate divisor false).1 < _        rw [hs]        constructor        · (simp only [OAI.EditApproximation.bitWordValue, Bool.toNat_true])          have he := Nat.sub_add_cancel hv          dsimp only [candidate, OAI.EditApproximation.bitWordValue] at he ⊢          nlinarith only [hp, he]        · omega  have proof_bitCompareWithWork_eq_3 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .eq ↔ OAI.EditApproximation.bitWordValue left = OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_bitAdder_value_1 (a : Bool) (b : Bool) (carry : Bool) :      (OAI.EditApproximation.bitSum a b carry).toNat + 2 * (OAI.EditApproximation.bitCarry a b carry).toNat =        a.toNat + b.toNat + carry.toNat := by    cases a <;> cases b <;> cases carry <;> decide  have proof_bitAddWithWork_value_2 (left : List.{0} Bool) (right : List.{0} Bool) (carry : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitAddWithWork left right carry).1 =        OAI.EditApproximation.bitWordValue left + OAI.EditApproximation.bitWordValue right + carry.toNat := by    induction left generalizing right carry with    | nil =>      simp only [OAI.EditApproximation.bitAddWithWork]      induction right generalizing carry with      | nil => cases carry <;> simp [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue]      | cons b bs ih =>        simp only [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 false b carry        simp only [Bool.toNat_false] at h        omega    | cons a as ih =>      cases right with      | nil =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a false carry        simp only [Bool.toNat_false] at h        omega      | cons b bs =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a b carry        omega  have proof_bitCeilDivWithWork_value_30 (divisor : List.{0} Bool) (bits : List.{0} Bool) (hd : LT.lt.{0} 0 (OAI.EditApproximation.bitWordValue divisor)) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitCeilDivWithWork divisor bits).1 =        ⌈((OAI.EditApproximation.bitWordValue bits : ℚ) / OAI.EditApproximation.bitWordValue divisor)⌉₊ := by    let q := OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).1    let r := OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1    have h := proof_bitDivModWithWork_value_23 divisor bits hd    have heq : OAI.EditApproximation.bitWordValue bits = OAI.EditApproximation.bitWordValue divisor * q + r := h.1    have hr : r < OAI.EditApproximation.bitWordValue divisor := h.2    have hdQ : (0 : ℚ) < OAI.EditApproximation.bitWordValue divisor := by exact_mod_cast hd    unfold OAI.EditApproximation.bitCeilDivWithWork    dsimp only    split_ifs with hz    · have hr0 : r = 0 := by        exact (proof_bitCompareWithWork_eq_3 (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 []).1 hz      have hratio : (OAI.EditApproximation.bitWordValue bits : ℚ) / OAI.EditApproximation.bitWordValue divisor = (q : ℚ) := by        apply (div_eq_iff hdQ.ne').mpr        exact_mod_cast (show OAI.EditApproximation.bitWordValue bits = q * OAI.EditApproximation.bitWordValue divisor by nlinarith only [heq, hr0])      rw [hratio]      exact (Nat.ceil_natCast q).symm    · have hr0 : r ≠ 0 := by        intro hzero        exact hz ((proof_bitCompareWithWork_eq_3 (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 []).2 hzero)      rw [proof_bitAddWithWork_value_2]      change q + 1 + 0 = _      simp only [Nat.add_zero]      symm      apply (Nat.ceil_eq_iff (by omega : q + 1 ≠ 0)).mpr      constructor      · simp only [Nat.add_sub_cancel]        rw [lt_div_iff₀ hdQ]        exact_mod_cast (show q * OAI.EditApproximation.bitWordValue divisor < OAI.EditApproximation.bitWordValue bits by          nlinarith only [heq, Nat.pos_of_ne_zero hr0])      · rw [div_le_iff₀ hdQ]        push_cast        exact_mod_cast (show OAI.EditApproximation.bitWordValue bits ≤ (q + 1) * OAI.EditApproximation.bitWordValue divisor by nlinarith only [heq, hr])  have proof_naturalCeilingWithWork_value_31 (a : OAI.EditApproximation.BinaryFraction) :      OAI.EditApproximation.bitWordValue (a.naturalCeilingWithWork).1 = ⌈a.value⌉₊ := by    cases hs : a.numerator.negative    · simpa only [OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork, hs, Bool.false_eq_true, ↓reduceIte,        OAI.EditApproximation.BinaryFraction.value, OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, Int.cast_natCast] using        proof_bitCeilDivWithWork_value_30 a.denominator a.numerator.bits a.denominator_pos    · have hn : a.value ≤ 0 := by        (simp only [OAI.EditApproximation.BinaryFraction.value, OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, hs, ↓reduceIte, Int.cast_neg, Int.cast_natCast])        exact div_nonpos_of_nonpos_of_nonneg (neg_nonpos.mpr (Nat.cast_nonneg _)) (Nat.cast_nonneg _)      (simp only [OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork, hs, ↓reduceIte, OAI.EditApproximation.bitWordValue])      exact (Nat.ceil_eq_zero.mpr hn).symm  have proof_representation_value_32 (a : OAI.EditApproximation.BinaryFraction) : a.representation.value = a.value := rfl  have proof_eq_of_num_den_33 {a : OAI.EditApproximation.UnreducedRational} {b : OAI.EditApproximation.UnreducedRational} (hnum : Eq.{1} a.num b.num) (hden : Eq.{1} a.den b.den) : a = b := by    cases a    cases b    cases hnum    cases hden    rfl  have proof_trimBitWordWithWork_value_6 (bits : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.trimBitWordWithWork bits).1 = OAI.EditApproximation.bitWordValue bits := by    induction bits with    | nil => rfl    | cons bit bits ih =>      simp only [OAI.EditApproximation.trimBitWordWithWork]      split_ifs with h      · have ht : OAI.EditApproximation.bitWordValue bits = 0 := by rw [← ih, h.1]; rfl        simp [h.2, OAI.EditApproximation.bitWordValue, ht]      · (simp only [OAI.EditApproximation.bitWordValue, ih])  have proof_canonicalizeWithWork_representation_34 (a : OAI.EditApproximation.BinaryFraction) :      (OAI.EditApproximation.BinaryFraction.canonicalizeWithWork a).1.representation = a.representation := by    apply proof_eq_of_num_den_33    · (simp only [OAI.EditApproximation.BinaryFraction.canonicalizeWithWork, OAI.EditApproximation.BinaryFraction.representation, OAI.EditApproximation.SignedBinary.value, proof_trimBitWordWithWork_value_6])    · exact proof_trimBitWordWithWork_value_6 a.denominator  have proof_bitMulWithWork_value_0 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitMulWithWork left right).1 = OAI.EditApproximation.bitWordValue left * OAI.EditApproximation.bitWordValue right := by    induction left with    | nil => simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue]    | cons bit bits ih =>      cases bit <;> simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue, proof_bitAddWithWork_value_2, ih] <;> ring  have proof_mulWithWork_value_35 (a : OAI.EditApproximation.SignedBinary) (b : OAI.EditApproximation.SignedBinary) :      (a.mulWithWork b).1.value = a.value * b.value := by    simp only [OAI.EditApproximation.SignedBinary.mulWithWork, OAI.EditApproximation.SignedBinary.value, proof_bitMulWithWork_value_0]    cases a.negative <;> cases b.negative <;> simp [OAI.EditApproximation.signedMagnitude]  have proof_mulWithWork_representation_36 (a : OAI.EditApproximation.BinaryFraction) (b : OAI.EditApproximation.BinaryFraction) :      (a.mulWithWork b).1.representation = a.representation.mul b.representation := by    apply proof_eq_of_num_den_33    · exact proof_mulWithWork_value_35 a.numerator b.numerator    · exact proof_bitMulWithWork_value_0 a.denominator b.denominator  have proof_canonicalMulWithWork_representation_37 (a : OAI.EditApproximation.BinaryFraction) (b : OAI.EditApproximation.BinaryFraction) :      (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork a b).1.representation = a.representation.mul b.representation := by    rw [OAI.EditApproximation.BinaryFraction.canonicalMulWithWork, proof_canonicalizeWithWork_representation_34, proof_mulWithWork_representation_36]  have proof_zero_representation_38 : OAI.EditApproximation.BinaryFraction.zero.representation = OAI.EditApproximation.UnreducedRational.zero := by    apply proof_eq_of_num_den_33 <;> rfl  have proof_invWithWork_representation_39 (a : OAI.EditApproximation.BinaryFraction) :      (a.invWithWork).1.representation = a.representation.inv := by    unfold OAI.EditApproximation.BinaryFraction.invWithWork    dsimp only    split_ifs with h    · have hz : OAI.EditApproximation.bitWordValue a.numerator.bits = 0 := by        simpa only [OAI.EditApproximation.bitWordValue] using (proof_bitCompareWithWork_eq_3 a.numerator.bits []).1 h      have hv : a.numerator.value = 0 := by (simp [OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, hz])      (simp only [OAI.EditApproximation.UnreducedRational.inv, OAI.EditApproximation.BinaryFraction.representation, hv, ↓reduceDIte])      exact proof_zero_representation_38    · have hn : OAI.EditApproximation.bitWordValue a.numerator.bits ≠ 0 := by        intro hz        exact h ((proof_bitCompareWithWork_eq_3 a.numerator.bits []).2 (by simpa [OAI.EditApproximation.bitWordValue] using hz))      have hv : a.numerator.value ≠ 0 := by        cases hs : a.numerator.negative <;> (simp [OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, hs, hn])      (simp only [OAI.EditApproximation.UnreducedRational.inv, OAI.EditApproximation.BinaryFraction.representation, hv, ↓reduceDIte])      apply proof_eq_of_num_den_33      · cases hs : a.numerator.negative <;>          simp [OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, hs, Int.sign_natCast_of_ne_zero hn]      · cases hs : a.numerator.negative <;> (simp [OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, hs])  have proof_divWithWork_representation_40 (a : OAI.EditApproximation.BinaryFraction) (b : OAI.EditApproximation.BinaryFraction) :      (a.divWithWork b).1.representation = a.representation.div b.representation := by    (simp only [OAI.EditApproximation.BinaryFraction.divWithWork, proof_canonicalMulWithWork_representation_37, proof_invWithWork_representation_39,      OAI.EditApproximation.UnreducedRational.div])  have proof_value_mul_41 (a : OAI.EditApproximation.UnreducedRational) (b : OAI.EditApproximation.UnreducedRational) : (a.mul b).value = a.value * b.value := by    simp [OAI.EditApproximation.UnreducedRational.mul, OAI.EditApproximation.UnreducedRational.value, mul_div_mul_comm]  have proof_value_inv_42 (a : OAI.EditApproximation.UnreducedRational) : a.inv.value = a.value⁻¹ := by    by_cases h : a.num = 0    · simp [OAI.EditApproximation.UnreducedRational.inv, h, OAI.EditApproximation.UnreducedRational.value, OAI.EditApproximation.UnreducedRational.zero]    · have hn : (a.num.natAbs : ℚ) ≠ 0 := by exact_mod_cast (Int.natAbs_pos.mpr h).ne'      have hd : (a.den : ℚ) ≠ 0 := by exact_mod_cast a.den_pos.ne'      have hsign : ((a.num.sign : ℤ) : ℚ) * a.num = (a.num.natAbs : ℚ) := by        simpa only [Int.cast_mul, Int.cast_natCast] using          congrArg (fun z : ℤ => (z : ℚ)) (Int.sign_mul_self_eq_natAbs a.num)      simp only [OAI.EditApproximation.UnreducedRational.inv, h, ↓reduceDIte, OAI.EditApproximation.UnreducedRational.value]      push_cast      apply eq_inv_of_mul_eq_one_left      field_simp [hn, hd]      exact hsign  have proof_value_div_43 (a : OAI.EditApproximation.UnreducedRational) (b : OAI.EditApproximation.UnreducedRational) : (a.div b).value = a.value / b.value := by    simp [proof_value_mul_41, proof_value_inv_42, OAI.EditApproximation.UnreducedRational.div, div_eq_mul_inv]  have proof_divWithWork_value_44 (a : OAI.EditApproximation.BinaryFraction) (b : OAI.EditApproximation.BinaryFraction) :      (OAI.EditApproximation.BinaryFraction.divWithWork a b).1.value = a.value / b.value := by    rw [← proof_representation_value_32, proof_divWithWork_representation_40,      proof_value_div_43, proof_representation_value_32, proof_representation_value_32]  have proof_canonicalMulWithWork_value_45 (a : OAI.EditApproximation.BinaryFraction) (b : OAI.EditApproximation.BinaryFraction) :      (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork a b).1.value = a.value * b.value := by    rw [← proof_representation_value_32, proof_canonicalMulWithWork_representation_37,      proof_value_mul_41, proof_representation_value_32, proof_representation_value_32]  have proof_value_ofInt_46 (a : ℤ) : (OAI.EditApproximation.SignedBinary.ofInt a).value = a := by    by_cases h : a < 0    · simpa only [OAI.EditApproximation.SignedBinary.ofInt, OAI.EditApproximation.SignedBinary.value, proof_bitWordValue_bits_15, OAI.EditApproximation.signedMagnitude, h, decide_true,        ↓reduceIte] using (Int.eq_neg_natAbs_of_nonpos (le_of_lt h)).symm    · simpa only [OAI.EditApproximation.SignedBinary.ofInt, OAI.EditApproximation.SignedBinary.value, proof_bitWordValue_bits_15, OAI.EditApproximation.signedMagnitude, h, decide_false,        Bool.false_eq_true, ↓reduceIte] using (Int.eq_natAbs_of_nonneg (le_of_not_gt h)).symm  have proof_nat_representation_47 (n : ℕ) : (OAI.EditApproximation.BinaryFraction.nat n).representation = OAI.EditApproximation.UnreducedRational.nat n := by    apply proof_eq_of_num_den_33    · change (OAI.EditApproximation.SignedBinary.ofInt (n : ℤ)).value = (n : ℤ)      exact proof_value_ofInt_46 _    · rfl  have proof_value_nat_48 (n : ℕ) : (OAI.EditApproximation.UnreducedRational.nat n).value = n := by (simp [OAI.EditApproximation.UnreducedRational.nat, OAI.EditApproximation.UnreducedRational.value])  have proof_nat_value_49 (n : ℕ) : (OAI.EditApproximation.BinaryFraction.nat n).value = (n : ℚ) := by    rw [← proof_representation_value_32, proof_nat_representation_47, proof_value_nat_48]  have proof_groupSampleCountWithWork_value_28 (M : ℕ) (Q : ℕ) (b : ℕ) (h : OAI.EditApproximation.BinaryFraction) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.BinaryFraction.groupSampleCountWithWork M Q b h).1 = OAI.EditApproximation.groupSampleCount M Q b h.value := by    simp only [OAI.EditApproximation.BinaryFraction.groupSampleCountWithWork, proof_wordMinWithWork_value_29, proof_bitWordValue_bits_15,      proof_naturalCeilingWithWork_value_31, proof_divWithWork_value_44, proof_canonicalMulWithWork_value_45,      proof_nat_value_49, OAI.EditApproximation.groupSampleCount]  exact    let count := (OAI.EditApproximation.BinaryFraction.groupSampleCountWithWork M Q b h).1    let test := (OAI.EditApproximation.naturalEqualWithWork (OAI.EditApproximation.bitWordValue count) M).1    OAI.EditApproximation.BinaryFraction.groupSampleCountAllocation M Q b h + OAI.EditApproximation.naturalEqualAllocation (OAI.EditApproximation.bitWordValue count) M +      if test then M else        let indices := OAI.EditApproximation.queryFinRange (OAI.EditApproximation.bitWordValue count) (OAI.EditApproximation.groupSampleCount M Q b h.value)          (proof_groupSampleCountWithWork_value_28 M Q b h)        OAI.EditApproximation.arithmeticMapAllocation allocation indices + 2 * indices.lengthdef countedGroupMemberSourceAllocation {M T : ℕ} (Q b : ℕ) (scales : Fin T → OAI.EditApproximation.BinaryFraction)    (connection : OAI.EditApproximation.BinaryFraction) (envelope values : Vector OAI.EditApproximation.BinaryFraction M)    (draw : ∀ t, Fin (OAI.EditApproximation.groupSampleCount M Q b (scales t).value) → Fin M × ℕ)    (allocation : ∀ t, Fin (OAI.EditApproximation.groupSampleCount M Q b (scales t).value) → ℕ) : ℕ := by  have proof_vectorMapWithWork_value_27 {α : Type 0} (d : ℕ) (f : Fin d → Prod.{0, 0} α ℕ) (i : Fin d) :      (OAI.EditApproximation.vectorMapWithWork d f).1.get i = (f i).1 := by    change (Vector.ofFn f |>.map Prod.fst)[i.val] = _    simp only [Vector.getElem_map, Vector.getElem_ofFn]  have proof_bitOrdering_matches_4 (high : Ordering) (a : Bool) (b : Bool) (x : ℕ) (y : ℕ) (h : OAI.EditApproximation.orderingMatches high x y) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitOrdering high a b) (a.toNat + 2 * x) (b.toNat + 2 * y) := by    rcases h with ⟨rfl, h⟩ | ⟨rfl, rfl⟩ | ⟨rfl, h⟩    · exact Or.inl ⟨rfl, by cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩    · cases a <;> cases b <;> simp [OAI.EditApproximation.bitOrdering, OAI.EditApproximation.orderingMatches]    · exact Or.inr (Or.inr ⟨rfl, by        cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩)  have proof_bitCompareWithWork_matches_5 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitCompareWithWork left right).1 (OAI.EditApproximation.bitWordValue left) (OAI.EditApproximation.bitWordValue right) := by    induction left generalizing right with    | nil =>      simp only [OAI.EditApproximation.bitCompareWithWork]      induction right with      | nil => (simp [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.orderingMatches, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        simpa only [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareNilLeftWithWork bs).1 false b 0 (OAI.EditApproximation.bitWordValue bs) ih    | cons a as ih =>      cases right with      | nil =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as []).1 a false (OAI.EditApproximation.bitWordValue as) 0 (ih [])      | cons b bs =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue] using          proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as bs).1 a b (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs) (ih bs)  have proof_bitCompareWithWork_lt_16 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .lt ↔ OAI.EditApproximation.bitWordValue left < OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_wordLEWithWork_value_26 (a : List.{0} Bool) (b : List.{0} Bool) :      (OAI.EditApproximation.wordLEWithWork a b).1 = true ↔ OAI.EditApproximation.bitWordValue a ≤ OAI.EditApproximation.bitWordValue b := by    simp only [OAI.EditApproximation.wordLEWithWork, Bool.not_eq_true', decide_eq_false_iff_not,      proof_bitCompareWithWork_lt_16, not_lt]  have proof_wordMinWithWork_value_29 (a : List.{0} Bool) (b : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.wordMinWithWork a b).1 = min (OAI.EditApproximation.bitWordValue a) (OAI.EditApproximation.bitWordValue b) := by    unfold OAI.EditApproximation.wordMinWithWork    dsimp only    split_ifs with h    · exact (min_eq_left ((proof_wordLEWithWork_value_26 a b).mp h)).symm    · exact (min_eq_right (le_of_not_ge (fun hle => h ((proof_wordLEWithWork_value_26 a b).mpr hle)))).symm  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_bitSubtractor_value_17 (a : Bool) (b : Bool) (borrow : Bool) :      a.toNat + 2 * (OAI.EditApproximation.bitBorrow a b borrow).toNat =        b.toNat + borrow.toNat + (OAI.EditApproximation.bitDifference a b borrow).toNat := by    cases a <;> cases b <;> cases borrow <;> decide  have proof_bitSubtractionRippleEquation_18 (a : ℕ) (b : ℕ) (borrow : ℕ) (nextBorrow : ℕ) (difference : ℕ) (left : ℕ) (right : ℕ) (result : ℕ) (tail : ℕ) (htail : Eq.{1} (HAdd.hAdd.{0, 0, 0} (HAdd.hAdd.{0, 0, 0} result right) nextBorrow) (HAdd.hAdd.{0, 0, 0} left tail)) (hbit : Eq.{1} (HAdd.hAdd.{0, 0, 0} a (HMul.hMul.{0, 0, 0} 2 nextBorrow))    (HAdd.hAdd.{0, 0, 0} (HAdd.hAdd.{0, 0, 0} b borrow) difference)) :      (difference + 2 * result) + (b + 2 * right) + borrow =        (a + 2 * left) + 2 * tail := by    omega  have proof_bitSubtractWithWork_value_19 (left : List.{0} Bool) (right : List.{0} Bool) (borrow : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork left right borrow).1 + OAI.EditApproximation.bitWordValue right + borrow.toNat =        OAI.EditApproximation.bitWordValue left + 2 ^ max left.length right.length *          (OAI.EditApproximation.bitSubtractWithWork left right borrow).2.1.toNat := by    induction left generalizing right borrow with    | nil =>      induction right generalizing borrow with      | nil => (simp [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitSubtractNilLeftWithWork, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        have h := ih (OAI.EditApproximation.bitBorrow false b borrow)        have hb := proof_bitSubtractor_value_17 false b borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitSubtractNilLeftWithWork, OAI.EditApproximation.bitWordValue,          List.length_nil, List.length_cons, Nat.zero_max, pow_succ, Bool.toNat_false] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 0 b.toNat borrow.toNat (OAI.EditApproximation.bitBorrow false b borrow).toNat          (OAI.EditApproximation.bitDifference false b borrow).toNat 0 (OAI.EditApproximation.bitWordValue bs)          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractNilLeftWithWork bs (OAI.EditApproximation.bitBorrow false b borrow)).1)          (2 ^ bs.length * (OAI.EditApproximation.bitSubtractNilLeftWithWork bs (OAI.EditApproximation.bitBorrow false b borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_zero, Nat.add_zero, Nat.zero_add, Nat.mul_assoc,          Nat.mul_left_comm] using hs    | cons a as ih =>      cases right with      | nil =>        have h := ih [] (OAI.EditApproximation.bitBorrow a false borrow)        have hb := proof_bitSubtractor_value_17 a false borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitWordValue, List.length_nil, List.length_cons,          Nat.max_zero, pow_succ, Bool.toNat_false] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 a.toNat 0 borrow.toNat (OAI.EditApproximation.bitBorrow a false borrow).toNat          (OAI.EditApproximation.bitDifference a false borrow).toNat (OAI.EditApproximation.bitWordValue as) 0          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork as [] (OAI.EditApproximation.bitBorrow a false borrow)).1)          (2 ^ as.length * (OAI.EditApproximation.bitSubtractWithWork as [] (OAI.EditApproximation.bitBorrow a false borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_zero, Nat.add_zero, Nat.zero_add, Nat.mul_assoc,          Nat.mul_left_comm] using hs      | cons b bs =>        have h := ih bs (OAI.EditApproximation.bitBorrow a b borrow)        have hb := proof_bitSubtractor_value_17 a b borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitWordValue, List.length_cons, Nat.succ_max_succ,          pow_succ] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 a.toNat b.toNat borrow.toNat (OAI.EditApproximation.bitBorrow a b borrow).toNat          (OAI.EditApproximation.bitDifference a b borrow).toNat (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs)          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork as bs (OAI.EditApproximation.bitBorrow a b borrow)).1)          (2 ^ max as.length bs.length * (OAI.EditApproximation.bitSubtractWithWork as bs (OAI.EditApproximation.bitBorrow a b borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_assoc, Nat.mul_left_comm] using hs  have proof_bitWordValue_lt_pow_length_20 (bits : List.{0} Bool) : OAI.EditApproximation.bitWordValue bits < 2 ^ bits.length := by    induction bits with    | nil => (simp [OAI.EditApproximation.bitWordValue])    | cons bit bits ih =>      cases bit <;> (simp only [OAI.EditApproximation.bitWordValue, List.length_cons, pow_succ, Bool.toNat_false, Bool.toNat_true]) <;> omega  have proof_bitSubtractWithWork_length_21 (left : List.{0} Bool) (right : List.{0} Bool) (borrow : Bool) :      (OAI.EditApproximation.bitSubtractWithWork left right borrow).1.length = max left.length right.length := by    induction left generalizing right borrow with    | nil =>      simp only [OAI.EditApproximation.bitSubtractWithWork]      induction right generalizing borrow with      | nil => simp [OAI.EditApproximation.bitSubtractNilLeftWithWork]      | cons b bs ih => simp [OAI.EditApproximation.bitSubtractNilLeftWithWork, ih]    | cons a as ih =>      cases right with      | nil => simp [OAI.EditApproximation.bitSubtractWithWork, ih]      | cons b bs => simp [OAI.EditApproximation.bitSubtractWithWork, ih, Nat.succ_max_succ]  have proof_bitSubtractWithWork_sub_22 (left : List.{0} Bool) (right : List.{0} Bool) (h : LE.le.{0} (OAI.EditApproximation.bitWordValue right) (OAI.EditApproximation.bitWordValue left)) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork left right false).1 = OAI.EditApproximation.bitWordValue left - OAI.EditApproximation.bitWordValue right := by    have hvalue := proof_bitSubtractWithWork_value_19 left right false    have hlt := proof_bitWordValue_lt_pow_length_20 (OAI.EditApproximation.bitSubtractWithWork left right false).1    rw [proof_bitSubtractWithWork_length_21] at hlt    cases hb : (OAI.EditApproximation.bitSubtractWithWork left right false).2.1    · simp only [hb, Bool.toNat_false, Nat.mul_zero, Nat.add_zero] at hvalue      omega    · simp only [hb, Bool.toNat_true, Bool.toNat_false, Nat.mul_one, Nat.add_zero] at hvalue      omega  have proof_bitDivModWithWork_value_23 (divisor : List.{0} Bool) (bits : List.{0} Bool) (hd : LT.lt.{0} 0 (OAI.EditApproximation.bitWordValue divisor)) :      OAI.EditApproximation.bitWordValue bits = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).1 +        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 ∧        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 < OAI.EditApproximation.bitWordValue divisor := by    induction bits with    | nil => (simp [OAI.EditApproximation.bitDivModWithWork, OAI.EditApproximation.bitWordValue, hd])    | cons bit bits ih =>      let previous := OAI.EditApproximation.bitDivModWithWork divisor bits      let candidate := bit :: previous.2.1      have hp : OAI.EditApproximation.bitWordValue bits = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue previous.1 +          OAI.EditApproximation.bitWordValue previous.2.1 := ih.1      have hr : OAI.EditApproximation.bitWordValue previous.2.1 < OAI.EditApproximation.bitWordValue divisor := ih.2      have hc : OAI.EditApproximation.bitWordValue candidate < 2 * OAI.EditApproximation.bitWordValue divisor := by        dsimp only [candidate, OAI.EditApproximation.bitWordValue]        cases bit <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega      by_cases hlt : (OAI.EditApproximation.bitCompareWithWork candidate divisor).1 = .lt      · have hv := (proof_bitCompareWithWork_lt_16 candidate divisor).1 hlt        simp only [OAI.EditApproximation.bitDivModWithWork, show (OAI.EditApproximation.bitCompareWithWork (bit :: (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1)          divisor).1 = .lt from hlt, ↓reduceIte]        change OAI.EditApproximation.bitWordValue (bit :: bits) = OAI.EditApproximation.bitWordValue divisor *          OAI.EditApproximation.bitWordValue (false :: previous.1) + OAI.EditApproximation.bitWordValue candidate ∧ OAI.EditApproximation.bitWordValue candidate < _        constructor        · (simp only [OAI.EditApproximation.bitWordValue, Bool.toNat_false])          dsimp only [candidate, OAI.EditApproximation.bitWordValue]          nlinarith only [hp]        · exact hv      · have hv : OAI.EditApproximation.bitWordValue divisor ≤ OAI.EditApproximation.bitWordValue candidate := by          exact Nat.le_of_not_gt (fun h => hlt ((proof_bitCompareWithWork_lt_16 candidate divisor).2 h))        have hs := proof_bitSubtractWithWork_sub_22 candidate divisor hv        simp only [OAI.EditApproximation.bitDivModWithWork, show (OAI.EditApproximation.bitCompareWithWork (bit :: (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1)          divisor).1 ≠ .lt from hlt, ↓reduceIte]        change OAI.EditApproximation.bitWordValue (bit :: bits) = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue (true :: previous.1) +          OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork candidate divisor false).1 ∧          OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork candidate divisor false).1 < _        rw [hs]        constructor        · (simp only [OAI.EditApproximation.bitWordValue, Bool.toNat_true])          have he := Nat.sub_add_cancel hv          dsimp only [candidate, OAI.EditApproximation.bitWordValue] at he ⊢          nlinarith only [hp, he]        · omega  have proof_bitCompareWithWork_eq_3 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .eq ↔ OAI.EditApproximation.bitWordValue left = OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_bitAdder_value_1 (a : Bool) (b : Bool) (carry : Bool) :      (OAI.EditApproximation.bitSum a b carry).toNat + 2 * (OAI.EditApproximation.bitCarry a b carry).toNat =        a.toNat + b.toNat + carry.toNat := by    cases a <;> cases b <;> cases carry <;> decide  have proof_bitAddWithWork_value_2 (left : List.{0} Bool) (right : List.{0} Bool) (carry : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitAddWithWork left right carry).1 =        OAI.EditApproximation.bitWordValue left + OAI.EditApproximation.bitWordValue right + carry.toNat := by    induction left generalizing right carry with    | nil =>      simp only [OAI.EditApproximation.bitAddWithWork]      induction right generalizing carry with      | nil => cases carry <;> simp [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue]      | cons b bs ih =>        simp only [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 false b carry        simp only [Bool.toNat_false] at h        omega    | cons a as ih =>      cases right with      | nil =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a false carry        simp only [Bool.toNat_false] at h        omega      | cons b bs =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a b carry        omega  have proof_bitCeilDivWithWork_value_30 (divisor : List.{0} Bool) (bits : List.{0} Bool) (hd : LT.lt.{0} 0 (OAI.EditApproximation.bitWordValue divisor)) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitCeilDivWithWork divisor bits).1 =        ⌈((OAI.EditApproximation.bitWordValue bits : ℚ) / OAI.EditApproximation.bitWordValue divisor)⌉₊ := by    let q := OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).1    let r := OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1    have h := proof_bitDivModWithWork_value_23 divisor bits hd    have heq : OAI.EditApproximation.bitWordValue bits = OAI.EditApproximation.bitWordValue divisor * q + r := h.1    have hr : r < OAI.EditApproximation.bitWordValue divisor := h.2    have hdQ : (0 : ℚ) < OAI.EditApproximation.bitWordValue divisor := by exact_mod_cast hd    unfold OAI.EditApproximation.bitCeilDivWithWork    dsimp only    split_ifs with hz    · have hr0 : r = 0 := by        exact (proof_bitCompareWithWork_eq_3 (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 []).1 hz      have hratio : (OAI.EditApproximation.bitWordValue bits : ℚ) / OAI.EditApproximation.bitWordValue divisor = (q : ℚ) := by        apply (div_eq_iff hdQ.ne').mpr        exact_mod_cast (show OAI.EditApproximation.bitWordValue bits = q * OAI.EditApproximation.bitWordValue divisor by nlinarith only [heq, hr0])      rw [hratio]      exact (Nat.ceil_natCast q).symm    · have hr0 : r ≠ 0 := by        intro hzero        exact hz ((proof_bitCompareWithWork_eq_3 (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 []).2 hzero)      rw [proof_bitAddWithWork_value_2]      change q + 1 + 0 = _      simp only [Nat.add_zero]      symm      apply (Nat.ceil_eq_iff (by omega : q + 1 ≠ 0)).mpr      constructor      · simp only [Nat.add_sub_cancel]        rw [lt_div_iff₀ hdQ]        exact_mod_cast (show q * OAI.EditApproximation.bitWordValue divisor < OAI.EditApproximation.bitWordValue bits by          nlinarith only [heq, Nat.pos_of_ne_zero hr0])      · rw [div_le_iff₀ hdQ]        push_cast        exact_mod_cast (show OAI.EditApproximation.bitWordValue bits ≤ (q + 1) * OAI.EditApproximation.bitWordValue divisor by nlinarith only [heq, hr])  have proof_naturalCeilingWithWork_value_31 (a : OAI.EditApproximation.BinaryFraction) :      OAI.EditApproximation.bitWordValue (a.naturalCeilingWithWork).1 = ⌈a.value⌉₊ := by    cases hs : a.numerator.negative    · simpa only [OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork, hs, Bool.false_eq_true, ↓reduceIte,        OAI.EditApproximation.BinaryFraction.value, OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, Int.cast_natCast] using        proof_bitCeilDivWithWork_value_30 a.denominator a.numerator.bits a.denominator_pos    · have hn : a.value ≤ 0 := by        (simp only [OAI.EditApproximation.BinaryFraction.value, OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, hs, ↓reduceIte, Int.cast_neg, Int.cast_natCast])        exact div_nonpos_of_nonpos_of_nonneg (neg_nonpos.mpr (Nat.cast_nonneg _)) (Nat.cast_nonneg _)      (simp only [OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork, hs, ↓reduceIte, OAI.EditApproximation.bitWordValue])      exact (Nat.ceil_eq_zero.mpr hn).symm  have proof_representation_value_32 (a : OAI.EditApproximation.BinaryFraction) : a.representation.value = a.value := rfl  have proof_eq_of_num_den_33 {a : OAI.EditApproximation.UnreducedRational} {b : OAI.EditApproximation.UnreducedRational} (hnum : Eq.{1} a.num b.num) (hden : Eq.{1} a.den b.den) : a = b := by    cases a    cases b    cases hnum    cases hden    rfl  have proof_trimBitWordWithWork_value_6 (bits : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.trimBitWordWithWork bits).1 = OAI.EditApproximation.bitWordValue bits := by    induction bits with    | nil => rfl    | cons bit bits ih =>      simp only [OAI.EditApproximation.trimBitWordWithWork]      split_ifs with h      · have ht : OAI.EditApproximation.bitWordValue bits = 0 := by rw [← ih, h.1]; rfl        simp [h.2, OAI.EditApproximation.bitWordValue, ht]      · (simp only [OAI.EditApproximation.bitWordValue, ih])  have proof_canonicalizeWithWork_representation_34 (a : OAI.EditApproximation.BinaryFraction) :      (OAI.EditApproximation.BinaryFraction.canonicalizeWithWork a).1.representation = a.representation := by    apply proof_eq_of_num_den_33    · (simp only [OAI.EditApproximation.BinaryFraction.canonicalizeWithWork, OAI.EditApproximation.BinaryFraction.representation, OAI.EditApproximation.SignedBinary.value, proof_trimBitWordWithWork_value_6])    · exact proof_trimBitWordWithWork_value_6 a.denominator  have proof_bitMulWithWork_value_0 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitMulWithWork left right).1 = OAI.EditApproximation.bitWordValue left * OAI.EditApproximation.bitWordValue right := by    induction left with    | nil => simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue]    | cons bit bits ih =>      cases bit <;> simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue, proof_bitAddWithWork_value_2, ih] <;> ring  have proof_mulWithWork_value_35 (a : OAI.EditApproximation.SignedBinary) (b : OAI.EditApproximation.SignedBinary) :      (a.mulWithWork b).1.value = a.value * b.value := by    simp only [OAI.EditApproximation.SignedBinary.mulWithWork, OAI.EditApproximation.SignedBinary.value, proof_bitMulWithWork_value_0]    cases a.negative <;> cases b.negative <;> simp [OAI.EditApproximation.signedMagnitude]  have proof_mulWithWork_representation_36 (a : OAI.EditApproximation.BinaryFraction) (b : OAI.EditApproximation.BinaryFraction) :      (a.mulWithWork b).1.representation = a.representation.mul b.representation := by    apply proof_eq_of_num_den_33    · exact proof_mulWithWork_value_35 a.numerator b.numerator    · exact proof_bitMulWithWork_value_0 a.denominator b.denominator  have proof_canonicalMulWithWork_representation_37 (a : OAI.EditApproximation.BinaryFraction) (b : OAI.EditApproximation.BinaryFraction) :      (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork a b).1.representation = a.representation.mul b.representation := by    rw [OAI.EditApproximation.BinaryFraction.canonicalMulWithWork, proof_canonicalizeWithWork_representation_34, proof_mulWithWork_representation_36]  have proof_zero_representation_38 : OAI.EditApproximation.BinaryFraction.zero.representation = OAI.EditApproximation.UnreducedRational.zero := by    apply proof_eq_of_num_den_33 <;> rfl  have proof_invWithWork_representation_39 (a : OAI.EditApproximation.BinaryFraction) :      (a.invWithWork).1.representation = a.representation.inv := by    unfold OAI.EditApproximation.BinaryFraction.invWithWork    dsimp only    split_ifs with h    · have hz : OAI.EditApproximation.bitWordValue a.numerator.bits = 0 := by        simpa only [OAI.EditApproximation.bitWordValue] using (proof_bitCompareWithWork_eq_3 a.numerator.bits []).1 h      have hv : a.numerator.value = 0 := by (simp [OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, hz])      (simp only [OAI.EditApproximation.UnreducedRational.inv, OAI.EditApproximation.BinaryFraction.representation, hv, ↓reduceDIte])      exact proof_zero_representation_38    · have hn : OAI.EditApproximation.bitWordValue a.numerator.bits ≠ 0 := by        intro hz        exact h ((proof_bitCompareWithWork_eq_3 a.numerator.bits []).2 (by simpa [OAI.EditApproximation.bitWordValue] using hz))      have hv : a.numerator.value ≠ 0 := by        cases hs : a.numerator.negative <;> (simp [OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, hs, hn])      (simp only [OAI.EditApproximation.UnreducedRational.inv, OAI.EditApproximation.BinaryFraction.representation, hv, ↓reduceDIte])      apply proof_eq_of_num_den_33      · cases hs : a.numerator.negative <;>          simp [OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, hs, Int.sign_natCast_of_ne_zero hn]      · cases hs : a.numerator.negative <;> (simp [OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, hs])  have proof_divWithWork_representation_40 (a : OAI.EditApproximation.BinaryFraction) (b : OAI.EditApproximation.BinaryFraction) :      (a.divWithWork b).1.representation = a.representation.div b.representation := by    (simp only [OAI.EditApproximation.BinaryFraction.divWithWork, proof_canonicalMulWithWork_representation_37, proof_invWithWork_representation_39,      OAI.EditApproximation.UnreducedRational.div])  have proof_value_mul_41 (a : OAI.EditApproximation.UnreducedRational) (b : OAI.EditApproximation.UnreducedRational) : (a.mul b).value = a.value * b.value := by    simp [OAI.EditApproximation.UnreducedRational.mul, OAI.EditApproximation.UnreducedRational.value, mul_div_mul_comm]  have proof_value_inv_42 (a : OAI.EditApproximation.UnreducedRational) : a.inv.value = a.value⁻¹ := by    by_cases h : a.num = 0    · simp [OAI.EditApproximation.UnreducedRational.inv, h, OAI.EditApproximation.UnreducedRational.value, OAI.EditApproximation.UnreducedRational.zero]    · have hn : (a.num.natAbs : ℚ) ≠ 0 := by exact_mod_cast (Int.natAbs_pos.mpr h).ne'      have hd : (a.den : ℚ) ≠ 0 := by exact_mod_cast a.den_pos.ne'      have hsign : ((a.num.sign : ℤ) : ℚ) * a.num = (a.num.natAbs : ℚ) := by        simpa only [Int.cast_mul, Int.cast_natCast] using          congrArg (fun z : ℤ => (z : ℚ)) (Int.sign_mul_self_eq_natAbs a.num)      simp only [OAI.EditApproximation.UnreducedRational.inv, h, ↓reduceDIte, OAI.EditApproximation.UnreducedRational.value]      push_cast      apply eq_inv_of_mul_eq_one_left      field_simp [hn, hd]      exact hsign  have proof_value_div_43 (a : OAI.EditApproximation.UnreducedRational) (b : OAI.EditApproximation.UnreducedRational) : (a.div b).value = a.value / b.value := by    simp [proof_value_mul_41, proof_value_inv_42, OAI.EditApproximation.UnreducedRational.div, div_eq_mul_inv]  have proof_divWithWork_value_44 (a : OAI.EditApproximation.BinaryFraction) (b : OAI.EditApproximation.BinaryFraction) :      (OAI.EditApproximation.BinaryFraction.divWithWork a b).1.value = a.value / b.value := by    rw [← proof_representation_value_32, proof_divWithWork_representation_40,      proof_value_div_43, proof_representation_value_32, proof_representation_value_32]  have proof_canonicalMulWithWork_value_45 (a : OAI.EditApproximation.BinaryFraction) (b : OAI.EditApproximation.BinaryFraction) :      (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork a b).1.value = a.value * b.value := by    rw [← proof_representation_value_32, proof_canonicalMulWithWork_representation_37,      proof_value_mul_41, proof_representation_value_32, proof_representation_value_32]  have proof_value_ofInt_46 (a : ℤ) : (OAI.EditApproximation.SignedBinary.ofInt a).value = a := by    by_cases h : a < 0    · simpa only [OAI.EditApproximation.SignedBinary.ofInt, OAI.EditApproximation.SignedBinary.value, proof_bitWordValue_bits_15, OAI.EditApproximation.signedMagnitude, h, decide_true,        ↓reduceIte] using (Int.eq_neg_natAbs_of_nonpos (le_of_lt h)).symm    · simpa only [OAI.EditApproximation.SignedBinary.ofInt, OAI.EditApproximation.SignedBinary.value, proof_bitWordValue_bits_15, OAI.EditApproximation.signedMagnitude, h, decide_false,        Bool.false_eq_true, ↓reduceIte] using (Int.eq_natAbs_of_nonneg (le_of_not_gt h)).symm  have proof_nat_representation_47 (n : ℕ) : (OAI.EditApproximation.BinaryFraction.nat n).representation = OAI.EditApproximation.UnreducedRational.nat n := by    apply proof_eq_of_num_den_33    · change (OAI.EditApproximation.SignedBinary.ofInt (n : ℤ)).value = (n : ℤ)      exact proof_value_ofInt_46 _    · rfl  have proof_value_nat_48 (n : ℕ) : (OAI.EditApproximation.UnreducedRational.nat n).value = n := by (simp [OAI.EditApproximation.UnreducedRational.nat, OAI.EditApproximation.UnreducedRational.value])  have proof_nat_value_49 (n : ℕ) : (OAI.EditApproximation.BinaryFraction.nat n).value = (n : ℚ) := by    rw [← proof_representation_value_32, proof_nat_representation_47, proof_value_nat_48]  have proof_groupSampleCountWithWork_value_28 (M : ℕ) (Q : ℕ) (b : ℕ) (h : OAI.EditApproximation.BinaryFraction) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.BinaryFraction.groupSampleCountWithWork M Q b h).1 = OAI.EditApproximation.groupSampleCount M Q b h.value := by    simp only [OAI.EditApproximation.BinaryFraction.groupSampleCountWithWork, proof_wordMinWithWork_value_29, proof_bitWordValue_bits_15,      proof_naturalCeilingWithWork_value_31, proof_divWithWork_value_44, proof_canonicalMulWithWork_value_45,      proof_nat_value_49, OAI.EditApproximation.groupSampleCount]  exact    let counts := OAI.EditApproximation.vectorMapWithWork T fun t => OAI.EditApproximation.BinaryFraction.groupSampleCountWithWork M Q b (scales t)    let count := fun t => OAI.EditApproximation.bitWordValue (counts.1.get t)    let heq : ∀ t, count t = OAI.EditApproximation.groupSampleCount M Q b (scales t).value := by      intro t      simp only [count, counts, proof_vectorMapWithWork_value_27, proof_groupSampleCountWithWork_value_28]    OAI.EditApproximation.vectorMapAllocation T (fun t => OAI.EditApproximation.BinaryFraction.groupSampleCountAllocation M Q b (scales t)) +      OAI.EditApproximation.BinaryFraction.groupMemberSourceAllocation scales count connection envelope values (fun t j => draw t (Fin.cast (heq t) j))        (fun t j => allocation t (Fin.cast (heq t) j))end OAI.EditApproximation.BinaryFractionendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.BinaryFractiondef unskippedGuardReadWithWork {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx) (_center : OAI.EditApproximation.TargetInterval ny)    (b exponent : ℕ) (F : OAI.EditApproximation.BinaryFraction) (band wide : List (Fin M → OAI.EditApproximation.TargetInterval ny))    (hne : band ≠ []) (read : Fin M → OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BinaryFraction × ℕ) : Bool × ℕ :=  let envelope := OAI.EditApproximation.BinaryFraction.envelopeVectorReadWithWork b band read  let total := OAI.EditApproximation.BinaryFraction.bandMassTotalWithWork envelope.1  let fb := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork F (OAI.EditApproximation.BinaryFraction.nat b)  let limit := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat 64) fb.1  let sumGuard := OAI.EditApproximation.BinaryFraction.leWithWork total.1 limit.1  let rounded := OAI.EditApproximation.BinaryFraction.roundedBandReadWithWork exponent b band hne read  let wideGuard := OAI.EditApproximation.actionMemberWithWork rounded.1.get wide  let gapGuard := OAI.EditApproximation.allWithWork (fun i =>    let sourceLength := OAI.EditApproximation.binaryNaturalSubtractWithWork (OAI.EditApproximation.sourceChild parent i).hi (OAI.EditApproximation.sourceChild parent i).lo    let gap := OAI.EditApproximation.BinaryFraction.stateGapWithWork (OAI.EditApproximation.bitWordValue sourceLength.1) (rounded.1.get i)    let bound := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat 2) (envelope.1.get i)    let test := OAI.EditApproximation.BinaryFraction.leWithWork gap.1.absolute bound.1    (test.1, sourceLength.2 + gap.2 + bound.2 + test.2 + 3)) (List.finRange M)  (sumGuard.1 && wideGuard.1 && gapGuard.1,    envelope.2 + total.2 + fb.2 + limit.2 + sumGuard.2 + rounded.2 + wideGuard.2 + gapGuard.2 + 5)def queryGroupInputsWithWork {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx)    (b exponent Q : ℕ) (cell : ℕ × ℕ) (h : OAI.EditApproximation.BinaryFraction)    (draw : Fin (OAI.EditApproximation.groupSampleCount M Q b h.value) → Fin M × ℕ) :    List (Fin M × OAI.EditApproximation.TargetInterval ny) × ℕ :=  let labels := OAI.EditApproximation.BinaryFraction.queryGroupLabelsWithWork M Q b h draw  let inputs := OAI.EditApproximation.arithmeticFlatMapWithWork (fun i =>    let states := OAI.EditApproximation.BinaryFraction.queryGroupRoundedStatesWithWork (ny := ny) parent b exponent cell i h    let tagged := OAI.EditApproximation.arithmeticMapWithWork (fun r => ((i, r), 1)) states.1    (tagged.1, states.2 + tagged.2 + 1)) labels.1  (inputs.1, labels.2 + inputs.2 + 1)def coarseIndexedRootWithWork {B d : ℕ} (k q L : ℕ)    (hB : 0 < B) (hq : 0 < q) (hL : 0 < L) (x y : List ℕ)    (draws : OAI.EditApproximation.CoarseThresholdDraws B d) : OAI.EditApproximation.BinaryFraction × ℕ := by  have proof_trimBitWordWithWork_value_6 (bits : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.trimBitWordWithWork bits).1 = OAI.EditApproximation.bitWordValue bits := by    induction bits with    | nil => rfl    | cons bit bits ih =>      simp only [OAI.EditApproximation.trimBitWordWithWork]      split_ifs with h      · have ht : OAI.EditApproximation.bitWordValue bits = 0 := by rw [← ih, h.1]; rfl        simp [h.2, OAI.EditApproximation.bitWordValue, ht]      · (simp only [OAI.EditApproximation.bitWordValue, ih])  have proof_bitAdder_value_1 (a : Bool) (b : Bool) (carry : Bool) :      (OAI.EditApproximation.bitSum a b carry).toNat + 2 * (OAI.EditApproximation.bitCarry a b carry).toNat =        a.toNat + b.toNat + carry.toNat := by    cases a <;> cases b <;> cases carry <;> decide  have proof_bitAddWithWork_value_2 (left : List.{0} Bool) (right : List.{0} Bool) (carry : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitAddWithWork left right carry).1 =        OAI.EditApproximation.bitWordValue left + OAI.EditApproximation.bitWordValue right + carry.toNat := by    induction left generalizing right carry with    | nil =>      simp only [OAI.EditApproximation.bitAddWithWork]      induction right generalizing carry with      | nil => cases carry <;> simp [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue]      | cons b bs ih =>        simp only [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 false b carry        simp only [Bool.toNat_false] at h        omega    | cons a as ih =>      cases right with      | nil =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a false carry        simp only [Bool.toNat_false] at h        omega      | cons b bs =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a b carry        omega  have proof_bitMulWithWork_value_0 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitMulWithWork left right).1 = OAI.EditApproximation.bitWordValue left * OAI.EditApproximation.bitWordValue right := by    induction left with    | nil => simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue]    | cons bit bits ih =>      cases bit <;> simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue, proof_bitAddWithWork_value_2, ih] <;> ring  have proof_bitPowerWithWork_value_76 (base : List.{0} Bool) (n : ℕ) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitPowerWithWork base n).1 = OAI.EditApproximation.bitWordValue base ^ n := by    induction n with    | zero => (simp [OAI.EditApproximation.bitPowerWithWork, OAI.EditApproximation.bitWordValue])    | succ n ih =>      simp only [OAI.EditApproximation.bitPowerWithWork, proof_trimBitWordWithWork_value_6, proof_bitMulWithWork_value_0, ih, pow_succ]  have proof_coarseDenominatorWithWork_value_127 (allowanceDen : List.{0} Bool) (q : List.{0} Bool) (L : List.{0} Bool) (branching : List.{0} Bool) (D : ℕ) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.coarseDenominatorWithWork allowanceDen q L branching D).1 =        OAI.EditApproximation.coarseCommonDenominator (OAI.EditApproximation.bitWordValue allowanceDen) (OAI.EditApproximation.bitWordValue q)          (OAI.EditApproximation.bitWordValue L) (OAI.EditApproximation.bitWordValue branching) D := by    simp only [OAI.EditApproximation.coarseDenominatorWithWork, proof_trimBitWordWithWork_value_6,      proof_bitMulWithWork_value_0, proof_bitPowerWithWork_value_76, OAI.EditApproximation.coarseCommonDenominator]  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_coarseRootDenominator_value_128 (B : ℕ) (q : ℕ) (L : ℕ) (d : ℕ) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.BinaryFraction.coarseRootDenominator B q L d).1 = OAI.EditApproximation.coarseCommonDenominator 1 q L B d := by    simp only [OAI.EditApproximation.BinaryFraction.coarseRootDenominator, proof_coarseDenominatorWithWork_value_127, proof_bitWordValue_bits_15]  have proof_coarseRootDenominator_pos_126 (B : ℕ) (q : ℕ) (L : ℕ) (d : ℕ) (hB : LT.lt.{0} 0 B) (hq : LT.lt.{0} 0 q) (hL : LT.lt.{0} 0 L) :      0 < OAI.EditApproximation.bitWordValue (OAI.EditApproximation.BinaryFraction.coarseRootDenominator B q L d).1 := by    rw [proof_coarseRootDenominator_value_128]    unfold OAI.EditApproximation.coarseCommonDenominator    positivity  exact    let den := OAI.EditApproximation.BinaryFraction.coarseRootDenominator B q L d    let denPos := proof_coarseRootDenominator_pos_126 B q L d hB hq hL    let two := OAI.EditApproximation.BinaryFraction.coarseGridNatWithWork den.1 denPos 2    let allowance := OAI.EditApproximation.BinaryFraction.coarseGridNatWithWork den.1 denPos k    let evaluated := OAI.EditApproximation.BinaryFraction.coarseIndexedWithWork k q L (OAI.EditApproximation.coarseEntryWidth x y) x y two.1 d 0 draws allowance.1 0    (OAI.EditApproximation.BinaryFraction.coarseBinaryRead evaluated.1 (OAI.EditApproximation.coarseRootShift k).val,      den.2 + two.2 + allowance.2 + evaluated.2 + 1)def queryGroupInputsAllocation {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx)    (b exponent Q : ℕ) (cell : ℕ × ℕ) (h : OAI.EditApproximation.BinaryFraction)    (draw : Fin (OAI.EditApproximation.groupSampleCount M Q b h.value) → Fin M × ℕ)    (allocation : Fin (OAI.EditApproximation.groupSampleCount M Q b h.value) → ℕ) : ℕ :=  let build := fun i : Fin M =>    let states := OAI.EditApproximation.BinaryFraction.queryGroupRoundedStatesWithWork (ny := ny) parent b exponent cell i h    let tagged := OAI.EditApproximation.arithmeticMapWithWork (fun r => ((i, r), 1)) states.1    (tagged.1, states.2 + tagged.2 + 1)  OAI.EditApproximation.BinaryFraction.queryGroupLabelsAllocation M Q b h draw allocation + OAI.EditApproximation.arithmeticFlatMapAllocation build    (fun i => OAI.EditApproximation.BinaryFraction.queryGroupRoundedStatesAllocation (ny := ny) parent b exponent cell i h +      OAI.EditApproximation.arithmeticMapAllocation (fun _ => 1) (OAI.EditApproximation.BinaryFraction.queryGroupRoundedStatesWithWork (ny := ny) parent b exponent cell i h).1)    (OAI.EditApproximation.BinaryFraction.queryGroupLabelsWithWork M Q b h draw).1def unskippedGuardReadAllocation {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx)    (_center : OAI.EditApproximation.TargetInterval ny) (b exponent : ℕ) (F : OAI.EditApproximation.BinaryFraction)    (band wide : List (Fin M → OAI.EditApproximation.TargetInterval ny)) (hne : band ≠ [])    (read : Fin M → OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BinaryFraction × ℕ)    (allocation : Fin M → OAI.EditApproximation.TargetInterval ny → ℕ) : ℕ :=  let envelope := (OAI.EditApproximation.BinaryFraction.envelopeVectorReadWithWork b band read).1  let total := (OAI.EditApproximation.BinaryFraction.bandMassTotalWithWork envelope).1  let fb := (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork F (OAI.EditApproximation.BinaryFraction.nat b)).1  let limit := (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat 64) fb).1  let rounded := (OAI.EditApproximation.BinaryFraction.roundedBandReadWithWork exponent b band hne read).1  OAI.EditApproximation.BinaryFraction.envelopeVectorReadAllocation b band read allocation + OAI.EditApproximation.BinaryFraction.bandMassAllocation envelope +    OAI.EditApproximation.BinaryFraction.canonicalMulAllocation F (OAI.EditApproximation.BinaryFraction.nat b) + OAI.EditApproximation.BinaryFraction.canonicalMulAllocation (OAI.EditApproximation.BinaryFraction.nat 64) fb + OAI.EditApproximation.BinaryFraction.leAllocation total limit +    OAI.EditApproximation.BinaryFraction.roundedBandReadAllocation exponent b band hne read allocation + OAI.EditApproximation.actionMemberAllocation rounded.get wide +    OAI.EditApproximation.allAllocation (OAI.EditApproximation.BinaryFraction.gapGuardAllocation parent envelope rounded) (List.finRange M)def queryGroupInputsTransportWithWork {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx)    (b exponent Q : ℕ) (cell : ℕ × ℕ) (word : OAI.EditApproximation.BinaryFraction) (scale : ℚ)    (hv : word.value = scale) (draw : Fin (OAI.EditApproximation.groupSampleCount M Q b scale) → Fin M × ℕ) :    List (Fin M × OAI.EditApproximation.TargetInterval ny) × ℕ :=  OAI.EditApproximation.BinaryFraction.queryGroupInputsWithWork parent b exponent Q cell word    (fun sample => draw (Fin.cast (congrArg (OAI.EditApproximation.groupSampleCount M Q b) hv) sample))def coarseIndexedCandidateWithWork {B d : ℕ} (q L : ℕ)    (hB : 0 < B) (hq : 0 < q) (hL : 0 < L) (x y : List ℕ)    (i : OAI.EditApproximation.CoarseGuessIndex (OAI.EditApproximation.coarseEntryWidth x y)) (draws : OAI.EditApproximation.CoarseThresholdDraws B d) :    OAI.EditApproximation.BinaryFraction × ℕ :=  let k := OAI.EditApproximation.coarseGuess (OAI.EditApproximation.coarseEntryWidth x y) i  let root := OAI.EditApproximation.BinaryFraction.coarseIndexedRootWithWork k q L hB hq hL x y draws  let shifted := OAI.EditApproximation.BinaryFraction.canonicalAddWithWork root.1 (OAI.EditApproximation.BinaryFraction.nat k)  let doubled := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.nat 2) shifted.1  (doubled.1, root.2 + shifted.2 + doubled.2 + Nat.size k + 3)def preparedUnskippedReadAllocation {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx)    (center : OAI.EditApproximation.TargetInterval ny) (b P exponent : ℕ) (tau F : OAI.EditApproximation.BinaryFraction)    (read initial : Fin M → OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BinaryFraction × ℕ)    (readAllocation initialAllocation : Fin M → OAI.EditApproximation.TargetInterval ny → ℕ) : ℕ :=  let band := (OAI.EditApproximation.BinaryFraction.preparedRepresentativeReadWithWork parent center (parent.hi - parent.lo) b P    tau (OAI.EditApproximation.BinaryFraction.inversePowerTwo exponent) read).1  OAI.EditApproximation.BinaryFraction.preparedRepresentativeReadAllocation parent center (parent.hi - parent.lo) b P    tau (OAI.EditApproximation.BinaryFraction.inversePowerTwo exponent) read readAllocation +    if hband : band = [] then 0 else      let wide := (OAI.EditApproximation.wideActionGridWithWork M parent center b P).1      OAI.EditApproximation.wideActionGridAllocation M parent center b P + wide.length +        OAI.EditApproximation.BinaryFraction.unskippedGuardReadAllocation parent center b exponent F band (wide.map Vector.get) hband initial initialAllocation +        if (OAI.EditApproximation.BinaryFraction.unskippedGuardReadWithWork parent center b exponent F band (wide.map Vector.get) hband initial).1 then 3 else 0def queryGroupInputsTransportAllocation {nx ny M : ℕ} (parent : OAI.EditApproximation.TargetInterval nx)    (b exponent Q : ℕ) (cell : ℕ × ℕ) (word : OAI.EditApproximation.BinaryFraction) (scale : ℚ)    (hv : word.value = scale) (draw : Fin (OAI.EditApproximation.groupSampleCount M Q b scale) → Fin M × ℕ)    (allocation : Fin (OAI.EditApproximation.groupSampleCount M Q b scale) → ℕ) : ℕ :=  OAI.EditApproximation.BinaryFraction.queryGroupInputsAllocation (ny := ny) parent b exponent Q cell word    (fun sample => draw (Fin.cast (congrArg (OAI.EditApproximation.groupSampleCount M Q b) hv) sample))    (fun sample => allocation (Fin.cast (congrArg (OAI.EditApproximation.groupSampleCount M Q b) hv) sample))def preparedUnskippedReadWithWorkRaw {nx ny M : ℕ}    (parent : OAI.EditApproximation.TargetInterval nx) (b P exponent : ℕ) (tau F : OAI.EditApproximation.BinaryFraction)    (read initial : Fin M → OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BinaryFraction × ℕ)    (center : OAI.EditApproximation.TargetInterval ny) : Option (OAI.EditApproximation.RawUnskippedBand M ny) × ℕ :=  let band := OAI.EditApproximation.BinaryFraction.preparedRepresentativeReadWithWork parent center (parent.hi - parent.lo) b P    tau (OAI.EditApproximation.BinaryFraction.inversePowerTwo exponent) read  if hband : band.1 = [] then (none, band.2 + 1) else    let wide := OAI.EditApproximation.wideActionGridWithWork M parent center b P    let guard := OAI.EditApproximation.BinaryFraction.unskippedGuardReadWithWork parent center b exponent F band.1      (wide.1.map Vector.get) hband initial    if guard.1 = true then      (some ⟨center, band.1, hband⟩, band.2 + wide.2 + guard.2 + wide.1.length + 3)    else (none, band.2 + wide.2 + guard.2 + wide.1.length + 2)def coarseIndexedInitialWithWork {B d : ℕ} (q L N : ℕ)    (hB : 0 < B) (hq : 0 < q) (hL : 0 < L) (x y : List ℕ)    (draws : OAI.EditApproximation.CoarseGuessIndex (OAI.EditApproximation.coarseEntryWidth x y) → OAI.EditApproximation.CoarseThresholdDraws B d) : ℕ × ℕ :=  let long := OAI.EditApproximation.binaryNaturalCompareWithWork (2 * x.length) y.length  if long.1 = .lt then (min N y.length, long.2 + Nat.size N + Nat.size y.length + 4) else  let equal := OAI.EditApproximation.BinaryFraction.naturalListEqualWithWork x y  if equal.1 then (0, long.2 + equal.2 + 3) else  let roots := OAI.EditApproximation.arithmeticMapWithWork (fun i => OAI.EditApproximation.BinaryFraction.coarseIndexedCandidateWithWork q L hB hq hL x y i (draws i))    (List.finRange (Nat.clog 2 (OAI.EditApproximation.coarseEntryWidth x y) + 1))  let smallest := OAI.EditApproximation.BinaryFraction.coarseMinimumWithWork roots.1  let rounded := OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork smallest.1  let result := OAI.EditApproximation.wordMinWithWork N.bits rounded.1  (OAI.EditApproximation.bitWordValue result.1, long.2 + equal.2 + roots.2 + smallest.2 + rounded.2 + result.2 + Nat.size N + 6)end OAI.EditApproximation.BinaryFractionendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.BinaryFractionvariable {ny M T : ℕ} (b exponent Q : ℕ)  (initial current : Fin M → TargetInterval ny → BinaryFraction × ℕ)  (initialAllocation currentAllocation : Fin M → TargetInterval ny → ℕ)  (scales : Fin T → BinaryFraction)  (draw : ∀ t, Fin (groupSampleCount M Q b (scales t).value) → Fin M)  (drawSource : ∀ t, Fin (groupSampleCount M Q b (scales t).value) → Fin M × ℕ)  (drawAllocation : ∀ t, Fin (groupSampleCount M Q b (scales t).value) → ℕ)def unskippedEstimateSourceWithWorkRaw (member : (OAI.EditApproximation.RawUnskippedBand M ny)) : OAI.EditApproximation.BinaryFraction × ℕ :=  let mass := OAI.EditApproximation.BinaryFraction.envelopeVectorReadWithWork b member.actions initial  let rounded := OAI.EditApproximation.BinaryFraction.roundedBandReadWithWork exponent b member.actions member.nonempty initial  let values := OAI.EditApproximation.vectorMapWithWork M fun i => current i (rounded.1.get i)  let connection := OAI.EditApproximation.BinaryFraction.endpointConnectionWithWork member.center rounded.1.get  let result := OAI.EditApproximation.BinaryFraction.countedGroupMemberSourceWithWork Q b scales connection.1 mass.1 values.1 drawSource  (result.1, mass.2 + rounded.2 + values.2 + connection.2 + result.2 + 5)def unskippedEstimateSourceAllocationRaw (member : (OAI.EditApproximation.RawUnskippedBand M ny)) : ℕ :=  let mass := (OAI.EditApproximation.BinaryFraction.envelopeVectorReadWithWork b member.actions initial).1  let rounded := (OAI.EditApproximation.BinaryFraction.roundedBandReadWithWork exponent b member.actions member.nonempty initial).1  let values := (OAI.EditApproximation.vectorMapWithWork M (fun i => current i (rounded.get i))).1  let connection := (OAI.EditApproximation.BinaryFraction.endpointConnectionWithWork member.center rounded.get).1  OAI.EditApproximation.BinaryFraction.envelopeVectorReadAllocation b member.actions initial initialAllocation +    OAI.EditApproximation.BinaryFraction.roundedBandReadAllocation exponent b member.actions member.nonempty initial initialAllocation +    OAI.EditApproximation.vectorMapAllocation M (fun i => currentAllocation i (rounded.get i)) +    OAI.EditApproximation.BinaryFraction.endpointConnectionAllocation member.center rounded.get + OAI.EditApproximation.BinaryFraction.countedGroupMemberSourceAllocation Q b scales connection mass values drawSource drawAllocationdef chooseUnskippedSourceWithWorkRaw (members : List (OAI.EditApproximation.RawUnskippedBand M ny)) (hne : members ≠ []) : (OAI.EditApproximation.RawUnskippedBand M ny) × ℕ :=  OAI.EditApproximation.BinaryFraction.selectGroupWithWork members hne    (OAI.EditApproximation.BinaryFraction.unskippedEstimateSourceWithWorkRaw b exponent Q initial current scales drawSource)def chooseUnskippedSourceAllocationRaw (members : List (OAI.EditApproximation.RawUnskippedBand M ny)) : ℕ :=  OAI.EditApproximation.BinaryFraction.selectGroupAllocation members    (OAI.EditApproximation.BinaryFraction.unskippedEstimateSourceWithWorkRaw b exponent Q initial current scales drawSource)    (OAI.EditApproximation.BinaryFraction.unskippedEstimateSourceAllocationRaw b exponent Q initial current      initialAllocation currentAllocation scales drawSource drawAllocation)def sampledGroupActionSourceWithWorkRaw (members : List (OAI.EditApproximation.RawUnskippedBand M ny)) (hne : members ≠ []) :    OAI.EditApproximation.BinaryBellmanAction (OAI.EditApproximation.TargetInterval ny) (Fin M × OAI.EditApproximation.TargetInterval ny) M × ℕ :=  let selected := OAI.EditApproximation.BinaryFraction.chooseUnskippedSourceWithWorkRaw b exponent Q initial current scales drawSource members hne  let rounded := OAI.EditApproximation.BinaryFraction.roundedBandReadWithWork exponent b selected.1.actions selected.1.nonempty initial  let result := OAI.EditApproximation.BinaryFraction.endpointActionWithWork selected.1.center rounded.1.get  (result.1, selected.2 + rounded.2 + result.2 + 3)def sampledGroupActionSourceAllocationRaw (members : List (OAI.EditApproximation.RawUnskippedBand M ny)) (hne : members ≠ []) : ℕ :=  let selected := (OAI.EditApproximation.BinaryFraction.chooseUnskippedSourceWithWorkRaw b exponent Q initial current    scales drawSource members hne).1  let rounded := (OAI.EditApproximation.BinaryFraction.roundedBandReadWithWork exponent b selected.actions selected.nonempty initial).1  OAI.EditApproximation.BinaryFraction.chooseUnskippedSourceAllocationRaw b exponent Q initial current    initialAllocation currentAllocation scales drawSource drawAllocation members +    OAI.EditApproximation.BinaryFraction.roundedBandReadAllocation exponent b selected.actions selected.nonempty initial initialAllocation +    OAI.EditApproximation.BinaryFraction.endpointActionAllocation selected.center rounded.getend OAI.EditApproximation.BinaryFractionendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.BinaryFractionopen Finsetdef preparedOnlineReadWithWorkRaw {α : Type u_1} (source target : List α) {M : ℕ}    (parent : OAI.EditApproximation.TargetInterval source.length) (P F exponent H b : ℕ) (_hb : 0 < b) (_hP : 0 < P)    (tau eta kappa : OAI.EditApproximation.BinaryFraction)    (child initial : Fin M → OAI.EditApproximation.TargetInterval target.length → OAI.EditApproximation.BinaryFraction × ℕ)    (table : ℕ → Fin M × OAI.EditApproximation.TargetInterval target.length → OAI.EditApproximation.BinaryFraction × ℕ)    (R : ℕ) (_hc : ∀ i q, (child i q).2 ≤ R) (_hi : ∀ i q, (initial i q).2 ≤ R)    (t : ℕ) (center : OAI.EditApproximation.TargetInterval target.length) (integer : ℕ) :    Option (OAI.EditApproximation.BinaryBellmanAction (OAI.EditApproximation.TargetInterval target.length)      (Fin M × OAI.EditApproximation.TargetInterval target.length) M) × ℕ := by  have proof_arithmeticFlatMapWithWork_value_69 {α : Type 0} {β : Type 0} (f : α → Prod.{0, 0} (List.{0} β) ℕ) (values : List.{0} α) :      (OAI.EditApproximation.arithmeticFlatMapWithWork f values).1 = values.flatMap (fun a => (f a).1) := by    induction values with    | nil => rfl    | cons a rest ih => simp only [OAI.EditApproximation.arithmeticFlatMapWithWork, ih, List.flatMap_cons]  have proof_arithmeticMapWithWork_value_70 {α : Type 0} {β : Type 0} (f : α → Prod.{0, 0} β ℕ) (values : List.{0} α) :      (OAI.EditApproximation.arithmeticMapWithWork f values).1 = values.map (fun a => (f a).1) := by    induction values with    | nil => rfl    | cons a rest ih => simp only [OAI.EditApproximation.arithmeticMapWithWork, ih, List.map_cons]  have proof_memberByWithWork_value_71 {α : Type 0} (equal : α → α → Prod.{0, 0} Bool ℕ) (heq : ∀ (a b : α), Eq.{1} (equal a b).1 Bool.true ↔ Eq.{0 + 1} a b) (a : α) (xs : List.{0} α) :      (OAI.EditApproximation.memberByWithWork equal a xs).1 = true ↔ a ∈ xs := by    induction xs with    | nil => simp only [OAI.EditApproximation.memberByWithWork, Bool.false_eq_true, List.not_mem_nil]    | cons b xs ih => simp only [OAI.EditApproximation.memberByWithWork, Bool.or_eq_true, heq, ih, List.mem_cons]  have proof_dedupByWithWork_value_72 {α : Type 0} [instLocal1 : DecidableEq.{0 + 1} α] (equal : α → α → Prod.{0, 0} Bool ℕ) (heq : ∀ (a b : α), Eq.{1} (equal a b).1 Bool.true ↔ Eq.{0 + 1} a b) (xs : List.{0} α) :      (OAI.EditApproximation.dedupByWithWork equal xs).1 = xs.dedup := by    induction xs with    | nil => rfl    | cons a rest ih =>      have hm := proof_memberByWithWork_value_71 equal heq a rest      have ht : (OAI.EditApproximation.memberByWithWork equal a rest).1 = decide (a ∈ rest) :=        Bool.eq_iff_iff.mpr (by simpa only [decide_eq_true_eq] using hm)      simp only [OAI.EditApproximation.dedupByWithWork, ht, ih, List.dedup_cons, decide_eq_true_eq]  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_bitOrdering_matches_4 (high : Ordering) (a : Bool) (b : Bool) (x : ℕ) (y : ℕ) (h : OAI.EditApproximation.orderingMatches high x y) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitOrdering high a b) (a.toNat + 2 * x) (b.toNat + 2 * y) := by    rcases h with ⟨rfl, h⟩ | ⟨rfl, rfl⟩ | ⟨rfl, h⟩    · exact Or.inl ⟨rfl, by cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩    · cases a <;> cases b <;> simp [OAI.EditApproximation.bitOrdering, OAI.EditApproximation.orderingMatches]    · exact Or.inr (Or.inr ⟨rfl, by        cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩)  have proof_bitCompareWithWork_matches_5 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitCompareWithWork left right).1 (OAI.EditApproximation.bitWordValue left) (OAI.EditApproximation.bitWordValue right) := by    induction left generalizing right with    | nil =>      simp only [OAI.EditApproximation.bitCompareWithWork]      induction right with      | nil => (simp [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.orderingMatches, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        simpa only [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareNilLeftWithWork bs).1 false b 0 (OAI.EditApproximation.bitWordValue bs) ih    | cons a as ih =>      cases right with      | nil =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as []).1 a false (OAI.EditApproximation.bitWordValue as) 0 (ih [])      | cons b bs =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue] using          proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as bs).1 a b (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs) (ih bs)  have proof_bitCompareWithWork_eq_3 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .eq ↔ OAI.EditApproximation.bitWordValue left = OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_binaryNaturalCompareWithWork_eq_73 (a : ℕ) (b : ℕ) :      (OAI.EditApproximation.binaryNaturalCompareWithWork a b).1 = .eq ↔ a = b := by    simpa only [OAI.EditApproximation.binaryNaturalCompareWithWork, proof_bitWordValue_bits_15] using proof_bitCompareWithWork_eq_3 a.bits b.bits  have proof_naturalEqualWithWork_value_74 (a : ℕ) (b : ℕ) :      (OAI.EditApproximation.naturalEqualWithWork a b).1 = true ↔ a = b := by    simp only [OAI.EditApproximation.naturalEqualWithWork, decide_eq_true_eq, proof_binaryNaturalCompareWithWork_eq_73]  have proof_coordinateEqualWithWork_value_75 {M : ℕ} {n : ℕ} (a : Prod.{0, 0} (Fin M) (OAI.EditApproximation.TargetInterval n)) (b : Prod.{0, 0} (Fin M) (OAI.EditApproximation.TargetInterval n)) :      (OAI.EditApproximation.coordinateEqualWithWork a b).1 = true ↔ a = b := by    simp only [OAI.EditApproximation.coordinateEqualWithWork, Bool.and_eq_true, proof_naturalEqualWithWork_value_74]    constructor    · rintro ⟨⟨hc, hl⟩, hh⟩      have hi : a.1 = b.1 := Fin.ext hc      have hq : a.2 = b.2 := by        rcases a with ⟨i, q⟩        rcases b with ⟨j, r⟩        cases q        cases r        cases hl        cases hh        rfl      exact Prod.ext hi hq    · intro h      subst b      exact ⟨⟨rfl, rfl⟩, rfl⟩  have proof_bandCoordinatesWithWork_value_68 {M : ℕ} {n : ℕ} (band : List.{0} (Fin M → OAI.EditApproximation.TargetInterval n)) :      (OAI.EditApproximation.BinaryFraction.bandCoordinatesWithWork band).1 = OAI.EditApproximation.listedBandCoordinates band := by    simp only [OAI.EditApproximation.BinaryFraction.bandCoordinatesWithWork, proof_dedupByWithWork_value_72 _ proof_coordinateEqualWithWork_value_75,      proof_arithmeticFlatMapWithWork_value_69, proof_arithmeticMapWithWork_value_70, OAI.EditApproximation.listedBandCoordinates,      List.ofFn_eq_map]  have proof_bitAdder_value_1 (a : Bool) (b : Bool) (carry : Bool) :      (OAI.EditApproximation.bitSum a b carry).toNat + 2 * (OAI.EditApproximation.bitCarry a b carry).toNat =        a.toNat + b.toNat + carry.toNat := by    cases a <;> cases b <;> cases carry <;> decide  have proof_bitAddWithWork_value_2 (left : List.{0} Bool) (right : List.{0} Bool) (carry : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitAddWithWork left right carry).1 =        OAI.EditApproximation.bitWordValue left + OAI.EditApproximation.bitWordValue right + carry.toNat := by    induction left generalizing right carry with    | nil =>      simp only [OAI.EditApproximation.bitAddWithWork]      induction right generalizing carry with      | nil => cases carry <;> simp [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue]      | cons b bs ih =>        simp only [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 false b carry        simp only [Bool.toNat_false] at h        omega    | cons a as ih =>      cases right with      | nil =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a false carry        simp only [Bool.toNat_false] at h        omega      | cons b bs =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a b carry        omega  have proof_binaryNaturalAddWithWork_value_52 (a : ℕ) (b : ℕ) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalAddWithWork a b).1 = a + b := by    simp [OAI.EditApproximation.binaryNaturalAddWithWork, proof_bitAddWithWork_value_2, proof_bitWordValue_bits_15]  have proof_onlineIndexSetupWithWork_value_129 {M : ℕ} {n : ℕ} (H : ℕ) (band : List.{0} (Fin M → OAI.EditApproximation.TargetInterval n)) :      (OAI.EditApproximation.BinaryFraction.onlineIndexSetupWithWork H band).1 = H + (OAI.EditApproximation.listedBandCoordinates band).length + 2 := by    simp only [OAI.EditApproximation.BinaryFraction.onlineIndexSetupWithWork, proof_binaryNaturalAddWithWork_value_52, proof_bandCoordinatesWithWork_value_68]  exact    let band := OAI.EditApproximation.BinaryFraction.preparedRepresentativeReadWithWork parent center (parent.hi - parent.lo) b P      tau (OAI.EditApproximation.BinaryFraction.inversePowerTwo exponent) child    let setup := OAI.EditApproximation.BinaryFraction.onlineIndexSetupWithWork H band.1    let G := setup.1    let accepted := OAI.EditApproximation.BinaryFraction.reduceOnlineIntegerWithWork (G ^ 80) (by      dsimp only [G, setup]      rw [proof_onlineIndexSetupWithWork_value_129]      positivity) integer    if hband : band.1 = [] then (none, band.2 + setup.2 + accepted.2 + 1) else      let guard := OAI.EditApproximation.BinaryFraction.preparedUnskippedReadWithWorkRaw parent b P exponent tau (OAI.EditApproximation.BinaryFraction.nat F) child initial center      if guard.1.isSome then        let sampled := OAI.EditApproximation.BinaryFraction.countedSampledOnlineReadWithWork center b initial table eta kappa band.1 hband          G (G ^ 80) t accepted.1        (some sampled.1, band.2 + setup.2 + accepted.2 + guard.2 + sampled.2 + 2)      else (none, band.2 + setup.2 + accepted.2 + guard.2 + 1)def preparedOnlineReadAllocationRaw {α : Type u_1} (source target : List α) {M : ℕ}  (parent : OAI.EditApproximation.TargetInterval source.length) (P F exponent H b : ℕ) (_hb : 0 < b) (_hP : 0 < P)  (tau eta kappa : OAI.EditApproximation.BinaryFraction)  (child initial : Fin M → OAI.EditApproximation.TargetInterval target.length → OAI.EditApproximation.BinaryFraction × ℕ)  (table : ℕ → Fin M × OAI.EditApproximation.TargetInterval target.length → OAI.EditApproximation.BinaryFraction × ℕ)  (R : ℕ) (_hc : ∀ i q, (child i q).2 ≤ R) (_hi : ∀ i q, (initial i q).2 ≤ R)  (childAllocation initialAllocation : Fin M → OAI.EditApproximation.TargetInterval target.length → ℕ)  (tableAllocation : ℕ → Fin M × OAI.EditApproximation.TargetInterval target.length → ℕ)    (t : ℕ) (center : OAI.EditApproximation.TargetInterval target.length) (integer : ℕ) : ℕ := by  have proof_arithmeticFlatMapWithWork_value_69 {α : Type 0} {β : Type 0} (f : α → Prod.{0, 0} (List.{0} β) ℕ) (values : List.{0} α) :      (OAI.EditApproximation.arithmeticFlatMapWithWork f values).1 = values.flatMap (fun a => (f a).1) := by    induction values with    | nil => rfl    | cons a rest ih => simp only [OAI.EditApproximation.arithmeticFlatMapWithWork, ih, List.flatMap_cons]  have proof_arithmeticMapWithWork_value_70 {α : Type 0} {β : Type 0} (f : α → Prod.{0, 0} β ℕ) (values : List.{0} α) :      (OAI.EditApproximation.arithmeticMapWithWork f values).1 = values.map (fun a => (f a).1) := by    induction values with    | nil => rfl    | cons a rest ih => simp only [OAI.EditApproximation.arithmeticMapWithWork, ih, List.map_cons]  have proof_memberByWithWork_value_71 {α : Type 0} (equal : α → α → Prod.{0, 0} Bool ℕ) (heq : ∀ (a b : α), Eq.{1} (equal a b).1 Bool.true ↔ Eq.{0 + 1} a b) (a : α) (xs : List.{0} α) :      (OAI.EditApproximation.memberByWithWork equal a xs).1 = true ↔ a ∈ xs := by    induction xs with    | nil => simp only [OAI.EditApproximation.memberByWithWork, Bool.false_eq_true, List.not_mem_nil]    | cons b xs ih => simp only [OAI.EditApproximation.memberByWithWork, Bool.or_eq_true, heq, ih, List.mem_cons]  have proof_dedupByWithWork_value_72 {α : Type 0} [instLocal1 : DecidableEq.{0 + 1} α] (equal : α → α → Prod.{0, 0} Bool ℕ) (heq : ∀ (a b : α), Eq.{1} (equal a b).1 Bool.true ↔ Eq.{0 + 1} a b) (xs : List.{0} α) :      (OAI.EditApproximation.dedupByWithWork equal xs).1 = xs.dedup := by    induction xs with    | nil => rfl    | cons a rest ih =>      have hm := proof_memberByWithWork_value_71 equal heq a rest      have ht : (OAI.EditApproximation.memberByWithWork equal a rest).1 = decide (a ∈ rest) :=        Bool.eq_iff_iff.mpr (by simpa only [decide_eq_true_eq] using hm)      simp only [OAI.EditApproximation.dedupByWithWork, ht, ih, List.dedup_cons, decide_eq_true_eq]  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_bitOrdering_matches_4 (high : Ordering) (a : Bool) (b : Bool) (x : ℕ) (y : ℕ) (h : OAI.EditApproximation.orderingMatches high x y) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitOrdering high a b) (a.toNat + 2 * x) (b.toNat + 2 * y) := by    rcases h with ⟨rfl, h⟩ | ⟨rfl, rfl⟩ | ⟨rfl, h⟩    · exact Or.inl ⟨rfl, by cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩    · cases a <;> cases b <;> simp [OAI.EditApproximation.bitOrdering, OAI.EditApproximation.orderingMatches]    · exact Or.inr (Or.inr ⟨rfl, by        cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩)  have proof_bitCompareWithWork_matches_5 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitCompareWithWork left right).1 (OAI.EditApproximation.bitWordValue left) (OAI.EditApproximation.bitWordValue right) := by    induction left generalizing right with    | nil =>      simp only [OAI.EditApproximation.bitCompareWithWork]      induction right with      | nil => (simp [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.orderingMatches, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        simpa only [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareNilLeftWithWork bs).1 false b 0 (OAI.EditApproximation.bitWordValue bs) ih    | cons a as ih =>      cases right with      | nil =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as []).1 a false (OAI.EditApproximation.bitWordValue as) 0 (ih [])      | cons b bs =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue] using          proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as bs).1 a b (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs) (ih bs)  have proof_bitCompareWithWork_eq_3 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .eq ↔ OAI.EditApproximation.bitWordValue left = OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_binaryNaturalCompareWithWork_eq_73 (a : ℕ) (b : ℕ) :      (OAI.EditApproximation.binaryNaturalCompareWithWork a b).1 = .eq ↔ a = b := by    simpa only [OAI.EditApproximation.binaryNaturalCompareWithWork, proof_bitWordValue_bits_15] using proof_bitCompareWithWork_eq_3 a.bits b.bits  have proof_naturalEqualWithWork_value_74 (a : ℕ) (b : ℕ) :      (OAI.EditApproximation.naturalEqualWithWork a b).1 = true ↔ a = b := by    simp only [OAI.EditApproximation.naturalEqualWithWork, decide_eq_true_eq, proof_binaryNaturalCompareWithWork_eq_73]  have proof_coordinateEqualWithWork_value_75 {M : ℕ} {n : ℕ} (a : Prod.{0, 0} (Fin M) (OAI.EditApproximation.TargetInterval n)) (b : Prod.{0, 0} (Fin M) (OAI.EditApproximation.TargetInterval n)) :      (OAI.EditApproximation.coordinateEqualWithWork a b).1 = true ↔ a = b := by    simp only [OAI.EditApproximation.coordinateEqualWithWork, Bool.and_eq_true, proof_naturalEqualWithWork_value_74]    constructor    · rintro ⟨⟨hc, hl⟩, hh⟩      have hi : a.1 = b.1 := Fin.ext hc      have hq : a.2 = b.2 := by        rcases a with ⟨i, q⟩        rcases b with ⟨j, r⟩        cases q        cases r        cases hl        cases hh        rfl      exact Prod.ext hi hq    · intro h      subst b      exact ⟨⟨rfl, rfl⟩, rfl⟩  have proof_bandCoordinatesWithWork_value_68 {M : ℕ} {n : ℕ} (band : List.{0} (Fin M → OAI.EditApproximation.TargetInterval n)) :      (OAI.EditApproximation.BinaryFraction.bandCoordinatesWithWork band).1 = OAI.EditApproximation.listedBandCoordinates band := by    simp only [OAI.EditApproximation.BinaryFraction.bandCoordinatesWithWork, proof_dedupByWithWork_value_72 _ proof_coordinateEqualWithWork_value_75,      proof_arithmeticFlatMapWithWork_value_69, proof_arithmeticMapWithWork_value_70, OAI.EditApproximation.listedBandCoordinates,      List.ofFn_eq_map]  have proof_bitAdder_value_1 (a : Bool) (b : Bool) (carry : Bool) :      (OAI.EditApproximation.bitSum a b carry).toNat + 2 * (OAI.EditApproximation.bitCarry a b carry).toNat =        a.toNat + b.toNat + carry.toNat := by    cases a <;> cases b <;> cases carry <;> decide  have proof_bitAddWithWork_value_2 (left : List.{0} Bool) (right : List.{0} Bool) (carry : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitAddWithWork left right carry).1 =        OAI.EditApproximation.bitWordValue left + OAI.EditApproximation.bitWordValue right + carry.toNat := by    induction left generalizing right carry with    | nil =>      simp only [OAI.EditApproximation.bitAddWithWork]      induction right generalizing carry with      | nil => cases carry <;> simp [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue]      | cons b bs ih =>        simp only [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 false b carry        simp only [Bool.toNat_false] at h        omega    | cons a as ih =>      cases right with      | nil =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a false carry        simp only [Bool.toNat_false] at h        omega      | cons b bs =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a b carry        omega  have proof_binaryNaturalAddWithWork_value_52 (a : ℕ) (b : ℕ) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalAddWithWork a b).1 = a + b := by    simp [OAI.EditApproximation.binaryNaturalAddWithWork, proof_bitAddWithWork_value_2, proof_bitWordValue_bits_15]  have proof_onlineIndexSetupWithWork_value_129 {M : ℕ} {n : ℕ} (H : ℕ) (band : List.{0} (Fin M → OAI.EditApproximation.TargetInterval n)) :      (OAI.EditApproximation.BinaryFraction.onlineIndexSetupWithWork H band).1 = H + (OAI.EditApproximation.listedBandCoordinates band).length + 2 := by    simp only [OAI.EditApproximation.BinaryFraction.onlineIndexSetupWithWork, proof_binaryNaturalAddWithWork_value_52, proof_bandCoordinatesWithWork_value_68]  exact    let band := (OAI.EditApproximation.BinaryFraction.preparedRepresentativeReadWithWork parent center (parent.hi - parent.lo) b P      tau (OAI.EditApproximation.BinaryFraction.inversePowerTwo exponent) child).1    let G := (OAI.EditApproximation.BinaryFraction.onlineIndexSetupWithWork H band).1    let accepted := (OAI.EditApproximation.BinaryFraction.reduceOnlineIntegerWithWork (G ^ 80) (by      dsimp only [G]; rw [proof_onlineIndexSetupWithWork_value_129]; positivity) integer).1    OAI.EditApproximation.BinaryFraction.preparedRepresentativeReadAllocation parent center (parent.hi - parent.lo) b P      tau (OAI.EditApproximation.BinaryFraction.inversePowerTwo exponent) child childAllocation +      OAI.EditApproximation.BinaryFraction.onlineIndexSetupAllocation H band + OAI.EditApproximation.reduceOnlineIntegerAllocation (G ^ 80) integer +      if hband : band = [] then 0 else        OAI.EditApproximation.BinaryFraction.preparedUnskippedReadAllocation parent center b P exponent tau (OAI.EditApproximation.BinaryFraction.nat F)          child initial childAllocation initialAllocation +        if (OAI.EditApproximation.BinaryFraction.preparedUnskippedReadWithWorkRaw parent b P exponent tau (OAI.EditApproximation.BinaryFraction.nat F) child initial center).1.isSome then          OAI.EditApproximation.BinaryFraction.countedSampledOnlineAllocation center b initial initialAllocation table tableAllocation eta kappa            band hband G (G ^ 80) t accepted + 1        else 0end OAI.EditApproximation.BinaryFractionendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditDistortioninductive Step (substitutions : Bool) {Alpha : Type u} : List Alpha → List Alpha → Prop  | insert (p q : List Alpha) (a : Alpha) : Step substitutions (p ++ q) (p ++ a :: q)  | delete (p q : List Alpha) (a : Alpha) : Step substitutions (p ++ a :: q) (p ++ q)  | substitute (h : substitutions = true) (p q : List Alpha) (a b : Alpha) :      Step substitutions (p ++ a :: q) (p ++ b :: q)inductive Script (substitutions : Bool) {Alpha : Type u} : ℕ → List Alpha → List Alpha → Prop  | nil (x : List Alpha) : Script substitutions 0 x x  | cons {n : ℕ} {x y z : List Alpha} (first : OAI.EditDistortion.Step substitutions x y)      (rest : Script substitutions n y z) : Script substitutions (n + 1) x znoncomputable def edit {Alpha : Type u} (x y : List Alpha) : ℕ :=  sInf {n | Script true n x y}end OAI.EditDistortionendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditDistortionvariable {Alpha : Type u} {s : Bool}noncomputable def cost (s : Bool) (x y : List Alpha) : ℕ := sInf {n | Script s n x y}end OAI.EditDistortionendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.CoarseSourceTreeopen Finset EditDistortiondef word {B : ℕ} {α : Type u} : {D : ℕ} → OAI.EditApproximation.CoarseSourceTree B α D → List α  | _, .leaf letter => letter.toList  | _, .branch children => (List.ofFn fun i => word (children i)).flattenend OAI.EditApproximation.CoarseSourceTreeendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationdef coarseLabelCount {B : ℕ} {α : Type u_1} (Q lam : ℚ) :    {d : ℕ} → OAI.EditApproximation.CoarseSourceTree B α d → OAI.EditApproximation.CoarseThresholdDraws B d → ℚ → ℕ  | _, tree, draws, allowance =>    if (tree.word.length : ℚ) ≤ allowance then 0 else    match tree, draws with    | .leaf _, _ => 0    | .branch children, (draws, below) => B +      OAI.EditApproximation.coarseLabelChildren Q lam allowance (fun child => coarseLabelCount Q lam child)        (List.ofFn fun i => (children i, draws i, below i))def coarseIndexedEntryBinaryCost (N B d : ℕ) [NeZero B] (x y : List ℕ)    (draws : OAI.EditApproximation.CoarseGuessIndex (OAI.EditApproximation.coarseEntryWidth x y) → OAI.EditApproximation.CoarseThresholdDraws B d) : ℕ :=  (OAI.EditApproximation.BinaryFraction.coarseIndexedInitialWithWork (OAI.EditApproximation.inputHeight N ^ 4) (64 * OAI.EditApproximation.inputHeight N) N    (Nat.pos_of_neZero B) (pow_pos (Nat.two_pow_pos _) _)    (Nat.mul_pos (by decide) (Nat.two_pow_pos _)) x y draws).2def coarseInitialLabelCount {α : Type u_1} [DecidableEq α]    (B d : ℕ) (Q lam : ℚ) (x y : List α)    (draws : OAI.EditApproximation.CoarseGuessIndex (OAI.EditApproximation.coarseEntryWidth x y) → OAI.EditApproximation.CoarseThresholdDraws B d) : ℕ :=  if 2 * x.length < y.length then 0  else if x = y then 0  else ∑ i, OAI.EditApproximation.coarseLabelCount Q lam (OAI.EditApproximation.coarseEntryTree B d x y) (draws i)    (OAI.EditApproximation.coarseGuess (OAI.EditApproximation.coarseEntryWidth x y) i)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen Finset EditDistortiondef coarseChildrenCost {B D : ℕ} {α : Type u} (k : ℕ)    (value : OAI.EditApproximation.CoarseSourceTree B α D → ℕ → Fin (2 * k + 1) → ℕ) :    List (OAI.EditApproximation.CoarseSourceTree B α D) → ℕ → Fin (2 * k + 1) → ℕ  | [], _, _ => 0  | child :: rest, start, shift =>    univ.inf' univ_nonempty (fun next => value child start next + 2 * Nat.dist shift.val next.val) +      coarseChildrenCost k value rest (start + child.word.length) shiftdef coarseShiftCost {B : ℕ} {α : Type u} [DecidableEq α] (k : ℕ) (frame : List (Option α)) :    {D : ℕ} → OAI.EditApproximation.CoarseSourceTree B α D → ℕ → Fin (2 * k + 1) → ℕ  | _, .leaf none, _, _ => 0  | _, .leaf (some letter), start, shift =>    if (frame[start + shift.val]?.getD none) = some letter then 0 else 1  | _, .branch children, start, shift =>    OAI.EditApproximation.coarseChildrenCost k (fun child => coarseShiftCost k frame child)      (List.ofFn children) start shiftend OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen Finsetopen EditDistortioninstance targetIntervalFintype (n : ℕ) : Fintype (OAI.EditApproximation.TargetInterval n) := by  have proof_targetStates_complete_12 (n : ℕ) (q : OAI.EditApproximation.TargetInterval n) : q ∈ OAI.EditApproximation.targetStates n := by    apply List.mem_flatMap.mpr    refine ⟨q.lo, List.mem_range.mpr (Nat.lt_succ_of_le (q.ordered.trans q.valid)), ?_⟩    apply List.mem_filterMap.mpr    refine ⟨q.hi, List.mem_range.mpr (Nat.lt_succ_of_le q.valid), ?_⟩    rw [OAI.EditApproximation.makeTargetState, dite_eq_left (show q.lo ≤ q.hi ∧ q.hi ≤ n from ⟨q.ordered, q.valid⟩)]  exact    Fintype.ofList (OAI.EditApproximation.targetStates n) (proof_targetStates_complete_12 n)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.UnskippedBandopen Finsetdef actions {α : Type u_1} {source target : List α} {M : ℕ}    {parent : OAI.EditApproximation.TargetInterval source.length} {b P thetaExponent : ℕ}    {tau F : ℚ} {child initial : Fin M → OAI.EditApproximation.TargetInterval target.length → ℚ}    (member : OAI.EditApproximation.UnskippedBand source target parent b P thetaExponent tau F child initial) :=  OAI.EditApproximation.representativeBandActions source target parent member.center b P tau    ((2 : ℚ) ^ (-(thetaExponent : ℤ))) childdef envelope {α : Type u_1} {source target : List α} {M : ℕ}    {parent : OAI.EditApproximation.TargetInterval source.length} {b P thetaExponent : ℕ}    {tau F : ℚ} {child initial : Fin M → OAI.EditApproximation.TargetInterval target.length → ℚ}    (member : OAI.EditApproximation.UnskippedBand source target parent b P thetaExponent tau F child initial) (i : Fin M) : ℚ :=  OAI.EditApproximation.bandChildEnvelope b member.actions initial idef rounded {α : Type u_1} {source target : List α} {M : ℕ}    {parent : OAI.EditApproximation.TargetInterval source.length} {b P thetaExponent : ℕ}    {tau F : ℚ} {child initial : Fin M → OAI.EditApproximation.TargetInterval target.length → ℚ}    (member : OAI.EditApproximation.UnskippedBand source target parent b P thetaExponent tau F child initial) :    Fin M → OAI.EditApproximation.TargetInterval target.length :=  OAI.EditApproximation.canonicalRoundedBandAction thetaExponent b member.actions member.nonempty initialdef rationalAction {α : Type u_1} {source target : List α} {M b P thetaExponent : ℕ}    {parent : OAI.EditApproximation.TargetInterval source.length} {tau F : ℚ}    {child initial : Fin M → OAI.EditApproximation.TargetInterval target.length → ℚ}    (member : OAI.EditApproximation.UnskippedBand source target parent b P thetaExponent tau F child initial) :    OAI.EditApproximation.RationalBellmanAction (OAI.EditApproximation.TargetInterval target.length) (Fin M × OAI.EditApproximation.TargetInterval target.length) M :=  ⟨member.center, OAI.EditApproximation.endpointActionConnection member.center member.rounded, fun i => (i, member.rounded i)⟩end OAI.EditApproximation.UnskippedBandendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen Finset MeasureTheory ProbabilityTheoryvariable {α : Type u_1} {source target : List α} {M b P thetaExponent : ℕ} {parent : TargetInterval source.length} {tau F : ℚ} {child initial : Fin M → TargetInterval target.length → ℚ}def unskippedGroupEstimate {T : ℕ} (scales : Fin T → ℚ) (count : Fin T → ℕ)    (value : Fin M → OAI.EditApproximation.TargetInterval target.length → ℚ)    (member : OAI.EditApproximation.UnskippedBand source target parent b P thetaExponent tau F child initial)    (draw : ∀ scale : Fin T, Fin (count scale) → Fin M) : ℚ :=  OAI.EditApproximation.groupMemberEstimate scales count (OAI.EditApproximation.endpointActionConnection member.center member.rounded)    member.envelope (fun i => value i (member.rounded i)) drawend OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen Finset MeasureTheory ProbabilityTheoryvariable {α : Type*} {source target : List α} {M b P thetaExponent : ℕ} {parent : TargetInterval source.length} {tau F : ℚ} {child initial : Fin M → TargetInterval target.length → ℚ}def groupDyadicScaleAt (M b : ℕ) (F : ℚ) (i : Fin (OAI.EditApproximation.groupDyadicScales M b F).length) : ℚ :=  (OAI.EditApproximation.groupDyadicScales M b F).get iend OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationabbrev CellGroupDraws (M F Q : ℕ) := ∀ b : ℕ, (ℕ × ℕ) →  ∀ scale : Fin (OAI.EditApproximation.groupDyadicScales M b F).length,    Fin (OAI.EditApproximation.groupSampleCount M Q b (OAI.EditApproximation.groupDyadicScaleAt M b F scale)) → Fin Mabbrev cellScaleReadDraw (M b Q : ℕ) (F : ℚ) :=  ∀ (t : Fin (OAI.EditApproximation.groupDyadicScales M b F).length),    Fin (OAI.EditApproximation.groupSampleCount M Q b (OAI.EditApproximation.groupDyadicScaleAt M b F t)) → Fin M × ℕabbrev GroupScalarKey (M F Q : ℕ) :=  Σ key : ℕ × (ℕ × ℕ), Σ scale : Fin (OAI.EditApproximation.groupDyadicScales M key.1 F).length,    Fin (OAI.EditApproximation.groupSampleCount M Q key.1 (OAI.EditApproximation.groupDyadicScaleAt M key.1 F scale))abbrev CountedCellGroupDraws (M F Q : ℕ) :=  ∀ b : ℕ, ∀ _cell : ℕ × ℕ, ∀ scale : Fin (OAI.EditApproximation.groupDyadicScales M b F).length,    Fin (OAI.EditApproximation.groupSampleCount M Q b (OAI.EditApproximation.groupDyadicScaleAt M b F scale)) → Fin M × ℕabbrev CellGroupSourceAllocations (M F Q : ℕ) := ∀ (b : ℕ) (_cell : ℕ × ℕ),  ∀ t : Fin (OAI.EditApproximation.groupDyadicScales M b F).length,    Fin (OAI.EditApproximation.groupSampleCount M Q b (OAI.EditApproximation.groupDyadicScaleAt M b F t)) → ℕabbrev CountedCellGroupAllocations (M F Q : ℕ) :=  ∀ b : ℕ, ∀ _cell : ℕ × ℕ, ∀ scale : Fin (OAI.EditApproximation.groupDyadicScales M b F).length,    Fin (OAI.EditApproximation.groupSampleCount M Q b (OAI.EditApproximation.groupDyadicScaleAt M b F scale)) → ℕabbrev CellGroupReadDraws (M F Q : ℕ) := ∀ (b : ℕ) (_cell : ℕ × ℕ),  OAI.EditApproximation.cellScaleReadDraw M b Q Fdef groupScalarKeys (M F Q : ℕ) (groups : List (ℕ × (ℕ × ℕ))) : List (OAI.EditApproximation.GroupScalarKey M F Q) :=  groups.flatMap fun (key : ℕ × (ℕ × ℕ)) =>    (List.finRange (OAI.EditApproximation.groupDyadicScales M key.1 F).length).flatMap      fun (scale : Fin (OAI.EditApproximation.groupDyadicScales M key.1 F).length) =>        (List.finRange (OAI.EditApproximation.groupSampleCount M Q key.1 (OAI.EditApproximation.groupDyadicScaleAt M key.1 F scale))).map          fun sample => Sigma.mk key (Sigma.mk scale sample)noncomputable def groupDrawFromValues {M F Q : ℕ} [NeZero M]    (keys : List (OAI.EditApproximation.GroupScalarKey M F Q)) (values : List ℚ) : OAI.EditApproximation.CellGroupDraws M F Q := by  classical  exact fun b cell scale sample => Fin.ofNat M ⌊OAI.EditApproximation.finiteAnswerTable keys values ⟨(b, cell), scale, sample⟩⌋₊def queryGroupKeyEqualWithWork {M F Q : ℕ} (a b : OAI.EditApproximation.GroupScalarKey M F Q) : Bool × ℕ :=  let scale := OAI.EditApproximation.naturalEqualWithWork a.1.1 b.1.1  let lo := OAI.EditApproximation.naturalEqualWithWork a.1.2.1 b.1.2.1  let hi := OAI.EditApproximation.naturalEqualWithWork a.1.2.2 b.1.2.2  let label := OAI.EditApproximation.naturalEqualWithWork a.2.1.val b.2.1.val  let sample := OAI.EditApproximation.naturalEqualWithWork a.2.2.val b.2.2.val  (scale.1 && lo.1 && hi.1 && label.1 && sample.1,    scale.2 + lo.2 + hi.2 + label.2 + sample.2 + 4)def queryGroupKeyEqualAllocation {M F Q : ℕ} (a b : OAI.EditApproximation.GroupScalarKey M F Q) : ℕ :=  OAI.EditApproximation.naturalEqualAllocation a.1.1 b.1.1 + OAI.EditApproximation.naturalEqualAllocation a.1.2.1 b.1.2.1 +    OAI.EditApproximation.naturalEqualAllocation a.1.2.2 b.1.2.2 + OAI.EditApproximation.naturalEqualAllocation a.2.1.val b.2.1.val +    OAI.EditApproximation.naturalEqualAllocation a.2.2.val b.2.2.val + 4end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.BinaryFractionopen Finsetdef queryGroupKeySamplesWithWork (M F Q eM eb eF : ℕ)    (hM : M = 2 ^ eM) (hF : F = 2 ^ eF) (cell : ℕ × ℕ) :    List (OAI.EditApproximation.GroupScalarKey M F Q) × ℕ := by  have proof_representation_value_32 (a : OAI.EditApproximation.BinaryFraction) : a.representation.value = a.value := rfl  have proof_eq_of_num_den_33 {a : OAI.EditApproximation.UnreducedRational} {b : OAI.EditApproximation.UnreducedRational} (hnum : Eq.{1} a.num b.num) (hden : Eq.{1} a.den b.den) : a = b := by    cases a    cases b    cases hnum    cases hden    rfl  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_value_ofInt_46 (a : ℤ) : (OAI.EditApproximation.SignedBinary.ofInt a).value = a := by    by_cases h : a < 0    · simpa only [OAI.EditApproximation.SignedBinary.ofInt, OAI.EditApproximation.SignedBinary.value, proof_bitWordValue_bits_15, OAI.EditApproximation.signedMagnitude, h, decide_true,        ↓reduceIte] using (Int.eq_neg_natAbs_of_nonpos (le_of_lt h)).symm    · simpa only [OAI.EditApproximation.SignedBinary.ofInt, OAI.EditApproximation.SignedBinary.value, proof_bitWordValue_bits_15, OAI.EditApproximation.signedMagnitude, h, decide_false,        Bool.false_eq_true, ↓reduceIte] using (Int.eq_natAbs_of_nonneg (le_of_not_gt h)).symm  have proof_nat_representation_47 (n : ℕ) : (OAI.EditApproximation.BinaryFraction.nat n).representation = OAI.EditApproximation.UnreducedRational.nat n := by    apply proof_eq_of_num_den_33    · change (OAI.EditApproximation.SignedBinary.ofInt (n : ℤ)).value = (n : ℤ)      exact proof_value_ofInt_46 _    · rfl  have proof_value_nat_48 (n : ℕ) : (OAI.EditApproximation.UnreducedRational.nat n).value = n := by (simp [OAI.EditApproximation.UnreducedRational.nat, OAI.EditApproximation.UnreducedRational.value])  have proof_nat_value_49 (n : ℕ) : (OAI.EditApproximation.BinaryFraction.nat n).value = (n : ℚ) := by    rw [← proof_representation_value_32, proof_nat_representation_47, proof_value_nat_48]  have proof_arithmeticMapWithWork_value_70 {α : Type 0} {β : Type 0} (f : α → Prod.{0, 0} β ℕ) (values : List.{0} α) :      (OAI.EditApproximation.arithmeticMapWithWork f values).1 = values.map (fun a => (f a).1) := by    induction values with    | nil => rfl    | cons a rest ih => simp only [OAI.EditApproximation.arithmeticMapWithWork, ih, List.map_cons]  have proof_powerTwoWord_value_13 (n : ℕ) : OAI.EditApproximation.bitWordValue (OAI.EditApproximation.powerTwoWord n) = 2 ^ n := by    induction n with    | zero => (simp [OAI.EditApproximation.powerTwoWord, OAI.EditApproximation.bitWordValue])    | succ n ih =>      (simp only [OAI.EditApproximation.powerTwoWord, List.replicate_succ, List.cons_append, OAI.EditApproximation.bitWordValue,        Bool.toNat_false, zero_add] at *)      rw [ih, pow_succ]      omega  have proof_inversePowerTwo_value_89 (n : ℕ) : (OAI.EditApproximation.BinaryFraction.inversePowerTwo n).value = (2 : ℚ) ^ (-(n : ℤ)) := by    (simp only [OAI.EditApproximation.BinaryFraction.inversePowerTwo, OAI.EditApproximation.BinaryFraction.value, OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, Bool.false_eq_true,      ↓reduceIte, OAI.EditApproximation.bitWordValue, Bool.toNat_true,      Int.cast_natCast, proof_powerTwoWord_value_13, Nat.cast_pow, Nat.cast_ofNat, zpow_neg, zpow_natCast])    norm_num [one_div]  have proof_signedPowerTwoWithWork_value_90 (e : ℤ) :      (OAI.EditApproximation.BinaryFraction.signedPowerTwoWithWork e).1.value = (2 : ℚ) ^ e := by    unfold OAI.EditApproximation.BinaryFraction.signedPowerTwoWithWork    split_ifs with h    · change (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.powerTwoWord e.toNat) : ℚ) / 1 = (2 : ℚ) ^ e      rw [div_one, proof_powerTwoWord_value_13, Nat.cast_pow, Nat.cast_ofNat, ← zpow_natCast,        Int.toNat_of_nonneg h]    · rw [proof_inversePowerTwo_value_89, Int.toNat_of_nonneg        (show 0 ≤ -e from neg_nonneg.mpr (le_of_lt (lt_of_not_ge h))), neg_neg]  have proof_groupScalesWithWork_value_91 (eM : ℕ) (eb : ℕ) (eF : ℕ) :      ((OAI.EditApproximation.BinaryFraction.groupScalesWithWork eM eb eF).1.map OAI.EditApproximation.BinaryFraction.value) =        OAI.EditApproximation.groupDyadicScales (2 ^ eM) (2 ^ eb) ((2 : ℚ) ^ eF) := by    have hlower : ((2 ^ eb : ℕ) : ℚ) / (2 ^ eM : ℕ) = (2 : ℚ) ^ ((eb : ℤ) - eM) := by      rw [Nat.cast_pow, Nat.cast_pow, Nat.cast_ofNat, zpow_sub₀ (by norm_num : (2 : ℚ) ≠ 0),        zpow_natCast, zpow_natCast]    have hupper : (64 : ℚ) * (2 : ℚ) ^ eF * (2 ^ eb : ℕ) =        (2 : ℚ) ^ ((6 + eF + eb : ℕ) : ℤ) := by      rw [Nat.cast_pow, Nat.cast_ofNat, zpow_natCast, pow_add, pow_add]      norm_num    have hlog : Int.log 2 ((2 : ℚ) ^ ((6 + eF + eb : ℕ) : ℤ)) = ((6 + eF + eb : ℕ) : ℤ) := by      simpa only [Nat.cast_ofNat] using Int.log_zpow (R := ℚ) (by decide : 1 < 2) ((6 + eF + eb : ℕ) : ℤ)    have hclog : Int.clog 2 ((2 : ℚ) ^ ((eb : ℤ) - eM)) = (eb : ℤ) - eM := by      simpa only [Nat.cast_ofNat] using Int.clog_zpow (R := ℚ) (by decide : 1 < 2) ((eb : ℤ) - eM)    simp only [OAI.EditApproximation.BinaryFraction.groupScalesWithWork, proof_arithmeticMapWithWork_value_70, List.map_map,      Function.comp_def, proof_signedPowerTwoWithWork_value_90, OAI.EditApproximation.groupDyadicScales, hlower, hupper, hlog, hclog]  have proof_computedGroupScales_value_87 (M : ℕ) (b : ℕ) (F : ℕ) (eM : ℕ) (eb : ℕ) (eF : ℕ) (hM : Eq.{1} M (HPow.hPow.{0, 0, 0} 2 eM)) (hb : Eq.{1} b (HPow.hPow.{0, 0, 0} 2 eb)) (hF : Eq.{1} F (HPow.hPow.{0, 0, 0} 2 eF)) :      (OAI.EditApproximation.BinaryFraction.groupScalesWithWork eM eb eF).1.map OAI.EditApproximation.BinaryFraction.value = OAI.EditApproximation.groupDyadicScales M b (OAI.EditApproximation.BinaryFraction.nat F).value := by    rw [proof_nat_value_49, hM, hb, hF, Nat.cast_pow, Nat.cast_ofNat]    exact proof_groupScalesWithWork_value_91 eM eb eF  have proof_bitOrdering_matches_4 (high : Ordering) (a : Bool) (b : Bool) (x : ℕ) (y : ℕ) (h : OAI.EditApproximation.orderingMatches high x y) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitOrdering high a b) (a.toNat + 2 * x) (b.toNat + 2 * y) := by    rcases h with ⟨rfl, h⟩ | ⟨rfl, rfl⟩ | ⟨rfl, h⟩    · exact Or.inl ⟨rfl, by cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩    · cases a <;> cases b <;> simp [OAI.EditApproximation.bitOrdering, OAI.EditApproximation.orderingMatches]    · exact Or.inr (Or.inr ⟨rfl, by        cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩)  have proof_bitCompareWithWork_matches_5 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitCompareWithWork left right).1 (OAI.EditApproximation.bitWordValue left) (OAI.EditApproximation.bitWordValue right) := by    induction left generalizing right with    | nil =>      simp only [OAI.EditApproximation.bitCompareWithWork]      induction right with      | nil => (simp [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.orderingMatches, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        simpa only [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareNilLeftWithWork bs).1 false b 0 (OAI.EditApproximation.bitWordValue bs) ih    | cons a as ih =>      cases right with      | nil =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as []).1 a false (OAI.EditApproximation.bitWordValue as) 0 (ih [])      | cons b bs =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue] using          proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as bs).1 a b (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs) (ih bs)  have proof_bitCompareWithWork_lt_16 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .lt ↔ OAI.EditApproximation.bitWordValue left < OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_wordLEWithWork_value_26 (a : List.{0} Bool) (b : List.{0} Bool) :      (OAI.EditApproximation.wordLEWithWork a b).1 = true ↔ OAI.EditApproximation.bitWordValue a ≤ OAI.EditApproximation.bitWordValue b := by    simp only [OAI.EditApproximation.wordLEWithWork, Bool.not_eq_true', decide_eq_false_iff_not,      proof_bitCompareWithWork_lt_16, not_lt]  have proof_wordMinWithWork_value_29 (a : List.{0} Bool) (b : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.wordMinWithWork a b).1 = min (OAI.EditApproximation.bitWordValue a) (OAI.EditApproximation.bitWordValue b) := by    unfold OAI.EditApproximation.wordMinWithWork    dsimp only    split_ifs with h    · exact (min_eq_left ((proof_wordLEWithWork_value_26 a b).mp h)).symm    · exact (min_eq_right (le_of_not_ge (fun hle => h ((proof_wordLEWithWork_value_26 a b).mpr hle)))).symm  have proof_bitSubtractor_value_17 (a : Bool) (b : Bool) (borrow : Bool) :      a.toNat + 2 * (OAI.EditApproximation.bitBorrow a b borrow).toNat =        b.toNat + borrow.toNat + (OAI.EditApproximation.bitDifference a b borrow).toNat := by    cases a <;> cases b <;> cases borrow <;> decide  have proof_bitSubtractionRippleEquation_18 (a : ℕ) (b : ℕ) (borrow : ℕ) (nextBorrow : ℕ) (difference : ℕ) (left : ℕ) (right : ℕ) (result : ℕ) (tail : ℕ) (htail : Eq.{1} (HAdd.hAdd.{0, 0, 0} (HAdd.hAdd.{0, 0, 0} result right) nextBorrow) (HAdd.hAdd.{0, 0, 0} left tail)) (hbit : Eq.{1} (HAdd.hAdd.{0, 0, 0} a (HMul.hMul.{0, 0, 0} 2 nextBorrow))    (HAdd.hAdd.{0, 0, 0} (HAdd.hAdd.{0, 0, 0} b borrow) difference)) :      (difference + 2 * result) + (b + 2 * right) + borrow =        (a + 2 * left) + 2 * tail := by    omega  have proof_bitSubtractWithWork_value_19 (left : List.{0} Bool) (right : List.{0} Bool) (borrow : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork left right borrow).1 + OAI.EditApproximation.bitWordValue right + borrow.toNat =        OAI.EditApproximation.bitWordValue left + 2 ^ max left.length right.length *          (OAI.EditApproximation.bitSubtractWithWork left right borrow).2.1.toNat := by    induction left generalizing right borrow with    | nil =>      induction right generalizing borrow with      | nil => (simp [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitSubtractNilLeftWithWork, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        have h := ih (OAI.EditApproximation.bitBorrow false b borrow)        have hb := proof_bitSubtractor_value_17 false b borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitSubtractNilLeftWithWork, OAI.EditApproximation.bitWordValue,          List.length_nil, List.length_cons, Nat.zero_max, pow_succ, Bool.toNat_false] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 0 b.toNat borrow.toNat (OAI.EditApproximation.bitBorrow false b borrow).toNat          (OAI.EditApproximation.bitDifference false b borrow).toNat 0 (OAI.EditApproximation.bitWordValue bs)          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractNilLeftWithWork bs (OAI.EditApproximation.bitBorrow false b borrow)).1)          (2 ^ bs.length * (OAI.EditApproximation.bitSubtractNilLeftWithWork bs (OAI.EditApproximation.bitBorrow false b borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_zero, Nat.add_zero, Nat.zero_add, Nat.mul_assoc,          Nat.mul_left_comm] using hs    | cons a as ih =>      cases right with      | nil =>        have h := ih [] (OAI.EditApproximation.bitBorrow a false borrow)        have hb := proof_bitSubtractor_value_17 a false borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitWordValue, List.length_nil, List.length_cons,          Nat.max_zero, pow_succ, Bool.toNat_false] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 a.toNat 0 borrow.toNat (OAI.EditApproximation.bitBorrow a false borrow).toNat          (OAI.EditApproximation.bitDifference a false borrow).toNat (OAI.EditApproximation.bitWordValue as) 0          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork as [] (OAI.EditApproximation.bitBorrow a false borrow)).1)          (2 ^ as.length * (OAI.EditApproximation.bitSubtractWithWork as [] (OAI.EditApproximation.bitBorrow a false borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_zero, Nat.add_zero, Nat.zero_add, Nat.mul_assoc,          Nat.mul_left_comm] using hs      | cons b bs =>        have h := ih bs (OAI.EditApproximation.bitBorrow a b borrow)        have hb := proof_bitSubtractor_value_17 a b borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitWordValue, List.length_cons, Nat.succ_max_succ,          pow_succ] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 a.toNat b.toNat borrow.toNat (OAI.EditApproximation.bitBorrow a b borrow).toNat          (OAI.EditApproximation.bitDifference a b borrow).toNat (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs)          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork as bs (OAI.EditApproximation.bitBorrow a b borrow)).1)          (2 ^ max as.length bs.length * (OAI.EditApproximation.bitSubtractWithWork as bs (OAI.EditApproximation.bitBorrow a b borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_assoc, Nat.mul_left_comm] using hs  have proof_bitWordValue_lt_pow_length_20 (bits : List.{0} Bool) : OAI.EditApproximation.bitWordValue bits < 2 ^ bits.length := by    induction bits with    | nil => (simp [OAI.EditApproximation.bitWordValue])    | cons bit bits ih =>      cases bit <;> (simp only [OAI.EditApproximation.bitWordValue, List.length_cons, pow_succ, Bool.toNat_false, Bool.toNat_true]) <;> omega  have proof_bitSubtractWithWork_length_21 (left : List.{0} Bool) (right : List.{0} Bool) (borrow : Bool) :      (OAI.EditApproximation.bitSubtractWithWork left right borrow).1.length = max left.length right.length := by    induction left generalizing right borrow with    | nil =>      simp only [OAI.EditApproximation.bitSubtractWithWork]      induction right generalizing borrow with      | nil => simp [OAI.EditApproximation.bitSubtractNilLeftWithWork]      | cons b bs ih => simp [OAI.EditApproximation.bitSubtractNilLeftWithWork, ih]    | cons a as ih =>      cases right with      | nil => simp [OAI.EditApproximation.bitSubtractWithWork, ih]      | cons b bs => simp [OAI.EditApproximation.bitSubtractWithWork, ih, Nat.succ_max_succ]  have proof_bitSubtractWithWork_sub_22 (left : List.{0} Bool) (right : List.{0} Bool) (h : LE.le.{0} (OAI.EditApproximation.bitWordValue right) (OAI.EditApproximation.bitWordValue left)) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork left right false).1 = OAI.EditApproximation.bitWordValue left - OAI.EditApproximation.bitWordValue right := by    have hvalue := proof_bitSubtractWithWork_value_19 left right false    have hlt := proof_bitWordValue_lt_pow_length_20 (OAI.EditApproximation.bitSubtractWithWork left right false).1    rw [proof_bitSubtractWithWork_length_21] at hlt    cases hb : (OAI.EditApproximation.bitSubtractWithWork left right false).2.1    · simp only [hb, Bool.toNat_false, Nat.mul_zero, Nat.add_zero] at hvalue      omega    · simp only [hb, Bool.toNat_true, Bool.toNat_false, Nat.mul_one, Nat.add_zero] at hvalue      omega  have proof_bitDivModWithWork_value_23 (divisor : List.{0} Bool) (bits : List.{0} Bool) (hd : LT.lt.{0} 0 (OAI.EditApproximation.bitWordValue divisor)) :      OAI.EditApproximation.bitWordValue bits = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).1 +        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 ∧        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 < OAI.EditApproximation.bitWordValue divisor := by    induction bits with    | nil => (simp [OAI.EditApproximation.bitDivModWithWork, OAI.EditApproximation.bitWordValue, hd])    | cons bit bits ih =>      let previous := OAI.EditApproximation.bitDivModWithWork divisor bits      let candidate := bit :: previous.2.1      have hp : OAI.EditApproximation.bitWordValue bits = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue previous.1 +          OAI.EditApproximation.bitWordValue previous.2.1 := ih.1      have hr : OAI.EditApproximation.bitWordValue previous.2.1 < OAI.EditApproximation.bitWordValue divisor := ih.2      have hc : OAI.EditApproximation.bitWordValue candidate < 2 * OAI.EditApproximation.bitWordValue divisor := by        dsimp only [candidate, OAI.EditApproximation.bitWordValue]        cases bit <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega      by_cases hlt : (OAI.EditApproximation.bitCompareWithWork candidate divisor).1 = .lt      · have hv := (proof_bitCompareWithWork_lt_16 candidate divisor).1 hlt        simp only [OAI.EditApproximation.bitDivModWithWork, show (OAI.EditApproximation.bitCompareWithWork (bit :: (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1)          divisor).1 = .lt from hlt, ↓reduceIte]        change OAI.EditApproximation.bitWordValue (bit :: bits) = OAI.EditApproximation.bitWordValue divisor *          OAI.EditApproximation.bitWordValue (false :: previous.1) + OAI.EditApproximation.bitWordValue candidate ∧ OAI.EditApproximation.bitWordValue candidate < _        constructor        · (simp only [OAI.EditApproximation.bitWordValue, Bool.toNat_false])          dsimp only [candidate, OAI.EditApproximation.bitWordValue]          nlinarith only [hp]        · exact hv      · have hv : OAI.EditApproximation.bitWordValue divisor ≤ OAI.EditApproximation.bitWordValue candidate := by          exact Nat.le_of_not_gt (fun h => hlt ((proof_bitCompareWithWork_lt_16 candidate divisor).2 h))        have hs := proof_bitSubtractWithWork_sub_22 candidate divisor hv        simp only [OAI.EditApproximation.bitDivModWithWork, show (OAI.EditApproximation.bitCompareWithWork (bit :: (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1)          divisor).1 ≠ .lt from hlt, ↓reduceIte]        change OAI.EditApproximation.bitWordValue (bit :: bits) = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue (true :: previous.1) +          OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork candidate divisor false).1 ∧          OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork candidate divisor false).1 < _        rw [hs]        constructor        · (simp only [OAI.EditApproximation.bitWordValue, Bool.toNat_true])          have he := Nat.sub_add_cancel hv          dsimp only [candidate, OAI.EditApproximation.bitWordValue] at he ⊢          nlinarith only [hp, he]        · omega  have proof_bitCompareWithWork_eq_3 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .eq ↔ OAI.EditApproximation.bitWordValue left = OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_bitAdder_value_1 (a : Bool) (b : Bool) (carry : Bool) :      (OAI.EditApproximation.bitSum a b carry).toNat + 2 * (OAI.EditApproximation.bitCarry a b carry).toNat =        a.toNat + b.toNat + carry.toNat := by    cases a <;> cases b <;> cases carry <;> decide  have proof_bitAddWithWork_value_2 (left : List.{0} Bool) (right : List.{0} Bool) (carry : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitAddWithWork left right carry).1 =        OAI.EditApproximation.bitWordValue left + OAI.EditApproximation.bitWordValue right + carry.toNat := by    induction left generalizing right carry with    | nil =>      simp only [OAI.EditApproximation.bitAddWithWork]      induction right generalizing carry with      | nil => cases carry <;> simp [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue]      | cons b bs ih =>        simp only [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 false b carry        simp only [Bool.toNat_false] at h        omega    | cons a as ih =>      cases right with      | nil =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a false carry        simp only [Bool.toNat_false] at h        omega      | cons b bs =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a b carry        omega  have proof_bitCeilDivWithWork_value_30 (divisor : List.{0} Bool) (bits : List.{0} Bool) (hd : LT.lt.{0} 0 (OAI.EditApproximation.bitWordValue divisor)) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitCeilDivWithWork divisor bits).1 =        ⌈((OAI.EditApproximation.bitWordValue bits : ℚ) / OAI.EditApproximation.bitWordValue divisor)⌉₊ := by    let q := OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).1    let r := OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1    have h := proof_bitDivModWithWork_value_23 divisor bits hd    have heq : OAI.EditApproximation.bitWordValue bits = OAI.EditApproximation.bitWordValue divisor * q + r := h.1    have hr : r < OAI.EditApproximation.bitWordValue divisor := h.2    have hdQ : (0 : ℚ) < OAI.EditApproximation.bitWordValue divisor := by exact_mod_cast hd    unfold OAI.EditApproximation.bitCeilDivWithWork    dsimp only    split_ifs with hz    · have hr0 : r = 0 := by        exact (proof_bitCompareWithWork_eq_3 (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 []).1 hz      have hratio : (OAI.EditApproximation.bitWordValue bits : ℚ) / OAI.EditApproximation.bitWordValue divisor = (q : ℚ) := by        apply (div_eq_iff hdQ.ne').mpr        exact_mod_cast (show OAI.EditApproximation.bitWordValue bits = q * OAI.EditApproximation.bitWordValue divisor by nlinarith only [heq, hr0])      rw [hratio]      exact (Nat.ceil_natCast q).symm    · have hr0 : r ≠ 0 := by        intro hzero        exact hz ((proof_bitCompareWithWork_eq_3 (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 []).2 hzero)      rw [proof_bitAddWithWork_value_2]      change q + 1 + 0 = _      simp only [Nat.add_zero]      symm      apply (Nat.ceil_eq_iff (by omega : q + 1 ≠ 0)).mpr      constructor      · simp only [Nat.add_sub_cancel]        rw [lt_div_iff₀ hdQ]        exact_mod_cast (show q * OAI.EditApproximation.bitWordValue divisor < OAI.EditApproximation.bitWordValue bits by          nlinarith only [heq, Nat.pos_of_ne_zero hr0])      · rw [div_le_iff₀ hdQ]        push_cast        exact_mod_cast (show OAI.EditApproximation.bitWordValue bits ≤ (q + 1) * OAI.EditApproximation.bitWordValue divisor by nlinarith only [heq, hr])  have proof_naturalCeilingWithWork_value_31 (a : OAI.EditApproximation.BinaryFraction) :      OAI.EditApproximation.bitWordValue (a.naturalCeilingWithWork).1 = ⌈a.value⌉₊ := by    cases hs : a.numerator.negative    · simpa only [OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork, hs, Bool.false_eq_true, ↓reduceIte,        OAI.EditApproximation.BinaryFraction.value, OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, Int.cast_natCast] using        proof_bitCeilDivWithWork_value_30 a.denominator a.numerator.bits a.denominator_pos    · have hn : a.value ≤ 0 := by        (simp only [OAI.EditApproximation.BinaryFraction.value, OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, hs, ↓reduceIte, Int.cast_neg, Int.cast_natCast])        exact div_nonpos_of_nonpos_of_nonneg (neg_nonpos.mpr (Nat.cast_nonneg _)) (Nat.cast_nonneg _)      (simp only [OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork, hs, ↓reduceIte, OAI.EditApproximation.bitWordValue])      exact (Nat.ceil_eq_zero.mpr hn).symm  have proof_trimBitWordWithWork_value_6 (bits : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.trimBitWordWithWork bits).1 = OAI.EditApproximation.bitWordValue bits := by    induction bits with    | nil => rfl    | cons bit bits ih =>      simp only [OAI.EditApproximation.trimBitWordWithWork]      split_ifs with h      · have ht : OAI.EditApproximation.bitWordValue bits = 0 := by rw [← ih, h.1]; rfl        simp [h.2, OAI.EditApproximation.bitWordValue, ht]      · (simp only [OAI.EditApproximation.bitWordValue, ih])  have proof_canonicalizeWithWork_representation_34 (a : OAI.EditApproximation.BinaryFraction) :      (OAI.EditApproximation.BinaryFraction.canonicalizeWithWork a).1.representation = a.representation := by    apply proof_eq_of_num_den_33    · (simp only [OAI.EditApproximation.BinaryFraction.canonicalizeWithWork, OAI.EditApproximation.BinaryFraction.representation, OAI.EditApproximation.SignedBinary.value, proof_trimBitWordWithWork_value_6])    · exact proof_trimBitWordWithWork_value_6 a.denominator  have proof_bitMulWithWork_value_0 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitMulWithWork left right).1 = OAI.EditApproximation.bitWordValue left * OAI.EditApproximation.bitWordValue right := by    induction left with    | nil => simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue]    | cons bit bits ih =>      cases bit <;> simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue, proof_bitAddWithWork_value_2, ih] <;> ring  have proof_mulWithWork_value_35 (a : OAI.EditApproximation.SignedBinary) (b : OAI.EditApproximation.SignedBinary) :      (a.mulWithWork b).1.value = a.value * b.value := by    simp only [OAI.EditApproximation.SignedBinary.mulWithWork, OAI.EditApproximation.SignedBinary.value, proof_bitMulWithWork_value_0]    cases a.negative <;> cases b.negative <;> simp [OAI.EditApproximation.signedMagnitude]  have proof_mulWithWork_representation_36 (a : OAI.EditApproximation.BinaryFraction) (b : OAI.EditApproximation.BinaryFraction) :      (a.mulWithWork b).1.representation = a.representation.mul b.representation := by    apply proof_eq_of_num_den_33    · exact proof_mulWithWork_value_35 a.numerator b.numerator    · exact proof_bitMulWithWork_value_0 a.denominator b.denominator  have proof_canonicalMulWithWork_representation_37 (a : OAI.EditApproximation.BinaryFraction) (b : OAI.EditApproximation.BinaryFraction) :      (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork a b).1.representation = a.representation.mul b.representation := by    rw [OAI.EditApproximation.BinaryFraction.canonicalMulWithWork, proof_canonicalizeWithWork_representation_34, proof_mulWithWork_representation_36]  have proof_zero_representation_38 : OAI.EditApproximation.BinaryFraction.zero.representation = OAI.EditApproximation.UnreducedRational.zero := by    apply proof_eq_of_num_den_33 <;> rfl  have proof_invWithWork_representation_39 (a : OAI.EditApproximation.BinaryFraction) :      (a.invWithWork).1.representation = a.representation.inv := by    unfold OAI.EditApproximation.BinaryFraction.invWithWork    dsimp only    split_ifs with h    · have hz : OAI.EditApproximation.bitWordValue a.numerator.bits = 0 := by        simpa only [OAI.EditApproximation.bitWordValue] using (proof_bitCompareWithWork_eq_3 a.numerator.bits []).1 h      have hv : a.numerator.value = 0 := by (simp [OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, hz])      (simp only [OAI.EditApproximation.UnreducedRational.inv, OAI.EditApproximation.BinaryFraction.representation, hv, ↓reduceDIte])      exact proof_zero_representation_38    · have hn : OAI.EditApproximation.bitWordValue a.numerator.bits ≠ 0 := by        intro hz        exact h ((proof_bitCompareWithWork_eq_3 a.numerator.bits []).2 (by simpa [OAI.EditApproximation.bitWordValue] using hz))      have hv : a.numerator.value ≠ 0 := by        cases hs : a.numerator.negative <;> (simp [OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, hs, hn])      (simp only [OAI.EditApproximation.UnreducedRational.inv, OAI.EditApproximation.BinaryFraction.representation, hv, ↓reduceDIte])      apply proof_eq_of_num_den_33      · cases hs : a.numerator.negative <;>          simp [OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, hs, Int.sign_natCast_of_ne_zero hn]      · cases hs : a.numerator.negative <;> (simp [OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, hs])  have proof_divWithWork_representation_40 (a : OAI.EditApproximation.BinaryFraction) (b : OAI.EditApproximation.BinaryFraction) :      (a.divWithWork b).1.representation = a.representation.div b.representation := by    (simp only [OAI.EditApproximation.BinaryFraction.divWithWork, proof_canonicalMulWithWork_representation_37, proof_invWithWork_representation_39,      OAI.EditApproximation.UnreducedRational.div])  have proof_value_mul_41 (a : OAI.EditApproximation.UnreducedRational) (b : OAI.EditApproximation.UnreducedRational) : (a.mul b).value = a.value * b.value := by    simp [OAI.EditApproximation.UnreducedRational.mul, OAI.EditApproximation.UnreducedRational.value, mul_div_mul_comm]  have proof_value_inv_42 (a : OAI.EditApproximation.UnreducedRational) : a.inv.value = a.value⁻¹ := by    by_cases h : a.num = 0    · simp [OAI.EditApproximation.UnreducedRational.inv, h, OAI.EditApproximation.UnreducedRational.value, OAI.EditApproximation.UnreducedRational.zero]    · have hn : (a.num.natAbs : ℚ) ≠ 0 := by exact_mod_cast (Int.natAbs_pos.mpr h).ne'      have hd : (a.den : ℚ) ≠ 0 := by exact_mod_cast a.den_pos.ne'      have hsign : ((a.num.sign : ℤ) : ℚ) * a.num = (a.num.natAbs : ℚ) := by        simpa only [Int.cast_mul, Int.cast_natCast] using          congrArg (fun z : ℤ => (z : ℚ)) (Int.sign_mul_self_eq_natAbs a.num)      simp only [OAI.EditApproximation.UnreducedRational.inv, h, ↓reduceDIte, OAI.EditApproximation.UnreducedRational.value]      push_cast      apply eq_inv_of_mul_eq_one_left      field_simp [hn, hd]      exact hsign  have proof_value_div_43 (a : OAI.EditApproximation.UnreducedRational) (b : OAI.EditApproximation.UnreducedRational) : (a.div b).value = a.value / b.value := by    simp [proof_value_mul_41, proof_value_inv_42, OAI.EditApproximation.UnreducedRational.div, div_eq_mul_inv]  have proof_divWithWork_value_44 (a : OAI.EditApproximation.BinaryFraction) (b : OAI.EditApproximation.BinaryFraction) :      (OAI.EditApproximation.BinaryFraction.divWithWork a b).1.value = a.value / b.value := by    rw [← proof_representation_value_32, proof_divWithWork_representation_40,      proof_value_div_43, proof_representation_value_32, proof_representation_value_32]  have proof_canonicalMulWithWork_value_45 (a : OAI.EditApproximation.BinaryFraction) (b : OAI.EditApproximation.BinaryFraction) :      (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork a b).1.value = a.value * b.value := by    rw [← proof_representation_value_32, proof_canonicalMulWithWork_representation_37,      proof_value_mul_41, proof_representation_value_32, proof_representation_value_32]  have proof_groupSampleCountWithWork_value_28 (M : ℕ) (Q : ℕ) (b : ℕ) (h : OAI.EditApproximation.BinaryFraction) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.BinaryFraction.groupSampleCountWithWork M Q b h).1 = OAI.EditApproximation.groupSampleCount M Q b h.value := by    simp only [OAI.EditApproximation.BinaryFraction.groupSampleCountWithWork, proof_wordMinWithWork_value_29, proof_bitWordValue_bits_15,      proof_naturalCeilingWithWork_value_31, proof_divWithWork_value_44, proof_canonicalMulWithWork_value_45,      proof_nat_value_49, OAI.EditApproximation.groupSampleCount]  have proof_queryScaleAt_value_88 (words : List.{0} OAI.EditApproximation.BinaryFraction) (scales : List.{0} ℚ) (h : Eq.{1} (List.map.{0, 0} OAI.EditApproximation.BinaryFraction.value words) scales) (i : Fin (List.length.{0} scales)) :      (OAI.EditApproximation.BinaryFraction.queryScaleAt words scales h i).value = scales[i.val] := by    subst scales    simp only [OAI.EditApproximation.BinaryFraction.queryScaleAt, List.getElem_map]  exact    let b := 2 ^ eb    let scales := OAI.EditApproximation.BinaryFraction.groupScalesWithWork eM eb eF    let hs : scales.1.map OAI.EditApproximation.BinaryFraction.value = OAI.EditApproximation.groupDyadicScales M b F := by      simpa only [proof_nat_value_49] using proof_computedGroupScales_value_87 M b F eM eb eF hM rfl hF    let hlen : scales.1.length = (OAI.EditApproximation.groupDyadicScales M b F).length := by      simpa only [List.length_map] using congrArg List.length hs    let indices := OAI.EditApproximation.queryFinRange scales.1.length (OAI.EditApproximation.groupDyadicScales M b F).length hlen    let samples := OAI.EditApproximation.arithmeticFlatMapWithWork (fun scale =>      let word := OAI.EditApproximation.BinaryFraction.queryScaleAt scales.1 (OAI.EditApproximation.groupDyadicScales M b F) hs scale      let count := OAI.EditApproximation.BinaryFraction.groupSampleCountWithWork M Q b word      let hc : OAI.EditApproximation.bitWordValue count.1 = OAI.EditApproximation.groupSampleCount M Q b (OAI.EditApproximation.groupDyadicScaleAt M b F scale) := by        rw [proof_groupSampleCountWithWork_value_28, proof_queryScaleAt_value_88]        rfl      let coordinates := OAI.EditApproximation.queryFinRange (OAI.EditApproximation.bitWordValue count.1)        (OAI.EditApproximation.groupSampleCount M Q b (OAI.EditApproximation.groupDyadicScaleAt M b F scale)) hc      let labeled := OAI.EditApproximation.arithmeticMapWithWork (fun sample =>        ((⟨(b, cell), scale, sample⟩ : OAI.EditApproximation.GroupScalarKey M F Q), 2)) coordinates      (labeled.1, scales.1.length + count.2 + labeled.2 + coordinates.length + 3)) indices    (samples.1, scales.2 + 4 * scales.1.length + samples.2 + eb + 4)def querySharedCellInputsWithWork {nx ny : ℕ} (M F Q eM eb eF : ℕ)    (hM : M = 2 ^ eM) (hF : F = 2 ^ eF) (parent : OAI.EditApproximation.TargetInterval nx)    (exponent : ℕ) (cell : ℕ × ℕ)    (draw : ∀ scale : Fin (OAI.EditApproximation.groupDyadicScales M (2 ^ eb) F).length,      Fin (OAI.EditApproximation.groupSampleCount M Q (2 ^ eb) (OAI.EditApproximation.groupDyadicScaleAt M (2 ^ eb) F scale)) → Fin M × ℕ) :    List (Fin M × OAI.EditApproximation.TargetInterval ny) × ℕ := by  have proof_representation_value_32 (a : OAI.EditApproximation.BinaryFraction) : a.representation.value = a.value := rfl  have proof_eq_of_num_den_33 {a : OAI.EditApproximation.UnreducedRational} {b : OAI.EditApproximation.UnreducedRational} (hnum : Eq.{1} a.num b.num) (hden : Eq.{1} a.den b.den) : a = b := by    cases a    cases b    cases hnum    cases hden    rfl  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_value_ofInt_46 (a : ℤ) : (OAI.EditApproximation.SignedBinary.ofInt a).value = a := by    by_cases h : a < 0    · simpa only [OAI.EditApproximation.SignedBinary.ofInt, OAI.EditApproximation.SignedBinary.value, proof_bitWordValue_bits_15, OAI.EditApproximation.signedMagnitude, h, decide_true,        ↓reduceIte] using (Int.eq_neg_natAbs_of_nonpos (le_of_lt h)).symm    · simpa only [OAI.EditApproximation.SignedBinary.ofInt, OAI.EditApproximation.SignedBinary.value, proof_bitWordValue_bits_15, OAI.EditApproximation.signedMagnitude, h, decide_false,        Bool.false_eq_true, ↓reduceIte] using (Int.eq_natAbs_of_nonneg (le_of_not_gt h)).symm  have proof_nat_representation_47 (n : ℕ) : (OAI.EditApproximation.BinaryFraction.nat n).representation = OAI.EditApproximation.UnreducedRational.nat n := by    apply proof_eq_of_num_den_33    · change (OAI.EditApproximation.SignedBinary.ofInt (n : ℤ)).value = (n : ℤ)      exact proof_value_ofInt_46 _    · rfl  have proof_value_nat_48 (n : ℕ) : (OAI.EditApproximation.UnreducedRational.nat n).value = n := by (simp [OAI.EditApproximation.UnreducedRational.nat, OAI.EditApproximation.UnreducedRational.value])  have proof_nat_value_49 (n : ℕ) : (OAI.EditApproximation.BinaryFraction.nat n).value = (n : ℚ) := by    rw [← proof_representation_value_32, proof_nat_representation_47, proof_value_nat_48]  have proof_arithmeticMapWithWork_value_70 {α : Type 0} {β : Type 0} (f : α → Prod.{0, 0} β ℕ) (values : List.{0} α) :      (OAI.EditApproximation.arithmeticMapWithWork f values).1 = values.map (fun a => (f a).1) := by    induction values with    | nil => rfl    | cons a rest ih => simp only [OAI.EditApproximation.arithmeticMapWithWork, ih, List.map_cons]  have proof_powerTwoWord_value_13 (n : ℕ) : OAI.EditApproximation.bitWordValue (OAI.EditApproximation.powerTwoWord n) = 2 ^ n := by    induction n with    | zero => (simp [OAI.EditApproximation.powerTwoWord, OAI.EditApproximation.bitWordValue])    | succ n ih =>      (simp only [OAI.EditApproximation.powerTwoWord, List.replicate_succ, List.cons_append, OAI.EditApproximation.bitWordValue,        Bool.toNat_false, zero_add] at *)      rw [ih, pow_succ]      omega  have proof_inversePowerTwo_value_89 (n : ℕ) : (OAI.EditApproximation.BinaryFraction.inversePowerTwo n).value = (2 : ℚ) ^ (-(n : ℤ)) := by    (simp only [OAI.EditApproximation.BinaryFraction.inversePowerTwo, OAI.EditApproximation.BinaryFraction.value, OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, Bool.false_eq_true,      ↓reduceIte, OAI.EditApproximation.bitWordValue, Bool.toNat_true,      Int.cast_natCast, proof_powerTwoWord_value_13, Nat.cast_pow, Nat.cast_ofNat, zpow_neg, zpow_natCast])    norm_num [one_div]  have proof_signedPowerTwoWithWork_value_90 (e : ℤ) :      (OAI.EditApproximation.BinaryFraction.signedPowerTwoWithWork e).1.value = (2 : ℚ) ^ e := by    unfold OAI.EditApproximation.BinaryFraction.signedPowerTwoWithWork    split_ifs with h    · change (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.powerTwoWord e.toNat) : ℚ) / 1 = (2 : ℚ) ^ e      rw [div_one, proof_powerTwoWord_value_13, Nat.cast_pow, Nat.cast_ofNat, ← zpow_natCast,        Int.toNat_of_nonneg h]    · rw [proof_inversePowerTwo_value_89, Int.toNat_of_nonneg        (show 0 ≤ -e from neg_nonneg.mpr (le_of_lt (lt_of_not_ge h))), neg_neg]  have proof_groupScalesWithWork_value_91 (eM : ℕ) (eb : ℕ) (eF : ℕ) :      ((OAI.EditApproximation.BinaryFraction.groupScalesWithWork eM eb eF).1.map OAI.EditApproximation.BinaryFraction.value) =        OAI.EditApproximation.groupDyadicScales (2 ^ eM) (2 ^ eb) ((2 : ℚ) ^ eF) := by    have hlower : ((2 ^ eb : ℕ) : ℚ) / (2 ^ eM : ℕ) = (2 : ℚ) ^ ((eb : ℤ) - eM) := by      rw [Nat.cast_pow, Nat.cast_pow, Nat.cast_ofNat, zpow_sub₀ (by norm_num : (2 : ℚ) ≠ 0),        zpow_natCast, zpow_natCast]    have hupper : (64 : ℚ) * (2 : ℚ) ^ eF * (2 ^ eb : ℕ) =        (2 : ℚ) ^ ((6 + eF + eb : ℕ) : ℤ) := by      rw [Nat.cast_pow, Nat.cast_ofNat, zpow_natCast, pow_add, pow_add]      norm_num    have hlog : Int.log 2 ((2 : ℚ) ^ ((6 + eF + eb : ℕ) : ℤ)) = ((6 + eF + eb : ℕ) : ℤ) := by      simpa only [Nat.cast_ofNat] using Int.log_zpow (R := ℚ) (by decide : 1 < 2) ((6 + eF + eb : ℕ) : ℤ)    have hclog : Int.clog 2 ((2 : ℚ) ^ ((eb : ℤ) - eM)) = (eb : ℤ) - eM := by      simpa only [Nat.cast_ofNat] using Int.clog_zpow (R := ℚ) (by decide : 1 < 2) ((eb : ℤ) - eM)    simp only [OAI.EditApproximation.BinaryFraction.groupScalesWithWork, proof_arithmeticMapWithWork_value_70, List.map_map,      Function.comp_def, proof_signedPowerTwoWithWork_value_90, OAI.EditApproximation.groupDyadicScales, hlower, hupper, hlog, hclog]  have proof_computedGroupScales_value_87 (M : ℕ) (b : ℕ) (F : ℕ) (eM : ℕ) (eb : ℕ) (eF : ℕ) (hM : Eq.{1} M (HPow.hPow.{0, 0, 0} 2 eM)) (hb : Eq.{1} b (HPow.hPow.{0, 0, 0} 2 eb)) (hF : Eq.{1} F (HPow.hPow.{0, 0, 0} 2 eF)) :      (OAI.EditApproximation.BinaryFraction.groupScalesWithWork eM eb eF).1.map OAI.EditApproximation.BinaryFraction.value = OAI.EditApproximation.groupDyadicScales M b (OAI.EditApproximation.BinaryFraction.nat F).value := by    rw [proof_nat_value_49, hM, hb, hF, Nat.cast_pow, Nat.cast_ofNat]    exact proof_groupScalesWithWork_value_91 eM eb eF  have proof_queryScaleAt_value_88 (words : List.{0} OAI.EditApproximation.BinaryFraction) (scales : List.{0} ℚ) (h : Eq.{1} (List.map.{0, 0} OAI.EditApproximation.BinaryFraction.value words) scales) (i : Fin (List.length.{0} scales)) :      (OAI.EditApproximation.BinaryFraction.queryScaleAt words scales h i).value = scales[i.val] := by    subst scales    simp only [OAI.EditApproximation.BinaryFraction.queryScaleAt, List.getElem_map]  have proof_queryGroupScaleAt_value_92 (M : ℕ) (b : ℕ) (F : ℕ) (words : List.{0} OAI.EditApproximation.BinaryFraction) (h : Eq.{1} (List.map.{0, 0} OAI.EditApproximation.BinaryFraction.value words)    (OAI.EditApproximation.groupDyadicScales M b ↑F)) (i : Fin (List.length.{0} (OAI.EditApproximation.groupDyadicScales M b ↑F))) :      (OAI.EditApproximation.BinaryFraction.queryScaleAt words (OAI.EditApproximation.groupDyadicScales M b F) h i).value = OAI.EditApproximation.groupDyadicScaleAt M b F i :=    proof_queryScaleAt_value_88 words (OAI.EditApproximation.groupDyadicScales M b F) h i  exact    let b := 2 ^ eb    let scales := OAI.EditApproximation.BinaryFraction.groupScalesWithWork eM eb eF    let hs : scales.1.map OAI.EditApproximation.BinaryFraction.value = OAI.EditApproximation.groupDyadicScales M b F := by      simpa only [proof_nat_value_49] using proof_computedGroupScales_value_87 M b F eM eb eF hM rfl hF    let hlen : scales.1.length = (OAI.EditApproximation.groupDyadicScales M b F).length := by      simpa only [List.length_map] using congrArg List.length hs    let indices := OAI.EditApproximation.queryFinRange scales.1.length (OAI.EditApproximation.groupDyadicScales M b F).length hlen    let inputs := OAI.EditApproximation.arithmeticFlatMapWithWork (fun scale =>      let word := OAI.EditApproximation.BinaryFraction.queryScaleAt scales.1 (OAI.EditApproximation.groupDyadicScales M b F) hs scale      let hv : word.value = OAI.EditApproximation.groupDyadicScaleAt M b F scale := proof_queryGroupScaleAt_value_92 M b F _ hs scale      let states := OAI.EditApproximation.BinaryFraction.queryGroupInputsTransportWithWork (ny := ny) parent b exponent Q cell word        (OAI.EditApproximation.groupDyadicScaleAt M b F scale) hv (draw scale)      (states.1, states.2 + scales.1.length + 1)) indices    (inputs.1, scales.2 + 4 * scales.1.length + inputs.2 + eb + 4)def groupKeySampleBlock {M F Q : ℕ} (b : ℕ) (raw : List OAI.EditApproximation.BinaryFraction)    (hs : raw.map OAI.EditApproximation.BinaryFraction.value = OAI.EditApproximation.groupDyadicScales M b F) (cell : ℕ × ℕ)    (scale : Fin (OAI.EditApproximation.groupDyadicScales M b F).length) : List (OAI.EditApproximation.GroupScalarKey M F Q) × ℕ := by  have proof_bitOrdering_matches_4 (high : Ordering) (a : Bool) (b : Bool) (x : ℕ) (y : ℕ) (h : OAI.EditApproximation.orderingMatches high x y) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitOrdering high a b) (a.toNat + 2 * x) (b.toNat + 2 * y) := by    rcases h with ⟨rfl, h⟩ | ⟨rfl, rfl⟩ | ⟨rfl, h⟩    · exact Or.inl ⟨rfl, by cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩    · cases a <;> cases b <;> simp [OAI.EditApproximation.bitOrdering, OAI.EditApproximation.orderingMatches]    · exact Or.inr (Or.inr ⟨rfl, by        cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩)  have proof_bitCompareWithWork_matches_5 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitCompareWithWork left right).1 (OAI.EditApproximation.bitWordValue left) (OAI.EditApproximation.bitWordValue right) := by    induction left generalizing right with    | nil =>      simp only [OAI.EditApproximation.bitCompareWithWork]      induction right with      | nil => (simp [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.orderingMatches, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        simpa only [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareNilLeftWithWork bs).1 false b 0 (OAI.EditApproximation.bitWordValue bs) ih    | cons a as ih =>      cases right with      | nil =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as []).1 a false (OAI.EditApproximation.bitWordValue as) 0 (ih [])      | cons b bs =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue] using          proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as bs).1 a b (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs) (ih bs)  have proof_bitCompareWithWork_lt_16 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .lt ↔ OAI.EditApproximation.bitWordValue left < OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_wordLEWithWork_value_26 (a : List.{0} Bool) (b : List.{0} Bool) :      (OAI.EditApproximation.wordLEWithWork a b).1 = true ↔ OAI.EditApproximation.bitWordValue a ≤ OAI.EditApproximation.bitWordValue b := by    simp only [OAI.EditApproximation.wordLEWithWork, Bool.not_eq_true', decide_eq_false_iff_not,      proof_bitCompareWithWork_lt_16, not_lt]  have proof_wordMinWithWork_value_29 (a : List.{0} Bool) (b : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.wordMinWithWork a b).1 = min (OAI.EditApproximation.bitWordValue a) (OAI.EditApproximation.bitWordValue b) := by    unfold OAI.EditApproximation.wordMinWithWork    dsimp only    split_ifs with h    · exact (min_eq_left ((proof_wordLEWithWork_value_26 a b).mp h)).symm    · exact (min_eq_right (le_of_not_ge (fun hle => h ((proof_wordLEWithWork_value_26 a b).mpr hle)))).symm  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_bitSubtractor_value_17 (a : Bool) (b : Bool) (borrow : Bool) :      a.toNat + 2 * (OAI.EditApproximation.bitBorrow a b borrow).toNat =        b.toNat + borrow.toNat + (OAI.EditApproximation.bitDifference a b borrow).toNat := by    cases a <;> cases b <;> cases borrow <;> decide  have proof_bitSubtractionRippleEquation_18 (a : ℕ) (b : ℕ) (borrow : ℕ) (nextBorrow : ℕ) (difference : ℕ) (left : ℕ) (right : ℕ) (result : ℕ) (tail : ℕ) (htail : Eq.{1} (HAdd.hAdd.{0, 0, 0} (HAdd.hAdd.{0, 0, 0} result right) nextBorrow) (HAdd.hAdd.{0, 0, 0} left tail)) (hbit : Eq.{1} (HAdd.hAdd.{0, 0, 0} a (HMul.hMul.{0, 0, 0} 2 nextBorrow))    (HAdd.hAdd.{0, 0, 0} (HAdd.hAdd.{0, 0, 0} b borrow) difference)) :      (difference + 2 * result) + (b + 2 * right) + borrow =        (a + 2 * left) + 2 * tail := by    omega  have proof_bitSubtractWithWork_value_19 (left : List.{0} Bool) (right : List.{0} Bool) (borrow : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork left right borrow).1 + OAI.EditApproximation.bitWordValue right + borrow.toNat =        OAI.EditApproximation.bitWordValue left + 2 ^ max left.length right.length *          (OAI.EditApproximation.bitSubtractWithWork left right borrow).2.1.toNat := by    induction left generalizing right borrow with    | nil =>      induction right generalizing borrow with      | nil => (simp [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitSubtractNilLeftWithWork, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        have h := ih (OAI.EditApproximation.bitBorrow false b borrow)        have hb := proof_bitSubtractor_value_17 false b borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitSubtractNilLeftWithWork, OAI.EditApproximation.bitWordValue,          List.length_nil, List.length_cons, Nat.zero_max, pow_succ, Bool.toNat_false] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 0 b.toNat borrow.toNat (OAI.EditApproximation.bitBorrow false b borrow).toNat          (OAI.EditApproximation.bitDifference false b borrow).toNat 0 (OAI.EditApproximation.bitWordValue bs)          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractNilLeftWithWork bs (OAI.EditApproximation.bitBorrow false b borrow)).1)          (2 ^ bs.length * (OAI.EditApproximation.bitSubtractNilLeftWithWork bs (OAI.EditApproximation.bitBorrow false b borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_zero, Nat.add_zero, Nat.zero_add, Nat.mul_assoc,          Nat.mul_left_comm] using hs    | cons a as ih =>      cases right with      | nil =>        have h := ih [] (OAI.EditApproximation.bitBorrow a false borrow)        have hb := proof_bitSubtractor_value_17 a false borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitWordValue, List.length_nil, List.length_cons,          Nat.max_zero, pow_succ, Bool.toNat_false] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 a.toNat 0 borrow.toNat (OAI.EditApproximation.bitBorrow a false borrow).toNat          (OAI.EditApproximation.bitDifference a false borrow).toNat (OAI.EditApproximation.bitWordValue as) 0          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork as [] (OAI.EditApproximation.bitBorrow a false borrow)).1)          (2 ^ as.length * (OAI.EditApproximation.bitSubtractWithWork as [] (OAI.EditApproximation.bitBorrow a false borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_zero, Nat.add_zero, Nat.zero_add, Nat.mul_assoc,          Nat.mul_left_comm] using hs      | cons b bs =>        have h := ih bs (OAI.EditApproximation.bitBorrow a b borrow)        have hb := proof_bitSubtractor_value_17 a b borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitWordValue, List.length_cons, Nat.succ_max_succ,          pow_succ] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 a.toNat b.toNat borrow.toNat (OAI.EditApproximation.bitBorrow a b borrow).toNat          (OAI.EditApproximation.bitDifference a b borrow).toNat (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs)          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork as bs (OAI.EditApproximation.bitBorrow a b borrow)).1)          (2 ^ max as.length bs.length * (OAI.EditApproximation.bitSubtractWithWork as bs (OAI.EditApproximation.bitBorrow a b borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_assoc, Nat.mul_left_comm] using hs  have proof_bitWordValue_lt_pow_length_20 (bits : List.{0} Bool) : OAI.EditApproximation.bitWordValue bits < 2 ^ bits.length := by    induction bits with    | nil => (simp [OAI.EditApproximation.bitWordValue])    | cons bit bits ih =>      cases bit <;> (simp only [OAI.EditApproximation.bitWordValue, List.length_cons, pow_succ, Bool.toNat_false, Bool.toNat_true]) <;> omega  have proof_bitSubtractWithWork_length_21 (left : List.{0} Bool) (right : List.{0} Bool) (borrow : Bool) :      (OAI.EditApproximation.bitSubtractWithWork left right borrow).1.length = max left.length right.length := by    induction left generalizing right borrow with    | nil =>      simp only [OAI.EditApproximation.bitSubtractWithWork]      induction right generalizing borrow with      | nil => simp [OAI.EditApproximation.bitSubtractNilLeftWithWork]      | cons b bs ih => simp [OAI.EditApproximation.bitSubtractNilLeftWithWork, ih]    | cons a as ih =>      cases right with      | nil => simp [OAI.EditApproximation.bitSubtractWithWork, ih]      | cons b bs => simp [OAI.EditApproximation.bitSubtractWithWork, ih, Nat.succ_max_succ]  have proof_bitSubtractWithWork_sub_22 (left : List.{0} Bool) (right : List.{0} Bool) (h : LE.le.{0} (OAI.EditApproximation.bitWordValue right) (OAI.EditApproximation.bitWordValue left)) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork left right false).1 = OAI.EditApproximation.bitWordValue left - OAI.EditApproximation.bitWordValue right := by    have hvalue := proof_bitSubtractWithWork_value_19 left right false    have hlt := proof_bitWordValue_lt_pow_length_20 (OAI.EditApproximation.bitSubtractWithWork left right false).1    rw [proof_bitSubtractWithWork_length_21] at hlt    cases hb : (OAI.EditApproximation.bitSubtractWithWork left right false).2.1    · simp only [hb, Bool.toNat_false, Nat.mul_zero, Nat.add_zero] at hvalue      omega    · simp only [hb, Bool.toNat_true, Bool.toNat_false, Nat.mul_one, Nat.add_zero] at hvalue      omega  have proof_bitDivModWithWork_value_23 (divisor : List.{0} Bool) (bits : List.{0} Bool) (hd : LT.lt.{0} 0 (OAI.EditApproximation.bitWordValue divisor)) :      OAI.EditApproximation.bitWordValue bits = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).1 +        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 ∧        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 < OAI.EditApproximation.bitWordValue divisor := by    induction bits with    | nil => (simp [OAI.EditApproximation.bitDivModWithWork, OAI.EditApproximation.bitWordValue, hd])    | cons bit bits ih =>      let previous := OAI.EditApproximation.bitDivModWithWork divisor bits      let candidate := bit :: previous.2.1      have hp : OAI.EditApproximation.bitWordValue bits = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue previous.1 +          OAI.EditApproximation.bitWordValue previous.2.1 := ih.1      have hr : OAI.EditApproximation.bitWordValue previous.2.1 < OAI.EditApproximation.bitWordValue divisor := ih.2      have hc : OAI.EditApproximation.bitWordValue candidate < 2 * OAI.EditApproximation.bitWordValue divisor := by        dsimp only [candidate, OAI.EditApproximation.bitWordValue]        cases bit <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega      by_cases hlt : (OAI.EditApproximation.bitCompareWithWork candidate divisor).1 = .lt      · have hv := (proof_bitCompareWithWork_lt_16 candidate divisor).1 hlt        simp only [OAI.EditApproximation.bitDivModWithWork, show (OAI.EditApproximation.bitCompareWithWork (bit :: (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1)          divisor).1 = .lt from hlt, ↓reduceIte]        change OAI.EditApproximation.bitWordValue (bit :: bits) = OAI.EditApproximation.bitWordValue divisor *          OAI.EditApproximation.bitWordValue (false :: previous.1) + OAI.EditApproximation.bitWordValue candidate ∧ OAI.EditApproximation.bitWordValue candidate < _        constructor        · (simp only [OAI.EditApproximation.bitWordValue, Bool.toNat_false])          dsimp only [candidate, OAI.EditApproximation.bitWordValue]          nlinarith only [hp]        · exact hv      · have hv : OAI.EditApproximation.bitWordValue divisor ≤ OAI.EditApproximation.bitWordValue candidate := by          exact Nat.le_of_not_gt (fun h => hlt ((proof_bitCompareWithWork_lt_16 candidate divisor).2 h))        have hs := proof_bitSubtractWithWork_sub_22 candidate divisor hv        simp only [OAI.EditApproximation.bitDivModWithWork, show (OAI.EditApproximation.bitCompareWithWork (bit :: (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1)          divisor).1 ≠ .lt from hlt, ↓reduceIte]        change OAI.EditApproximation.bitWordValue (bit :: bits) = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue (true :: previous.1) +          OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork candidate divisor false).1 ∧          OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork candidate divisor false).1 < _        rw [hs]        constructor        · (simp only [OAI.EditApproximation.bitWordValue, Bool.toNat_true])          have he := Nat.sub_add_cancel hv          dsimp only [candidate, OAI.EditApproximation.bitWordValue] at he ⊢          nlinarith only [hp, he]        · omega  have proof_bitCompareWithWork_eq_3 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .eq ↔ OAI.EditApproximation.bitWordValue left = OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_bitAdder_value_1 (a : Bool) (b : Bool) (carry : Bool) :      (OAI.EditApproximation.bitSum a b carry).toNat + 2 * (OAI.EditApproximation.bitCarry a b carry).toNat =        a.toNat + b.toNat + carry.toNat := by    cases a <;> cases b <;> cases carry <;> decide  have proof_bitAddWithWork_value_2 (left : List.{0} Bool) (right : List.{0} Bool) (carry : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitAddWithWork left right carry).1 =        OAI.EditApproximation.bitWordValue left + OAI.EditApproximation.bitWordValue right + carry.toNat := by    induction left generalizing right carry with    | nil =>      simp only [OAI.EditApproximation.bitAddWithWork]      induction right generalizing carry with      | nil => cases carry <;> simp [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue]      | cons b bs ih =>        simp only [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 false b carry        simp only [Bool.toNat_false] at h        omega    | cons a as ih =>      cases right with      | nil =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a false carry        simp only [Bool.toNat_false] at h        omega      | cons b bs =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a b carry        omega  have proof_bitCeilDivWithWork_value_30 (divisor : List.{0} Bool) (bits : List.{0} Bool) (hd : LT.lt.{0} 0 (OAI.EditApproximation.bitWordValue divisor)) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitCeilDivWithWork divisor bits).1 =        ⌈((OAI.EditApproximation.bitWordValue bits : ℚ) / OAI.EditApproximation.bitWordValue divisor)⌉₊ := by    let q := OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).1    let r := OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1    have h := proof_bitDivModWithWork_value_23 divisor bits hd    have heq : OAI.EditApproximation.bitWordValue bits = OAI.EditApproximation.bitWordValue divisor * q + r := h.1    have hr : r < OAI.EditApproximation.bitWordValue divisor := h.2    have hdQ : (0 : ℚ) < OAI.EditApproximation.bitWordValue divisor := by exact_mod_cast hd    unfold OAI.EditApproximation.bitCeilDivWithWork    dsimp only    split_ifs with hz    · have hr0 : r = 0 := by        exact (proof_bitCompareWithWork_eq_3 (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 []).1 hz      have hratio : (OAI.EditApproximation.bitWordValue bits : ℚ) / OAI.EditApproximation.bitWordValue divisor = (q : ℚ) := by        apply (div_eq_iff hdQ.ne').mpr        exact_mod_cast (show OAI.EditApproximation.bitWordValue bits = q * OAI.EditApproximation.bitWordValue divisor by nlinarith only [heq, hr0])      rw [hratio]      exact (Nat.ceil_natCast q).symm    · have hr0 : r ≠ 0 := by        intro hzero        exact hz ((proof_bitCompareWithWork_eq_3 (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 []).2 hzero)      rw [proof_bitAddWithWork_value_2]      change q + 1 + 0 = _      simp only [Nat.add_zero]      symm      apply (Nat.ceil_eq_iff (by omega : q + 1 ≠ 0)).mpr      constructor      · simp only [Nat.add_sub_cancel]        rw [lt_div_iff₀ hdQ]        exact_mod_cast (show q * OAI.EditApproximation.bitWordValue divisor < OAI.EditApproximation.bitWordValue bits by          nlinarith only [heq, Nat.pos_of_ne_zero hr0])      · rw [div_le_iff₀ hdQ]        push_cast        exact_mod_cast (show OAI.EditApproximation.bitWordValue bits ≤ (q + 1) * OAI.EditApproximation.bitWordValue divisor by nlinarith only [heq, hr])  have proof_naturalCeilingWithWork_value_31 (a : OAI.EditApproximation.BinaryFraction) :      OAI.EditApproximation.bitWordValue (a.naturalCeilingWithWork).1 = ⌈a.value⌉₊ := by    cases hs : a.numerator.negative    · simpa only [OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork, hs, Bool.false_eq_true, ↓reduceIte,        OAI.EditApproximation.BinaryFraction.value, OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, Int.cast_natCast] using        proof_bitCeilDivWithWork_value_30 a.denominator a.numerator.bits a.denominator_pos    · have hn : a.value ≤ 0 := by        (simp only [OAI.EditApproximation.BinaryFraction.value, OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, hs, ↓reduceIte, Int.cast_neg, Int.cast_natCast])        exact div_nonpos_of_nonpos_of_nonneg (neg_nonpos.mpr (Nat.cast_nonneg _)) (Nat.cast_nonneg _)      (simp only [OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork, hs, ↓reduceIte, OAI.EditApproximation.bitWordValue])      exact (Nat.ceil_eq_zero.mpr hn).symm  have proof_representation_value_32 (a : OAI.EditApproximation.BinaryFraction) : a.representation.value = a.value := rfl  have proof_eq_of_num_den_33 {a : OAI.EditApproximation.UnreducedRational} {b : OAI.EditApproximation.UnreducedRational} (hnum : Eq.{1} a.num b.num) (hden : Eq.{1} a.den b.den) : a = b := by    cases a    cases b    cases hnum    cases hden    rfl  have proof_trimBitWordWithWork_value_6 (bits : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.trimBitWordWithWork bits).1 = OAI.EditApproximation.bitWordValue bits := by    induction bits with    | nil => rfl    | cons bit bits ih =>      simp only [OAI.EditApproximation.trimBitWordWithWork]      split_ifs with h      · have ht : OAI.EditApproximation.bitWordValue bits = 0 := by rw [← ih, h.1]; rfl        simp [h.2, OAI.EditApproximation.bitWordValue, ht]      · (simp only [OAI.EditApproximation.bitWordValue, ih])  have proof_canonicalizeWithWork_representation_34 (a : OAI.EditApproximation.BinaryFraction) :      (OAI.EditApproximation.BinaryFraction.canonicalizeWithWork a).1.representation = a.representation := by    apply proof_eq_of_num_den_33    · (simp only [OAI.EditApproximation.BinaryFraction.canonicalizeWithWork, OAI.EditApproximation.BinaryFraction.representation, OAI.EditApproximation.SignedBinary.value, proof_trimBitWordWithWork_value_6])    · exact proof_trimBitWordWithWork_value_6 a.denominator  have proof_bitMulWithWork_value_0 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitMulWithWork left right).1 = OAI.EditApproximation.bitWordValue left * OAI.EditApproximation.bitWordValue right := by    induction left with    | nil => simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue]    | cons bit bits ih =>      cases bit <;> simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue, proof_bitAddWithWork_value_2, ih] <;> ring  have proof_mulWithWork_value_35 (a : OAI.EditApproximation.SignedBinary) (b : OAI.EditApproximation.SignedBinary) :      (a.mulWithWork b).1.value = a.value * b.value := by    simp only [OAI.EditApproximation.SignedBinary.mulWithWork, OAI.EditApproximation.SignedBinary.value, proof_bitMulWithWork_value_0]    cases a.negative <;> cases b.negative <;> simp [OAI.EditApproximation.signedMagnitude]  have proof_mulWithWork_representation_36 (a : OAI.EditApproximation.BinaryFraction) (b : OAI.EditApproximation.BinaryFraction) :      (a.mulWithWork b).1.representation = a.representation.mul b.representation := by    apply proof_eq_of_num_den_33    · exact proof_mulWithWork_value_35 a.numerator b.numerator    · exact proof_bitMulWithWork_value_0 a.denominator b.denominator  have proof_canonicalMulWithWork_representation_37 (a : OAI.EditApproximation.BinaryFraction) (b : OAI.EditApproximation.BinaryFraction) :      (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork a b).1.representation = a.representation.mul b.representation := by    rw [OAI.EditApproximation.BinaryFraction.canonicalMulWithWork, proof_canonicalizeWithWork_representation_34, proof_mulWithWork_representation_36]  have proof_zero_representation_38 : OAI.EditApproximation.BinaryFraction.zero.representation = OAI.EditApproximation.UnreducedRational.zero := by    apply proof_eq_of_num_den_33 <;> rfl  have proof_invWithWork_representation_39 (a : OAI.EditApproximation.BinaryFraction) :      (a.invWithWork).1.representation = a.representation.inv := by    unfold OAI.EditApproximation.BinaryFraction.invWithWork    dsimp only    split_ifs with h    · have hz : OAI.EditApproximation.bitWordValue a.numerator.bits = 0 := by        simpa only [OAI.EditApproximation.bitWordValue] using (proof_bitCompareWithWork_eq_3 a.numerator.bits []).1 h      have hv : a.numerator.value = 0 := by (simp [OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, hz])      (simp only [OAI.EditApproximation.UnreducedRational.inv, OAI.EditApproximation.BinaryFraction.representation, hv, ↓reduceDIte])      exact proof_zero_representation_38    · have hn : OAI.EditApproximation.bitWordValue a.numerator.bits ≠ 0 := by        intro hz        exact h ((proof_bitCompareWithWork_eq_3 a.numerator.bits []).2 (by simpa [OAI.EditApproximation.bitWordValue] using hz))      have hv : a.numerator.value ≠ 0 := by        cases hs : a.numerator.negative <;> (simp [OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, hs, hn])      (simp only [OAI.EditApproximation.UnreducedRational.inv, OAI.EditApproximation.BinaryFraction.representation, hv, ↓reduceDIte])      apply proof_eq_of_num_den_33      · cases hs : a.numerator.negative <;>          simp [OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, hs, Int.sign_natCast_of_ne_zero hn]      · cases hs : a.numerator.negative <;> (simp [OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, hs])  have proof_divWithWork_representation_40 (a : OAI.EditApproximation.BinaryFraction) (b : OAI.EditApproximation.BinaryFraction) :      (a.divWithWork b).1.representation = a.representation.div b.representation := by    (simp only [OAI.EditApproximation.BinaryFraction.divWithWork, proof_canonicalMulWithWork_representation_37, proof_invWithWork_representation_39,      OAI.EditApproximation.UnreducedRational.div])  have proof_value_mul_41 (a : OAI.EditApproximation.UnreducedRational) (b : OAI.EditApproximation.UnreducedRational) : (a.mul b).value = a.value * b.value := by    simp [OAI.EditApproximation.UnreducedRational.mul, OAI.EditApproximation.UnreducedRational.value, mul_div_mul_comm]  have proof_value_inv_42 (a : OAI.EditApproximation.UnreducedRational) : a.inv.value = a.value⁻¹ := by    by_cases h : a.num = 0    · simp [OAI.EditApproximation.UnreducedRational.inv, h, OAI.EditApproximation.UnreducedRational.value, OAI.EditApproximation.UnreducedRational.zero]    · have hn : (a.num.natAbs : ℚ) ≠ 0 := by exact_mod_cast (Int.natAbs_pos.mpr h).ne'      have hd : (a.den : ℚ) ≠ 0 := by exact_mod_cast a.den_pos.ne'      have hsign : ((a.num.sign : ℤ) : ℚ) * a.num = (a.num.natAbs : ℚ) := by        simpa only [Int.cast_mul, Int.cast_natCast] using          congrArg (fun z : ℤ => (z : ℚ)) (Int.sign_mul_self_eq_natAbs a.num)      simp only [OAI.EditApproximation.UnreducedRational.inv, h, ↓reduceDIte, OAI.EditApproximation.UnreducedRational.value]      push_cast      apply eq_inv_of_mul_eq_one_left      field_simp [hn, hd]      exact hsign  have proof_value_div_43 (a : OAI.EditApproximation.UnreducedRational) (b : OAI.EditApproximation.UnreducedRational) : (a.div b).value = a.value / b.value := by    simp [proof_value_mul_41, proof_value_inv_42, OAI.EditApproximation.UnreducedRational.div, div_eq_mul_inv]  have proof_divWithWork_value_44 (a : OAI.EditApproximation.BinaryFraction) (b : OAI.EditApproximation.BinaryFraction) :      (OAI.EditApproximation.BinaryFraction.divWithWork a b).1.value = a.value / b.value := by    rw [← proof_representation_value_32, proof_divWithWork_representation_40,      proof_value_div_43, proof_representation_value_32, proof_representation_value_32]  have proof_canonicalMulWithWork_value_45 (a : OAI.EditApproximation.BinaryFraction) (b : OAI.EditApproximation.BinaryFraction) :      (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork a b).1.value = a.value * b.value := by    rw [← proof_representation_value_32, proof_canonicalMulWithWork_representation_37,      proof_value_mul_41, proof_representation_value_32, proof_representation_value_32]  have proof_value_ofInt_46 (a : ℤ) : (OAI.EditApproximation.SignedBinary.ofInt a).value = a := by    by_cases h : a < 0    · simpa only [OAI.EditApproximation.SignedBinary.ofInt, OAI.EditApproximation.SignedBinary.value, proof_bitWordValue_bits_15, OAI.EditApproximation.signedMagnitude, h, decide_true,        ↓reduceIte] using (Int.eq_neg_natAbs_of_nonpos (le_of_lt h)).symm    · simpa only [OAI.EditApproximation.SignedBinary.ofInt, OAI.EditApproximation.SignedBinary.value, proof_bitWordValue_bits_15, OAI.EditApproximation.signedMagnitude, h, decide_false,        Bool.false_eq_true, ↓reduceIte] using (Int.eq_natAbs_of_nonneg (le_of_not_gt h)).symm  have proof_nat_representation_47 (n : ℕ) : (OAI.EditApproximation.BinaryFraction.nat n).representation = OAI.EditApproximation.UnreducedRational.nat n := by    apply proof_eq_of_num_den_33    · change (OAI.EditApproximation.SignedBinary.ofInt (n : ℤ)).value = (n : ℤ)      exact proof_value_ofInt_46 _    · rfl  have proof_value_nat_48 (n : ℕ) : (OAI.EditApproximation.UnreducedRational.nat n).value = n := by (simp [OAI.EditApproximation.UnreducedRational.nat, OAI.EditApproximation.UnreducedRational.value])  have proof_nat_value_49 (n : ℕ) : (OAI.EditApproximation.BinaryFraction.nat n).value = (n : ℚ) := by    rw [← proof_representation_value_32, proof_nat_representation_47, proof_value_nat_48]  have proof_groupSampleCountWithWork_value_28 (M : ℕ) (Q : ℕ) (b : ℕ) (h : OAI.EditApproximation.BinaryFraction) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.BinaryFraction.groupSampleCountWithWork M Q b h).1 = OAI.EditApproximation.groupSampleCount M Q b h.value := by    simp only [OAI.EditApproximation.BinaryFraction.groupSampleCountWithWork, proof_wordMinWithWork_value_29, proof_bitWordValue_bits_15,      proof_naturalCeilingWithWork_value_31, proof_divWithWork_value_44, proof_canonicalMulWithWork_value_45,      proof_nat_value_49, OAI.EditApproximation.groupSampleCount]  have proof_queryScaleAt_value_88 (words : List.{0} OAI.EditApproximation.BinaryFraction) (scales : List.{0} ℚ) (h : Eq.{1} (List.map.{0, 0} OAI.EditApproximation.BinaryFraction.value words) scales) (i : Fin (List.length.{0} scales)) :      (OAI.EditApproximation.BinaryFraction.queryScaleAt words scales h i).value = scales[i.val] := by    subst scales    simp only [OAI.EditApproximation.BinaryFraction.queryScaleAt, List.getElem_map]  exact    let word := OAI.EditApproximation.BinaryFraction.queryScaleAt raw (OAI.EditApproximation.groupDyadicScales M b F) hs scale    let count := OAI.EditApproximation.BinaryFraction.groupSampleCountWithWork M Q b word    let hc : OAI.EditApproximation.bitWordValue count.1 = OAI.EditApproximation.groupSampleCount M Q b (OAI.EditApproximation.groupDyadicScaleAt M b F scale) := by      rw [proof_groupSampleCountWithWork_value_28, proof_queryScaleAt_value_88]      rfl    let coordinates := OAI.EditApproximation.queryFinRange (OAI.EditApproximation.bitWordValue count.1)      (OAI.EditApproximation.groupSampleCount M Q b (OAI.EditApproximation.groupDyadicScaleAt M b F scale)) hc    let labeled := OAI.EditApproximation.arithmeticMapWithWork (fun sample =>      ((⟨(b, cell), scale, sample⟩ : OAI.EditApproximation.GroupScalarKey M F Q), 2)) coordinates    (labeled.1, raw.length + count.2 + labeled.2 + coordinates.length + 3)def groupKeySampleBlockAllocation {M F Q : ℕ} (b : ℕ) (raw : List OAI.EditApproximation.BinaryFraction)    (hs : raw.map OAI.EditApproximation.BinaryFraction.value = OAI.EditApproximation.groupDyadicScales M b F) (_cell : ℕ × ℕ)    (scale : Fin (OAI.EditApproximation.groupDyadicScales M b F).length) : ℕ := by  have proof_bitOrdering_matches_4 (high : Ordering) (a : Bool) (b : Bool) (x : ℕ) (y : ℕ) (h : OAI.EditApproximation.orderingMatches high x y) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitOrdering high a b) (a.toNat + 2 * x) (b.toNat + 2 * y) := by    rcases h with ⟨rfl, h⟩ | ⟨rfl, rfl⟩ | ⟨rfl, h⟩    · exact Or.inl ⟨rfl, by cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩    · cases a <;> cases b <;> simp [OAI.EditApproximation.bitOrdering, OAI.EditApproximation.orderingMatches]    · exact Or.inr (Or.inr ⟨rfl, by        cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩)  have proof_bitCompareWithWork_matches_5 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitCompareWithWork left right).1 (OAI.EditApproximation.bitWordValue left) (OAI.EditApproximation.bitWordValue right) := by    induction left generalizing right with    | nil =>      simp only [OAI.EditApproximation.bitCompareWithWork]      induction right with      | nil => (simp [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.orderingMatches, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        simpa only [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareNilLeftWithWork bs).1 false b 0 (OAI.EditApproximation.bitWordValue bs) ih    | cons a as ih =>      cases right with      | nil =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as []).1 a false (OAI.EditApproximation.bitWordValue as) 0 (ih [])      | cons b bs =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue] using          proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as bs).1 a b (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs) (ih bs)  have proof_bitCompareWithWork_lt_16 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .lt ↔ OAI.EditApproximation.bitWordValue left < OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_wordLEWithWork_value_26 (a : List.{0} Bool) (b : List.{0} Bool) :      (OAI.EditApproximation.wordLEWithWork a b).1 = true ↔ OAI.EditApproximation.bitWordValue a ≤ OAI.EditApproximation.bitWordValue b := by    simp only [OAI.EditApproximation.wordLEWithWork, Bool.not_eq_true', decide_eq_false_iff_not,      proof_bitCompareWithWork_lt_16, not_lt]  have proof_wordMinWithWork_value_29 (a : List.{0} Bool) (b : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.wordMinWithWork a b).1 = min (OAI.EditApproximation.bitWordValue a) (OAI.EditApproximation.bitWordValue b) := by    unfold OAI.EditApproximation.wordMinWithWork    dsimp only    split_ifs with h    · exact (min_eq_left ((proof_wordLEWithWork_value_26 a b).mp h)).symm    · exact (min_eq_right (le_of_not_ge (fun hle => h ((proof_wordLEWithWork_value_26 a b).mpr hle)))).symm  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_bitSubtractor_value_17 (a : Bool) (b : Bool) (borrow : Bool) :      a.toNat + 2 * (OAI.EditApproximation.bitBorrow a b borrow).toNat =        b.toNat + borrow.toNat + (OAI.EditApproximation.bitDifference a b borrow).toNat := by    cases a <;> cases b <;> cases borrow <;> decide  have proof_bitSubtractionRippleEquation_18 (a : ℕ) (b : ℕ) (borrow : ℕ) (nextBorrow : ℕ) (difference : ℕ) (left : ℕ) (right : ℕ) (result : ℕ) (tail : ℕ) (htail : Eq.{1} (HAdd.hAdd.{0, 0, 0} (HAdd.hAdd.{0, 0, 0} result right) nextBorrow) (HAdd.hAdd.{0, 0, 0} left tail)) (hbit : Eq.{1} (HAdd.hAdd.{0, 0, 0} a (HMul.hMul.{0, 0, 0} 2 nextBorrow))    (HAdd.hAdd.{0, 0, 0} (HAdd.hAdd.{0, 0, 0} b borrow) difference)) :      (difference + 2 * result) + (b + 2 * right) + borrow =        (a + 2 * left) + 2 * tail := by    omega  have proof_bitSubtractWithWork_value_19 (left : List.{0} Bool) (right : List.{0} Bool) (borrow : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork left right borrow).1 + OAI.EditApproximation.bitWordValue right + borrow.toNat =        OAI.EditApproximation.bitWordValue left + 2 ^ max left.length right.length *          (OAI.EditApproximation.bitSubtractWithWork left right borrow).2.1.toNat := by    induction left generalizing right borrow with    | nil =>      induction right generalizing borrow with      | nil => (simp [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitSubtractNilLeftWithWork, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        have h := ih (OAI.EditApproximation.bitBorrow false b borrow)        have hb := proof_bitSubtractor_value_17 false b borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitSubtractNilLeftWithWork, OAI.EditApproximation.bitWordValue,          List.length_nil, List.length_cons, Nat.zero_max, pow_succ, Bool.toNat_false] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 0 b.toNat borrow.toNat (OAI.EditApproximation.bitBorrow false b borrow).toNat          (OAI.EditApproximation.bitDifference false b borrow).toNat 0 (OAI.EditApproximation.bitWordValue bs)          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractNilLeftWithWork bs (OAI.EditApproximation.bitBorrow false b borrow)).1)          (2 ^ bs.length * (OAI.EditApproximation.bitSubtractNilLeftWithWork bs (OAI.EditApproximation.bitBorrow false b borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_zero, Nat.add_zero, Nat.zero_add, Nat.mul_assoc,          Nat.mul_left_comm] using hs    | cons a as ih =>      cases right with      | nil =>        have h := ih [] (OAI.EditApproximation.bitBorrow a false borrow)        have hb := proof_bitSubtractor_value_17 a false borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitWordValue, List.length_nil, List.length_cons,          Nat.max_zero, pow_succ, Bool.toNat_false] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 a.toNat 0 borrow.toNat (OAI.EditApproximation.bitBorrow a false borrow).toNat          (OAI.EditApproximation.bitDifference a false borrow).toNat (OAI.EditApproximation.bitWordValue as) 0          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork as [] (OAI.EditApproximation.bitBorrow a false borrow)).1)          (2 ^ as.length * (OAI.EditApproximation.bitSubtractWithWork as [] (OAI.EditApproximation.bitBorrow a false borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_zero, Nat.add_zero, Nat.zero_add, Nat.mul_assoc,          Nat.mul_left_comm] using hs      | cons b bs =>        have h := ih bs (OAI.EditApproximation.bitBorrow a b borrow)        have hb := proof_bitSubtractor_value_17 a b borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitWordValue, List.length_cons, Nat.succ_max_succ,          pow_succ] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 a.toNat b.toNat borrow.toNat (OAI.EditApproximation.bitBorrow a b borrow).toNat          (OAI.EditApproximation.bitDifference a b borrow).toNat (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs)          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork as bs (OAI.EditApproximation.bitBorrow a b borrow)).1)          (2 ^ max as.length bs.length * (OAI.EditApproximation.bitSubtractWithWork as bs (OAI.EditApproximation.bitBorrow a b borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_assoc, Nat.mul_left_comm] using hs  have proof_bitWordValue_lt_pow_length_20 (bits : List.{0} Bool) : OAI.EditApproximation.bitWordValue bits < 2 ^ bits.length := by    induction bits with    | nil => (simp [OAI.EditApproximation.bitWordValue])    | cons bit bits ih =>      cases bit <;> (simp only [OAI.EditApproximation.bitWordValue, List.length_cons, pow_succ, Bool.toNat_false, Bool.toNat_true]) <;> omega  have proof_bitSubtractWithWork_length_21 (left : List.{0} Bool) (right : List.{0} Bool) (borrow : Bool) :      (OAI.EditApproximation.bitSubtractWithWork left right borrow).1.length = max left.length right.length := by    induction left generalizing right borrow with    | nil =>      simp only [OAI.EditApproximation.bitSubtractWithWork]      induction right generalizing borrow with      | nil => simp [OAI.EditApproximation.bitSubtractNilLeftWithWork]      | cons b bs ih => simp [OAI.EditApproximation.bitSubtractNilLeftWithWork, ih]    | cons a as ih =>      cases right with      | nil => simp [OAI.EditApproximation.bitSubtractWithWork, ih]      | cons b bs => simp [OAI.EditApproximation.bitSubtractWithWork, ih, Nat.succ_max_succ]  have proof_bitSubtractWithWork_sub_22 (left : List.{0} Bool) (right : List.{0} Bool) (h : LE.le.{0} (OAI.EditApproximation.bitWordValue right) (OAI.EditApproximation.bitWordValue left)) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork left right false).1 = OAI.EditApproximation.bitWordValue left - OAI.EditApproximation.bitWordValue right := by    have hvalue := proof_bitSubtractWithWork_value_19 left right false    have hlt := proof_bitWordValue_lt_pow_length_20 (OAI.EditApproximation.bitSubtractWithWork left right false).1    rw [proof_bitSubtractWithWork_length_21] at hlt    cases hb : (OAI.EditApproximation.bitSubtractWithWork left right false).2.1    · simp only [hb, Bool.toNat_false, Nat.mul_zero, Nat.add_zero] at hvalue      omega    · simp only [hb, Bool.toNat_true, Bool.toNat_false, Nat.mul_one, Nat.add_zero] at hvalue      omega  have proof_bitDivModWithWork_value_23 (divisor : List.{0} Bool) (bits : List.{0} Bool) (hd : LT.lt.{0} 0 (OAI.EditApproximation.bitWordValue divisor)) :      OAI.EditApproximation.bitWordValue bits = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).1 +        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 ∧        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 < OAI.EditApproximation.bitWordValue divisor := by    induction bits with    | nil => (simp [OAI.EditApproximation.bitDivModWithWork, OAI.EditApproximation.bitWordValue, hd])    | cons bit bits ih =>      let previous := OAI.EditApproximation.bitDivModWithWork divisor bits      let candidate := bit :: previous.2.1      have hp : OAI.EditApproximation.bitWordValue bits = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue previous.1 +          OAI.EditApproximation.bitWordValue previous.2.1 := ih.1      have hr : OAI.EditApproximation.bitWordValue previous.2.1 < OAI.EditApproximation.bitWordValue divisor := ih.2      have hc : OAI.EditApproximation.bitWordValue candidate < 2 * OAI.EditApproximation.bitWordValue divisor := by        dsimp only [candidate, OAI.EditApproximation.bitWordValue]        cases bit <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega      by_cases hlt : (OAI.EditApproximation.bitCompareWithWork candidate divisor).1 = .lt      · have hv := (proof_bitCompareWithWork_lt_16 candidate divisor).1 hlt        simp only [OAI.EditApproximation.bitDivModWithWork, show (OAI.EditApproximation.bitCompareWithWork (bit :: (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1)          divisor).1 = .lt from hlt, ↓reduceIte]        change OAI.EditApproximation.bitWordValue (bit :: bits) = OAI.EditApproximation.bitWordValue divisor *          OAI.EditApproximation.bitWordValue (false :: previous.1) + OAI.EditApproximation.bitWordValue candidate ∧ OAI.EditApproximation.bitWordValue candidate < _        constructor        · (simp only [OAI.EditApproximation.bitWordValue, Bool.toNat_false])          dsimp only [candidate, OAI.EditApproximation.bitWordValue]          nlinarith only [hp]        · exact hv      · have hv : OAI.EditApproximation.bitWordValue divisor ≤ OAI.EditApproximation.bitWordValue candidate := by          exact Nat.le_of_not_gt (fun h => hlt ((proof_bitCompareWithWork_lt_16 candidate divisor).2 h))        have hs := proof_bitSubtractWithWork_sub_22 candidate divisor hv        simp only [OAI.EditApproximation.bitDivModWithWork, show (OAI.EditApproximation.bitCompareWithWork (bit :: (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1)          divisor).1 ≠ .lt from hlt, ↓reduceIte]        change OAI.EditApproximation.bitWordValue (bit :: bits) = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue (true :: previous.1) +          OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork candidate divisor false).1 ∧          OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork candidate divisor false).1 < _        rw [hs]        constructor        · (simp only [OAI.EditApproximation.bitWordValue, Bool.toNat_true])          have he := Nat.sub_add_cancel hv          dsimp only [candidate, OAI.EditApproximation.bitWordValue] at he ⊢          nlinarith only [hp, he]        · omega  have proof_bitCompareWithWork_eq_3 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .eq ↔ OAI.EditApproximation.bitWordValue left = OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_bitAdder_value_1 (a : Bool) (b : Bool) (carry : Bool) :      (OAI.EditApproximation.bitSum a b carry).toNat + 2 * (OAI.EditApproximation.bitCarry a b carry).toNat =        a.toNat + b.toNat + carry.toNat := by    cases a <;> cases b <;> cases carry <;> decide  have proof_bitAddWithWork_value_2 (left : List.{0} Bool) (right : List.{0} Bool) (carry : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitAddWithWork left right carry).1 =        OAI.EditApproximation.bitWordValue left + OAI.EditApproximation.bitWordValue right + carry.toNat := by    induction left generalizing right carry with    | nil =>      simp only [OAI.EditApproximation.bitAddWithWork]      induction right generalizing carry with      | nil => cases carry <;> simp [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue]      | cons b bs ih =>        simp only [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 false b carry        simp only [Bool.toNat_false] at h        omega    | cons a as ih =>      cases right with      | nil =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a false carry        simp only [Bool.toNat_false] at h        omega      | cons b bs =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a b carry        omega  have proof_bitCeilDivWithWork_value_30 (divisor : List.{0} Bool) (bits : List.{0} Bool) (hd : LT.lt.{0} 0 (OAI.EditApproximation.bitWordValue divisor)) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitCeilDivWithWork divisor bits).1 =        ⌈((OAI.EditApproximation.bitWordValue bits : ℚ) / OAI.EditApproximation.bitWordValue divisor)⌉₊ := by    let q := OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).1    let r := OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1    have h := proof_bitDivModWithWork_value_23 divisor bits hd    have heq : OAI.EditApproximation.bitWordValue bits = OAI.EditApproximation.bitWordValue divisor * q + r := h.1    have hr : r < OAI.EditApproximation.bitWordValue divisor := h.2    have hdQ : (0 : ℚ) < OAI.EditApproximation.bitWordValue divisor := by exact_mod_cast hd    unfold OAI.EditApproximation.bitCeilDivWithWork    dsimp only    split_ifs with hz    · have hr0 : r = 0 := by        exact (proof_bitCompareWithWork_eq_3 (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 []).1 hz      have hratio : (OAI.EditApproximation.bitWordValue bits : ℚ) / OAI.EditApproximation.bitWordValue divisor = (q : ℚ) := by        apply (div_eq_iff hdQ.ne').mpr        exact_mod_cast (show OAI.EditApproximation.bitWordValue bits = q * OAI.EditApproximation.bitWordValue divisor by nlinarith only [heq, hr0])      rw [hratio]      exact (Nat.ceil_natCast q).symm    · have hr0 : r ≠ 0 := by        intro hzero        exact hz ((proof_bitCompareWithWork_eq_3 (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 []).2 hzero)      rw [proof_bitAddWithWork_value_2]      change q + 1 + 0 = _      simp only [Nat.add_zero]      symm      apply (Nat.ceil_eq_iff (by omega : q + 1 ≠ 0)).mpr      constructor      · simp only [Nat.add_sub_cancel]        rw [lt_div_iff₀ hdQ]        exact_mod_cast (show q * OAI.EditApproximation.bitWordValue divisor < OAI.EditApproximation.bitWordValue bits by          nlinarith only [heq, Nat.pos_of_ne_zero hr0])      · rw [div_le_iff₀ hdQ]        push_cast        exact_mod_cast (show OAI.EditApproximation.bitWordValue bits ≤ (q + 1) * OAI.EditApproximation.bitWordValue divisor by nlinarith only [heq, hr])  have proof_naturalCeilingWithWork_value_31 (a : OAI.EditApproximation.BinaryFraction) :      OAI.EditApproximation.bitWordValue (a.naturalCeilingWithWork).1 = ⌈a.value⌉₊ := by    cases hs : a.numerator.negative    · simpa only [OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork, hs, Bool.false_eq_true, ↓reduceIte,        OAI.EditApproximation.BinaryFraction.value, OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, Int.cast_natCast] using        proof_bitCeilDivWithWork_value_30 a.denominator a.numerator.bits a.denominator_pos    · have hn : a.value ≤ 0 := by        (simp only [OAI.EditApproximation.BinaryFraction.value, OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, hs, ↓reduceIte, Int.cast_neg, Int.cast_natCast])        exact div_nonpos_of_nonpos_of_nonneg (neg_nonpos.mpr (Nat.cast_nonneg _)) (Nat.cast_nonneg _)      (simp only [OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork, hs, ↓reduceIte, OAI.EditApproximation.bitWordValue])      exact (Nat.ceil_eq_zero.mpr hn).symm  have proof_representation_value_32 (a : OAI.EditApproximation.BinaryFraction) : a.representation.value = a.value := rfl  have proof_eq_of_num_den_33 {a : OAI.EditApproximation.UnreducedRational} {b : OAI.EditApproximation.UnreducedRational} (hnum : Eq.{1} a.num b.num) (hden : Eq.{1} a.den b.den) : a = b := by    cases a    cases b    cases hnum    cases hden    rfl  have proof_trimBitWordWithWork_value_6 (bits : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.trimBitWordWithWork bits).1 = OAI.EditApproximation.bitWordValue bits := by    induction bits with    | nil => rfl    | cons bit bits ih =>      simp only [OAI.EditApproximation.trimBitWordWithWork]      split_ifs with h      · have ht : OAI.EditApproximation.bitWordValue bits = 0 := by rw [← ih, h.1]; rfl        simp [h.2, OAI.EditApproximation.bitWordValue, ht]      · (simp only [OAI.EditApproximation.bitWordValue, ih])  have proof_canonicalizeWithWork_representation_34 (a : OAI.EditApproximation.BinaryFraction) :      (OAI.EditApproximation.BinaryFraction.canonicalizeWithWork a).1.representation = a.representation := by    apply proof_eq_of_num_den_33    · (simp only [OAI.EditApproximation.BinaryFraction.canonicalizeWithWork, OAI.EditApproximation.BinaryFraction.representation, OAI.EditApproximation.SignedBinary.value, proof_trimBitWordWithWork_value_6])    · exact proof_trimBitWordWithWork_value_6 a.denominator  have proof_bitMulWithWork_value_0 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitMulWithWork left right).1 = OAI.EditApproximation.bitWordValue left * OAI.EditApproximation.bitWordValue right := by    induction left with    | nil => simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue]    | cons bit bits ih =>      cases bit <;> simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue, proof_bitAddWithWork_value_2, ih] <;> ring  have proof_mulWithWork_value_35 (a : OAI.EditApproximation.SignedBinary) (b : OAI.EditApproximation.SignedBinary) :      (a.mulWithWork b).1.value = a.value * b.value := by    simp only [OAI.EditApproximation.SignedBinary.mulWithWork, OAI.EditApproximation.SignedBinary.value, proof_bitMulWithWork_value_0]    cases a.negative <;> cases b.negative <;> simp [OAI.EditApproximation.signedMagnitude]  have proof_mulWithWork_representation_36 (a : OAI.EditApproximation.BinaryFraction) (b : OAI.EditApproximation.BinaryFraction) :      (a.mulWithWork b).1.representation = a.representation.mul b.representation := by    apply proof_eq_of_num_den_33    · exact proof_mulWithWork_value_35 a.numerator b.numerator    · exact proof_bitMulWithWork_value_0 a.denominator b.denominator  have proof_canonicalMulWithWork_representation_37 (a : OAI.EditApproximation.BinaryFraction) (b : OAI.EditApproximation.BinaryFraction) :      (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork a b).1.representation = a.representation.mul b.representation := by    rw [OAI.EditApproximation.BinaryFraction.canonicalMulWithWork, proof_canonicalizeWithWork_representation_34, proof_mulWithWork_representation_36]  have proof_zero_representation_38 : OAI.EditApproximation.BinaryFraction.zero.representation = OAI.EditApproximation.UnreducedRational.zero := by    apply proof_eq_of_num_den_33 <;> rfl  have proof_invWithWork_representation_39 (a : OAI.EditApproximation.BinaryFraction) :      (a.invWithWork).1.representation = a.representation.inv := by    unfold OAI.EditApproximation.BinaryFraction.invWithWork    dsimp only    split_ifs with h    · have hz : OAI.EditApproximation.bitWordValue a.numerator.bits = 0 := by        simpa only [OAI.EditApproximation.bitWordValue] using (proof_bitCompareWithWork_eq_3 a.numerator.bits []).1 h      have hv : a.numerator.value = 0 := by (simp [OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, hz])      (simp only [OAI.EditApproximation.UnreducedRational.inv, OAI.EditApproximation.BinaryFraction.representation, hv, ↓reduceDIte])      exact proof_zero_representation_38    · have hn : OAI.EditApproximation.bitWordValue a.numerator.bits ≠ 0 := by        intro hz        exact h ((proof_bitCompareWithWork_eq_3 a.numerator.bits []).2 (by simpa [OAI.EditApproximation.bitWordValue] using hz))      have hv : a.numerator.value ≠ 0 := by        cases hs : a.numerator.negative <;> (simp [OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, hs, hn])      (simp only [OAI.EditApproximation.UnreducedRational.inv, OAI.EditApproximation.BinaryFraction.representation, hv, ↓reduceDIte])      apply proof_eq_of_num_den_33      · cases hs : a.numerator.negative <;>          simp [OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, hs, Int.sign_natCast_of_ne_zero hn]      · cases hs : a.numerator.negative <;> (simp [OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, hs])  have proof_divWithWork_representation_40 (a : OAI.EditApproximation.BinaryFraction) (b : OAI.EditApproximation.BinaryFraction) :      (a.divWithWork b).1.representation = a.representation.div b.representation := by    (simp only [OAI.EditApproximation.BinaryFraction.divWithWork, proof_canonicalMulWithWork_representation_37, proof_invWithWork_representation_39,      OAI.EditApproximation.UnreducedRational.div])  have proof_value_mul_41 (a : OAI.EditApproximation.UnreducedRational) (b : OAI.EditApproximation.UnreducedRational) : (a.mul b).value = a.value * b.value := by    simp [OAI.EditApproximation.UnreducedRational.mul, OAI.EditApproximation.UnreducedRational.value, mul_div_mul_comm]  have proof_value_inv_42 (a : OAI.EditApproximation.UnreducedRational) : a.inv.value = a.value⁻¹ := by    by_cases h : a.num = 0    · simp [OAI.EditApproximation.UnreducedRational.inv, h, OAI.EditApproximation.UnreducedRational.value, OAI.EditApproximation.UnreducedRational.zero]    · have hn : (a.num.natAbs : ℚ) ≠ 0 := by exact_mod_cast (Int.natAbs_pos.mpr h).ne'      have hd : (a.den : ℚ) ≠ 0 := by exact_mod_cast a.den_pos.ne'      have hsign : ((a.num.sign : ℤ) : ℚ) * a.num = (a.num.natAbs : ℚ) := by        simpa only [Int.cast_mul, Int.cast_natCast] using          congrArg (fun z : ℤ => (z : ℚ)) (Int.sign_mul_self_eq_natAbs a.num)      simp only [OAI.EditApproximation.UnreducedRational.inv, h, ↓reduceDIte, OAI.EditApproximation.UnreducedRational.value]      push_cast      apply eq_inv_of_mul_eq_one_left      field_simp [hn, hd]      exact hsign  have proof_value_div_43 (a : OAI.EditApproximation.UnreducedRational) (b : OAI.EditApproximation.UnreducedRational) : (a.div b).value = a.value / b.value := by    simp [proof_value_mul_41, proof_value_inv_42, OAI.EditApproximation.UnreducedRational.div, div_eq_mul_inv]  have proof_divWithWork_value_44 (a : OAI.EditApproximation.BinaryFraction) (b : OAI.EditApproximation.BinaryFraction) :      (OAI.EditApproximation.BinaryFraction.divWithWork a b).1.value = a.value / b.value := by    rw [← proof_representation_value_32, proof_divWithWork_representation_40,      proof_value_div_43, proof_representation_value_32, proof_representation_value_32]  have proof_canonicalMulWithWork_value_45 (a : OAI.EditApproximation.BinaryFraction) (b : OAI.EditApproximation.BinaryFraction) :      (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork a b).1.value = a.value * b.value := by    rw [← proof_representation_value_32, proof_canonicalMulWithWork_representation_37,      proof_value_mul_41, proof_representation_value_32, proof_representation_value_32]  have proof_value_ofInt_46 (a : ℤ) : (OAI.EditApproximation.SignedBinary.ofInt a).value = a := by    by_cases h : a < 0    · simpa only [OAI.EditApproximation.SignedBinary.ofInt, OAI.EditApproximation.SignedBinary.value, proof_bitWordValue_bits_15, OAI.EditApproximation.signedMagnitude, h, decide_true,        ↓reduceIte] using (Int.eq_neg_natAbs_of_nonpos (le_of_lt h)).symm    · simpa only [OAI.EditApproximation.SignedBinary.ofInt, OAI.EditApproximation.SignedBinary.value, proof_bitWordValue_bits_15, OAI.EditApproximation.signedMagnitude, h, decide_false,        Bool.false_eq_true, ↓reduceIte] using (Int.eq_natAbs_of_nonneg (le_of_not_gt h)).symm  have proof_nat_representation_47 (n : ℕ) : (OAI.EditApproximation.BinaryFraction.nat n).representation = OAI.EditApproximation.UnreducedRational.nat n := by    apply proof_eq_of_num_den_33    · change (OAI.EditApproximation.SignedBinary.ofInt (n : ℤ)).value = (n : ℤ)      exact proof_value_ofInt_46 _    · rfl  have proof_value_nat_48 (n : ℕ) : (OAI.EditApproximation.UnreducedRational.nat n).value = n := by (simp [OAI.EditApproximation.UnreducedRational.nat, OAI.EditApproximation.UnreducedRational.value])  have proof_nat_value_49 (n : ℕ) : (OAI.EditApproximation.BinaryFraction.nat n).value = (n : ℚ) := by    rw [← proof_representation_value_32, proof_nat_representation_47, proof_value_nat_48]  have proof_groupSampleCountWithWork_value_28 (M : ℕ) (Q : ℕ) (b : ℕ) (h : OAI.EditApproximation.BinaryFraction) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.BinaryFraction.groupSampleCountWithWork M Q b h).1 = OAI.EditApproximation.groupSampleCount M Q b h.value := by    simp only [OAI.EditApproximation.BinaryFraction.groupSampleCountWithWork, proof_wordMinWithWork_value_29, proof_bitWordValue_bits_15,      proof_naturalCeilingWithWork_value_31, proof_divWithWork_value_44, proof_canonicalMulWithWork_value_45,      proof_nat_value_49, OAI.EditApproximation.groupSampleCount]  have proof_queryScaleAt_value_88 (words : List.{0} OAI.EditApproximation.BinaryFraction) (scales : List.{0} ℚ) (h : Eq.{1} (List.map.{0, 0} OAI.EditApproximation.BinaryFraction.value words) scales) (i : Fin (List.length.{0} scales)) :      (OAI.EditApproximation.BinaryFraction.queryScaleAt words scales h i).value = scales[i.val] := by    subst scales    simp only [OAI.EditApproximation.BinaryFraction.queryScaleAt, List.getElem_map]  exact    let word := OAI.EditApproximation.BinaryFraction.queryScaleAt raw (OAI.EditApproximation.groupDyadicScales M b F) hs scale    let count := OAI.EditApproximation.BinaryFraction.groupSampleCountWithWork M Q b word    let hc : OAI.EditApproximation.bitWordValue count.1 = OAI.EditApproximation.groupSampleCount M Q b (OAI.EditApproximation.groupDyadicScaleAt M b F scale) := by      rw [proof_groupSampleCountWithWork_value_28, proof_queryScaleAt_value_88]      rfl    let coordinates := OAI.EditApproximation.queryFinRange (OAI.EditApproximation.bitWordValue count.1)      (OAI.EditApproximation.groupSampleCount M Q b (OAI.EditApproximation.groupDyadicScaleAt M b F scale)) hc    OAI.EditApproximation.BinaryFraction.groupSampleCountAllocation M Q b word + OAI.EditApproximation.arithmeticMapAllocation (fun _ => 2) coordinates +      2 * coordinates.lengthdef querySharedCellInputsAllocation {nx ny : ℕ} (M F Q eM eb eF : ℕ)    (hM : M = 2 ^ eM) (hF : F = 2 ^ eF) (parent : OAI.EditApproximation.TargetInterval nx)    (exponent : ℕ) (cell : ℕ × ℕ)    (draw : ∀ scale : Fin (OAI.EditApproximation.groupDyadicScales M (2 ^ eb) F).length,      Fin (OAI.EditApproximation.groupSampleCount M Q (2 ^ eb) (OAI.EditApproximation.groupDyadicScaleAt M (2 ^ eb) F scale)) → Fin M × ℕ)    (allocation : ∀ scale : Fin (OAI.EditApproximation.groupDyadicScales M (2 ^ eb) F).length,      Fin (OAI.EditApproximation.groupSampleCount M Q (2 ^ eb) (OAI.EditApproximation.groupDyadicScaleAt M (2 ^ eb) F scale)) → ℕ) : ℕ := by  have proof_representation_value_32 (a : OAI.EditApproximation.BinaryFraction) : a.representation.value = a.value := rfl  have proof_eq_of_num_den_33 {a : OAI.EditApproximation.UnreducedRational} {b : OAI.EditApproximation.UnreducedRational} (hnum : Eq.{1} a.num b.num) (hden : Eq.{1} a.den b.den) : a = b := by    cases a    cases b    cases hnum    cases hden    rfl  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_value_ofInt_46 (a : ℤ) : (OAI.EditApproximation.SignedBinary.ofInt a).value = a := by    by_cases h : a < 0    · simpa only [OAI.EditApproximation.SignedBinary.ofInt, OAI.EditApproximation.SignedBinary.value, proof_bitWordValue_bits_15, OAI.EditApproximation.signedMagnitude, h, decide_true,        ↓reduceIte] using (Int.eq_neg_natAbs_of_nonpos (le_of_lt h)).symm    · simpa only [OAI.EditApproximation.SignedBinary.ofInt, OAI.EditApproximation.SignedBinary.value, proof_bitWordValue_bits_15, OAI.EditApproximation.signedMagnitude, h, decide_false,        Bool.false_eq_true, ↓reduceIte] using (Int.eq_natAbs_of_nonneg (le_of_not_gt h)).symm  have proof_nat_representation_47 (n : ℕ) : (OAI.EditApproximation.BinaryFraction.nat n).representation = OAI.EditApproximation.UnreducedRational.nat n := by    apply proof_eq_of_num_den_33    · change (OAI.EditApproximation.SignedBinary.ofInt (n : ℤ)).value = (n : ℤ)      exact proof_value_ofInt_46 _    · rfl  have proof_value_nat_48 (n : ℕ) : (OAI.EditApproximation.UnreducedRational.nat n).value = n := by (simp [OAI.EditApproximation.UnreducedRational.nat, OAI.EditApproximation.UnreducedRational.value])  have proof_nat_value_49 (n : ℕ) : (OAI.EditApproximation.BinaryFraction.nat n).value = (n : ℚ) := by    rw [← proof_representation_value_32, proof_nat_representation_47, proof_value_nat_48]  have proof_arithmeticMapWithWork_value_70 {α : Type 0} {β : Type 0} (f : α → Prod.{0, 0} β ℕ) (values : List.{0} α) :      (OAI.EditApproximation.arithmeticMapWithWork f values).1 = values.map (fun a => (f a).1) := by    induction values with    | nil => rfl    | cons a rest ih => simp only [OAI.EditApproximation.arithmeticMapWithWork, ih, List.map_cons]  have proof_powerTwoWord_value_13 (n : ℕ) : OAI.EditApproximation.bitWordValue (OAI.EditApproximation.powerTwoWord n) = 2 ^ n := by    induction n with    | zero => (simp [OAI.EditApproximation.powerTwoWord, OAI.EditApproximation.bitWordValue])    | succ n ih =>      (simp only [OAI.EditApproximation.powerTwoWord, List.replicate_succ, List.cons_append, OAI.EditApproximation.bitWordValue,        Bool.toNat_false, zero_add] at *)      rw [ih, pow_succ]      omega  have proof_inversePowerTwo_value_89 (n : ℕ) : (OAI.EditApproximation.BinaryFraction.inversePowerTwo n).value = (2 : ℚ) ^ (-(n : ℤ)) := by    (simp only [OAI.EditApproximation.BinaryFraction.inversePowerTwo, OAI.EditApproximation.BinaryFraction.value, OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, Bool.false_eq_true,      ↓reduceIte, OAI.EditApproximation.bitWordValue, Bool.toNat_true,      Int.cast_natCast, proof_powerTwoWord_value_13, Nat.cast_pow, Nat.cast_ofNat, zpow_neg, zpow_natCast])    norm_num [one_div]  have proof_signedPowerTwoWithWork_value_90 (e : ℤ) :      (OAI.EditApproximation.BinaryFraction.signedPowerTwoWithWork e).1.value = (2 : ℚ) ^ e := by    unfold OAI.EditApproximation.BinaryFraction.signedPowerTwoWithWork    split_ifs with h    · change (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.powerTwoWord e.toNat) : ℚ) / 1 = (2 : ℚ) ^ e      rw [div_one, proof_powerTwoWord_value_13, Nat.cast_pow, Nat.cast_ofNat, ← zpow_natCast,        Int.toNat_of_nonneg h]    · rw [proof_inversePowerTwo_value_89, Int.toNat_of_nonneg        (show 0 ≤ -e from neg_nonneg.mpr (le_of_lt (lt_of_not_ge h))), neg_neg]  have proof_groupScalesWithWork_value_91 (eM : ℕ) (eb : ℕ) (eF : ℕ) :      ((OAI.EditApproximation.BinaryFraction.groupScalesWithWork eM eb eF).1.map OAI.EditApproximation.BinaryFraction.value) =        OAI.EditApproximation.groupDyadicScales (2 ^ eM) (2 ^ eb) ((2 : ℚ) ^ eF) := by    have hlower : ((2 ^ eb : ℕ) : ℚ) / (2 ^ eM : ℕ) = (2 : ℚ) ^ ((eb : ℤ) - eM) := by      rw [Nat.cast_pow, Nat.cast_pow, Nat.cast_ofNat, zpow_sub₀ (by norm_num : (2 : ℚ) ≠ 0),        zpow_natCast, zpow_natCast]    have hupper : (64 : ℚ) * (2 : ℚ) ^ eF * (2 ^ eb : ℕ) =        (2 : ℚ) ^ ((6 + eF + eb : ℕ) : ℤ) := by      rw [Nat.cast_pow, Nat.cast_ofNat, zpow_natCast, pow_add, pow_add]      norm_num    have hlog : Int.log 2 ((2 : ℚ) ^ ((6 + eF + eb : ℕ) : ℤ)) = ((6 + eF + eb : ℕ) : ℤ) := by      simpa only [Nat.cast_ofNat] using Int.log_zpow (R := ℚ) (by decide : 1 < 2) ((6 + eF + eb : ℕ) : ℤ)    have hclog : Int.clog 2 ((2 : ℚ) ^ ((eb : ℤ) - eM)) = (eb : ℤ) - eM := by      simpa only [Nat.cast_ofNat] using Int.clog_zpow (R := ℚ) (by decide : 1 < 2) ((eb : ℤ) - eM)    simp only [OAI.EditApproximation.BinaryFraction.groupScalesWithWork, proof_arithmeticMapWithWork_value_70, List.map_map,      Function.comp_def, proof_signedPowerTwoWithWork_value_90, OAI.EditApproximation.groupDyadicScales, hlower, hupper, hlog, hclog]  have proof_computedGroupScales_value_87 (M : ℕ) (b : ℕ) (F : ℕ) (eM : ℕ) (eb : ℕ) (eF : ℕ) (hM : Eq.{1} M (HPow.hPow.{0, 0, 0} 2 eM)) (hb : Eq.{1} b (HPow.hPow.{0, 0, 0} 2 eb)) (hF : Eq.{1} F (HPow.hPow.{0, 0, 0} 2 eF)) :      (OAI.EditApproximation.BinaryFraction.groupScalesWithWork eM eb eF).1.map OAI.EditApproximation.BinaryFraction.value = OAI.EditApproximation.groupDyadicScales M b (OAI.EditApproximation.BinaryFraction.nat F).value := by    rw [proof_nat_value_49, hM, hb, hF, Nat.cast_pow, Nat.cast_ofNat]    exact proof_groupScalesWithWork_value_91 eM eb eF  have proof_queryScaleAt_value_88 (words : List.{0} OAI.EditApproximation.BinaryFraction) (scales : List.{0} ℚ) (h : Eq.{1} (List.map.{0, 0} OAI.EditApproximation.BinaryFraction.value words) scales) (i : Fin (List.length.{0} scales)) :      (OAI.EditApproximation.BinaryFraction.queryScaleAt words scales h i).value = scales[i.val] := by    subst scales    simp only [OAI.EditApproximation.BinaryFraction.queryScaleAt, List.getElem_map]  have proof_queryGroupScaleAt_value_92 (M : ℕ) (b : ℕ) (F : ℕ) (words : List.{0} OAI.EditApproximation.BinaryFraction) (h : Eq.{1} (List.map.{0, 0} OAI.EditApproximation.BinaryFraction.value words)    (OAI.EditApproximation.groupDyadicScales M b ↑F)) (i : Fin (List.length.{0} (OAI.EditApproximation.groupDyadicScales M b ↑F))) :      (OAI.EditApproximation.BinaryFraction.queryScaleAt words (OAI.EditApproximation.groupDyadicScales M b F) h i).value = OAI.EditApproximation.groupDyadicScaleAt M b F i :=    proof_queryScaleAt_value_88 words (OAI.EditApproximation.groupDyadicScales M b F) h i  exact    let b := 2 ^ eb    let scales := OAI.EditApproximation.BinaryFraction.groupScalesWithWork eM eb eF    let hs : scales.1.map OAI.EditApproximation.BinaryFraction.value = OAI.EditApproximation.groupDyadicScales M b F := by      simpa only [proof_nat_value_49] using proof_computedGroupScales_value_87 M b F eM eb eF hM rfl hF    let hlen : scales.1.length = (OAI.EditApproximation.groupDyadicScales M b F).length := by      simpa only [List.length_map] using congrArg List.length hs    let indices := OAI.EditApproximation.queryFinRange scales.1.length (OAI.EditApproximation.groupDyadicScales M b F).length hlen    let build := fun scale =>      let word := OAI.EditApproximation.BinaryFraction.queryScaleAt scales.1 (OAI.EditApproximation.groupDyadicScales M b F) hs scale      let hv : word.value = OAI.EditApproximation.groupDyadicScaleAt M b F scale := proof_queryGroupScaleAt_value_92 M b F _ hs scale      let states := OAI.EditApproximation.BinaryFraction.queryGroupInputsTransportWithWork (ny := ny) parent b exponent Q cell word        (OAI.EditApproximation.groupDyadicScaleAt M b F scale) hv (draw scale)      (states.1, states.2 + scales.1.length + 1)    OAI.EditApproximation.BinaryFraction.groupScalesAllocation eM eb eF + 2 * scales.1.length + eb + 1 +      OAI.EditApproximation.arithmeticFlatMapAllocation build (fun scale =>        let word := OAI.EditApproximation.BinaryFraction.queryScaleAt scales.1 (OAI.EditApproximation.groupDyadicScales M b F) hs scale        let hv : word.value = OAI.EditApproximation.groupDyadicScaleAt M b F scale := proof_queryGroupScaleAt_value_92 M b F _ hs scale        OAI.EditApproximation.BinaryFraction.queryGroupInputsTransportAllocation (ny := ny) parent b exponent Q cell word          (OAI.EditApproximation.groupDyadicScaleAt M b F scale) hv (draw scale) (allocation scale)) indicesdef queryGroupKeySamplesAllocation (M F Q eM eb eF : ℕ)    (hM : M = 2 ^ eM) (hF : F = 2 ^ eF) (cell : ℕ × ℕ) : ℕ := by  have proof_representation_value_32 (a : OAI.EditApproximation.BinaryFraction) : a.representation.value = a.value := rfl  have proof_eq_of_num_den_33 {a : OAI.EditApproximation.UnreducedRational} {b : OAI.EditApproximation.UnreducedRational} (hnum : Eq.{1} a.num b.num) (hden : Eq.{1} a.den b.den) : a = b := by    cases a    cases b    cases hnum    cases hden    rfl  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_value_ofInt_46 (a : ℤ) : (OAI.EditApproximation.SignedBinary.ofInt a).value = a := by    by_cases h : a < 0    · simpa only [OAI.EditApproximation.SignedBinary.ofInt, OAI.EditApproximation.SignedBinary.value, proof_bitWordValue_bits_15, OAI.EditApproximation.signedMagnitude, h, decide_true,        ↓reduceIte] using (Int.eq_neg_natAbs_of_nonpos (le_of_lt h)).symm    · simpa only [OAI.EditApproximation.SignedBinary.ofInt, OAI.EditApproximation.SignedBinary.value, proof_bitWordValue_bits_15, OAI.EditApproximation.signedMagnitude, h, decide_false,        Bool.false_eq_true, ↓reduceIte] using (Int.eq_natAbs_of_nonneg (le_of_not_gt h)).symm  have proof_nat_representation_47 (n : ℕ) : (OAI.EditApproximation.BinaryFraction.nat n).representation = OAI.EditApproximation.UnreducedRational.nat n := by    apply proof_eq_of_num_den_33    · change (OAI.EditApproximation.SignedBinary.ofInt (n : ℤ)).value = (n : ℤ)      exact proof_value_ofInt_46 _    · rfl  have proof_value_nat_48 (n : ℕ) : (OAI.EditApproximation.UnreducedRational.nat n).value = n := by (simp [OAI.EditApproximation.UnreducedRational.nat, OAI.EditApproximation.UnreducedRational.value])  have proof_nat_value_49 (n : ℕ) : (OAI.EditApproximation.BinaryFraction.nat n).value = (n : ℚ) := by    rw [← proof_representation_value_32, proof_nat_representation_47, proof_value_nat_48]  have proof_arithmeticMapWithWork_value_70 {α : Type 0} {β : Type 0} (f : α → Prod.{0, 0} β ℕ) (values : List.{0} α) :      (OAI.EditApproximation.arithmeticMapWithWork f values).1 = values.map (fun a => (f a).1) := by    induction values with    | nil => rfl    | cons a rest ih => simp only [OAI.EditApproximation.arithmeticMapWithWork, ih, List.map_cons]  have proof_powerTwoWord_value_13 (n : ℕ) : OAI.EditApproximation.bitWordValue (OAI.EditApproximation.powerTwoWord n) = 2 ^ n := by    induction n with    | zero => (simp [OAI.EditApproximation.powerTwoWord, OAI.EditApproximation.bitWordValue])    | succ n ih =>      (simp only [OAI.EditApproximation.powerTwoWord, List.replicate_succ, List.cons_append, OAI.EditApproximation.bitWordValue,        Bool.toNat_false, zero_add] at *)      rw [ih, pow_succ]      omega  have proof_inversePowerTwo_value_89 (n : ℕ) : (OAI.EditApproximation.BinaryFraction.inversePowerTwo n).value = (2 : ℚ) ^ (-(n : ℤ)) := by    (simp only [OAI.EditApproximation.BinaryFraction.inversePowerTwo, OAI.EditApproximation.BinaryFraction.value, OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, Bool.false_eq_true,      ↓reduceIte, OAI.EditApproximation.bitWordValue, Bool.toNat_true,      Int.cast_natCast, proof_powerTwoWord_value_13, Nat.cast_pow, Nat.cast_ofNat, zpow_neg, zpow_natCast])    norm_num [one_div]  have proof_signedPowerTwoWithWork_value_90 (e : ℤ) :      (OAI.EditApproximation.BinaryFraction.signedPowerTwoWithWork e).1.value = (2 : ℚ) ^ e := by    unfold OAI.EditApproximation.BinaryFraction.signedPowerTwoWithWork    split_ifs with h    · change (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.powerTwoWord e.toNat) : ℚ) / 1 = (2 : ℚ) ^ e      rw [div_one, proof_powerTwoWord_value_13, Nat.cast_pow, Nat.cast_ofNat, ← zpow_natCast,        Int.toNat_of_nonneg h]    · rw [proof_inversePowerTwo_value_89, Int.toNat_of_nonneg        (show 0 ≤ -e from neg_nonneg.mpr (le_of_lt (lt_of_not_ge h))), neg_neg]  have proof_groupScalesWithWork_value_91 (eM : ℕ) (eb : ℕ) (eF : ℕ) :      ((OAI.EditApproximation.BinaryFraction.groupScalesWithWork eM eb eF).1.map OAI.EditApproximation.BinaryFraction.value) =        OAI.EditApproximation.groupDyadicScales (2 ^ eM) (2 ^ eb) ((2 : ℚ) ^ eF) := by    have hlower : ((2 ^ eb : ℕ) : ℚ) / (2 ^ eM : ℕ) = (2 : ℚ) ^ ((eb : ℤ) - eM) := by      rw [Nat.cast_pow, Nat.cast_pow, Nat.cast_ofNat, zpow_sub₀ (by norm_num : (2 : ℚ) ≠ 0),        zpow_natCast, zpow_natCast]    have hupper : (64 : ℚ) * (2 : ℚ) ^ eF * (2 ^ eb : ℕ) =        (2 : ℚ) ^ ((6 + eF + eb : ℕ) : ℤ) := by      rw [Nat.cast_pow, Nat.cast_ofNat, zpow_natCast, pow_add, pow_add]      norm_num    have hlog : Int.log 2 ((2 : ℚ) ^ ((6 + eF + eb : ℕ) : ℤ)) = ((6 + eF + eb : ℕ) : ℤ) := by      simpa only [Nat.cast_ofNat] using Int.log_zpow (R := ℚ) (by decide : 1 < 2) ((6 + eF + eb : ℕ) : ℤ)    have hclog : Int.clog 2 ((2 : ℚ) ^ ((eb : ℤ) - eM)) = (eb : ℤ) - eM := by      simpa only [Nat.cast_ofNat] using Int.clog_zpow (R := ℚ) (by decide : 1 < 2) ((eb : ℤ) - eM)    simp only [OAI.EditApproximation.BinaryFraction.groupScalesWithWork, proof_arithmeticMapWithWork_value_70, List.map_map,      Function.comp_def, proof_signedPowerTwoWithWork_value_90, OAI.EditApproximation.groupDyadicScales, hlower, hupper, hlog, hclog]  have proof_computedGroupScales_value_87 (M : ℕ) (b : ℕ) (F : ℕ) (eM : ℕ) (eb : ℕ) (eF : ℕ) (hM : Eq.{1} M (HPow.hPow.{0, 0, 0} 2 eM)) (hb : Eq.{1} b (HPow.hPow.{0, 0, 0} 2 eb)) (hF : Eq.{1} F (HPow.hPow.{0, 0, 0} 2 eF)) :      (OAI.EditApproximation.BinaryFraction.groupScalesWithWork eM eb eF).1.map OAI.EditApproximation.BinaryFraction.value = OAI.EditApproximation.groupDyadicScales M b (OAI.EditApproximation.BinaryFraction.nat F).value := by    rw [proof_nat_value_49, hM, hb, hF, Nat.cast_pow, Nat.cast_ofNat]    exact proof_groupScalesWithWork_value_91 eM eb eF  exact    let b := 2 ^ eb    let scales := OAI.EditApproximation.BinaryFraction.groupScalesWithWork eM eb eF    let hs : scales.1.map OAI.EditApproximation.BinaryFraction.value = OAI.EditApproximation.groupDyadicScales M b F := by      simpa only [proof_nat_value_49] using proof_computedGroupScales_value_87 M b F eM eb eF hM rfl hF    let hlen : scales.1.length = (OAI.EditApproximation.groupDyadicScales M b F).length := by      simpa only [List.length_map] using congrArg List.length hs    let indices := OAI.EditApproximation.queryFinRange scales.1.length (OAI.EditApproximation.groupDyadicScales M b F).length hlen    OAI.EditApproximation.BinaryFraction.groupScalesAllocation eM eb eF + 2 * scales.1.length + eb + 1 +      OAI.EditApproximation.arithmeticFlatMapAllocation (OAI.EditApproximation.BinaryFraction.groupKeySampleBlock (Q := Q) b scales.1 hs cell)        (OAI.EditApproximation.BinaryFraction.groupKeySampleBlockAllocation (Q := Q) b scales.1 hs cell) indicesend OAI.EditApproximation.BinaryFractionendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.BinaryFractiondef querySharedInputsWithWork {nx ny : ℕ} (M N F Q exponent eM eF : ℕ)    (hM : M = 2 ^ eM) (hF : F = 2 ^ eF) (parent : OAI.EditApproximation.TargetInterval nx)    (a value : OAI.EditApproximation.BinaryFraction) (query : OAI.EditApproximation.TargetInterval ny) (draw : OAI.EditApproximation.CountedCellGroupDraws M F Q) :    List (Fin M × OAI.EditApproximation.TargetInterval ny) × ℕ :=  let scales := OAI.EditApproximation.BinaryFraction.queryExponentsWithWork N F a value  let radius := OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork value  let inputs := OAI.EditApproximation.arithmeticFlatMapWithWork (fun eb =>    let side := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.inversePowerTwo exponent) (OAI.EditApproximation.BinaryFraction.nat (2 ^ eb))    let cells := OAI.EditApproximation.BinaryFraction.targetCellsWithWork side.1 (OAI.EditApproximation.bitWordValue radius.1) query    let states := OAI.EditApproximation.arithmeticFlatMapWithWork (fun cell =>      OAI.EditApproximation.BinaryFraction.querySharedCellInputsWithWork M F Q eM eb eF hM hF parent exponent cell (draw (2 ^ eb) cell)) cells.1    (states.1, side.2 + cells.2 + states.2 + eb + exponent + 4)) scales.1  let sorted := OAI.EditApproximation.queryOrderedChildInputsWithWork inputs.1  (sorted.1, scales.2 + radius.2 + inputs.2 + sorted.2 + 3)def queryGroupDrawReadWithWork {M F Q : ℕ} [NeZero M]    (keys : List (OAI.EditApproximation.GroupScalarKey M F Q)) (values : List OAI.EditApproximation.BinaryFraction)    (b : ℕ) (cell : ℕ × ℕ) (scale : Fin (OAI.EditApproximation.groupDyadicScales M b F).length)    (sample : Fin (OAI.EditApproximation.groupSampleCount M Q b (OAI.EditApproximation.groupDyadicScaleAt M b F scale))) : Fin M × ℕ := by  have proof_bitOrdering_matches_4 (high : Ordering) (a : Bool) (b : Bool) (x : ℕ) (y : ℕ) (h : OAI.EditApproximation.orderingMatches high x y) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitOrdering high a b) (a.toNat + 2 * x) (b.toNat + 2 * y) := by    rcases h with ⟨rfl, h⟩ | ⟨rfl, rfl⟩ | ⟨rfl, h⟩    · exact Or.inl ⟨rfl, by cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩    · cases a <;> cases b <;> simp [OAI.EditApproximation.bitOrdering, OAI.EditApproximation.orderingMatches]    · exact Or.inr (Or.inr ⟨rfl, by        cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩)  have proof_bitCompareWithWork_matches_5 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitCompareWithWork left right).1 (OAI.EditApproximation.bitWordValue left) (OAI.EditApproximation.bitWordValue right) := by    induction left generalizing right with    | nil =>      simp only [OAI.EditApproximation.bitCompareWithWork]      induction right with      | nil => (simp [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.orderingMatches, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        simpa only [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareNilLeftWithWork bs).1 false b 0 (OAI.EditApproximation.bitWordValue bs) ih    | cons a as ih =>      cases right with      | nil =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as []).1 a false (OAI.EditApproximation.bitWordValue as) 0 (ih [])      | cons b bs =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue] using          proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as bs).1 a b (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs) (ih bs)  have proof_bitCompareWithWork_lt_16 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .lt ↔ OAI.EditApproximation.bitWordValue left < OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_bitSubtractor_value_17 (a : Bool) (b : Bool) (borrow : Bool) :      a.toNat + 2 * (OAI.EditApproximation.bitBorrow a b borrow).toNat =        b.toNat + borrow.toNat + (OAI.EditApproximation.bitDifference a b borrow).toNat := by    cases a <;> cases b <;> cases borrow <;> decide  have proof_bitSubtractionRippleEquation_18 (a : ℕ) (b : ℕ) (borrow : ℕ) (nextBorrow : ℕ) (difference : ℕ) (left : ℕ) (right : ℕ) (result : ℕ) (tail : ℕ) (htail : Eq.{1} (HAdd.hAdd.{0, 0, 0} (HAdd.hAdd.{0, 0, 0} result right) nextBorrow) (HAdd.hAdd.{0, 0, 0} left tail)) (hbit : Eq.{1} (HAdd.hAdd.{0, 0, 0} a (HMul.hMul.{0, 0, 0} 2 nextBorrow))    (HAdd.hAdd.{0, 0, 0} (HAdd.hAdd.{0, 0, 0} b borrow) difference)) :      (difference + 2 * result) + (b + 2 * right) + borrow =        (a + 2 * left) + 2 * tail := by    omega  have proof_bitSubtractWithWork_value_19 (left : List.{0} Bool) (right : List.{0} Bool) (borrow : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork left right borrow).1 + OAI.EditApproximation.bitWordValue right + borrow.toNat =        OAI.EditApproximation.bitWordValue left + 2 ^ max left.length right.length *          (OAI.EditApproximation.bitSubtractWithWork left right borrow).2.1.toNat := by    induction left generalizing right borrow with    | nil =>      induction right generalizing borrow with      | nil => (simp [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitSubtractNilLeftWithWork, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        have h := ih (OAI.EditApproximation.bitBorrow false b borrow)        have hb := proof_bitSubtractor_value_17 false b borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitSubtractNilLeftWithWork, OAI.EditApproximation.bitWordValue,          List.length_nil, List.length_cons, Nat.zero_max, pow_succ, Bool.toNat_false] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 0 b.toNat borrow.toNat (OAI.EditApproximation.bitBorrow false b borrow).toNat          (OAI.EditApproximation.bitDifference false b borrow).toNat 0 (OAI.EditApproximation.bitWordValue bs)          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractNilLeftWithWork bs (OAI.EditApproximation.bitBorrow false b borrow)).1)          (2 ^ bs.length * (OAI.EditApproximation.bitSubtractNilLeftWithWork bs (OAI.EditApproximation.bitBorrow false b borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_zero, Nat.add_zero, Nat.zero_add, Nat.mul_assoc,          Nat.mul_left_comm] using hs    | cons a as ih =>      cases right with      | nil =>        have h := ih [] (OAI.EditApproximation.bitBorrow a false borrow)        have hb := proof_bitSubtractor_value_17 a false borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitWordValue, List.length_nil, List.length_cons,          Nat.max_zero, pow_succ, Bool.toNat_false] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 a.toNat 0 borrow.toNat (OAI.EditApproximation.bitBorrow a false borrow).toNat          (OAI.EditApproximation.bitDifference a false borrow).toNat (OAI.EditApproximation.bitWordValue as) 0          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork as [] (OAI.EditApproximation.bitBorrow a false borrow)).1)          (2 ^ as.length * (OAI.EditApproximation.bitSubtractWithWork as [] (OAI.EditApproximation.bitBorrow a false borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_zero, Nat.add_zero, Nat.zero_add, Nat.mul_assoc,          Nat.mul_left_comm] using hs      | cons b bs =>        have h := ih bs (OAI.EditApproximation.bitBorrow a b borrow)        have hb := proof_bitSubtractor_value_17 a b borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitWordValue, List.length_cons, Nat.succ_max_succ,          pow_succ] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 a.toNat b.toNat borrow.toNat (OAI.EditApproximation.bitBorrow a b borrow).toNat          (OAI.EditApproximation.bitDifference a b borrow).toNat (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs)          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork as bs (OAI.EditApproximation.bitBorrow a b borrow)).1)          (2 ^ max as.length bs.length * (OAI.EditApproximation.bitSubtractWithWork as bs (OAI.EditApproximation.bitBorrow a b borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_assoc, Nat.mul_left_comm] using hs  have proof_bitWordValue_lt_pow_length_20 (bits : List.{0} Bool) : OAI.EditApproximation.bitWordValue bits < 2 ^ bits.length := by    induction bits with    | nil => (simp [OAI.EditApproximation.bitWordValue])    | cons bit bits ih =>      cases bit <;> (simp only [OAI.EditApproximation.bitWordValue, List.length_cons, pow_succ, Bool.toNat_false, Bool.toNat_true]) <;> omega  have proof_bitSubtractWithWork_length_21 (left : List.{0} Bool) (right : List.{0} Bool) (borrow : Bool) :      (OAI.EditApproximation.bitSubtractWithWork left right borrow).1.length = max left.length right.length := by    induction left generalizing right borrow with    | nil =>      simp only [OAI.EditApproximation.bitSubtractWithWork]      induction right generalizing borrow with      | nil => simp [OAI.EditApproximation.bitSubtractNilLeftWithWork]      | cons b bs ih => simp [OAI.EditApproximation.bitSubtractNilLeftWithWork, ih]    | cons a as ih =>      cases right with      | nil => simp [OAI.EditApproximation.bitSubtractWithWork, ih]      | cons b bs => simp [OAI.EditApproximation.bitSubtractWithWork, ih, Nat.succ_max_succ]  have proof_bitSubtractWithWork_sub_22 (left : List.{0} Bool) (right : List.{0} Bool) (h : LE.le.{0} (OAI.EditApproximation.bitWordValue right) (OAI.EditApproximation.bitWordValue left)) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork left right false).1 = OAI.EditApproximation.bitWordValue left - OAI.EditApproximation.bitWordValue right := by    have hvalue := proof_bitSubtractWithWork_value_19 left right false    have hlt := proof_bitWordValue_lt_pow_length_20 (OAI.EditApproximation.bitSubtractWithWork left right false).1    rw [proof_bitSubtractWithWork_length_21] at hlt    cases hb : (OAI.EditApproximation.bitSubtractWithWork left right false).2.1    · simp only [hb, Bool.toNat_false, Nat.mul_zero, Nat.add_zero] at hvalue      omega    · simp only [hb, Bool.toNat_true, Bool.toNat_false, Nat.mul_one, Nat.add_zero] at hvalue      omega  have proof_bitDivModWithWork_value_23 (divisor : List.{0} Bool) (bits : List.{0} Bool) (hd : LT.lt.{0} 0 (OAI.EditApproximation.bitWordValue divisor)) :      OAI.EditApproximation.bitWordValue bits = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).1 +        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 ∧        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 < OAI.EditApproximation.bitWordValue divisor := by    induction bits with    | nil => (simp [OAI.EditApproximation.bitDivModWithWork, OAI.EditApproximation.bitWordValue, hd])    | cons bit bits ih =>      let previous := OAI.EditApproximation.bitDivModWithWork divisor bits      let candidate := bit :: previous.2.1      have hp : OAI.EditApproximation.bitWordValue bits = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue previous.1 +          OAI.EditApproximation.bitWordValue previous.2.1 := ih.1      have hr : OAI.EditApproximation.bitWordValue previous.2.1 < OAI.EditApproximation.bitWordValue divisor := ih.2      have hc : OAI.EditApproximation.bitWordValue candidate < 2 * OAI.EditApproximation.bitWordValue divisor := by        dsimp only [candidate, OAI.EditApproximation.bitWordValue]        cases bit <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega      by_cases hlt : (OAI.EditApproximation.bitCompareWithWork candidate divisor).1 = .lt      · have hv := (proof_bitCompareWithWork_lt_16 candidate divisor).1 hlt        simp only [OAI.EditApproximation.bitDivModWithWork, show (OAI.EditApproximation.bitCompareWithWork (bit :: (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1)          divisor).1 = .lt from hlt, ↓reduceIte]        change OAI.EditApproximation.bitWordValue (bit :: bits) = OAI.EditApproximation.bitWordValue divisor *          OAI.EditApproximation.bitWordValue (false :: previous.1) + OAI.EditApproximation.bitWordValue candidate ∧ OAI.EditApproximation.bitWordValue candidate < _        constructor        · (simp only [OAI.EditApproximation.bitWordValue, Bool.toNat_false])          dsimp only [candidate, OAI.EditApproximation.bitWordValue]          nlinarith only [hp]        · exact hv      · have hv : OAI.EditApproximation.bitWordValue divisor ≤ OAI.EditApproximation.bitWordValue candidate := by          exact Nat.le_of_not_gt (fun h => hlt ((proof_bitCompareWithWork_lt_16 candidate divisor).2 h))        have hs := proof_bitSubtractWithWork_sub_22 candidate divisor hv        simp only [OAI.EditApproximation.bitDivModWithWork, show (OAI.EditApproximation.bitCompareWithWork (bit :: (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1)          divisor).1 ≠ .lt from hlt, ↓reduceIte]        change OAI.EditApproximation.bitWordValue (bit :: bits) = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue (true :: previous.1) +          OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork candidate divisor false).1 ∧          OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork candidate divisor false).1 < _        rw [hs]        constructor        · (simp only [OAI.EditApproximation.bitWordValue, Bool.toNat_true])          have he := Nat.sub_add_cancel hv          dsimp only [candidate, OAI.EditApproximation.bitWordValue] at he ⊢          nlinarith only [hp, he]        · omega  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_binaryNaturalDivModWithWork_spec_24 (n : ℕ) (d : ℕ) (hd : LT.lt.{0} 0 d) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalDivModWithWork n d).1 = n / d ∧        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalDivModWithWork n d).2.1 = n % d := by    have h := proof_bitDivModWithWork_value_23 d.bits n.bits (by simpa only [proof_bitWordValue_bits_15] using hd)    simp only [proof_bitWordValue_bits_15] at h    have hmod : n % d = OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork d.bits n.bits).2.1 := by      conv_lhs => rw [h.1]      simp only [Nat.add_mod, Nat.mul_mod_right, Nat.zero_add, Nat.mod_eq_of_lt h.2]    have hdiv : n / d = OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork d.bits n.bits).1 := by      conv_lhs => rw [h.1]      rw [Nat.mul_add_div hd, Nat.div_eq_of_lt h.2, Nat.add_zero]    exact ⟨hdiv.symm, hmod.symm⟩  exact    let word := OAI.EditApproximation.BinaryFraction.gatheredWordLookupWithWork OAI.EditApproximation.queryGroupKeyEqualWithWork keys values ⟨(b, cell), scale, sample⟩    let floor := OAI.EditApproximation.BinaryFraction.naturalFloorWithWork word.1    let reduced := OAI.EditApproximation.binaryNaturalDivModWithWork (OAI.EditApproximation.bitWordValue floor.1) M    (⟨OAI.EditApproximation.bitWordValue reduced.2.1, by      rw [(proof_binaryNaturalDivModWithWork_spec_24 _ M (NeZero.pos M)).2]      exact Nat.mod_lt _ (NeZero.pos M)⟩,      word.2 + floor.2 + reduced.2.2 + 3)def queryGroupSourceKeysWithWork {n : ℕ} (M N F Q exponent eM eF : ℕ)    (hM : M = 2 ^ eM) (hF : F = 2 ^ eF) (a value : OAI.EditApproximation.BinaryFraction)    (q : OAI.EditApproximation.TargetInterval n) : List (OAI.EditApproximation.GroupScalarKey M F Q) × ℕ :=  let scales := OAI.EditApproximation.BinaryFraction.queryExponentsWithWork N F a value  let radius := OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork value  let keys := OAI.EditApproximation.arithmeticFlatMapWithWork (fun eb =>    let side := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.inversePowerTwo exponent) (OAI.EditApproximation.BinaryFraction.nat (2 ^ eb))    let cells := OAI.EditApproximation.BinaryFraction.targetCellsWithWork side.1 (OAI.EditApproximation.bitWordValue radius.1) q    let sources := OAI.EditApproximation.arithmeticFlatMapWithWork      (OAI.EditApproximation.BinaryFraction.queryGroupKeySamplesWithWork M F Q eM eb eF hM hF) cells.1    (sources.1, side.2 + cells.2 + sources.2 + eb + exponent + 4)) scales.1  (keys.1, scales.2 + radius.2 + keys.2 + 2)def queryGroupDrawReadAllocation {M F Q : ℕ} [NeZero M]    (keys : List (OAI.EditApproximation.GroupScalarKey M F Q)) (values : List OAI.EditApproximation.BinaryFraction)    (b : ℕ) (cell : ℕ × ℕ) (scale : Fin (OAI.EditApproximation.groupDyadicScales M b F).length)    (sample : Fin (OAI.EditApproximation.groupSampleCount M Q b (OAI.EditApproximation.groupDyadicScaleAt M b F scale))) : ℕ :=  let key : OAI.EditApproximation.GroupScalarKey M F Q := ⟨(b, cell), scale, sample⟩  let word := (OAI.EditApproximation.BinaryFraction.gatheredWordLookupWithWork OAI.EditApproximation.queryGroupKeyEqualWithWork keys values key).1  let floor := (OAI.EditApproximation.BinaryFraction.naturalFloorWithWork word).1  OAI.EditApproximation.BinaryFraction.gatheredLookupAllocation OAI.EditApproximation.queryGroupKeyEqualWithWork OAI.EditApproximation.queryGroupKeyEqualAllocation keys values key +    OAI.EditApproximation.BinaryFraction.naturalFloorAllocation word + OAI.EditApproximation.bitDivModAllocation M.bits (OAI.EditApproximation.bitWordValue floor).bitsdef queryGroupSourceKeysAllocation {n : ℕ} (M N F Q exponent eM eF : ℕ)    (hM : M = 2 ^ eM) (hF : F = 2 ^ eF) (a value : OAI.EditApproximation.BinaryFraction) (q : OAI.EditApproximation.TargetInterval n) : ℕ :=  let radius := (OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork value).1  let build := fun eb =>    let side := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.inversePowerTwo exponent) (OAI.EditApproximation.BinaryFraction.nat (2 ^ eb))    let cells := OAI.EditApproximation.BinaryFraction.targetCellsWithWork side.1 (OAI.EditApproximation.bitWordValue radius) q    let sources := OAI.EditApproximation.arithmeticFlatMapWithWork (OAI.EditApproximation.BinaryFraction.queryGroupKeySamplesWithWork M F Q eM eb eF hM hF) cells.1    (sources.1, side.2 + cells.2 + sources.2 + eb + exponent + 4)  let allocation := fun eb =>    let side := (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.inversePowerTwo exponent) (OAI.EditApproximation.BinaryFraction.nat (2 ^ eb))).1    let cells := (OAI.EditApproximation.BinaryFraction.targetCellsWithWork side (OAI.EditApproximation.bitWordValue radius) q).1    OAI.EditApproximation.BinaryFraction.canonicalMulAllocation (OAI.EditApproximation.BinaryFraction.inversePowerTwo exponent) (OAI.EditApproximation.BinaryFraction.nat (2 ^ eb)) + OAI.EditApproximation.BinaryFraction.targetCellsAllocation side (OAI.EditApproximation.bitWordValue radius) q +      OAI.EditApproximation.arithmeticFlatMapAllocation (OAI.EditApproximation.BinaryFraction.queryGroupKeySamplesWithWork M F Q eM eb eF hM hF)        (OAI.EditApproximation.BinaryFraction.queryGroupKeySamplesAllocation M F Q eM eb eF hM hF) cells + eb + exponent + 2  OAI.EditApproximation.BinaryFraction.queryExponentsAllocation N F a value + OAI.EditApproximation.BinaryFraction.naturalCeilingAllocation value +    OAI.EditApproximation.arithmeticFlatMapAllocation build allocation (OAI.EditApproximation.BinaryFraction.queryExponentsWithWork N F a value).1def querySharedInputsAllocation {nx ny : ℕ} (M N F Q exponent eM eF : ℕ)    (hM : M = 2 ^ eM) (hF : F = 2 ^ eF) (parent : OAI.EditApproximation.TargetInterval nx)    (a value : OAI.EditApproximation.BinaryFraction) (query : OAI.EditApproximation.TargetInterval ny) (draw : OAI.EditApproximation.CountedCellGroupDraws M F Q)    (allocation : OAI.EditApproximation.CountedCellGroupAllocations M F Q) : ℕ :=  let scales := (OAI.EditApproximation.BinaryFraction.queryExponentsWithWork N F a value).1  let radius := (OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork value).1  let build := fun eb =>    let side := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.inversePowerTwo exponent) (OAI.EditApproximation.BinaryFraction.nat (2 ^ eb))    let cells := OAI.EditApproximation.BinaryFraction.targetCellsWithWork side.1 (OAI.EditApproximation.bitWordValue radius) query    let states := OAI.EditApproximation.arithmeticFlatMapWithWork (fun cell =>      OAI.EditApproximation.BinaryFraction.querySharedCellInputsWithWork (ny := ny) M F Q eM eb eF hM hF parent exponent cell (draw (2 ^ eb) cell)) cells.1    (states.1, side.2 + cells.2 + states.2 + eb + exponent + 4)  let alloc := fun eb =>    let side := (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.inversePowerTwo exponent) (OAI.EditApproximation.BinaryFraction.nat (2 ^ eb))).1    let cells := (OAI.EditApproximation.BinaryFraction.targetCellsWithWork side (OAI.EditApproximation.bitWordValue radius) query).1    OAI.EditApproximation.BinaryFraction.canonicalMulAllocation (OAI.EditApproximation.BinaryFraction.inversePowerTwo exponent) (OAI.EditApproximation.BinaryFraction.nat (2 ^ eb)) + OAI.EditApproximation.BinaryFraction.targetCellsAllocation side (OAI.EditApproximation.bitWordValue radius) query +      OAI.EditApproximation.arithmeticFlatMapAllocation        (fun cell => OAI.EditApproximation.BinaryFraction.querySharedCellInputsWithWork (ny := ny) M F Q eM eb eF hM hF parent exponent cell (draw (2 ^ eb) cell))        (fun cell => OAI.EditApproximation.BinaryFraction.querySharedCellInputsAllocation (ny := ny) M F Q eM eb eF hM hF parent exponent cell          (draw (2 ^ eb) cell) (allocation (2 ^ eb) cell)) cells + eb + exponent + 2  let inputs := (OAI.EditApproximation.arithmeticFlatMapWithWork build scales).1  OAI.EditApproximation.BinaryFraction.queryExponentsAllocation N F a value + OAI.EditApproximation.BinaryFraction.naturalCeilingAllocation value +    OAI.EditApproximation.arithmeticFlatMapAllocation build alloc scales + OAI.EditApproximation.queryOrderedChildInputsAllocation inputsdef preparedCellGroupSourceAllocationRaw {α : Type u_1} (source target : List α) {M : ℕ}  (parent : OAI.EditApproximation.TargetInterval source.length) (b P F exponent Q : ℕ) (_hb : 0 < b) (_hP : 0 < P)  (tau a : OAI.EditApproximation.BinaryFraction)  (parentInitial : OAI.EditApproximation.TargetInterval target.length → OAI.EditApproximation.BinaryFraction × ℕ)  (child initial current : Fin M → OAI.EditApproximation.TargetInterval target.length → OAI.EditApproximation.BinaryFraction × ℕ)  (R C : ℕ) (_hr : ∀ i q, (child i q).2 ≤ R) (_hi : ∀ i q, (initial i q).2 ≤ C)  (raw : List OAI.EditApproximation.BinaryFraction) (hraw : raw.map OAI.EditApproximation.BinaryFraction.value = OAI.EditApproximation.groupDyadicScales M b (OAI.EditApproximation.BinaryFraction.nat F).value)  (draw : ∀ t : Fin (OAI.EditApproximation.groupDyadicScales M b (OAI.EditApproximation.BinaryFraction.nat F).value).length,    Fin (OAI.EditApproximation.groupSampleCount M Q b (OAI.EditApproximation.groupDyadicScaleAt M b (OAI.EditApproximation.BinaryFraction.nat F).value t)) → Fin M × ℕ)  (parentAllocation : OAI.EditApproximation.TargetInterval target.length → ℕ)  (childAllocation initialAllocation currentAllocation : Fin M → OAI.EditApproximation.TargetInterval target.length → ℕ)  (drawAllocation : ∀ t : Fin (OAI.EditApproximation.groupDyadicScales M b (OAI.EditApproximation.BinaryFraction.nat F).value).length,    Fin (OAI.EditApproximation.groupSampleCount M Q b (OAI.EditApproximation.groupDyadicScaleAt M b (OAI.EditApproximation.BinaryFraction.nat F).value t)) → ℕ)    (cell : ℕ × ℕ) : ℕ := by  have proof_indexedGroupScales_value_130 (raw : List.{0} OAI.EditApproximation.BinaryFraction) (M : ℕ) (b : ℕ) (F : ℚ) (h : Eq.{1} (List.map.{0, 0} OAI.EditApproximation.BinaryFraction.value raw) (OAI.EditApproximation.groupDyadicScales M b F)) (i : Fin (List.length.{0} (OAI.EditApproximation.groupDyadicScales M b F))) :      (OAI.EditApproximation.BinaryFraction.indexedGroupScales raw M b F h i).value = OAI.EditApproximation.groupDyadicScaleAt M b F i := by    unfold OAI.EditApproximation.BinaryFraction.indexedGroupScales OAI.EditApproximation.groupDyadicScaleAt    simp only [List.get_eq_getElem]    rw [← List.getElem_map OAI.EditApproximation.BinaryFraction.value (l := raw) (i := i.val) (h := by rw [h]; exact i.isLt)]    simp only [h]  exact    let centers := (OAI.EditApproximation.BinaryFraction.cellCentersReadWithWork P F b a (OAI.EditApproximation.BinaryFraction.inversePowerTwo exponent) parentInitial cell).1    let members := (OAI.EditApproximation.filterMapWithWork      (OAI.EditApproximation.BinaryFraction.preparedUnskippedReadWithWorkRaw parent b P exponent tau (OAI.EditApproximation.BinaryFraction.nat F) child initial) centers).1    OAI.EditApproximation.BinaryFraction.cellCentersReadAllocation P F b a (OAI.EditApproximation.BinaryFraction.inversePowerTwo exponent) parentInitial parentAllocation cell +      OAI.EditApproximation.filterMapAllocation (OAI.EditApproximation.BinaryFraction.preparedUnskippedReadWithWorkRaw parent b P exponent tau (OAI.EditApproximation.BinaryFraction.nat F) child initial)        (fun center => OAI.EditApproximation.BinaryFraction.preparedUnskippedReadAllocation parent center b P exponent tau (OAI.EditApproximation.BinaryFraction.nat F)          child initial childAllocation initialAllocation) centers +      if hempty : members = [] then 0 else        OAI.EditApproximation.BinaryFraction.sampledGroupActionSourceAllocationRaw b exponent Q initial current initialAllocation currentAllocation          (OAI.EditApproximation.BinaryFraction.indexedGroupScales raw M b (OAI.EditApproximation.BinaryFraction.nat F).value hraw)          (fun t j => draw t (Fin.cast (congrArg (OAI.EditApproximation.groupSampleCount M Q b)            (proof_indexedGroupScales_value_130 raw M b (OAI.EditApproximation.BinaryFraction.nat F).value hraw t)) j))          (fun t j => drawAllocation t (Fin.cast (congrArg (OAI.EditApproximation.groupSampleCount M Q b)            (proof_indexedGroupScales_value_130 raw M b (OAI.EditApproximation.BinaryFraction.nat F).value hraw t)) j)) members hempty + 1def preparedCellGroupSourceWithWorkRaw {α : Type u_1} (source target : List α) {M : ℕ}  (parent : OAI.EditApproximation.TargetInterval source.length) (b P F exponent Q : ℕ) (_hb : 0 < b) (_hP : 0 < P)  (tau a : OAI.EditApproximation.BinaryFraction)  (parentInitial : OAI.EditApproximation.TargetInterval target.length → OAI.EditApproximation.BinaryFraction × ℕ)  (child initial current : Fin M → OAI.EditApproximation.TargetInterval target.length → OAI.EditApproximation.BinaryFraction × ℕ)  (R C : ℕ) (_hr : ∀ i q, (child i q).2 ≤ R) (_hi : ∀ i q, (initial i q).2 ≤ C)  (raw : List OAI.EditApproximation.BinaryFraction) (hraw : raw.map OAI.EditApproximation.BinaryFraction.value = OAI.EditApproximation.groupDyadicScales M b (OAI.EditApproximation.BinaryFraction.nat F).value)  (draw : ∀ t : Fin (OAI.EditApproximation.groupDyadicScales M b (OAI.EditApproximation.BinaryFraction.nat F).value).length,    Fin (OAI.EditApproximation.groupSampleCount M Q b (OAI.EditApproximation.groupDyadicScaleAt M b (OAI.EditApproximation.BinaryFraction.nat F).value t)) → Fin M × ℕ)    (cell : ℕ × ℕ) :    Option (OAI.EditApproximation.BinaryBellmanAction (OAI.EditApproximation.TargetInterval target.length)      (Fin M × OAI.EditApproximation.TargetInterval target.length) M) × ℕ := by  have proof_indexedGroupScales_value_130 (raw : List.{0} OAI.EditApproximation.BinaryFraction) (M : ℕ) (b : ℕ) (F : ℚ) (h : Eq.{1} (List.map.{0, 0} OAI.EditApproximation.BinaryFraction.value raw) (OAI.EditApproximation.groupDyadicScales M b F)) (i : Fin (List.length.{0} (OAI.EditApproximation.groupDyadicScales M b F))) :      (OAI.EditApproximation.BinaryFraction.indexedGroupScales raw M b F h i).value = OAI.EditApproximation.groupDyadicScaleAt M b F i := by    unfold OAI.EditApproximation.BinaryFraction.indexedGroupScales OAI.EditApproximation.groupDyadicScaleAt    simp only [List.get_eq_getElem]    rw [← List.getElem_map OAI.EditApproximation.BinaryFraction.value (l := raw) (i := i.val) (h := by rw [h]; exact i.isLt)]    simp only [h]  exact    let centers := OAI.EditApproximation.BinaryFraction.cellCentersReadWithWork P F b a (OAI.EditApproximation.BinaryFraction.inversePowerTwo exponent) parentInitial cell    let members := OAI.EditApproximation.filterMapWithWork      (OAI.EditApproximation.BinaryFraction.preparedUnskippedReadWithWorkRaw parent b P exponent tau (OAI.EditApproximation.BinaryFraction.nat F) child initial) centers.1    if h : members.1 = [] then (none, centers.2 + members.2 + 1) else      let selected := OAI.EditApproximation.BinaryFraction.sampledGroupActionSourceWithWorkRaw b exponent Q initial current (OAI.EditApproximation.BinaryFraction.indexedGroupScales raw M b (OAI.EditApproximation.BinaryFraction.nat F).value hraw)        (fun t j => draw t (Fin.cast (congrArg (OAI.EditApproximation.groupSampleCount M Q b)          (proof_indexedGroupScales_value_130 raw M b (OAI.EditApproximation.BinaryFraction.nat F).value hraw t)) j)) members.1 h      (some selected.1, centers.2 + members.2 + selected.2 + 2)end OAI.EditApproximation.BinaryFractionendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen Finsetdef querySharedInputCover {α : Type u_1} (source target : List α) {M : ℕ}    (parent : OAI.EditApproximation.TargetInterval source.length) (N F exponent Q : ℕ) (a : ℚ)    (initial : OAI.EditApproximation.TargetInterval target.length → ℚ) (q : OAI.EditApproximation.TargetInterval target.length)    (draw : OAI.EditApproximation.CellGroupDraws M F Q) : Finset (Fin M × OAI.EditApproximation.TargetInterval target.length) :=  (OAI.EditApproximation.localGroupQueryKeys N F exponent a initial q).toFinset.biUnion fun key =>    Finset.univ.biUnion fun scale : Fin (OAI.EditApproximation.groupDyadicScales M key.1 F).length =>      OAI.EditApproximation.groupCurrentInputCover source target parent key.1 exponent Q key.2        (OAI.EditApproximation.groupDyadicScaleAt M key.1 F scale) (draw key.1 key.2 scale)def coarseThresholdChildrenCost {B D : ℕ} {α : Type u}    (k : ℕ) (Q lam : ℚ)    (value : OAI.EditApproximation.CoarseSourceTree B α D → OAI.EditApproximation.CoarseThresholdDraws B D → ℚ → ℕ → Fin (2 * k + 1) → ℚ)    (allowance : ℚ) :    List (OAI.EditApproximation.CoarseSourceTree B α D × Fin B × OAI.EditApproximation.CoarseThresholdDraws B D) → ℕ → Fin (2 * k + 1) → ℚ  | [], _, _ => 0  | (child, draw, below) :: rest, start, shift =>    let threshold := OAI.EditApproximation.coarseChildThreshold B Q allowance draw    let childMinimum := univ.inf' univ_nonempty (fun next =>      value child below (lam * threshold) start next + (2 * Nat.dist shift.val next.val : ℕ))    OAI.EditApproximation.coarseThresholdContribution threshold (allowance / Q) childMinimum +      coarseThresholdChildrenCost k Q lam value allowance rest (start + child.word.length) shiftdef coarseThresholdEstimate {B : ℕ} {α : Type u} [DecidableEq α]    (k : ℕ) (Q lam : ℚ) (frame : List (Option α)) :    {D : ℕ} → OAI.EditApproximation.CoarseSourceTree B α D → OAI.EditApproximation.CoarseThresholdDraws B D → ℚ → ℕ → Fin (2 * k + 1) → ℚ  | _, tree, draws, allowance, start, shift =>    if (tree.word.length : ℚ) ≤ allowance then 0 else    match tree, draws with    | .leaf letter, _ => (OAI.EditApproximation.coarseShiftCost k frame (.leaf (B := B) letter) start shift : ℚ)    | .branch children, (draws, below) =>      OAI.EditApproximation.coarseThresholdChildrenCost k Q lam        (fun child => coarseThresholdEstimate k Q lam frame child) allowance        (List.ofFn fun i => (children i, draws i, below i)) start shiftend OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen MeasureTheory ProbabilityTheoryabbrev PhysicalScalarIndex (M J N n exponent F Q R B : ℕ)    (key : OAI.EditApproximation.PhysicalCommonKey M J N n exponent B) : Type :=  match key with  | .inl _ => Fin R  | .inr group => Σ _time : Fin R,      Σ scale : Fin (OAI.EditApproximation.groupDyadicScales M ((OAI.EditApproximation.dyadicScales N).get group.2.1) F).length,        Fin (OAI.EditApproximation.groupSampleCount M Q ((OAI.EditApproximation.dyadicScales N).get group.2.1)          (OAI.EditApproximation.groupDyadicScaleAt M ((OAI.EditApproximation.dyadicScales N).get group.2.1) F scale))def computedPhysicalCoarseDepth (source target : List ℕ) (N : ℕ)    (entry : OAI.EditApproximation.PhysicalEntry (OAI.EditApproximation.integerParameters N).M      (OAI.EditApproximation.intervalTreeDepth (OAI.EditApproximation.integerParameters N).M source.length) target.length) : ℕ :=  OAI.EditApproximation.computedCoarseDepth N (OAI.EditApproximation.coarseEntryWidth (OAI.EditApproximation.physicalSource source entry.1)    (OAI.EditApproximation.substring target entry.2.lo entry.2.hi))abbrev PhysicalScalarKey (M J N n exponent F Q R B : ℕ) :=  Σ key : OAI.EditApproximation.PhysicalCommonKey M J N n exponent B, OAI.EditApproximation.PhysicalScalarIndex M J N n exponent F Q R B keyinstance physicalScalarIndexFintype (M J N n exponent F Q R B : ℕ)    (key : OAI.EditApproximation.PhysicalCommonKey M J N n exponent B) :    Fintype (OAI.EditApproximation.PhysicalScalarIndex M J N n exponent F Q R B key) := by  cases key <;> dsimp only [OAI.EditApproximation.PhysicalScalarIndex] <;> infer_instancedef physicalScalarRange (M J N n exponent F Q R B : ℕ)    (key : OAI.EditApproximation.PhysicalScalarKey M J N n exponent F Q R B) : ℕ :=  match key.1 with  | .inl online => online.2.val.val  | .inr _ => Minstance physicalScalarRangeNeZero (M J N n exponent F Q R B : ℕ) [NeZero M]    (key : OAI.EditApproximation.PhysicalScalarKey M J N n exponent F Q R B) :    NeZero (OAI.EditApproximation.physicalScalarRange M J N n exponent F Q R B key) := by  rcases key with ⟨key, index⟩  cases key <;> dsimp only [OAI.EditApproximation.physicalScalarRange] <;> infer_instanceend OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationdef queryGroupSourceGather {ι : Type u_1} {β : Type u_2} {n : ℕ} (M N F Q exponent eM eF : ℕ)    (hM : M = 2 ^ eM) (hF : F = 2 ^ eF) (a : OAI.EditApproximation.BinaryFraction)    (initial : OAI.EditApproximation.TargetInterval n → OAI.EditApproximation.BinaryFraction × ℕ) (q : OAI.EditApproximation.TargetInterval n)    (reader : OAI.EditApproximation.GroupScalarKey M F Q → OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction)    (next : List (OAI.EditApproximation.GroupScalarKey M F Q) → List OAI.EditApproximation.BinaryFraction → OAI.EditApproximation.BitQuery ι β) : OAI.EditApproximation.BitQuery ι β :=  let query := initial q  .charge query.2 ((OAI.EditApproximation.BitQuery.compute    (OAI.EditApproximation.BinaryFraction.queryGroupSourceKeysWithWork M N F Q exponent eM eF hM hF a query.1 q)).bind      fun keys => OAI.EditApproximation.BitQuery.collect reader keys (next keys))def physicalScalarCodeWithWork {M J N n exponent F Q R B : ℕ}    (key : OAI.EditApproximation.PhysicalScalarKey M J N n exponent F Q R B) : ℕ × ℕ :=  match key with  | ⟨.inl online, time⟩ =>      let entry := OAI.EditApproximation.physicalEntryCodeWithWork (online.1.1.val, online.1.2.2)      let first := OAI.EditApproximation.naturalPairWithWork online.2.val.val time.val      let second := OAI.EditApproximation.naturalPairWithWork online.1.2.1.val first.1      let last := OAI.EditApproximation.naturalPairWithWork entry.1 second.1      (2 * last.1, entry.2 + first.2 + second.2 + last.2 + 2)  | ⟨.inr group, index⟩ =>      let node := OAI.EditApproximation.physicalNodeCodeWithWork group.1.val      let a := OAI.EditApproximation.naturalPairWithWork index.2.1.val index.2.2.val      let b := OAI.EditApproximation.naturalPairWithWork index.1.val a.1      let c := OAI.EditApproximation.naturalPairWithWork group.2.2.2.val b.1      let d := OAI.EditApproximation.naturalPairWithWork group.2.2.1.val c.1      let e := OAI.EditApproximation.naturalPairWithWork group.2.1.val d.1      let f := OAI.EditApproximation.naturalPairWithWork node.1 e.1      (2 * f.1 + 1, node.2 + a.2 + b.2 + c.2 + d.2 + e.2 + f.2 + 3)def physicalScalarCodeAllocation {M J N n exponent F Q R B : ℕ}    (key : OAI.EditApproximation.PhysicalScalarKey M J N n exponent F Q R B) : ℕ :=  match key with  | ⟨.inl online, _⟩ => 2 * online.1.1.val.1.val + J + 20  | ⟨.inr group, _⟩ => 2 * group.1.val.1.val + J + 25end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable (M J N n exponent F Q R B : ℕ) [NeZero M]abbrev PhysicalGroupQueries (b : ℕ) :=  ∀ scale : Fin (OAI.EditApproximation.groupDyadicScales M b F).length,    Fin (OAI.EditApproximation.groupSampleCount M Q b (OAI.EditApproximation.groupDyadicScaleAt M b F scale)) →      OAI.EditApproximation.FiniteQuery (OAI.EditApproximation.PhysicalScalarKey M J N n exponent F Q R B)def physicalScalarOnlineRead (node : OAI.EditApproximation.PhysicalInternalNode M J) (time : Fin R)    (key : ℕ × OAI.EditApproximation.TargetInterval n) (range : ℕ) : OAI.EditApproximation.FiniteQuery (OAI.EditApproximation.PhysicalScalarKey M J N n exponent F Q R B) :=  if hb : key.1 ∈ OAI.EditApproximation.dyadicScales N then    if hr : 0 < range ∧ range ≤ B then      .read ⟨.inl ((node, OAI.EditApproximation.physicalScaleIndex N key.1 hb, key.2),        OAI.EditApproximation.positiveDrawRangeOfLE B range hr.1 hr.2), time⟩ .done    else .done 0  else .done 0def physicalScalarGroupQueriesAt (key : OAI.EditApproximation.PhysicalLocalGroupKey M J N n exponent) (time : Fin R) :    OAI.EditApproximation.PhysicalGroupQueries M J N n exponent F Q R B ((OAI.EditApproximation.dyadicScales N).get key.2.1) :=  fun scale sample => .read ⟨.inr key, ⟨time, scale, sample⟩⟩ .doneend OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable (M J N n exponent F Q R B : ℕ)abbrev BitPhysicalGroupQueries (b : ℕ) :=  ∀ scale : Fin (OAI.EditApproximation.groupDyadicScales M b F).length,    Fin (OAI.EditApproximation.groupSampleCount M Q b (OAI.EditApproximation.groupDyadicScaleAt M b F scale)) →      OAI.EditApproximation.BitQuery (OAI.EditApproximation.PhysicalScalarKey M J N n exponent F Q R B) OAI.EditApproximation.BinaryFractiondef queryPhysicalScalarRead (key : OAI.EditApproximation.PhysicalScalarKey M J N n exponent F Q R B) :    OAI.EditApproximation.BitQuery (OAI.EditApproximation.PhysicalScalarKey M J N n exponent F Q R B) OAI.EditApproximation.BinaryFraction :=  .charge ((OAI.EditApproximation.physicalScalarCodeWithWork key).2 + 1) (.read key .done)def queryPhysicalScalarGroupQueriesAt (key : OAI.EditApproximation.PhysicalLocalGroupKey M J N n exponent) (time : Fin R) :    OAI.EditApproximation.BitPhysicalGroupQueries M J N n exponent F Q R B ((OAI.EditApproximation.dyadicScales N).get key.2.1) :=  fun scale sample => OAI.EditApproximation.queryPhysicalScalarRead M J N n exponent F Q R B    ⟨.inr key, ⟨time, scale, sample⟩⟩end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen Finset MeasureTheory ProbabilityTheoryvariable {α : Type u_1} {source target : List α} {M b P thetaExponent : ℕ} {parent : TargetInterval source.length} {tau F : ℚ} {child initial : Fin M → TargetInterval target.length → ℚ}def dyadicUnskippedGroupEstimate (Q : ℕ)    (value : Fin M → OAI.EditApproximation.TargetInterval target.length → ℚ)    (member : OAI.EditApproximation.UnskippedBand source target parent b P thetaExponent tau F child initial)    (draw : ∀ scale : Fin (OAI.EditApproximation.groupDyadicScales M b F).length,      Fin (OAI.EditApproximation.groupSampleCount M Q b (OAI.EditApproximation.groupDyadicScaleAt M b F scale)) → Fin M) : ℚ :=  OAI.EditApproximation.unskippedGroupEstimate (OAI.EditApproximation.groupDyadicScaleAt M b F)    (fun scale => OAI.EditApproximation.groupSampleCount M Q b (OAI.EditApproximation.groupDyadicScaleAt M b F scale)) value member drawdef chooseUnskippedGroup (Q : ℕ)    (value : Fin M → OAI.EditApproximation.TargetInterval target.length → ℚ)    (members : List (OAI.EditApproximation.UnskippedBand source target parent b P thetaExponent tau F child initial))    (hnonempty : members ≠ [])    (draw : ∀ scale : Fin (OAI.EditApproximation.groupDyadicScales M b F).length,      Fin (OAI.EditApproximation.groupSampleCount M Q b (OAI.EditApproximation.groupDyadicScaleAt M b F scale)) → Fin M) :    OAI.EditApproximation.UnskippedBand source target parent b P thetaExponent tau F child initial :=  OAI.EditApproximation.selectGroupMember members hnonempty (fun member => OAI.EditApproximation.dyadicUnskippedGroupEstimate Q value member draw)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen Finsetdef chooseCellGroupAction {α : Type u_1} (source target : List α) {M : ℕ}    (parent : OAI.EditApproximation.TargetInterval source.length) (b P F thetaExponent Q : ℕ) (tau a : ℚ)    (parentInitial : OAI.EditApproximation.TargetInterval target.length → ℚ)    (child initial value : Fin M → OAI.EditApproximation.TargetInterval target.length → ℚ) (cell : ℕ × ℕ)    (draw : ∀ scale : Fin (OAI.EditApproximation.groupDyadicScales M b F).length,      Fin (OAI.EditApproximation.groupSampleCount M Q b (OAI.EditApproximation.groupDyadicScaleAt M b F scale)) → Fin M) :    Option (OAI.EditApproximation.RationalBellmanAction (OAI.EditApproximation.TargetInterval target.length) (Fin M × OAI.EditApproximation.TargetInterval target.length) M) :=  let members := OAI.EditApproximation.cellUnskippedBands source target parent b P F thetaExponent tau a parentInitial child initial cell  if h : members = [] then none else some (OAI.EditApproximation.chooseUnskippedGroup Q value members h draw).rationalActionend OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable {α : Type u_1} {M : ℕ} (source target : List α) (parent : TargetInterval source.length) (N P F exponent Q : ℕ) (tau a : ℚ) (parentInitial : TargetInterval target.length → ℚ) (child initial current : Fin M → TargetInterval target.length → ℚ) (draw : CellGroupDraws M F Q)local notation (name := source_Combinatorics_EditApproximation_Geometry_LocalGroupCones_8) "theta" => (2 : ℚ) ^ (-(exponent : ℤ))def localCellGroupActions (q : OAI.EditApproximation.TargetInterval target.length) : List (OAI.EditApproximation.PhysicalRationalAction M target.length) :=  ((OAI.EditApproximation.dyadicScales N).filter fun (b : ℕ) => decide    (parentInitial q / (16 * F) ≤ b ∧ (b : ℚ) ≤ 8 * a * parentInitial q)).flatMap fun (b : ℕ) =>      (OAI.EditApproximation.localTargetCells (theta * b) ⌈parentInitial q⌉₊ q).filterMap fun cell =>        OAI.EditApproximation.chooseCellGroupAction source target parent b P F exponent Q tau a parentInitial          child initial current cell (draw b cell)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable {ι : Type u_1} {α : Type u_2} (source target : List α) {M : ℕ} (parent : TargetInterval source.length) (N P F exponent H Q : ℕ) (tau a eta kappa delta : ℚ) (t : ℕ) (parentInitial : TargetInterval target.length → ℚ) (child initial : Fin M → TargetInterval target.length → ℚ) (draw : CellGroupDraws M F Q) (integer : ℕ → TargetInterval target.length → ℕ) (q : TargetInterval target.length) (readEarlier : (Fin M × ℕ × TargetInterval target.length) → FiniteQuery ι) (readCurrent : (Fin M × TargetInterval target.length) → FiniteQuery ι)def localRefinementStepQuery : OAI.EditApproximation.FiniteQuery ι := by  have proof_mixedRadix_injective_84 {radix : ℕ} {lo : ℕ} {lo' : ℕ} {hi : ℕ} {hi' : ℕ} (hlo : LT.lt.{0} lo radix) (hlo' : LT.lt.{0} lo' radix) (heq : Eq.{1} (HAdd.hAdd.{0, 0, 0} lo (HMul.hMul.{0, 0, 0} radix hi)) (HAdd.hAdd.{0, 0, 0} lo' (HMul.hMul.{0, 0, 0} radix hi'))) : lo = lo' ∧ hi = hi' := by    have hmod := congrArg (fun n => n % radix) heq    simp only [Nat.add_mul_mod_self_left, Nat.mod_eq_of_lt hlo, Nat.mod_eq_of_lt hlo'] at hmod    refine ⟨hmod, ?_⟩    apply Nat.mul_left_cancel (by omega : 0 < radix)    omega  have proof_childInputCode_injective_83 (M : ℕ) (n : ℕ) :      Function.Injective (@OAI.EditApproximation.childInputCode M n) := by    rintro ⟨i, q⟩ ⟨i', q'⟩ heq    obtain ⟨hi, hq⟩ := proof_mixedRadix_injective_84 i.isLt i'.isLt heq    have hqlo : q.lo < n + 1 := by have := q.ordered.trans q.valid; omega    have hqlo' : q'.lo < n + 1 := by have := q'.ordered.trans q'.valid; omega    obtain ⟨hlo, hhi⟩ := proof_mixedRadix_injective_84 hqlo hqlo' hq    have hqeq : q = q' := by cases q; cases q'; cases hlo; cases hhi; rfl    exact Prod.ext (Fin.ext hi) hqeq  have proof_historyInputCode_injective_82 (M : ℕ) (n : ℕ) :      Function.Injective (OAI.EditApproximation.historyInputCode (M := M) (n := n)) := by    rintro ⟨i, s, q⟩ ⟨i', s', q'⟩ heq    have h := Nat.pair_eq_pair.mp heq    have hc := proof_childInputCode_injective_83 M n h.2    cases hc    cases h.1    rfl  exact    let earlierKeys := OAI.EditApproximation.orderedInputs OAI.EditApproximation.historyInputCode (proof_historyInputCode_injective_82 M target.length)      (OAI.EditApproximation.queryEarlierInputCover parent N P F exponent t a parentInitial q)    OAI.EditApproximation.FiniteQuery.collect readEarlier earlierKeys fun earlierAnswers =>      let earlier := fun i s r => OAI.EditApproximation.finiteAnswerTable earlierKeys earlierAnswers (i, s, r)      let online := OAI.EditApproximation.localOnlineCandidates source target parent N P F exponent H tau a eta kappa        parentInitial child initial earlier (t - 1) integer q      let sharedKeys := OAI.EditApproximation.orderedInputs OAI.EditApproximation.childInputCode (proof_childInputCode_injective_83 M target.length)        (OAI.EditApproximation.querySharedInputCover source target parent N F exponent Q a parentInitial q draw)      OAI.EditApproximation.FiniteQuery.collect readCurrent sharedKeys fun sharedAnswers =>        let current := fun i r => OAI.EditApproximation.finiteAnswerTable sharedKeys sharedAnswers (i, r)        let selected := OAI.EditApproximation.localCellGroupActions source target parent N P F exponent Q tau a          parentInitial child initial current draw q        let needed := OAI.EditApproximation.actionCurrentInputCover selected ∪ OAI.EditApproximation.actionCurrentInputCover online        let currentKeys := OAI.EditApproximation.orderedInputs OAI.EditApproximation.childInputCode (proof_childInputCode_injective_83 M target.length) needed        OAI.EditApproximation.FiniteQuery.collect readCurrent currentKeys fun currentAnswers =>          let value := OAI.EditApproximation.rationalActionValue (fun q r => OAI.EditApproximation.targetEndpointDistance q r) (128 * F)            (OAI.EditApproximation.finiteAnswerTable currentKeys currentAnswers) q          let fallback := OAI.EditApproximation.rationalBellman parentInitial (fun q r => OAI.EditApproximation.targetEndpointDistance q r) (128 * F)            (OAI.EditApproximation.rationalActualWideActions parent (OAI.EditApproximation.localRefinementRepresentatives N P F a parentInitial q) P)            (fun input => earlier input.1 (t - 1) input.2) q          .done (OAI.EditApproximation.rationalRefinementUpdate delta (OAI.EditApproximation.rationalMinimum fallback (selected.map value))            (OAI.EditApproximation.rationalOnlineMinimum (online.map value)))end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable {ι : Type u_1} {α : Type u_2} (source target : List α) {M : ℕ} (parent : TargetInterval source.length) (N P F exponent H Q : ℕ) (tau a eta kappa delta : ℚ) (t : ℕ) (parentInitial : TargetInterval target.length → ℚ) (child initial : Fin M → TargetInterval target.length → ℚ) (draw : CellGroupDraws M F Q) (q : TargetInterval target.length) (readInteger : (ℕ × TargetInterval target.length) → ℕ → FiniteQuery ι) (readEarlier : (Fin M × ℕ × TargetInterval target.length) → FiniteQuery ι) (readCurrent : (Fin M × TargetInterval target.length) → FiniteQuery ι)def localOnlineSourceStepQuery : OAI.EditApproximation.FiniteQuery ι :=  let keys := OAI.EditApproximation.localOnlineSourceKeys N P F a parentInitial q  OAI.EditApproximation.FiniteQuery.collect    (fun key => readInteger key (OAI.EditApproximation.keyedOnlineSourceRange source target parent P exponent H tau child key))    keys fun values =>      OAI.EditApproximation.localRefinementStepQuery source target parent N P F exponent H Q tau a eta kappa delta t        parentInitial child initial draw (fun b r => ⌊OAI.EditApproximation.finiteAnswerTable keys values (b, r)⌋₊) q        readEarlier readCurrentend OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable {ι : Type u_1} {β : Type u_2} {α : Type u_3} (source target : List α) {M : ℕ} (parent : TargetInterval source.length) (N P F exponent Q eM eF : ℕ) (hP : 0 < P) (hM : M = 2 ^ eM) (hF : F = 2 ^ eF) (a : BinaryFraction) (t : ℕ) (initial : TargetInterval target.length → BinaryFraction × ℕ) (draw : CountedCellGroupDraws M F Q) (q : TargetInterval target.length) (readEarlier : (Fin M × ℕ × TargetInterval target.length) → BitQuery ι BinaryFraction) (readCurrent : (Fin M × TargetInterval target.length) → BitQuery ι BinaryFraction) (online : List (Fin M × ℕ × TargetInterval target.length) → List BinaryFraction →    List (BinaryBellmanAction (TargetInterval target.length)      (Fin M × TargetInterval target.length) M) × ℕ) (selected : List (Fin M × TargetInterval target.length) → List BinaryFraction →    List (BinaryBellmanAction (TargetInterval target.length)      (Fin M × TargetInterval target.length) M) × ℕ) (next : List (Fin M × ℕ × TargetInterval target.length) → List BinaryFraction →    List (BinaryBellmanAction (TargetInterval target.length) (Fin M × TargetInterval target.length) M) →    List (BinaryBellmanAction (TargetInterval target.length) (Fin M × TargetInterval target.length) M) →    List (Fin M × TargetInterval target.length) → List BinaryFraction → BitQuery ι β)def queryRefinementGather : OAI.EditApproximation.BitQuery ι β :=  (OAI.EditApproximation.BitQuery.compute (OAI.EditApproximation.BinaryFraction.queryEarlierInputsWithWork M parent N P F exponent t hP a initial q)).bind    fun earlierKeys => OAI.EditApproximation.BitQuery.collect readEarlier earlierKeys fun earlierWords =>      (OAI.EditApproximation.BitQuery.compute (online earlierKeys earlierWords)).bind fun onlineActions =>        let word := initial q        .charge word.2 ((OAI.EditApproximation.BitQuery.compute (OAI.EditApproximation.BinaryFraction.querySharedInputsWithWork M N F Q exponent          eM eF hM hF parent a word.1 q draw)).bind fun sharedKeys =>            OAI.EditApproximation.BitQuery.collect readCurrent sharedKeys fun sharedWords =>              (OAI.EditApproximation.BitQuery.compute (selected sharedKeys sharedWords)).bind fun selectedActions =>                (OAI.EditApproximation.BitQuery.compute (OAI.EditApproximation.queryNeededInputsWithWork selectedActions onlineActions)).bind                  fun currentKeys => OAI.EditApproximation.BitQuery.collect readCurrent currentKeys                    (next earlierKeys earlierWords selectedActions onlineActions currentKeys))end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.BinaryFractionvariable {nx ny M : ℕ} (parent : TargetInterval nx) (N P F : ℕ) (a delta : BinaryFraction) (initial : TargetInterval ny → BinaryFraction × ℕ) (t : ℕ) (earlierKeys : List (Fin M × ℕ × TargetInterval ny)) (earlierWords : List BinaryFraction) (groups online : List (BinaryBellmanAction (TargetInterval ny) (Fin M × TargetInterval ny) M)) (currentKeys : List (Fin M × TargetInterval ny)) (currentWords : List BinaryFraction) (query : TargetInterval ny)def queryRefinementFinishWithWork : OAI.EditApproximation.BinaryFraction × ℕ :=  let fallback := initial query  let representatives := OAI.EditApproximation.BinaryFraction.localRepresentativeReadWithWork N P F a initial query  let result := OAI.EditApproximation.BinaryFraction.physicalContinuationReadWithWork parent representatives.1 P F delta fallback.1    (OAI.EditApproximation.BinaryFraction.queryHistoryReadWithWork earlierKeys earlierWords (t - 1))    (fun input => OAI.EditApproximation.BinaryFraction.queryChildReadWithWork currentKeys currentWords input.1 input.2)    groups online query  (result.1, fallback.2 + representatives.2 + result.2 + 2)end OAI.EditApproximation.BinaryFractionendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable {ι : Type u_1} {α : Type u_2} (source target : List α) {M : ℕ} [NeZero M] (parent : TargetInterval source.length) (N P F exponent H Q : ℕ) (tau a eta kappa delta : ℚ) (t : ℕ) (parentInitial : TargetInterval target.length → ℚ) (child initial : Fin M → TargetInterval target.length → ℚ) (q : TargetInterval target.length) (readGroup : GroupScalarKey M F Q → FiniteQuery ι) (readInteger : (ℕ × TargetInterval target.length) → ℕ → FiniteQuery ι) (readEarlier : (Fin M × ℕ × TargetInterval target.length) → FiniteQuery ι) (readCurrent : (Fin M × TargetInterval target.length) → FiniteQuery ι)noncomputable def localRandomSourceStepQuery : OAI.EditApproximation.FiniteQuery ι :=  let keys := OAI.EditApproximation.groupScalarKeys M F Q (OAI.EditApproximation.localGroupQueryKeys N F exponent a parentInitial q)  OAI.EditApproximation.FiniteQuery.collect readGroup keys fun values =>    OAI.EditApproximation.localOnlineSourceStepQuery source target parent N P F exponent H Q tau a eta kappa delta t      parentInitial child initial (OAI.EditApproximation.groupDrawFromValues keys values) q readInteger readEarlier readCurrentend OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable {ι : Type u_1} {α : Type u_2} (source target : List α) {M : ℕ} [NeZero M] (parent : TargetInterval source.length) (N P F exponent H Q : ℕ) (tau a eta kappa delta : ℚ) (t : ℕ) (parentInitial : TargetInterval target.length → ℚ) (readMass readInitial : Fin M × TargetInterval target.length → FiniteQuery ι) (readGroup : GroupScalarKey M F Q → FiniteQuery ι) (readInteger : (ℕ × TargetInterval target.length) → ℕ → FiniteQuery ι) (q : TargetInterval target.length) (readEarlier : (Fin M × ℕ × TargetInterval target.length) → FiniteQuery ι) (readCurrent : (Fin M × TargetInterval target.length) → FiniteQuery ι)noncomputable def localRandomBandDataQuery : OAI.EditApproximation.FiniteQuery ι :=  let keys := OAI.EditApproximation.refinementBandInputList (M := M) parent N P F exponent a parentInitial q  OAI.EditApproximation.FiniteQuery.collect readMass keys fun massValues =>    OAI.EditApproximation.FiniteQuery.collect readInitial keys fun initialValues =>      OAI.EditApproximation.localRandomSourceStepQuery source target parent N P F exponent H Q tau a eta kappa delta t        parentInitial (fun i r => OAI.EditApproximation.finiteAnswerTable keys massValues (i, r))        (fun i r => OAI.EditApproximation.finiteAnswerTable keys initialValues (i, r)) q readGroup readInteger readEarlier readCurrentend OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable {ι : Type u_1} {α : Type u_2} (source target : List α) {M : ℕ} [NeZero M] (parent : TargetInterval source.length) (N P F exponent H Q : ℕ) (tau a eta kappa delta : ℚ) (t : ℕ) (readParentInitial : TargetInterval target.length → FiniteQuery ι) (readMass readInitial : Fin M × TargetInterval target.length → FiniteQuery ι) (readGroup : GroupScalarKey M F Q → FiniteQuery ι) (readInteger : (ℕ × TargetInterval target.length) → ℕ → FiniteQuery ι) (q : TargetInterval target.length) (readEarlier : (Fin M × ℕ × TargetInterval target.length) → FiniteQuery ι) (readCurrent : (Fin M × TargetInterval target.length) → FiniteQuery ι)noncomputable def localRandomDataQuery : OAI.EditApproximation.FiniteQuery ι :=  OAI.EditApproximation.FiniteQuery.bind (readParentInitial q) fun value =>    let keys := OAI.EditApproximation.refinementInitialSupport N P F exponent a value q    OAI.EditApproximation.FiniteQuery.collect readParentInitial keys fun initialValues =>      OAI.EditApproximation.localRandomBandDataQuery source target parent N P F exponent H Q tau a eta kappa delta t        (OAI.EditApproximation.finiteAnswerTable keys initialValues) readMass readInitial readGroup readInteger q readEarlier readCurrentend OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable {M J N n exponent F Q R B : ℕ}def physicalScalarCode (key : OAI.EditApproximation.PhysicalScalarKey M J N n exponent F Q R B) : ℕ :=  match key with  | ⟨.inl online, time⟩ => 2 * Nat.pair (OAI.EditApproximation.physicalEntryCode (online.1.1.val, online.1.2.2))      (Nat.pair online.1.2.1.val (Nat.pair online.2.val.val time.val))  | ⟨.inr group, index⟩ => 2 * Nat.pair (OAI.EditApproximation.physicalNodeCode group.1.val)      (Nat.pair group.2.1.val (Nat.pair group.2.2.1.val (Nat.pair group.2.2.2.val        (Nat.pair index.1.val (Nat.pair index.2.1.val index.2.2.val))))) + 1end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable (M J N n exponent F Q R B : ℕ) [NeZero M]open MeasureTheory ProbabilityTheorydef physicalScalarGroupQueries (node : OAI.EditApproximation.PhysicalInternalNode M J) (time : Fin R)    (b : ℕ) (cell : ℕ × ℕ) : OAI.EditApproximation.PhysicalGroupQueries M J N n exponent F Q R B b := by  have proof_physicalScaleIndex_get_93 (N : ℕ) (b : ℕ) (hb : Membership.mem.{0, 0} (OAI.EditApproximation.dyadicScales N) b) :      (OAI.EditApproximation.dyadicScales N).get (OAI.EditApproximation.physicalScaleIndex N b hb) = b :=    List.getElem_idxOf (List.idxOf_lt_length_of_mem hb)  exact    if hb : b ∈ OAI.EditApproximation.dyadicScales N then      if hc : cell.1 ≤ n * 2 ^ exponent ∧ cell.2 ≤ n * 2 ^ exponent then        let key : OAI.EditApproximation.PhysicalLocalGroupKey M J N n exponent :=          (node, OAI.EditApproximation.physicalScaleIndex N b hb,            ⟨cell.1, Nat.lt_succ_of_le hc.1⟩, ⟨cell.2, Nat.lt_succ_of_le hc.2⟩)        Eq.mp (congrArg (OAI.EditApproximation.PhysicalGroupQueries M J N n exponent F Q R B)          (proof_physicalScaleIndex_get_93 N b hb)) (OAI.EditApproximation.physicalScalarGroupQueriesAt M J N n exponent F Q R B key time)      else fun _ _ => .done 0    else fun _ _ => .done 0end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable (M J N n exponent F Q R B : ℕ) [NeZero M]def physicalScalarGroupRead (node : OAI.EditApproximation.PhysicalInternalNode M J) (time : Fin R)    (key : OAI.EditApproximation.GroupScalarKey M F Q) : OAI.EditApproximation.FiniteQuery (OAI.EditApproximation.PhysicalScalarKey M J N n exponent F Q R B) :=  OAI.EditApproximation.physicalScalarGroupQueries M J N n exponent F Q R B node time key.1.1 key.1.2 key.2.1 key.2.2end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable {σ : Type u_1} {α : Type u_2} (source target : List α) {M J : ℕ} [NeZero M] (N P F exponent H Q : ℕ) (tau a eta kappa delta : ℚ) (pass copy T S t : ℕ) (ht : 0 < t) (node : PhysicalNode M J) (hbelow : node.1.val < J) (readGroup : GroupScalarKey M F Q → FiniteQuery σ) (readInteger : (ℕ × TargetInterval target.length) → ℕ → FiniteQuery σ) (q : TargetInterval target.length)noncomputable def physicalRandomDataRequestQuery :    OAI.EditApproximation.FiniteQuery (Sum σ {child : OAI.EditApproximation.PhysicalTableRequest M J target.length //      child.combinedRank T S < (OAI.EditApproximation.PhysicalTableRequest.refinement pass copy node T t q).combinedRank T S}) :=  OAI.EditApproximation.localRandomDataQuery source target (OAI.EditApproximation.physicalSourceInterval source.length node)    N P F exponent H Q tau a eta kappa delta t    (fun r => OAI.EditApproximation.FiniteQuery.mapKeys Sum.inr      (OAI.EditApproximation.physicalRefinementWarmupRead pass copy T S t ht node q node le_rfl 0 (Nat.zero_le T) r))    (fun input => OAI.EditApproximation.FiniteQuery.mapKeys Sum.inr      (OAI.EditApproximation.physicalRefinementMassQuery pass copy T S t ht node hbelow q input))    (fun input => OAI.EditApproximation.FiniteQuery.mapKeys Sum.inr      (OAI.EditApproximation.physicalRefinementWarmupRead pass copy T S t ht node q        (OAI.EditApproximation.physicalChild node hbelow input.1) (by change node.1.val ≤ node.1.val + 1; omega)        0 (Nat.zero_le T) input.2))    (fun key => OAI.EditApproximation.FiniteQuery.mapKeys Sum.inl (readGroup key))    (fun key range => OAI.EditApproximation.FiniteQuery.mapKeys Sum.inl (readInteger key range)) q    (fun input => OAI.EditApproximation.FiniteQuery.mapKeys Sum.inr      (OAI.EditApproximation.physicalRefinementEarlierQuery pass copy T S t node hbelow q input))    (fun input => OAI.EditApproximation.FiniteQuery.mapKeys Sum.inr      (OAI.EditApproximation.physicalRefinementCurrentQuery pass copy T S t node hbelow q input))end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable {σ : Type*} {α : Type u_2} [DecidableEq α] {M J R : ℕ} [NeZero M] [NeZero R] (source target : List α) (N P F exponent H Q T S copies : ℕ) (factor : ℕ → ℚ) (multiplier : ℕ → ℕ) (tau eta kappa delta : ℚ) (readGroup : ℕ → ℕ → PhysicalInternalNode M J → Fin R → GroupScalarKey M F Q → FiniteQuery σ) (readInteger : ℕ → ℕ → PhysicalInternalNode M J → Fin R →    (ℕ × TargetInterval target.length) → ℕ → FiniteQuery σ) (initial : PhysicalEntry M J target.length → ℕ)def physicalInactiveGlobalQuery (request : OAI.EditApproximation.PhysicalTableRequest M J target.length) :    OAI.EditApproximation.FiniteQuery {child : OAI.EditApproximation.PhysicalTableRequest M J target.length //      child.combinedRank T S < request.combinedRank T S} :=  if request.index ≤ T then    OAI.EditApproximation.physicalWarmupRequestQuery source target N P F (factor request.pass)      request.pass request.copy T S request.index request.node request.state      (OAI.EditApproximation.globalSeedRead N T S copies multiplier initial request)  else OAI.EditApproximation.physicalInitialQuery source target N P F (factor request.pass)    (OAI.EditApproximation.globalSeedRead N T S copies multiplier initial request) (request.node, request.state)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable {σ : Type u_1} {α : Type u_2} [DecidableEq α] {M J R : ℕ} [NeZero M] [NeZero R] (source target : List α) (N P F exponent H Q T S copies : ℕ) (factor : ℕ → ℚ) (multiplier : ℕ → ℕ) (tau eta kappa delta : ℚ) (readGroup : ℕ → ℕ → PhysicalInternalNode M J → Fin R → GroupScalarKey M F Q → FiniteQuery σ) (readInteger : ℕ → ℕ → PhysicalInternalNode M J → Fin R →    (ℕ × TargetInterval target.length) → ℕ → FiniteQuery σ) (initial : PhysicalEntry M J target.length → ℕ)noncomputable def physicalRandomGlobalQuery (request : OAI.EditApproximation.PhysicalTableRequest M J target.length) :    OAI.EditApproximation.FiniteQuery (Sum σ {child : OAI.EditApproximation.PhysicalTableRequest M J target.length //      child.combinedRank T S < request.combinedRank T S}) := by  by_cases hactive : T < request.index ∧ request.node.1.val < J ∧      ¬ (OAI.EditApproximation.physicalSourceInterval source.length request.node).hi -        (OAI.EditApproximation.physicalSourceInterval source.length request.node).lo ≤ 1  · have ht : 0 < request.index - T := Nat.sub_pos_of_lt hactive.1    have hrequest : OAI.EditApproximation.PhysicalTableRequest.refinement request.pass request.copy request.node        T (request.index - T) request.state = request := by      have hi : T + (request.index - T) = request.index := by omega      unfold OAI.EditApproximation.PhysicalTableRequest.refinement      rw [hi]    let node : OAI.EditApproximation.PhysicalInternalNode M J := ⟨request.node, hactive.2.1⟩    let time : Fin R := Fin.ofNat R (request.index - T - 1)    exact OAI.EditApproximation.FiniteQuery.mapKeys      (Sum.map id (fun child => ⟨child.val, by simpa only [hrequest] using child.property⟩))      (OAI.EditApproximation.physicalRandomDataRequestQuery source target N P F exponent H Q tau        (OAI.EditApproximation.refinementFactor (factor request.pass) F) eta kappa delta request.pass request.copy T S        (request.index - T) ht request.node hactive.2.1        (readGroup request.pass request.copy node time)        (readInteger request.pass request.copy node time) request.state)  · exact OAI.EditApproximation.FiniteQuery.mapKeys Sum.inr      (OAI.EditApproximation.physicalInactiveGlobalQuery source target N P F T S copies factor multiplier initial request)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.PhysicalTableRequestdef entryCapacity (M J n : ℕ) : ℕ := (n + 1) ^ 2 * (M ^ J * (J + 1))def code {M J n : ℕ} (copies T S : ℕ) (request : OAI.EditApproximation.PhysicalTableRequest M J n) : ℕ :=  request.index + (T + S + 1) * (request.copy + copies *    (OAI.EditApproximation.physicalEntryCode (request.node, request.state) + OAI.EditApproximation.PhysicalTableRequest.entryCapacity M J n * request.pass))end OAI.EditApproximation.PhysicalTableRequestendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.SourceRankedvariable {σ : Type u_1} {κ : Type u_2} (tableRank : κ → ℕ) (supported : κ → Prop)def supportedChild (parent : κ) : Sum σ {key : κ // tableRank key < tableRank parent} → Prop  | .inl _ => True  | .inr table => supported table.valdef supportedChildMap (parent : {key : κ // supported key}) :    {key : Sum σ {key : κ // tableRank key < tableRank parent.val} //      OAI.EditApproximation.SourceRanked.supportedChild tableRank supported parent.val key} →    Sum σ {key : {key : κ // supported key} // tableRank key.val < tableRank parent.val}  | ⟨.inl source, _⟩ => .inl source  | ⟨.inr table, hs⟩ => .inr ⟨⟨table.val, hs⟩, table.property⟩noncomputable def restrictBody    (tableBody : (parent : κ) → OAI.EditApproximation.FiniteQuery (Sum σ {key : κ // tableRank key < tableRank parent}))    (parent : {key : κ // supported key}) :    OAI.EditApproximation.FiniteQuery (Sum σ {key : {key : κ // supported key} // tableRank key.val < tableRank parent.val}) := by  classical  exact OAI.EditApproximation.FiniteQuery.mapKeys (OAI.EditApproximation.SourceRanked.supportedChildMap tableRank supported parent)    (OAI.EditApproximation.FiniteQuery.restrict (OAI.EditApproximation.SourceRanked.supportedChild tableRank supported parent.val) (tableBody parent.val))end OAI.EditApproximation.SourceRankedendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable {σ : Type u_1} {α : Type u_2} [DecidableEq α] {M J R : ℕ} [NeZero M] [NeZero R] (source target : List α) (N P F exponent H Q T S passes copies : ℕ) (factor : ℕ → ℚ) (multiplier : ℕ → ℕ) (tau eta kappa delta : ℚ) (readGroup : ℕ → ℕ → PhysicalInternalNode M J → Fin R → GroupScalarKey M F Q → FiniteQuery σ) (readInteger : ℕ → ℕ → PhysicalInternalNode M J → Fin R →    (ℕ × TargetInterval target.length) → ℕ → FiniteQuery σ) (initial : PhysicalEntry M J target.length → ℕ)noncomputable def physicalRandomBoundedQuery    (request : {request : OAI.EditApproximation.PhysicalTableRequest M J target.length // request.Bounded passes copies T S}) :    OAI.EditApproximation.FiniteQuery (Sum σ {child : {child : OAI.EditApproximation.PhysicalTableRequest M J target.length //      child.Bounded passes copies T S} // child.val.combinedRank T S < request.val.combinedRank T S}) :=  OAI.EditApproximation.SourceRanked.restrictBody (OAI.EditApproximation.PhysicalTableRequest.combinedRank T S)    (OAI.EditApproximation.PhysicalTableRequest.Bounded passes copies T S)    (OAI.EditApproximation.physicalRandomGlobalQuery source target N P F exponent H Q T S copies factor multiplier      tau eta kappa delta readGroup readInteger initial) requestnoncomputable def chargedRandomGlobalQuery    (request : OAI.EditApproximation.ChargedPhysicalRequest M J target.length passes copies T S) :    OAI.EditApproximation.FiniteQuery (Sum σ {child : OAI.EditApproximation.ChargedPhysicalRequest M J target.length passes copies T S //      child.rank < request.rank}) := by  have proof_table_rank_lt_99 {M : ℕ} {J : ℕ} {ny : ℕ} {passes : ℕ} {copies : ℕ} {T : ℕ} {S : ℕ} (parent : Subtype.{1} fun request => OAI.EditApproximation.PhysicalTableRequest.Bounded (M := M) (J := J) (ny := ny) passes copies T S request) (child : Subtype.{1} fun request => OAI.EditApproximation.PhysicalTableRequest.Bounded (M := M) (J := J) (ny := ny) passes copies T S request) (h : LT.lt.{0} (OAI.EditApproximation.PhysicalTableRequest.combinedRank T S child.val)    (OAI.EditApproximation.PhysicalTableRequest.combinedRank T S parent.val)) :      OAI.EditApproximation.ChargedPhysicalRequest.rank (Sum.inr child : OAI.EditApproximation.ChargedPhysicalRequest M J ny passes copies T S) < OAI.EditApproximation.ChargedPhysicalRequest.rank (Sum.inr parent) := by    simpa only [OAI.EditApproximation.ChargedPhysicalRequest.rank, OAI.EditApproximation.ChargedPhysicalRequest.depth, OAI.EditApproximation.ChargedPhysicalRequest.index, ← Nat.add_assoc, OAI.EditApproximation.PhysicalTableRequest.combinedRank] using      Nat.add_lt_add_right h 1  exact    match request with    | .inl entry => .done (initial entry)    | .inr parent =>      if parent.val.index ≤ T then        OAI.EditApproximation.FiniteQuery.mapKeys Sum.inr (OAI.EditApproximation.chargedWarmupQuery source target N P F factor multiplier parent)      else if parent.val.node.1.val < J then        if (OAI.EditApproximation.physicalSourceInterval source.length parent.val.node).hi -            (OAI.EditApproximation.physicalSourceInterval source.length parent.val.node).lo ≤ 1 then          OAI.EditApproximation.FiniteQuery.mapKeys Sum.inr            (OAI.EditApproximation.physicalInitialQuery source target N P F (factor parent.val.pass)              (OAI.EditApproximation.chargedSeedQuery N multiplier parent) (parent.val.node, parent.val.state))        else OAI.EditApproximation.FiniteQuery.mapKeys          (Sum.map id (fun child =>            ⟨Sum.inr child.val, proof_table_rank_lt_99 parent child.val child.property⟩))          (OAI.EditApproximation.physicalRandomBoundedQuery source target N P F exponent H Q T S passes copies factor multiplier            tau eta kappa delta readGroup readInteger initial parent)      else OAI.EditApproximation.FiniteQuery.mapKeys Sum.inr        (OAI.EditApproximation.physicalInitialQuery source target N P F (factor parent.val.pass)          (OAI.EditApproximation.chargedSeedQuery N multiplier parent) (parent.val.node, parent.val.state))end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable {α : Type u_1} [DecidableEq α] {M J R : ℕ} [NeZero M] [NeZero R] (source target : List α) (N P F exponent H Q T S passes copies : ℕ)abbrev PhysicalFamilyScalarKey := Fin (passes + 1) × Fin (copies + 1) ×  OAI.EditApproximation.PhysicalScalarKey M J N target.length exponent F Q R (OAI.EditApproximation.localOnlineMassBound M P H)abbrev PhysicalFamilyScalarDraw := ∀ key : OAI.EditApproximation.PhysicalFamilyScalarKey    (M := M) (J := J) (R := R) target N P F exponent H Q passes copies,  Fin (OAI.EditApproximation.physicalScalarRange M J N target.length exponent F Q R (OAI.EditApproximation.localOnlineMassBound M P H) key.2.2)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable {α : Type u_1} [DecidableEq α] {M J R : ℕ} [NeZero M] [NeZero R] (source target : List α) (N P F exponent H Q T S passes copies : ℕ)variable (draw : PhysicalFamilyScalarDraw  (M := M) (J := J) (R := R) target N P F exponent H Q passes copies)def physicalFamilyAnswer (key : OAI.EditApproximation.PhysicalFamilyScalarKey    (M := M) (J := J) (R := R) target N P F exponent H Q passes copies) : ℚ :=  (draw key).valdef physicalFamilyGroupRead (pass copy : ℕ) (node : OAI.EditApproximation.PhysicalInternalNode M J) (time : Fin R)    (key : OAI.EditApproximation.GroupScalarKey M F Q) : OAI.EditApproximation.FiniteQuery (OAI.EditApproximation.PhysicalFamilyScalarKey      (M := M) (J := J) (R := R) target N P F exponent H Q passes copies) :=  OAI.EditApproximation.FiniteQuery.mapKeys (fun scalar => (Fin.ofNat (passes + 1) pass, Fin.ofNat (copies + 1) copy, scalar))    (OAI.EditApproximation.physicalScalarGroupRead M J N target.length exponent F Q R (OAI.EditApproximation.localOnlineMassBound M P H) node time key)def physicalFamilyOnlineRead (pass copy : ℕ) (node : OAI.EditApproximation.PhysicalInternalNode M J) (time : Fin R)    (key : ℕ × OAI.EditApproximation.TargetInterval target.length) (range : ℕ) : OAI.EditApproximation.FiniteQuery (OAI.EditApproximation.PhysicalFamilyScalarKey      (M := M) (J := J) (R := R) target N P F exponent H Q passes copies) :=  OAI.EditApproximation.FiniteQuery.mapKeys (fun scalar => (Fin.ofNat (passes + 1) pass, Fin.ofNat (copies + 1) copy, scalar))    (OAI.EditApproximation.physicalScalarOnlineRead M J N target.length exponent F Q R (OAI.EditApproximation.localOnlineMassBound M P H) node time key range)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable {M J R passes copies T S : ℕ} [NeZero M] [NeZero R] (source target : List ℕ) (N P F exponent H Q eM eF : ℕ) (hP : 0 < P) (hM : M = 2 ^ eM) (hF : F = 2 ^ eF) (A a : ℕ → BinaryFraction) (tau eta kappa delta : BinaryFraction) (multiplier : ℕ → ℕ) (occurrence : BinaryMemo PositionCounts) (symbolBits positionBits : ℕ) (coarse : PhysicalEntry M J target.length → BinaryFraction × ℕ) (draw : PhysicalFamilyScalarDraw (M := M) (J := J) (R := R)    target N P F exponent H Q passes copies)abbrev QueryFamilyMemoKey :=  Sum (OAI.EditApproximation.PhysicalFamilyScalarKey (M := M) (J := J) (R := R) target N P F exponent H Q passes copies)    (OAI.EditApproximation.ChargedPhysicalRequest M J target.length (passes + 1) copies T S)def queryFamilySourceWordWithWork    (key : OAI.EditApproximation.PhysicalFamilyScalarKey (M := M) (J := J) (R := R)      target N P F exponent H Q passes copies) : OAI.EditApproximation.BinaryFraction × ℕ :=  (OAI.EditApproximation.BinaryFraction.nat (draw key).val, Nat.size (draw key).val + 3)def queryFamilyMemoRemaining : OAI.EditApproximation.QueryFamilyMemoKey (M := M) (J := J) (R := R) (passes := passes) (copies := copies) (T := T) (S := S) target N P F exponent H Q → ℕ  | .inl _ => 0  | .inr request => OAI.EditApproximation.chargedPhysicalRemaining requestend OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen Filter MeasureTheoryabbrev ComputedFamilySeed (source target : List ℕ) (N : ℕ) :=  OAI.EditApproximation.ClampedPhysicalSeed (OAI.EditApproximation.integerParameters N).M    (OAI.EditApproximation.intervalTreeDepth (OAI.EditApproximation.integerParameters N).M source.length) target.length Nabbrev ComputedFamilyDraw (source target : List ℕ) (N : ℕ) :=  OAI.EditApproximation.PhysicalFamilyScalarDraw (M := (OAI.EditApproximation.integerParameters N).M)    (J := OAI.EditApproximation.intervalTreeDepth (OAI.EditApproximation.integerParameters N).M source.length) (R := OAI.EditApproximation.inputHeight N ^ 2)    target N (OAI.EditApproximation.integerParameters N).P (OAI.EditApproximation.inputSmallLog N) (40 * OAI.EditApproximation.smallLogExponent N)    (OAI.EditApproximation.inputHeight N) (OAI.EditApproximation.inputSmallLog N ^ 80) (OAI.EditApproximation.computedSeedPassCount N) (OAI.EditApproximation.inputHeight N ^ 2)abbrev ComputedFamilyInput (source target : List ℕ) (N : ℕ) :=  OAI.EditApproximation.ComputedFamilySeed source target N × OAI.EditApproximation.ComputedFamilyDraw source target Nend OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable {α : Type u_1} {M J R : ℕ} (target : List α) (N P F exponent H Q passes copies : ℕ)local notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalFamilyEncoding_3) "Key" => PhysicalFamilyScalarKey (M := M) (J := J) (R := R)  target N P F exponent H Q passes copiesdef physicalFamilyCode (key : Key) : ℕ :=  Nat.pair key.1.val (Nat.pair key.2.1.val (OAI.EditApproximation.physicalScalarCode key.2.2))end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.ChargedPhysicalRequestdef code {M J ny passes copies T S : ℕ} : OAI.EditApproximation.ChargedPhysicalRequest M J ny passes copies T S → ℕ  | .inl entry => 2 * OAI.EditApproximation.physicalEntryCode entry  | .inr request => 2 * OAI.EditApproximation.PhysicalTableRequest.code copies T S request.val + 1end OAI.EditApproximation.ChargedPhysicalRequestendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationabbrev ComputedFamilyScalarKey (source target : List ℕ) (N R : ℕ) :=  OAI.EditApproximation.PhysicalFamilyScalarKey (M := (OAI.EditApproximation.integerParameters N).M)    (J := OAI.EditApproximation.intervalTreeDepth (OAI.EditApproximation.integerParameters N).M source.length) (R := R)    target N (OAI.EditApproximation.integerParameters N).P (OAI.EditApproximation.inputSmallLog N) (40 * OAI.EditApproximation.smallLogExponent N)    (OAI.EditApproximation.inputHeight N) (OAI.EditApproximation.inputSmallLog N ^ 80) (OAI.EditApproximation.computedSeedPassCount N) (OAI.EditApproximation.inputHeight N ^ 2)def computedFamilyMemoCode (source target : List ℕ) (N R : ℕ) :    Sum (OAI.EditApproximation.ComputedFamilyScalarKey source target N R) (OAI.EditApproximation.ComputedFamilyTableKey source target N) → ℕ :=  OAI.EditApproximation.SourceRanked.keyCode    (OAI.EditApproximation.physicalFamilyCode target N (OAI.EditApproximation.integerParameters N).P (OAI.EditApproximation.inputSmallLog N) (40 * OAI.EditApproximation.smallLogExponent N)      (OAI.EditApproximation.inputHeight N) (OAI.EditApproximation.inputSmallLog N ^ 80) (OAI.EditApproximation.computedSeedPassCount N) (OAI.EditApproximation.inputHeight N ^ 2))    OAI.EditApproximation.ChargedPhysicalRequest.codeend OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen EditDistortion Finset MeasureTheory ProbabilityTheorydef coarseInitialCandidate {α : Type u} [DecidableEq α]    (B D : ℕ) (Q lam : ℚ) (x y : List α)    (i : OAI.EditApproximation.CoarseGuessIndex (OAI.EditApproximation.coarseEntryWidth x y)) (draws : OAI.EditApproximation.CoarseThresholdDraws B D) : ℚ :=  let k := OAI.EditApproximation.coarseGuess (OAI.EditApproximation.coarseEntryWidth x y) i  2 * (OAI.EditApproximation.coarseThresholdEstimate k Q lam    (OAI.EditApproximation.coarseTargetFrame k (OAI.EditApproximation.coarsePadTo (OAI.EditApproximation.coarseEntryWidth x y) y))    (OAI.EditApproximation.coarseEntryTree B D x y) draws k 0 (OAI.EditApproximation.coarseRootShift k) + k)def coarseInitialMinimum {α : Type u} [DecidableEq α]    (B D : ℕ) (Q lam : ℚ) (x y : List α)    (draws : OAI.EditApproximation.CoarseGuessIndex (OAI.EditApproximation.coarseEntryWidth x y) → OAI.EditApproximation.CoarseThresholdDraws B D) : ℚ :=  univ.inf' univ_nonempty (fun i => OAI.EditApproximation.coarseInitialCandidate B D Q lam x y i (draws i))def coarseInitialValue {α : Type u} [DecidableEq α]    (B D : ℕ) (Q lam : ℚ) (N : ℕ) (x y : List α)    (draws : OAI.EditApproximation.CoarseGuessIndex (OAI.EditApproximation.coarseEntryWidth x y) → OAI.EditApproximation.CoarseThresholdDraws B D) : ℕ :=  if 2 * x.length < y.length then min N y.length  else if x = y then 0  else min N ⌈OAI.EditApproximation.coarseInitialMinimum B D Q lam x y draws⌉₊end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen Finset MeasureTheory ProbabilityTheorydef coarseActiveArrayWork {B : ℕ} {α : Type u} (k : ℕ) (Q lam : ℚ) :    {D : ℕ} → OAI.EditApproximation.CoarseSourceTree B α D → OAI.EditApproximation.CoarseThresholdDraws B D → ℚ → ℕ  | _, tree, draws, allowance =>    if (tree.word.length : ℚ) ≤ allowance then 0 else    match tree, draws with    | .leaf _, _ => B * (2 * k + 1)    | .branch children, (draws, below) =>      B * (2 * k + 1) +        OAI.EditApproximation.coarseActiveChildrenWork Q lam allowance (fun child => coarseActiveArrayWork k Q lam child)          (List.ofFn fun i => (children i, draws i, below i))def coarseFullSeedTable (N B : ℕ) {I : Type u_1} {α : Type u_2} [DecidableEq α]    (depth : I → ℕ) (x y : I → List α)    (draws : OAI.EditApproximation.CoarseFullSeedDraws B depth x y) : I → ℕ :=  fun i => OAI.EditApproximation.coarseInitialValue B (depth i) (OAI.EditApproximation.initialThresholdQ N) (OAI.EditApproximation.initialLambda N) N (x i) (y i) (draws i)def coarseInitialArrayWork {α : Type u} [DecidableEq α]    (B D : ℕ) (Q lam : ℚ) (x y : List α)    (draws : OAI.EditApproximation.CoarseGuessIndex (OAI.EditApproximation.coarseEntryWidth x y) → OAI.EditApproximation.CoarseThresholdDraws B D) : ℕ :=  if 2 * x.length < y.length then 0  else if x = y then 0  else ∑ i, OAI.EditApproximation.coarseActiveArrayWork (OAI.EditApproximation.coarseGuess (OAI.EditApproximation.coarseEntryWidth x y) i) Q lam    (OAI.EditApproximation.coarseEntryTree B D x y) (draws i) (OAI.EditApproximation.coarseGuess (OAI.EditApproximation.coarseEntryWidth x y) i)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen Filteropen scoped Topologydef integerEqualWithWork : List ℤ → List ℤ → Bool × ℕ  | [], [] => (true, 1)  | [], _ :: _ => (false, 1)  | _ :: _, [] => (false, 1)  | x :: xs, y :: ys =>    if x = y then      let tail := integerEqualWithWork xs ys      (tail.1, tail.2 + 1)    else (false, 1)def integerPreprocessingWork (source target : List ℤ) : ℕ :=  (OAI.EditApproximation.integerInputInspectionWithWork source target).2 +  (OAI.EditApproximation.encodeIntegerSymbolsWithWork source).2 + (OAI.EditApproximation.encodeIntegerSymbolsWithWork target).2 +  (OAI.EditApproximation.integerOccurrenceBuildWithWork source target).2 + (OAI.EditApproximation.integerEqualWithWork source target).2 + 1end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen Filterabbrev ComputedFamilyMemoKey (source target : List ℕ) (N : ℕ) :=  Sum (OAI.EditApproximation.ComputedFamilyScalarKey source target N (OAI.EditApproximation.inputHeight N ^ 2))    (OAI.EditApproximation.ComputedFamilyTableKey source target N)def integerPreevaluationWork (source target : List ℤ) (N : ℕ) (epsilon : OAI.EditApproximation.BinaryFraction) : ℕ :=  OAI.EditApproximation.integerPreprocessingWork source target + OAI.EditApproximation.globalParameterWork N +    (OAI.EditApproximation.physicalLargeInputWithWork N epsilon).2end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable {α : Type u_1} {M J R : ℕ} (target : List α) (N P F exponent H Q passes copies : ℕ)def physicalFamilyCodeWithWork    (key : OAI.EditApproximation.PhysicalFamilyScalarKey (M := M) (J := J) (R := R)      target N P F exponent H Q passes copies) : ℕ × ℕ :=  let scalar := OAI.EditApproximation.physicalScalarCodeWithWork key.2.2  let copy := OAI.EditApproximation.naturalPairWithWork key.2.1.val scalar.1  let pass := OAI.EditApproximation.naturalPairWithWork key.1.val copy.1  (pass.1, scalar.2 + copy.2 + pass.2 + 2)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationdef computedFamilyMemoCodeWithWork (source target : List ℕ) (N R : ℕ) :    Sum (OAI.EditApproximation.ComputedFamilyScalarKey source target N R) (OAI.EditApproximation.ComputedFamilyTableKey source target N) → ℕ × ℕ  | .inl key =>      let result := OAI.EditApproximation.physicalFamilyCodeWithWork target N (OAI.EditApproximation.integerParameters N).P (OAI.EditApproximation.inputSmallLog N)        (40 * OAI.EditApproximation.smallLogExponent N) (OAI.EditApproximation.inputHeight N) (OAI.EditApproximation.inputSmallLog N ^ 80)        (OAI.EditApproximation.computedSeedPassCount N) (OAI.EditApproximation.inputHeight N ^ 2) key      (2 * result.1, result.2 + 2)  | .inr key => let result := OAI.EditApproximation.chargedPhysicalCodeWithWork key      (2 * result.1 + 1, result.2 + 3)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable (M J N n exponent F Q R B : ℕ)open Finsetopen MeasureTheory ProbabilityTheorydef queryPhysicalScalarGroupQueries (node : OAI.EditApproximation.PhysicalInternalNode M J) (time : Fin R)    (b : ℕ) (cell : ℕ × ℕ) : OAI.EditApproximation.BitPhysicalGroupQueries M J N n exponent F Q R B b := by  have proof_log_two_add_one_eq_size_103 (N : ℕ) (hN : LT.lt.{0} 0 N) :      Nat.log 2 N + 1 = Nat.size N := by    apply Nat.le_antisymm    · have h := Nat.pow_log_le_self 2 hN.ne'      have hlt : Nat.log 2 N < Nat.size N := Nat.lt_size.mpr h      omega    · exact Nat.size_le.mpr (Nat.lt_pow_succ_log_self (by decide : 1 < 2) N)  have proof_powerTwoWord_value_13 (n : ℕ) : OAI.EditApproximation.bitWordValue (OAI.EditApproximation.powerTwoWord n) = 2 ^ n := by    induction n with    | zero => (simp [OAI.EditApproximation.powerTwoWord, OAI.EditApproximation.bitWordValue])    | succ n ih =>      (simp only [OAI.EditApproximation.powerTwoWord, List.replicate_succ, List.cons_append, OAI.EditApproximation.bitWordValue,        Bool.toNat_false, zero_add] at *)      rw [ih, pow_succ]      omega  have proof_arithmeticMapWithWork_value_70 {α : Type 0} {β : Type 0} (f : α → Prod.{0, 0} β ℕ) (values : List.{0} α) :      (OAI.EditApproximation.arithmeticMapWithWork f values).1 = values.map (fun a => (f a).1) := by    induction values with    | nil => rfl    | cons a rest ih => simp only [OAI.EditApproximation.arithmeticMapWithWork, ih, List.map_cons]  have proof_dyadicScalesWithWork_value_104 (N : ℕ) :      (OAI.EditApproximation.dyadicScalesWithWork N).1 = OAI.EditApproximation.dyadicScales N := by    have hcount : max 1 N.bits.length = Nat.log 2 N + 1 := by      by_cases hz : N = 0      · subst N        decide      · have h := proof_log_two_add_one_eq_size_103 N (Nat.pos_of_ne_zero hz)        have hp := Nat.size_pos.mpr (Nat.pos_of_ne_zero hz)        rw [Nat.size_eq_bits_len, max_eq_right hp, h]    simp only [OAI.EditApproximation.dyadicScalesWithWork, proof_arithmeticMapWithWork_value_70, proof_powerTwoWord_value_13, hcount,      OAI.EditApproximation.dyadicScales]  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_bitOrdering_matches_4 (high : Ordering) (a : Bool) (b : Bool) (x : ℕ) (y : ℕ) (h : OAI.EditApproximation.orderingMatches high x y) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitOrdering high a b) (a.toNat + 2 * x) (b.toNat + 2 * y) := by    rcases h with ⟨rfl, h⟩ | ⟨rfl, rfl⟩ | ⟨rfl, h⟩    · exact Or.inl ⟨rfl, by cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩    · cases a <;> cases b <;> simp [OAI.EditApproximation.bitOrdering, OAI.EditApproximation.orderingMatches]    · exact Or.inr (Or.inr ⟨rfl, by        cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩)  have proof_bitCompareWithWork_matches_5 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitCompareWithWork left right).1 (OAI.EditApproximation.bitWordValue left) (OAI.EditApproximation.bitWordValue right) := by    induction left generalizing right with    | nil =>      simp only [OAI.EditApproximation.bitCompareWithWork]      induction right with      | nil => (simp [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.orderingMatches, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        simpa only [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareNilLeftWithWork bs).1 false b 0 (OAI.EditApproximation.bitWordValue bs) ih    | cons a as ih =>      cases right with      | nil =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as []).1 a false (OAI.EditApproximation.bitWordValue as) 0 (ih [])      | cons b bs =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue] using          proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as bs).1 a b (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs) (ih bs)  have proof_bitCompareWithWork_eq_3 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .eq ↔ OAI.EditApproximation.bitWordValue left = OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_binaryNaturalCompareWithWork_eq_73 (a : ℕ) (b : ℕ) :      (OAI.EditApproximation.binaryNaturalCompareWithWork a b).1 = .eq ↔ a = b := by    simpa only [OAI.EditApproximation.binaryNaturalCompareWithWork, proof_bitWordValue_bits_15] using proof_bitCompareWithWork_eq_3 a.bits b.bits  have proof_naturalEqualWithWork_value_74 (a : ℕ) (b : ℕ) :      (OAI.EditApproximation.naturalEqualWithWork a b).1 = true ↔ a = b := by    simp only [OAI.EditApproximation.naturalEqualWithWork, decide_eq_true_eq, proof_binaryNaturalCompareWithWork_eq_73]  have proof_queryNaturalIndexWithWork_value_105 (a : ℕ) (xs : List.{0} ℕ) :      (OAI.EditApproximation.queryNaturalIndexWithWork a xs).1 = xs.idxOf a := by    induction xs with    | nil => rfl    | cons b xs ih =>      simp only [OAI.EditApproximation.queryNaturalIndexWithWork]      by_cases hab : a = b      · subst b        rw [ite_eq_left ((proof_naturalEqualWithWork_value_74 a a).mpr rfl)]        simp      · rw [ite_eq_right (fun h => hab ((proof_naturalEqualWithWork_value_74 a b).mp h))]        simp only [ih, List.idxOf_cons, beq_iff_eq]        rw [ite_eq_right (Ne.symm hab)]  have proof_queryScaleDispatchWithWork_value_106 (N : ℕ) (b : ℕ) :      (OAI.EditApproximation.queryScaleDispatchWithWork N b).1 = (OAI.EditApproximation.dyadicScales N).idxOf b := by    simp only [OAI.EditApproximation.queryScaleDispatchWithWork, proof_queryNaturalIndexWithWork_value_105, proof_dyadicScalesWithWork_value_104]  have proof_bitCompareWithWork_lt_16 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .lt ↔ OAI.EditApproximation.bitWordValue left < OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_binaryNaturalCompareWithWork_lt_53 (a : ℕ) (b : ℕ) :      (OAI.EditApproximation.binaryNaturalCompareWithWork a b).1 = .lt ↔ a < b := by    simpa only [OAI.EditApproximation.binaryNaturalCompareWithWork, proof_bitWordValue_bits_15] using proof_bitCompareWithWork_lt_16 a.bits b.bits  have proof_queryScalePresentWithWork_value_101 (N : ℕ) (b : ℕ) :      (OAI.EditApproximation.queryScalePresentWithWork N b).1 = true ↔ b ∈ OAI.EditApproximation.dyadicScales N := by    simp only [OAI.EditApproximation.queryScalePresentWithWork, decide_eq_true_eq, proof_binaryNaturalCompareWithWork_lt_53,      proof_queryScaleDispatchWithWork_value_106]    have hl : (OAI.EditApproximation.dyadicScales N).length = max 1 N.bits.length := by      rw [← proof_dyadicScalesWithWork_value_104 N]      (simp only [OAI.EditApproximation.dyadicScalesWithWork, proof_arithmeticMapWithWork_value_70, List.length_map, List.length_range])    rw [← hl]    exact List.idxOf_lt_length_iff  have proof_wordLEWithWork_value_26 (a : List.{0} Bool) (b : List.{0} Bool) :      (OAI.EditApproximation.wordLEWithWork a b).1 = true ↔ OAI.EditApproximation.bitWordValue a ≤ OAI.EditApproximation.bitWordValue b := by    simp only [OAI.EditApproximation.wordLEWithWork, Bool.not_eq_true', decide_eq_false_iff_not,      proof_bitCompareWithWork_lt_16, not_lt]  have proof_bitAdder_value_1 (a : Bool) (b : Bool) (carry : Bool) :      (OAI.EditApproximation.bitSum a b carry).toNat + 2 * (OAI.EditApproximation.bitCarry a b carry).toNat =        a.toNat + b.toNat + carry.toNat := by    cases a <;> cases b <;> cases carry <;> decide  have proof_bitAddWithWork_value_2 (left : List.{0} Bool) (right : List.{0} Bool) (carry : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitAddWithWork left right carry).1 =        OAI.EditApproximation.bitWordValue left + OAI.EditApproximation.bitWordValue right + carry.toNat := by    induction left generalizing right carry with    | nil =>      simp only [OAI.EditApproximation.bitAddWithWork]      induction right generalizing carry with      | nil => cases carry <;> simp [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue]      | cons b bs ih =>        simp only [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 false b carry        simp only [Bool.toNat_false] at h        omega    | cons a as ih =>      cases right with      | nil =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a false carry        simp only [Bool.toNat_false] at h        omega      | cons b bs =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a b carry        omega  have proof_bitMulWithWork_value_0 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitMulWithWork left right).1 = OAI.EditApproximation.bitWordValue left * OAI.EditApproximation.bitWordValue right := by    induction left with    | nil => simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue]    | cons bit bits ih =>      cases bit <;> simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue, proof_bitAddWithWork_value_2, ih] <;> ring  have proof_binaryNaturalMulWithWork_value_55 (a : ℕ) (b : ℕ) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalMulWithWork a b).1 = a * b := by    simp [OAI.EditApproximation.binaryNaturalMulWithWork, proof_bitMulWithWork_value_0, proof_bitWordValue_bits_15]  have proof_queryCellValidWithWork_value_102 (n : ℕ) (exponent : ℕ) (cell : Prod.{0, 0} ℕ ℕ) :      (OAI.EditApproximation.queryCellValidWithWork n exponent cell).1 = true ↔        cell.1 ≤ n * 2 ^ exponent ∧ cell.2 ≤ n * 2 ^ exponent := by    simp only [OAI.EditApproximation.queryCellValidWithWork, Bool.and_eq_true, proof_wordLEWithWork_value_26, proof_bitWordValue_bits_15,      proof_binaryNaturalMulWithWork_value_55, proof_powerTwoWord_value_13]  have proof_physicalScaleIndex_get_93 (N : ℕ) (b : ℕ) (hb : Membership.mem.{0, 0} (OAI.EditApproximation.dyadicScales N) b) :      (OAI.EditApproximation.dyadicScales N).get (OAI.EditApproximation.physicalScaleIndex N b hb) = b :=    List.getElem_idxOf (List.idxOf_lt_length_of_mem hb)  exact    if hb : (OAI.EditApproximation.queryScalePresentWithWork N b).1 = true then      if hc : (OAI.EditApproximation.queryCellValidWithWork n exponent cell).1 = true then        let key : OAI.EditApproximation.PhysicalLocalGroupKey M J N n exponent :=          (node, OAI.EditApproximation.physicalScaleIndex N b ((proof_queryScalePresentWithWork_value_101 N b).mp hb),            ⟨cell.1, Nat.lt_succ_of_le ((proof_queryCellValidWithWork_value_102 n exponent cell).mp hc).1⟩,            ⟨cell.2, Nat.lt_succ_of_le ((proof_queryCellValidWithWork_value_102 n exponent cell).mp hc).2⟩)        Eq.mp (congrArg (OAI.EditApproximation.BitPhysicalGroupQueries M J N n exponent F Q R B)          (proof_physicalScaleIndex_get_93 N b ((proof_queryScalePresentWithWork_value_101 N b).mp hb)))            (OAI.EditApproximation.queryPhysicalScalarGroupQueriesAt M J N n exponent F Q R B key time)      else fun _ _ => .done (OAI.EditApproximation.BinaryFraction.nat 0)    else fun _ _ => .done (OAI.EditApproximation.BinaryFraction.nat 0)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable (M J N n exponent F Q R B : ℕ)def queryPhysicalScalarGroupRead (node : OAI.EditApproximation.PhysicalInternalNode M J) (time : Fin R)    (key : OAI.EditApproximation.GroupScalarKey M F Q) : OAI.EditApproximation.BitQuery (OAI.EditApproximation.PhysicalScalarKey M J N n exponent F Q R B) OAI.EditApproximation.BinaryFraction :=  .charge ((OAI.EditApproximation.queryScalePresentWithWork N key.1.1).2 +    (OAI.EditApproximation.queryCellValidWithWork n exponent key.1.2).2 + 2)    (OAI.EditApproximation.queryPhysicalScalarGroupQueries M J N n exponent F Q R B node time      key.1.1 key.1.2 key.2.1 key.2.2)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable (M J N n exponent F Q R B : ℕ)open Finsetdef queryPhysicalScalarOnlineRead (node : OAI.EditApproximation.PhysicalInternalNode M J) (time : Fin R)    (key : ℕ × OAI.EditApproximation.TargetInterval n) (range : ℕ) :    OAI.EditApproximation.BitQuery (OAI.EditApproximation.PhysicalScalarKey M J N n exponent F Q R B) OAI.EditApproximation.BinaryFraction := by  have proof_log_two_add_one_eq_size_103 (N : ℕ) (hN : LT.lt.{0} 0 N) :      Nat.log 2 N + 1 = Nat.size N := by    apply Nat.le_antisymm    · have h := Nat.pow_log_le_self 2 hN.ne'      have hlt : Nat.log 2 N < Nat.size N := Nat.lt_size.mpr h      omega    · exact Nat.size_le.mpr (Nat.lt_pow_succ_log_self (by decide : 1 < 2) N)  have proof_powerTwoWord_value_13 (n : ℕ) : OAI.EditApproximation.bitWordValue (OAI.EditApproximation.powerTwoWord n) = 2 ^ n := by    induction n with    | zero => (simp [OAI.EditApproximation.powerTwoWord, OAI.EditApproximation.bitWordValue])    | succ n ih =>      (simp only [OAI.EditApproximation.powerTwoWord, List.replicate_succ, List.cons_append, OAI.EditApproximation.bitWordValue,        Bool.toNat_false, zero_add] at *)      rw [ih, pow_succ]      omega  have proof_arithmeticMapWithWork_value_70 {α : Type 0} {β : Type 0} (f : α → Prod.{0, 0} β ℕ) (values : List.{0} α) :      (OAI.EditApproximation.arithmeticMapWithWork f values).1 = values.map (fun a => (f a).1) := by    induction values with    | nil => rfl    | cons a rest ih => simp only [OAI.EditApproximation.arithmeticMapWithWork, ih, List.map_cons]  have proof_dyadicScalesWithWork_value_104 (N : ℕ) :      (OAI.EditApproximation.dyadicScalesWithWork N).1 = OAI.EditApproximation.dyadicScales N := by    have hcount : max 1 N.bits.length = Nat.log 2 N + 1 := by      by_cases hz : N = 0      · subst N        decide      · have h := proof_log_two_add_one_eq_size_103 N (Nat.pos_of_ne_zero hz)        have hp := Nat.size_pos.mpr (Nat.pos_of_ne_zero hz)        rw [Nat.size_eq_bits_len, max_eq_right hp, h]    simp only [OAI.EditApproximation.dyadicScalesWithWork, proof_arithmeticMapWithWork_value_70, proof_powerTwoWord_value_13, hcount,      OAI.EditApproximation.dyadicScales]  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_bitOrdering_matches_4 (high : Ordering) (a : Bool) (b : Bool) (x : ℕ) (y : ℕ) (h : OAI.EditApproximation.orderingMatches high x y) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitOrdering high a b) (a.toNat + 2 * x) (b.toNat + 2 * y) := by    rcases h with ⟨rfl, h⟩ | ⟨rfl, rfl⟩ | ⟨rfl, h⟩    · exact Or.inl ⟨rfl, by cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩    · cases a <;> cases b <;> simp [OAI.EditApproximation.bitOrdering, OAI.EditApproximation.orderingMatches]    · exact Or.inr (Or.inr ⟨rfl, by        cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩)  have proof_bitCompareWithWork_matches_5 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitCompareWithWork left right).1 (OAI.EditApproximation.bitWordValue left) (OAI.EditApproximation.bitWordValue right) := by    induction left generalizing right with    | nil =>      simp only [OAI.EditApproximation.bitCompareWithWork]      induction right with      | nil => (simp [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.orderingMatches, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        simpa only [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareNilLeftWithWork bs).1 false b 0 (OAI.EditApproximation.bitWordValue bs) ih    | cons a as ih =>      cases right with      | nil =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as []).1 a false (OAI.EditApproximation.bitWordValue as) 0 (ih [])      | cons b bs =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue] using          proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as bs).1 a b (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs) (ih bs)  have proof_bitCompareWithWork_eq_3 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .eq ↔ OAI.EditApproximation.bitWordValue left = OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_binaryNaturalCompareWithWork_eq_73 (a : ℕ) (b : ℕ) :      (OAI.EditApproximation.binaryNaturalCompareWithWork a b).1 = .eq ↔ a = b := by    simpa only [OAI.EditApproximation.binaryNaturalCompareWithWork, proof_bitWordValue_bits_15] using proof_bitCompareWithWork_eq_3 a.bits b.bits  have proof_naturalEqualWithWork_value_74 (a : ℕ) (b : ℕ) :      (OAI.EditApproximation.naturalEqualWithWork a b).1 = true ↔ a = b := by    simp only [OAI.EditApproximation.naturalEqualWithWork, decide_eq_true_eq, proof_binaryNaturalCompareWithWork_eq_73]  have proof_queryNaturalIndexWithWork_value_105 (a : ℕ) (xs : List.{0} ℕ) :      (OAI.EditApproximation.queryNaturalIndexWithWork a xs).1 = xs.idxOf a := by    induction xs with    | nil => rfl    | cons b xs ih =>      simp only [OAI.EditApproximation.queryNaturalIndexWithWork]      by_cases hab : a = b      · subst b        rw [ite_eq_left ((proof_naturalEqualWithWork_value_74 a a).mpr rfl)]        simp      · rw [ite_eq_right (fun h => hab ((proof_naturalEqualWithWork_value_74 a b).mp h))]        simp only [ih, List.idxOf_cons, beq_iff_eq]        rw [ite_eq_right (Ne.symm hab)]  have proof_queryScaleDispatchWithWork_value_106 (N : ℕ) (b : ℕ) :      (OAI.EditApproximation.queryScaleDispatchWithWork N b).1 = (OAI.EditApproximation.dyadicScales N).idxOf b := by    simp only [OAI.EditApproximation.queryScaleDispatchWithWork, proof_queryNaturalIndexWithWork_value_105, proof_dyadicScalesWithWork_value_104]  have proof_bitCompareWithWork_lt_16 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .lt ↔ OAI.EditApproximation.bitWordValue left < OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_binaryNaturalCompareWithWork_lt_53 (a : ℕ) (b : ℕ) :      (OAI.EditApproximation.binaryNaturalCompareWithWork a b).1 = .lt ↔ a < b := by    simpa only [OAI.EditApproximation.binaryNaturalCompareWithWork, proof_bitWordValue_bits_15] using proof_bitCompareWithWork_lt_16 a.bits b.bits  have proof_queryScalePresentWithWork_value_101 (N : ℕ) (b : ℕ) :      (OAI.EditApproximation.queryScalePresentWithWork N b).1 = true ↔ b ∈ OAI.EditApproximation.dyadicScales N := by    simp only [OAI.EditApproximation.queryScalePresentWithWork, decide_eq_true_eq, proof_binaryNaturalCompareWithWork_lt_53,      proof_queryScaleDispatchWithWork_value_106]    have hl : (OAI.EditApproximation.dyadicScales N).length = max 1 N.bits.length := by      rw [← proof_dyadicScalesWithWork_value_104 N]      (simp only [OAI.EditApproximation.dyadicScalesWithWork, proof_arithmeticMapWithWork_value_70, List.length_map, List.length_range])    rw [← hl]    exact List.idxOf_lt_length_iff  have proof_wordLEWithWork_value_26 (a : List.{0} Bool) (b : List.{0} Bool) :      (OAI.EditApproximation.wordLEWithWork a b).1 = true ↔ OAI.EditApproximation.bitWordValue a ≤ OAI.EditApproximation.bitWordValue b := by    simp only [OAI.EditApproximation.wordLEWithWork, Bool.not_eq_true', decide_eq_false_iff_not,      proof_bitCompareWithWork_lt_16, not_lt]  have proof_queryRangeValidWithWork_value_107 (B : ℕ) (range : ℕ) :      (OAI.EditApproximation.queryRangeValidWithWork B range).1 = true ↔ 0 < range ∧ range ≤ B := by    simp only [OAI.EditApproximation.queryRangeValidWithWork, Bool.and_eq_true, decide_eq_true_eq,      proof_binaryNaturalCompareWithWork_lt_53, proof_wordLEWithWork_value_26, proof_bitWordValue_bits_15]  exact    .charge ((OAI.EditApproximation.queryScalePresentWithWork N key.1).2 + (OAI.EditApproximation.queryRangeValidWithWork B range).2 + 2)      (if hb : (OAI.EditApproximation.queryScalePresentWithWork N key.1).1 = true then        if hr : (OAI.EditApproximation.queryRangeValidWithWork B range).1 = true then          OAI.EditApproximation.queryPhysicalScalarRead M J N n exponent F Q R B            ⟨.inl ((node, OAI.EditApproximation.physicalScaleIndex N key.1 ((proof_queryScalePresentWithWork_value_101 N key.1).mp hb), key.2),              OAI.EditApproximation.positiveDrawRangeOfLE B range ((proof_queryRangeValidWithWork_value_107 B range).mp hr).1                ((proof_queryRangeValidWithWork_value_107 B range).mp hr).2), time⟩        else .done (OAI.EditApproximation.BinaryFraction.nat 0)      else .done (OAI.EditApproximation.BinaryFraction.nat 0))end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable {α : Type u_1} {M J R : ℕ} (target : List α) (N P F exponent H Q passes copies pass copy : ℕ)def queryFamilyTagWithWork    (scalar : OAI.EditApproximation.PhysicalScalarKey M J N target.length exponent F Q R (OAI.EditApproximation.localOnlineMassBound M P H)) :    OAI.EditApproximation.PhysicalFamilyScalarKey (M := M) (J := J) (R := R)      target N P F exponent H Q passes copies × ℕ :=  let p := OAI.EditApproximation.queryFinOfNatWithWork (passes + 1) pass (Nat.succ_pos _)  let c := OAI.EditApproximation.queryFinOfNatWithWork (copies + 1) copy (Nat.succ_pos _)  let key := (p.1, c.1, scalar)  (key, p.2 + c.2 + (OAI.EditApproximation.physicalFamilyCodeWithWork target N P F exponent H Q passes copies key).2 + 1)def queryFamilyGroupRead (node : OAI.EditApproximation.PhysicalInternalNode M J) (time : Fin R)    (key : OAI.EditApproximation.GroupScalarKey M F Q) :    OAI.EditApproximation.BitQuery (OAI.EditApproximation.PhysicalFamilyScalarKey (M := M) (J := J) (R := R)      target N P F exponent H Q passes copies) OAI.EditApproximation.BinaryFraction :=  OAI.EditApproximation.BitQuery.mapKeysWithWork    (OAI.EditApproximation.queryFamilyTagWithWork target N P F exponent H Q passes copies pass copy)    (OAI.EditApproximation.queryPhysicalScalarGroupRead M J N target.length exponent F Q R (OAI.EditApproximation.localOnlineMassBound M P H)      node time key)def queryFamilyOnlineRead (node : OAI.EditApproximation.PhysicalInternalNode M J) (time : Fin R)    (key : ℕ × OAI.EditApproximation.TargetInterval target.length) (range : ℕ) :    OAI.EditApproximation.BitQuery (OAI.EditApproximation.PhysicalFamilyScalarKey (M := M) (J := J) (R := R)      target N P F exponent H Q passes copies) OAI.EditApproximation.BinaryFraction :=  OAI.EditApproximation.BitQuery.mapKeysWithWork    (OAI.EditApproximation.queryFamilyTagWithWork target N P F exponent H Q passes copies pass copy)    (OAI.EditApproximation.queryPhysicalScalarOnlineRead M J N target.length exponent F Q R (OAI.EditApproximation.localOnlineMassBound M P H)      node time key range)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable {σ : Type u_1} {M J n : ℕ} (passes copies T S : ℕ) (parent : {r : PhysicalTableRequest M J n // r.Bounded passes copies T S})abbrev QueryPhysicalChild := Sum σ {child : OAI.EditApproximation.PhysicalTableRequest M J n //  child.combinedRank T S < parent.val.combinedRank T S}def querySupportedChildWithWork (key : OAI.EditApproximation.QueryPhysicalChild (σ := σ) passes copies T S parent) : Bool × ℕ :=  match key with  | .inl _ => (true, 1)  | .inr child => OAI.EditApproximation.queryPhysicalBoundedWithWork passes copies T S child.valdef queryRestrictPhysicalBody (program : OAI.EditApproximation.BitQuery (OAI.EditApproximation.QueryPhysicalChild (σ := σ) passes copies T S parent) OAI.EditApproximation.BinaryFraction) :    OAI.EditApproximation.BitQuery (Sum σ {child : {r : OAI.EditApproximation.PhysicalTableRequest M J n // r.Bounded passes copies T S} //      child.val.combinedRank T S < parent.val.combinedRank T S}) OAI.EditApproximation.BinaryFraction := by  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_bitOrdering_matches_4 (high : Ordering) (a : Bool) (b : Bool) (x : ℕ) (y : ℕ) (h : OAI.EditApproximation.orderingMatches high x y) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitOrdering high a b) (a.toNat + 2 * x) (b.toNat + 2 * y) := by    rcases h with ⟨rfl, h⟩ | ⟨rfl, rfl⟩ | ⟨rfl, h⟩    · exact Or.inl ⟨rfl, by cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩    · cases a <;> cases b <;> simp [OAI.EditApproximation.bitOrdering, OAI.EditApproximation.orderingMatches]    · exact Or.inr (Or.inr ⟨rfl, by        cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩)  have proof_bitCompareWithWork_matches_5 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitCompareWithWork left right).1 (OAI.EditApproximation.bitWordValue left) (OAI.EditApproximation.bitWordValue right) := by    induction left generalizing right with    | nil =>      simp only [OAI.EditApproximation.bitCompareWithWork]      induction right with      | nil => (simp [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.orderingMatches, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        simpa only [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareNilLeftWithWork bs).1 false b 0 (OAI.EditApproximation.bitWordValue bs) ih    | cons a as ih =>      cases right with      | nil =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as []).1 a false (OAI.EditApproximation.bitWordValue as) 0 (ih [])      | cons b bs =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue] using          proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as bs).1 a b (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs) (ih bs)  have proof_bitCompareWithWork_lt_16 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .lt ↔ OAI.EditApproximation.bitWordValue left < OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_binaryNaturalCompareWithWork_lt_53 (a : ℕ) (b : ℕ) :      (OAI.EditApproximation.binaryNaturalCompareWithWork a b).1 = .lt ↔ a < b := by    simpa only [OAI.EditApproximation.binaryNaturalCompareWithWork, proof_bitWordValue_bits_15] using proof_bitCompareWithWork_lt_16 a.bits b.bits  have proof_wordLEWithWork_value_26 (a : List.{0} Bool) (b : List.{0} Bool) :      (OAI.EditApproximation.wordLEWithWork a b).1 = true ↔ OAI.EditApproximation.bitWordValue a ≤ OAI.EditApproximation.bitWordValue b := by    simp only [OAI.EditApproximation.wordLEWithWork, Bool.not_eq_true', decide_eq_false_iff_not,      proof_bitCompareWithWork_lt_16, not_lt]  have proof_bitAdder_value_1 (a : Bool) (b : Bool) (carry : Bool) :      (OAI.EditApproximation.bitSum a b carry).toNat + 2 * (OAI.EditApproximation.bitCarry a b carry).toNat =        a.toNat + b.toNat + carry.toNat := by    cases a <;> cases b <;> cases carry <;> decide  have proof_bitAddWithWork_value_2 (left : List.{0} Bool) (right : List.{0} Bool) (carry : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitAddWithWork left right carry).1 =        OAI.EditApproximation.bitWordValue left + OAI.EditApproximation.bitWordValue right + carry.toNat := by    induction left generalizing right carry with    | nil =>      simp only [OAI.EditApproximation.bitAddWithWork]      induction right generalizing carry with      | nil => cases carry <;> simp [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue]      | cons b bs ih =>        simp only [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 false b carry        simp only [Bool.toNat_false] at h        omega    | cons a as ih =>      cases right with      | nil =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a false carry        simp only [Bool.toNat_false] at h        omega      | cons b bs =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a b carry        omega  have proof_binaryNaturalAddWithWork_value_52 (a : ℕ) (b : ℕ) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalAddWithWork a b).1 = a + b := by    simp [OAI.EditApproximation.binaryNaturalAddWithWork, proof_bitAddWithWork_value_2, proof_bitWordValue_bits_15]  have proof_queryPhysicalBoundedWithWork_value_109 {M : ℕ} {J : ℕ} {n : ℕ} (passes : ℕ) (copies : ℕ) (T : ℕ) (S : ℕ) (request : OAI.EditApproximation.PhysicalTableRequest M J n) :      (OAI.EditApproximation.queryPhysicalBoundedWithWork passes copies T S request).1 = true ↔        request.Bounded passes copies T S := by    simp only [OAI.EditApproximation.queryPhysicalBoundedWithWork, Bool.and_eq_true, decide_eq_true_eq,      proof_binaryNaturalCompareWithWork_lt_53, proof_wordLEWithWork_value_26, proof_bitWordValue_bits_15,      proof_binaryNaturalAddWithWork_value_52, OAI.EditApproximation.PhysicalTableRequest.Bounded]    tauto  have proof_querySupportedChildWithWork_value_108 {σ : Type u_1} {M : ℕ} {J : ℕ} {n : ℕ} (passes : ℕ) (copies : ℕ) (T : ℕ) (S : ℕ) (parent : Subtype.{1} fun r => OAI.EditApproximation.PhysicalTableRequest.Bounded (M := M) (J := J) (ny := n) passes copies T S r) (key : OAI.EditApproximation.QueryPhysicalChild.{u_1} (σ := σ) passes copies T S parent) :      (OAI.EditApproximation.querySupportedChildWithWork passes copies T S parent key).1 = true ↔        OAI.EditApproximation.SourceRanked.supportedChild (OAI.EditApproximation.PhysicalTableRequest.combinedRank T S)          (OAI.EditApproximation.PhysicalTableRequest.Bounded passes copies T S) parent.val key := by    cases key with    | inl source => exact iff_of_true rfl trivial    | inr child => exact proof_queryPhysicalBoundedWithWork_value_109 passes copies T S child.val  exact    OAI.EditApproximation.BitQuery.mapKeysWithWork      (fun key => (OAI.EditApproximation.SourceRanked.supportedChildMap (OAI.EditApproximation.PhysicalTableRequest.combinedRank T S)        (OAI.EditApproximation.PhysicalTableRequest.Bounded passes copies T S) parent key, 1))      (OAI.EditApproximation.BitQuery.restrictWithWork        (OAI.EditApproximation.SourceRanked.supportedChild (OAI.EditApproximation.PhysicalTableRequest.combinedRank T S)          (OAI.EditApproximation.PhysicalTableRequest.Bounded passes copies T S) parent.val)        (OAI.EditApproximation.querySupportedChildWithWork passes copies T S parent)        (proof_querySupportedChildWithWork_value_108 passes copies T S parent) program)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable {ι : Type u_1} {α : Type*} (source target : List α) (N P F : ℕ) (A a : BinaryFraction) (reader : TargetInterval target.length → BitQuery ι BinaryFraction) (q : TargetInterval target.length)def queryInitialConeProgramAt {n : ℕ} (sourceLength N P F : ℕ) (A a : OAI.EditApproximation.BinaryFraction)    (reader : OAI.EditApproximation.TargetInterval n → OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction) (q : OAI.EditApproximation.TargetInterval n) :    OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction :=  (reader q).bind fun value =>    (OAI.EditApproximation.BitQuery.compute (OAI.EditApproximation.BinaryFraction.queryInitialConeCentersWithWork N P A value q)).bind fun keys =>      OAI.EditApproximation.BitQuery.collect reader keys fun words =>        OAI.EditApproximation.BitQuery.compute (OAI.EditApproximation.BinaryFraction.cachedInitialProgramReadWithWork sourceLength N P F A a          (OAI.EditApproximation.BinaryFraction.queryInitialSeedReadWithWork value q keys words) q)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable {M J n passes copies T S : ℕ} (parent : {r : PhysicalTableRequest M J n // r.Bounded passes copies T S})def queryChargedRead    (key : {child : OAI.EditApproximation.ChargedPhysicalRequest M J n passes copies T S //      child.rank < OAI.EditApproximation.ChargedPhysicalRequest.rank (.inr parent)}) :    OAI.EditApproximation.BitQuery {child : OAI.EditApproximation.ChargedPhysicalRequest M J n passes copies T S //      child.rank < OAI.EditApproximation.ChargedPhysicalRequest.rank (.inr parent)} OAI.EditApproximation.BinaryFraction :=  .charge ((OAI.EditApproximation.chargedPhysicalCodeWithWork key.val).2 + 1) (.read key .done)def queryChargedPreviousRead (hp : 0 < parent.val.pass) (q : OAI.EditApproximation.TargetInterval n) (copy : Fin copies) :    OAI.EditApproximation.BitQuery {child : OAI.EditApproximation.ChargedPhysicalRequest M J n passes copies T S //      child.rank < OAI.EditApproximation.ChargedPhysicalRequest.rank (.inr parent)} OAI.EditApproximation.BinaryFraction := by  have proof_table_rank_lt_99 {M : ℕ} {J : ℕ} {ny : ℕ} {passes : ℕ} {copies : ℕ} {T : ℕ} {S : ℕ} (parent : Subtype.{1} fun request => OAI.EditApproximation.PhysicalTableRequest.Bounded (M := M) (J := J) (ny := ny) passes copies T S request) (child : Subtype.{1} fun request => OAI.EditApproximation.PhysicalTableRequest.Bounded (M := M) (J := J) (ny := ny) passes copies T S request) (h : LT.lt.{0} (OAI.EditApproximation.PhysicalTableRequest.combinedRank T S child.val)    (OAI.EditApproximation.PhysicalTableRequest.combinedRank T S parent.val)) :      OAI.EditApproximation.ChargedPhysicalRequest.rank (Sum.inr child : OAI.EditApproximation.ChargedPhysicalRequest M J ny passes copies T S) < OAI.EditApproximation.ChargedPhysicalRequest.rank (Sum.inr parent) := by    simpa only [OAI.EditApproximation.ChargedPhysicalRequest.rank, OAI.EditApproximation.ChargedPhysicalRequest.depth, OAI.EditApproximation.ChargedPhysicalRequest.index, ← Nat.add_assoc, OAI.EditApproximation.PhysicalTableRequest.combinedRank] using      Nat.add_lt_add_right h 1  have proof_combinedRank_lt_of_progress_80 {M : ℕ} {J : ℕ} {ny : ℕ} (T : ℕ) (S : ℕ) (first : OAI.EditApproximation.PhysicalTableRequest M J ny) (second : OAI.EditApproximation.PhysicalTableRequest M J ny) (hprogress : LT.lt.{0} second.remainingDepth first.remainingDepth ∧      LE.le.{0} (OAI.EditApproximation.PhysicalTableRequest.rank T S second)        (OAI.EditApproximation.PhysicalTableRequest.rank T S first) ∨    LE.le.{0} second.remainingDepth first.remainingDepth ∧      LT.lt.{0} (OAI.EditApproximation.PhysicalTableRequest.rank T S second)        (OAI.EditApproximation.PhysicalTableRequest.rank T S first)) :      OAI.EditApproximation.PhysicalTableRequest.combinedRank T S second < OAI.EditApproximation.PhysicalTableRequest.combinedRank T S first := by    unfold OAI.EditApproximation.PhysicalTableRequest.combinedRank    rcases hprogress with h | h    · exact Nat.add_lt_add_of_lt_of_le h.1 h.2    · exact Nat.add_lt_add_of_le_of_lt h.1 h.2  have proof_rank_lt_previous_pass_98 {M : ℕ} {J : ℕ} {ny : ℕ} (T : ℕ) (S : ℕ) (first : OAI.EditApproximation.PhysicalTableRequest M J ny) (second : OAI.EditApproximation.PhysicalTableRequest M J ny) (hpass : LT.lt.{0} second.pass first.pass) (hindex : LE.le.{0} second.index (HAdd.hAdd.{0, 0, 0} T S)) :      OAI.EditApproximation.PhysicalTableRequest.rank T S second < OAI.EditApproximation.PhysicalTableRequest.rank T S first := by    have hblock : second.pass * (T + S + 1) + second.index <        (second.pass + 1) * (T + S + 1) := by      nlinarith only [hindex]    have hnext := Nat.mul_le_mul_right (T + S + 1) (Nat.succ_le_of_lt hpass)    exact hblock.trans_le (hnext.trans (Nat.le_add_right _ _))  have proof_previousPassRequest_progress_97 {M : ℕ} {J : ℕ} {ny : ℕ} (T : ℕ) (S : ℕ) (copy : ℕ) (parent : OAI.EditApproximation.PhysicalTableRequest M J ny) (hpass : LT.lt.{0} 0 parent.pass) (state : OAI.EditApproximation.TargetInterval ny) :      (OAI.EditApproximation.previousPassRequest T S copy parent state).remainingDepth = parent.remainingDepth ∧        (OAI.EditApproximation.previousPassRequest T S copy parent state).rank T S < parent.rank T S := by    refine ⟨rfl, ?_⟩    exact proof_rank_lt_previous_pass_98 T S parent _ (by      change parent.pass - 1 < parent.pass      omega) le_rfl  exact    OAI.EditApproximation.queryChargedRead parent ⟨.inr (OAI.EditApproximation.chargedPreviousPass parent q copy), by      apply proof_table_rank_lt_99      apply proof_combinedRank_lt_of_progress_80 T S parent.val _      exact Or.inr ⟨(proof_previousPassRequest_progress_97 T S copy.val parent.val hp q).1.le,        (proof_previousPassRequest_progress_97 T S copy.val parent.val hp q).2⟩⟩end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable {M J n passes copies T S : ℕ} (parent : {r : PhysicalTableRequest M J n // r.Bounded passes copies T S})open Finsetdef queryChargedSeedAt (N : ℕ) (multiplier : ℕ → ℕ) (q : OAI.EditApproximation.TargetInterval n) :    OAI.EditApproximation.BitQuery {child : OAI.EditApproximation.ChargedPhysicalRequest M J n passes copies T S //      child.rank < OAI.EditApproximation.ChargedPhysicalRequest.rank (.inr parent)} OAI.EditApproximation.BinaryFraction := by  have proof_coarse_rank_lt_100 {M : ℕ} {J : ℕ} {ny : ℕ} {passes : ℕ} {copies : ℕ} {T : ℕ} {S : ℕ} (entry : OAI.EditApproximation.PhysicalEntry M J ny) (request : Subtype.{1} fun request => OAI.EditApproximation.PhysicalTableRequest.Bounded (M := M) (J := J) (ny := ny) passes copies T S request) (hnode : Eq.{1} entry.1 request.val.node) :      OAI.EditApproximation.ChargedPhysicalRequest.rank (Sum.inl entry : OAI.EditApproximation.ChargedPhysicalRequest M J ny passes copies T S) < OAI.EditApproximation.ChargedPhysicalRequest.rank (Sum.inr request) := by    change J - entry.1.1.val + 0 < request.val.remainingDepth + (request.val.rank T S + 1)    rw [hnode]    unfold OAI.EditApproximation.PhysicalTableRequest.remainingDepth    omega  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_bitOrdering_matches_4 (high : Ordering) (a : Bool) (b : Bool) (x : ℕ) (y : ℕ) (h : OAI.EditApproximation.orderingMatches high x y) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitOrdering high a b) (a.toNat + 2 * x) (b.toNat + 2 * y) := by    rcases h with ⟨rfl, h⟩ | ⟨rfl, rfl⟩ | ⟨rfl, h⟩    · exact Or.inl ⟨rfl, by cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩    · cases a <;> cases b <;> simp [OAI.EditApproximation.bitOrdering, OAI.EditApproximation.orderingMatches]    · exact Or.inr (Or.inr ⟨rfl, by        cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩)  have proof_bitCompareWithWork_matches_5 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitCompareWithWork left right).1 (OAI.EditApproximation.bitWordValue left) (OAI.EditApproximation.bitWordValue right) := by    induction left generalizing right with    | nil =>      simp only [OAI.EditApproximation.bitCompareWithWork]      induction right with      | nil => (simp [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.orderingMatches, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        simpa only [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareNilLeftWithWork bs).1 false b 0 (OAI.EditApproximation.bitWordValue bs) ih    | cons a as ih =>      cases right with      | nil =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as []).1 a false (OAI.EditApproximation.bitWordValue as) 0 (ih [])      | cons b bs =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue] using          proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as bs).1 a b (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs) (ih bs)  have proof_bitCompareWithWork_eq_3 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .eq ↔ OAI.EditApproximation.bitWordValue left = OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_binaryNaturalCompareWithWork_eq_73 (a : ℕ) (b : ℕ) :      (OAI.EditApproximation.binaryNaturalCompareWithWork a b).1 = .eq ↔ a = b := by    simpa only [OAI.EditApproximation.binaryNaturalCompareWithWork, proof_bitWordValue_bits_15] using proof_bitCompareWithWork_eq_3 a.bits b.bits  have proof_naturalEqualWithWork_value_74 (a : ℕ) (b : ℕ) :      (OAI.EditApproximation.naturalEqualWithWork a b).1 = true ↔ a = b := by    simp only [OAI.EditApproximation.naturalEqualWithWork, decide_eq_true_eq, proof_binaryNaturalCompareWithWork_eq_73]  exact    .charge ((OAI.EditApproximation.naturalEqualWithWork parent.val.pass 0).2 + 1)      (if hp : (OAI.EditApproximation.naturalEqualWithWork parent.val.pass 0).1 = true then        OAI.EditApproximation.queryChargedRead parent ⟨.inl (parent.val.node, q), proof_coarse_rank_lt_100 _ parent rfl⟩      else .charge (copies + 1)        (OAI.EditApproximation.BitQuery.collect (OAI.EditApproximation.queryChargedPreviousRead parent          (Nat.pos_of_ne_zero (fun h => hp ((proof_naturalEqualWithWork_value_74 _ _).mpr h))) q)          (List.finRange copies) fun words => OAI.EditApproximation.BitQuery.compute            (OAI.EditApproximation.BinaryFraction.querySeedMedianWithWork N (multiplier (parent.val.pass - 1)) words)))end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable (source target : List ℕ) {M J passes copies T S : ℕ} (N P F : ℕ) (A a : BinaryFraction) (multiplier : ℕ → ℕ) (parent : {r : PhysicalTableRequest M J target.length // r.Bounded passes copies T S}) (occurrence : BinaryMemo PositionCounts) (symbolBits positionBits : ℕ) (q : TargetInterval target.length)def queryPhysicalInitial :    OAI.EditApproximation.BitQuery {child : OAI.EditApproximation.ChargedPhysicalRequest M J target.length passes copies T S //      child.rank < OAI.EditApproximation.ChargedPhysicalRequest.rank (.inr parent)} OAI.EditApproximation.BinaryFraction :=  let interval := OAI.EditApproximation.physicalSourceInterval source.length parent.val.node  let length := OAI.EditApproximation.saturatingSubtractWithWork interval.hi interval.lo  let test := OAI.EditApproximation.wordLEWithWork length.1 [true]  .charge (length.2 + test.2 + 2)    (if test.1 then      OAI.EditApproximation.BitQuery.compute (OAI.EditApproximation.queryIndexedSliceWithWork source interval target.length q        occurrence symbolBits positionBits)    else OAI.EditApproximation.queryInitialConeProgramAt (OAI.EditApproximation.bitWordValue length.1) N P F A a      (OAI.EditApproximation.queryChargedSeedAt parent N multiplier) q)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable {ι : Type u_1} {nx ny M : ℕ} (parent : TargetInterval nx) (N P F : ℕ) (a : BinaryFraction) (initialRead : TargetInterval ny → BitQuery ι BinaryFraction) (childRead : (Fin M × TargetInterval ny) → BitQuery ι BinaryFraction) (q : TargetInterval ny)def queryWarmupProgram : OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction :=  (initialRead q).bind fun value =>    (OAI.EditApproximation.BitQuery.compute (OAI.EditApproximation.BinaryFraction.queryRawCentersWithWork N P F a value q)).bind fun centers =>      OAI.EditApproximation.BitQuery.collect initialRead centers fun words =>        let initial := OAI.EditApproximation.BinaryFraction.queryOverrideParentReadWithWork value q centers words        (OAI.EditApproximation.BitQuery.compute (OAI.EditApproximation.BinaryFraction.queryWarmupInputsWithWork M parent N P F a initial q)).bind          fun inputs => OAI.EditApproximation.BitQuery.collect childRead inputs fun childWords =>            OAI.EditApproximation.BitQuery.compute (OAI.EditApproximation.BinaryFraction.localWarmupReadKernelWithWork parent N P F a initial              (fun input => OAI.EditApproximation.BinaryFraction.queryChildReadWithWork inputs childWords input.1 input.2) q)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable {M J ny passes copies T S : ℕ} (parent : {r : PhysicalTableRequest M J ny // r.Bounded passes copies T S}) (hbelow : parent.val.node.1.val < J) (hindex : 0 < parent.val.index) (input : Fin M × TargetInterval ny)def queryChargedWarmupChild :    OAI.EditApproximation.BitQuery {child : OAI.EditApproximation.ChargedPhysicalRequest M J ny passes copies T S //      child.rank < OAI.EditApproximation.ChargedPhysicalRequest.rank (.inr parent)} OAI.EditApproximation.BinaryFraction := by  have proof_table_rank_lt_99 {M : ℕ} {J : ℕ} {ny : ℕ} {passes : ℕ} {copies : ℕ} {T : ℕ} {S : ℕ} (parent : Subtype.{1} fun request => OAI.EditApproximation.PhysicalTableRequest.Bounded (M := M) (J := J) (ny := ny) passes copies T S request) (child : Subtype.{1} fun request => OAI.EditApproximation.PhysicalTableRequest.Bounded (M := M) (J := J) (ny := ny) passes copies T S request) (h : LT.lt.{0} (OAI.EditApproximation.PhysicalTableRequest.combinedRank T S child.val)    (OAI.EditApproximation.PhysicalTableRequest.combinedRank T S parent.val)) :      OAI.EditApproximation.ChargedPhysicalRequest.rank (Sum.inr child : OAI.EditApproximation.ChargedPhysicalRequest M J ny passes copies T S) < OAI.EditApproximation.ChargedPhysicalRequest.rank (Sum.inr parent) := by    simpa only [OAI.EditApproximation.ChargedPhysicalRequest.rank, OAI.EditApproximation.ChargedPhysicalRequest.depth, OAI.EditApproximation.ChargedPhysicalRequest.index, ← Nat.add_assoc, OAI.EditApproximation.PhysicalTableRequest.combinedRank] using      Nat.add_lt_add_right h 1  have proof_combinedRank_lt_of_progress_80 {M : ℕ} {J : ℕ} {ny : ℕ} (T : ℕ) (S : ℕ) (first : OAI.EditApproximation.PhysicalTableRequest M J ny) (second : OAI.EditApproximation.PhysicalTableRequest M J ny) (hprogress : LT.lt.{0} second.remainingDepth first.remainingDepth ∧      LE.le.{0} (OAI.EditApproximation.PhysicalTableRequest.rank T S second)        (OAI.EditApproximation.PhysicalTableRequest.rank T S first) ∨    LE.le.{0} second.remainingDepth first.remainingDepth ∧      LT.lt.{0} (OAI.EditApproximation.PhysicalTableRequest.rank T S second)        (OAI.EditApproximation.PhysicalTableRequest.rank T S first)) :      OAI.EditApproximation.PhysicalTableRequest.combinedRank T S second < OAI.EditApproximation.PhysicalTableRequest.combinedRank T S first := by    unfold OAI.EditApproximation.PhysicalTableRequest.combinedRank    rcases hprogress with h | h    · exact Nat.add_lt_add_of_lt_of_le h.1 h.2    · exact Nat.add_lt_add_of_le_of_lt h.1 h.2  have proof_warmup_previous_child_progress_81 {M : ℕ} {J : ℕ} {ny : ℕ} (pass : ℕ) (copy : ℕ) (T : ℕ) (S : ℕ) (j : ℕ) (node : OAI.EditApproximation.PhysicalNode M J) (hbelow : LT.lt.{0} (↑(Sigma.fst.{0, 0} node)) J) (i : Fin M) (state : OAI.EditApproximation.TargetInterval ny) (previousState : OAI.EditApproximation.TargetInterval ny) (hj : LT.lt.{0} 0 j) :      (OAI.EditApproximation.PhysicalTableRequest.warmup pass copy (OAI.EditApproximation.physicalChild node hbelow i) (j - 1) previousState).remainingDepth <          (OAI.EditApproximation.PhysicalTableRequest.warmup pass copy node j state).remainingDepth ∧        OAI.EditApproximation.PhysicalTableRequest.rank T S (OAI.EditApproximation.PhysicalTableRequest.warmup pass copy (OAI.EditApproximation.physicalChild node hbelow i) (j - 1) previousState) <          OAI.EditApproximation.PhysicalTableRequest.rank T S (OAI.EditApproximation.PhysicalTableRequest.warmup pass copy node j state) := by    constructor    · unfold OAI.EditApproximation.PhysicalTableRequest.remainingDepth OAI.EditApproximation.PhysicalTableRequest.warmup OAI.EditApproximation.physicalChild      dsimp only      omega    · dsimp only [OAI.EditApproximation.PhysicalTableRequest.rank, OAI.EditApproximation.PhysicalTableRequest.warmup]      omega  have proof_combinedRank_warmup_child_79 {M : ℕ} {J : ℕ} {ny : ℕ} (pass : ℕ) (copy : ℕ) (T : ℕ) (S : ℕ) (j : ℕ) (node : OAI.EditApproximation.PhysicalNode M J) (hbelow : LT.lt.{0} (↑(Sigma.fst.{0, 0} node)) J) (i : Fin M) (state : OAI.EditApproximation.TargetInterval ny) (previousState : OAI.EditApproximation.TargetInterval ny) (hj : LT.lt.{0} 0 j) :      OAI.EditApproximation.PhysicalTableRequest.combinedRank T S (OAI.EditApproximation.PhysicalTableRequest.warmup pass copy (OAI.EditApproximation.physicalChild node hbelow i) (j - 1) previousState) <        OAI.EditApproximation.PhysicalTableRequest.combinedRank T S (OAI.EditApproximation.PhysicalTableRequest.warmup pass copy node j state) :=    proof_combinedRank_lt_of_progress_80 T S _ _ (Or.inr      ⟨(proof_warmup_previous_child_progress_81 pass copy T S j node hbelow i state previousState hj).1.le,        (proof_warmup_previous_child_progress_81 pass copy T S j node hbelow i state previousState hj).2⟩)  exact    OAI.EditApproximation.queryChargedRead parent ⟨.inr ⟨OAI.EditApproximation.PhysicalTableRequest.warmup parent.val.pass parent.val.copy        (OAI.EditApproximation.physicalChild parent.val.node hbelow input.1) (parent.val.index - 1) input.2,        parent.property.1, parent.property.2.1,        (Nat.sub_le _ _).trans parent.property.2.2⟩, by      apply proof_table_rank_lt_99      exact proof_combinedRank_warmup_child_79 parent.val.pass parent.val.copy T S        parent.val.index parent.val.node hbelow input.1 parent.val.state input.2 hindex⟩end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable (source target : List ℕ) {M J passes copies T S : ℕ} (N P F : ℕ) (A a : BinaryFraction) (multiplier : ℕ → ℕ) (parent : {r : PhysicalTableRequest M J target.length // r.Bounded passes copies T S}) (occurrence : BinaryMemo PositionCounts) (symbolBits positionBits : ℕ)open Finsetdef queryChargedWarmup :    OAI.EditApproximation.BitQuery {child : OAI.EditApproximation.ChargedPhysicalRequest M J target.length passes copies T S //      child.rank < OAI.EditApproximation.ChargedPhysicalRequest.rank (.inr parent)} OAI.EditApproximation.BinaryFraction := by  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_bitOrdering_matches_4 (high : Ordering) (a : Bool) (b : Bool) (x : ℕ) (y : ℕ) (h : OAI.EditApproximation.orderingMatches high x y) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitOrdering high a b) (a.toNat + 2 * x) (b.toNat + 2 * y) := by    rcases h with ⟨rfl, h⟩ | ⟨rfl, rfl⟩ | ⟨rfl, h⟩    · exact Or.inl ⟨rfl, by cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩    · cases a <;> cases b <;> simp [OAI.EditApproximation.bitOrdering, OAI.EditApproximation.orderingMatches]    · exact Or.inr (Or.inr ⟨rfl, by        cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩)  have proof_bitCompareWithWork_matches_5 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitCompareWithWork left right).1 (OAI.EditApproximation.bitWordValue left) (OAI.EditApproximation.bitWordValue right) := by    induction left generalizing right with    | nil =>      simp only [OAI.EditApproximation.bitCompareWithWork]      induction right with      | nil => (simp [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.orderingMatches, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        simpa only [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareNilLeftWithWork bs).1 false b 0 (OAI.EditApproximation.bitWordValue bs) ih    | cons a as ih =>      cases right with      | nil =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as []).1 a false (OAI.EditApproximation.bitWordValue as) 0 (ih [])      | cons b bs =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue] using          proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as bs).1 a b (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs) (ih bs)  have proof_bitCompareWithWork_lt_16 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .lt ↔ OAI.EditApproximation.bitWordValue left < OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_binaryNaturalCompareWithWork_lt_53 (a : ℕ) (b : ℕ) :      (OAI.EditApproximation.binaryNaturalCompareWithWork a b).1 = .lt ↔ a < b := by    simpa only [OAI.EditApproximation.binaryNaturalCompareWithWork, proof_bitWordValue_bits_15] using proof_bitCompareWithWork_lt_16 a.bits b.bits  have proof_bitCompareWithWork_eq_3 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .eq ↔ OAI.EditApproximation.bitWordValue left = OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_binaryNaturalCompareWithWork_eq_73 (a : ℕ) (b : ℕ) :      (OAI.EditApproximation.binaryNaturalCompareWithWork a b).1 = .eq ↔ a = b := by    simpa only [OAI.EditApproximation.binaryNaturalCompareWithWork, proof_bitWordValue_bits_15] using proof_bitCompareWithWork_eq_3 a.bits b.bits  have proof_naturalEqualWithWork_value_74 (a : ℕ) (b : ℕ) :      (OAI.EditApproximation.naturalEqualWithWork a b).1 = true ↔ a = b := by    simp only [OAI.EditApproximation.naturalEqualWithWork, decide_eq_true_eq, proof_binaryNaturalCompareWithWork_eq_73]  exact    .charge ((OAI.EditApproximation.naturalEqualWithWork parent.val.index 0).2 + 1)      (if hz : (OAI.EditApproximation.naturalEqualWithWork parent.val.index 0).1 = true then        OAI.EditApproximation.queryPhysicalInitial source target N P F A a multiplier parent occurrence symbolBits positionBits          parent.val.state      else .charge ((OAI.EditApproximation.binaryNaturalCompareWithWork parent.val.node.1.val J).2 + 1)        (if hb : (OAI.EditApproximation.binaryNaturalCompareWithWork parent.val.node.1.val J).1 = .lt then          let interval := OAI.EditApproximation.physicalSourceInterval source.length parent.val.node          let length := OAI.EditApproximation.saturatingSubtractWithWork interval.hi interval.lo          let test := OAI.EditApproximation.wordLEWithWork length.1 [true]          .charge (length.2 + test.2 + 1)            (if test.1 then              OAI.EditApproximation.queryPhysicalInitial source target N P F A a multiplier parent occurrence symbolBits                positionBits parent.val.state            else OAI.EditApproximation.queryWarmupProgram interval N P F a              (OAI.EditApproximation.queryPhysicalInitial source target N P F A a multiplier parent occurrence symbolBits positionBits)              (OAI.EditApproximation.queryChargedWarmupChild parent ((proof_binaryNaturalCompareWithWork_lt_53 _ _).mp hb)                (Nat.pos_of_ne_zero (fun h => hz ((proof_naturalEqualWithWork_value_74 _ _).mpr h))))              parent.val.state)        else OAI.EditApproximation.queryPhysicalInitial source target N P F A a multiplier parent occurrence symbolBits positionBits          parent.val.state))end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable {M J R passes copies T S : ℕ} [NeZero M] [NeZero R] (source target : List ℕ) (N P F exponent H Q eM eF : ℕ) (hP : 0 < P) (hM : M = 2 ^ eM) (hF : F = 2 ^ eF) (A a : ℕ → BinaryFraction) (tau eta kappa delta : BinaryFraction) (multiplier : ℕ → ℕ) (occurrence : BinaryMemo PositionCounts) (symbolBits positionBits : ℕ)abbrev ChargedFamilyQueryKey (parent : OAI.EditApproximation.ChargedPhysicalRequest M J target.length (passes + 1) copies T S) :=  Sum (OAI.EditApproximation.PhysicalFamilyScalarKey (M := M) (J := J) (R := R) target N P F exponent H Q passes copies)    {child : OAI.EditApproximation.ChargedPhysicalRequest M J target.length (passes + 1) copies T S // child.rank < parent.rank}end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable {κ : Type u_1} (rank : κ → ℕ) (raw : (key : κ) → BitQuery {child : κ // rank child < rank key} BinaryFraction) (base : List Bool) (hbase : 0 < bitWordValue base) (remaining : κ → ℕ)def rankedNormalizeBody (key : κ) :    OAI.EditApproximation.BitQuery {child : κ // rank child < rank key} OAI.EditApproximation.BinaryFraction :=  (raw key).normalize base hbase (remaining key)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable {σ : Type u_1} {α : Type u_2} [DecidableEq α] {M J R : ℕ} [NeZero M] [NeZero R] (source target : List α) (N P F exponent H Q T S passes copies : ℕ) (factor : ℕ → ℚ) (multiplier : ℕ → ℕ) (tau eta kappa delta : ℚ) (readGroup : ℕ → ℕ → PhysicalInternalNode M J → Fin R → GroupScalarKey M F Q → FiniteQuery σ) (readInteger : ℕ → ℕ → PhysicalInternalNode M J → Fin R →    (ℕ × TargetInterval target.length) → ℕ → FiniteQuery σ) (initial : PhysicalEntry M J target.length → ℕ) (sourceAnswer : σ → ℚ)noncomputable def chargedRandomMemoEvaluate (bits : ℕ)    (encode : Sum σ (OAI.EditApproximation.ChargedPhysicalRequest M J target.length passes copies T S) → ℕ)    (request : OAI.EditApproximation.ChargedPhysicalRequest M J target.length passes copies T S) :=  OAI.EditApproximation.rankedMemoEvaluate (OAI.EditApproximation.SourceRanked.rank OAI.EditApproximation.ChargedPhysicalRequest.rank)    (OAI.EditApproximation.SourceRanked.body OAI.EditApproximation.ChargedPhysicalRequest.rank      (OAI.EditApproximation.chargedRandomGlobalQuery source target N P F exponent H Q T S passes copies factor multiplier        tau eta kappa delta readGroup readInteger initial) sourceAnswer)    bits encode (.inr request) .emptyend OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable {α : Type u_1} [DecidableEq α] {M J R : ℕ} [NeZero M] [NeZero R] (source target : List α) (N P F exponent H Q T S passes copies : ℕ) (factor : ℕ → ℚ) (multiplier : ℕ → ℕ) (tau eta kappa delta : ℚ) (initial : PhysicalEntry M J target.length → ℕ)noncomputable def physicalFamilyProgram :=  OAI.EditApproximation.chargedRandomGlobalQuery source target N P F exponent H Q T S (passes + 1) copies    factor multiplier tau eta kappa delta    (OAI.EditApproximation.physicalFamilyGroupRead (M := M) (J := J) (R := R) target N P F exponent H Q passes copies)    (OAI.EditApproximation.physicalFamilyOnlineRead (M := M) (J := J) (R := R) target N P F exponent H Q passes copies)    initialend OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen MeasureTheory ProbabilityTheoryvariable {α : Type u_1} [DecidableEq α] {M J : ℕ} (source target : List α) (N B : ℕ) (depth : PhysicalEntry M J target.length → ℕ)abbrev PhysicalCoarseDraw := OAI.EditApproximation.CoarseFullSeedDraws B depth  (fun state : OAI.EditApproximation.PhysicalEntry M J target.length => OAI.EditApproximation.physicalSource source state.1)  (fun state : OAI.EditApproximation.PhysicalEntry M J target.length => OAI.EditApproximation.substring target state.2.lo state.2.hi)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen MeasureTheory ProbabilityTheoryvariable {α : Type u_1} [DecidableEq α] {M J : ℕ} (source target : List α) (N B : ℕ) (depth : PhysicalEntry M J target.length → ℕ)open EditDistortion Finset MeasureTheory ProbabilityTheoryopen Finset MeasureTheory ProbabilityTheorynoncomputable def physicalCoarseSeedTable (draw : OAI.EditApproximation.PhysicalCoarseDraw source target B depth) :    OAI.EditApproximation.ClampedPhysicalSeed M J target.length N := by  have proof_coarseInitialValue_le_length_111 {α : Type u_1} [instLocal1 : DecidableEq.{u_1 + 1} α] (B : ℕ) (D : ℕ) (Q : ℚ) (lam : ℚ) (N : ℕ) (x : List.{u_1} α) (y : List.{u_1} α) (draws : OAI.EditApproximation.CoarseGuessIndex (OAI.EditApproximation.coarseEntryWidth.{u_1} x y) →    OAI.EditApproximation.CoarseThresholdDraws B D) :      OAI.EditApproximation.coarseInitialValue B D Q lam N x y draws ≤ N := by    unfold OAI.EditApproximation.coarseInitialValue    split_ifs    · exact min_le_left _ _    · exact Nat.zero_le _    · exact min_le_left _ _  have proof_trans_112 {Alpha : Type u_1} {s : Bool} {m : ℕ} {n : ℕ} {x : List.{u_1} Alpha} {y : List.{u_1} Alpha} {z : List.{u_1} Alpha} (h : OAI.EditDistortion.Script.{u_1} s m x y) (k : OAI.EditDistortion.Script.{u_1} s n y z) : OAI.EditDistortion.Script s (m + n) x z := by    induction h with    | nil => simpa using k    | @cons l x w y e h ih =>      simpa only [Nat.add_right_comm] using OAI.EditDistortion.Script.cons e (ih k)  have proof_to_nil_113 {Alpha : Type u_1} {s : Bool} (x : List.{u_1} Alpha) : OAI.EditDistortion.Script s x.length x [] := by    induction x with    | nil => exact .nil []    | cons a x ih => exact .cons (.delete [] x a) ih  have proof_single_114 {Alpha : Type u_1} {s : Bool} {x : List.{u_1} Alpha} {y : List.{u_1} Alpha} (h : OAI.EditDistortion.Step.{u_1} s x y) : OAI.EditDistortion.Script s 1 x y :=    .cons h (.nil y)  have proof_symm_115 {Alpha : Type u_1} {s : Bool} {x : List.{u_1} Alpha} {y : List.{u_1} Alpha} (h : OAI.EditDistortion.Step.{u_1} s x y) : OAI.EditDistortion.Step s y x := by    cases h with    | insert p q a => exact .delete p q a    | delete p q a => exact .insert p q a    | substitute hs p q a b => exact .substitute hs p q b a  have proof_symm_116 {Alpha : Type u_1} {s : Bool} {n : ℕ} {x : List.{u_1} Alpha} {y : List.{u_1} Alpha} (h : OAI.EditDistortion.Script.{u_1} s n x y) : OAI.EditDistortion.Script s n y x := by    induction h with    | nil x => exact .nil x    | cons e h ih => exact (proof_trans_112 ih (proof_single_114 (proof_symm_115 e)))  have proof_exists_script_117 {Alpha : Type u_1} {s : Bool} (x : List.{u_1} Alpha) (y : List.{u_1} Alpha) : ∃ n, OAI.EditDistortion.Script s n x y :=    ⟨x.length + y.length, (proof_trans_112 (proof_to_nil_113 x)    (proof_symm_116 (proof_to_nil_113 y)))⟩  have proof_cost_spec_118 {Alpha : Type u_1} {s : Bool} (x : List.{u_1} Alpha) (y : List.{u_1} Alpha) : OAI.EditDistortion.Script s (OAI.EditDistortion.cost s x y) x y :=    Nat.sInf_mem (proof_exists_script_117 x y)  have proof_eq_of_zero_119 {Alpha : Type u_1} {s : Bool} {x : List.{u_1} Alpha} {y : List.{u_1} Alpha} (h : OAI.EditDistortion.Script.{u_1} s 0 x y) : x = y := by    cases h    rfl  have proof_cost_le_120 {Alpha : Type u_1} {s : Bool} {n : ℕ} {x : List.{u_1} Alpha} {y : List.{u_1} Alpha} (h : OAI.EditDistortion.Script.{u_1} s n x y) : OAI.EditDistortion.cost s x y ≤ n :=    Nat.sInf_le h  have proof_cost_refl_121 {Alpha : Type u_1} {s : Bool} (x : List.{u_1} Alpha) : OAI.EditDistortion.cost s x x = 0 :=    Nat.eq_zero_of_le_zero (proof_cost_le_120 (.nil x))  have proof_cost_eq_zero_iff_122 {Alpha : Type u_1} {s : Bool} {x : List.{u_1} Alpha} {y : List.{u_1} Alpha} : OAI.EditDistortion.cost s x y = 0 ↔ x = y := by    constructor    · intro h      have hc := proof_cost_spec_118 (s := s) x y      rw [h] at hc      exact (proof_eq_of_zero_119 hc)    · rintro rfl      exact proof_cost_refl_121 _  have proof_coarseInitialValue_zero_123 {α : Type u_1} [instLocal1 : DecidableEq.{u_1 + 1} α] (B : ℕ) (D : ℕ) (Q : ℚ) (lam : ℚ) (N : ℕ) (x : List.{u_1} α) (y : List.{u_1} α) (draws : OAI.EditApproximation.CoarseGuessIndex (OAI.EditApproximation.coarseEntryWidth.{u_1} x y) →    OAI.EditApproximation.CoarseThresholdDraws B D) (hzero : Eq.{1} (OAI.EditDistortion.edit.{u_1} x y) 0) : OAI.EditApproximation.coarseInitialValue B D Q lam N x y draws = 0 := by    have hxy : x = y := (proof_cost_eq_zero_iff_122 (s := true)).mp hzero    subst y    simp only [OAI.EditApproximation.coarseInitialValue, ite_eq_right (by omega : ¬ 2 * x.length < x.length), ite_true]  have proof_computed_fullSeedTable_range_zero_110 (N : ℕ) (B : ℕ) {I : Type 0} {α : Type u_1} [instLocal4 : DecidableEq.{u_1 + 1} α] (depth : I → ℕ) (x : I → List.{u_1} α) (y : I → List.{u_1} α) (draws : OAI.EditApproximation.CoarseFullSeedDraws.{0, u_1} B depth x y) :      ∀ i, OAI.EditApproximation.coarseFullSeedTable N B depth x y draws i ≤ N ∧        (OAI.EditDistortion.edit (x i) (y i) = 0 → OAI.EditApproximation.coarseFullSeedTable N B depth x y draws i = 0) := by    intro i    exact ⟨proof_coarseInitialValue_le_length_111 _ _ _ _ _ _ _ _,      proof_coarseInitialValue_zero_123 _ _ _ _ _ _ _ _⟩  exact    fun state =>     ⟨OAI.EditApproximation.coarseFullSeedTable N B depth       (fun state : OAI.EditApproximation.PhysicalEntry M J target.length => OAI.EditApproximation.physicalSource source state.1)       (fun state : OAI.EditApproximation.PhysicalEntry M J target.length => OAI.EditApproximation.substring target state.2.lo state.2.hi) draw state,       Nat.lt_succ_of_le ((proof_computed_fullSeedTable_range_zero_110 N B depth _ _ draw state).1)⟩end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen MeasureTheory ProbabilityTheoryvariable {α : Type u_1} [DecidableEq α] {M J R : ℕ} [NeZero M] [NeZero R] [MeasurableSpace (Fin M)] [MeasurableSingletonClass (Fin M)] (source target : List α) (N P T S H : ℕ)local notation (name := source_Combinatorics_EditApproximation_Geometry_LocalTraceMemoOutput_5) "passes" => computedSeedPassCount Ndef localFinalRootRequest (hH : 0 < H) (rootQ : OAI.EditApproximation.TargetInterval target.length) :    OAI.EditApproximation.ChargedPhysicalRequest M J target.length (passes + 1) (H ^ 2) T S :=  .inr ⟨OAI.EditApproximation.PhysicalTableRequest.refinement passes 0    (Sigma.mk (Fin.mk 0 (Nat.zero_lt_succ J)) PUnit.unit) T S rootQ,    ⟨Nat.lt_succ_self _, pow_pos hH 2, le_rfl⟩⟩end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen Filternoncomputable def computedFamilyKernelWork (source target : List ℕ) (N : ℕ)    (input : OAI.EditApproximation.ComputedFamilyInput source target N)    (cost : OAI.EditApproximation.ComputedFamilyMemoKey source target N → ℕ) : ℕ :=  OAI.EditApproximation.rankedMemoKernelWork (OAI.EditApproximation.SourceRanked.rank OAI.EditApproximation.ChargedPhysicalRequest.rank)    (OAI.EditApproximation.SourceRanked.body OAI.EditApproximation.ChargedPhysicalRequest.rank      (OAI.EditApproximation.physicalFamilyProgram source target N (OAI.EditApproximation.integerParameters N).P (OAI.EditApproximation.inputSmallLog N)        (40 * OAI.EditApproximation.smallLogExponent N) (OAI.EditApproximation.inputHeight N) (OAI.EditApproximation.inputSmallLog N ^ 80)        (OAI.EditApproximation.integerParameters N).T (OAI.EditApproximation.integerParameters N).S (OAI.EditApproximation.computedSeedPassCount N) (OAI.EditApproximation.inputHeight N ^ 2)        (OAI.EditApproximation.scheduledSeedFactor N) (OAI.EditApproximation.scheduledSeedMultiplier N)        (OAI.EditApproximation.rationalParameters (OAI.EditApproximation.inputSmallLog N)).tau (OAI.EditApproximation.rationalParameters (OAI.EditApproximation.inputSmallLog N)).eta        (OAI.EditApproximation.rationalParameters (OAI.EditApproximation.inputSmallLog N)).kappa (OAI.EditApproximation.rationalParameters (OAI.EditApproximation.inputSmallLog N)).delta        (OAI.EditApproximation.clampedSeedNat input.1))      (OAI.EditApproximation.physicalFamilyAnswer target N (OAI.EditApproximation.integerParameters N).P (OAI.EditApproximation.inputSmallLog N)        (40 * OAI.EditApproximation.smallLogExponent N) (OAI.EditApproximation.inputHeight N) (OAI.EditApproximation.inputSmallLog N ^ 80)        (OAI.EditApproximation.computedSeedPassCount N) (OAI.EditApproximation.inputHeight N ^ 2) input.2))    (16384 * OAI.EditApproximation.inputHeight N + 5) (OAI.EditApproximation.computedFamilyMemoCode source target N (OAI.EditApproximation.inputHeight N ^ 2)) cost    (.inr (OAI.EditApproximation.localFinalRootRequest target N (OAI.EditApproximation.integerParameters N).T (OAI.EditApproximation.integerParameters N).S      (OAI.EditApproximation.inputHeight N) (Nat.two_pow_pos _) (OAI.EditApproximation.finalTargetState target.length))) .emptynoncomputable def computedFamilyAddressWork (source target : List ℕ) (N : ℕ)    (input : OAI.EditApproximation.ComputedFamilyInput source target N) : ℕ :=  OAI.EditApproximation.rankedMemoAddressWork (OAI.EditApproximation.SourceRanked.rank OAI.EditApproximation.ChargedPhysicalRequest.rank)    (OAI.EditApproximation.SourceRanked.body OAI.EditApproximation.ChargedPhysicalRequest.rank      (OAI.EditApproximation.physicalFamilyProgram source target N (OAI.EditApproximation.integerParameters N).P (OAI.EditApproximation.inputSmallLog N)        (40 * OAI.EditApproximation.smallLogExponent N) (OAI.EditApproximation.inputHeight N) (OAI.EditApproximation.inputSmallLog N ^ 80)        (OAI.EditApproximation.integerParameters N).T (OAI.EditApproximation.integerParameters N).S (OAI.EditApproximation.computedSeedPassCount N) (OAI.EditApproximation.inputHeight N ^ 2)        (OAI.EditApproximation.scheduledSeedFactor N) (OAI.EditApproximation.scheduledSeedMultiplier N)        (OAI.EditApproximation.rationalParameters (OAI.EditApproximation.inputSmallLog N)).tau (OAI.EditApproximation.rationalParameters (OAI.EditApproximation.inputSmallLog N)).eta        (OAI.EditApproximation.rationalParameters (OAI.EditApproximation.inputSmallLog N)).kappa (OAI.EditApproximation.rationalParameters (OAI.EditApproximation.inputSmallLog N)).delta        (OAI.EditApproximation.clampedSeedNat input.1))      (OAI.EditApproximation.physicalFamilyAnswer target N (OAI.EditApproximation.integerParameters N).P (OAI.EditApproximation.inputSmallLog N)        (40 * OAI.EditApproximation.smallLogExponent N) (OAI.EditApproximation.inputHeight N) (OAI.EditApproximation.inputSmallLog N ^ 80)        (OAI.EditApproximation.computedSeedPassCount N) (OAI.EditApproximation.inputHeight N ^ 2) input.2))    (16384 * OAI.EditApproximation.inputHeight N + 5) (OAI.EditApproximation.computedFamilyMemoCode source target N (OAI.EditApproximation.inputHeight N ^ 2))    (fun key => (OAI.EditApproximation.computedFamilyMemoCodeWithWork source target N (OAI.EditApproximation.inputHeight N ^ 2) key).2)    (.inr (OAI.EditApproximation.localFinalRootRequest target N (OAI.EditApproximation.integerParameters N).T (OAI.EditApproximation.integerParameters N).S      (OAI.EditApproximation.inputHeight N) (Nat.two_pow_pos _) (OAI.EditApproximation.finalTargetState target.length))) .emptynoncomputable def computedFamilyCoarseCopyStorage (source target : List ℕ) (N : ℕ)    (input : OAI.EditApproximation.ComputedFamilyInput source target N) : ℕ :=  OAI.EditApproximation.computedFamilyKernelWork source target N input (OAI.EditApproximation.coarseHistoryKeyCost    (OAI.EditApproximation.physicalCoarseInputStorage (M := (OAI.EditApproximation.integerParameters N).M)      (J := OAI.EditApproximation.intervalTreeDepth (OAI.EditApproximation.integerParameters N).M source.length) source target))noncomputable def computedFamilyCoarseArrayCapacity (source target : List ℕ) (N : ℕ)    (input : OAI.EditApproximation.ComputedFamilyInput source target N) : ℕ :=  OAI.EditApproximation.computedFamilyKernelWork source target N input (OAI.EditApproximation.coarseHistoryKeyCost (fun _ => (N + 2) ^ 37))noncomputable def computedFamilyCoarseScratchCapacity (source target : List ℕ) (N : ℕ)    (input : OAI.EditApproximation.ComputedFamilyInput source target N) : ℕ :=  OAI.EditApproximation.computedFamilyKernelWork source target N input (OAI.EditApproximation.coarseHistoryKeyCost (fun _ => (N + 2) ^ 181))noncomputable def computedFamilyCoarseControlCapacity (source target : List ℕ) (N : ℕ)    (input : OAI.EditApproximation.ComputedFamilyInput source target N) : ℕ :=  OAI.EditApproximation.computedFamilyKernelWork source target N input (OAI.EditApproximation.coarseHistoryKeyCost (fun _ => (N + 2) ^ 182))end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen MeasureTheory ProbabilityTheoryvariable {α : Type} [DecidableEq α] {M J R : ℕ} [NeZero M] [NeZero R] (source target : List α) (N P T S H : ℕ)local notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalFamilyMemo_4) "Seed" => ClampedPhysicalSeed M J target.length Nlocal notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalFamilyMemo_5) "ell" => inputSmallLog Nlocal notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalFamilyMemo_6) "exponent" => (40 * smallLogExponent N : ℕ)local notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalFamilyMemo_7) "passes" => computedSeedPassCount Nlocal notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalFamilyMemo_8) "tau" => RationalParameters.tau (rationalParameters ell)local notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalFamilyMemo_9) "eta" => RationalParameters.eta (rationalParameters ell)local notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalFamilyMemo_10) "kappa" => RationalParameters.kappa (rationalParameters ell)local notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalFamilyMemo_11) "delta" => RationalParameters.delta (rationalParameters ell)local notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalFamilyMemo_12) "Key" => PhysicalFamilyScalarKey (M := M) (J := J) (R := R)  target N P ell exponent H (ell ^ 80) passes (H ^ 2)local notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalFamilyMemo_13) "Family" => PhysicalFamilyScalarDraw (M := M) (J := J) (R := R)  target N P ell exponent H (ell ^ 80) passes (H ^ 2)local notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalFamilyMemo_14) "Table" => ChargedPhysicalRequest M J target.length (passes + 1) (H ^ 2) T Snoncomputable def physicalFamilyMemoResult (hH : 0 < H) (bits : ℕ)    (encode : Sum Key Table → ℕ) (rootQ : OAI.EditApproximation.TargetInterval target.length) (input : Seed × Family) :=  OAI.EditApproximation.chargedRandomMemoEvaluate source target N P ell exponent H (ell ^ 80) T S (passes + 1) (H ^ 2)    (OAI.EditApproximation.scheduledSeedFactor N) (OAI.EditApproximation.scheduledSeedMultiplier N) tau eta kappa delta    (OAI.EditApproximation.physicalFamilyGroupRead target N P ell exponent H (ell ^ 80) passes (H ^ 2))    (OAI.EditApproximation.physicalFamilyOnlineRead target N P ell exponent H (ell ^ 80) passes (H ^ 2))    (OAI.EditApproximation.clampedSeedNat input.1)    (OAI.EditApproximation.physicalFamilyAnswer target N P ell exponent H (ell ^ 80) passes (H ^ 2) input.2)    bits encode (OAI.EditApproximation.localFinalRootRequest target N T S H hH rootQ)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen MeasureTheory ProbabilityTheory Finsetattribute [local instance] Classical.propDecidablenoncomputable def selectionIndicator (p : Prop) : ℝ := if p then 1 else 0end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationnoncomputable def coarseIndexedEntryCostSum {M J B : ℕ} [NeZero B] (source target : List ℕ)    (N : ℕ) (depth : OAI.EditApproximation.PhysicalEntry M J target.length → ℕ)    (draw : OAI.EditApproximation.PhysicalCoarseDraw source target B depth)    (selected : OAI.EditApproximation.PhysicalEntry M J target.length → Prop) : ℝ := by  classical  exact ∑ entry : OAI.EditApproximation.PhysicalEntry M J target.length, OAI.EditApproximation.selectionIndicator (selected entry) *    (OAI.EditApproximation.coarseIndexedEntryBinaryCost N B (depth entry) (OAI.EditApproximation.physicalSource source entry.1)      (OAI.EditApproximation.substring target entry.2.lo entry.2.hi) (draw entry) : ℝ)def querySupportedChildAllocation {σ : Type u_1} {M J n : ℕ} (passes copies T S : ℕ)    (parent : {r : OAI.EditApproximation.PhysicalTableRequest M J n // r.Bounded passes copies T S})    (key : OAI.EditApproximation.QueryPhysicalChild (σ := σ) passes copies T S parent) : ℕ :=  match key with  | .inl _ => 0  | .inr child => OAI.EditApproximation.queryPhysicalBoundedAllocation passes copies T S child.valend OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen MeasureTheory ProbabilityTheoryvariable {ι : Type u_1} [Fintype ι] (range : ι → ℕ) [∀ i, NeZero (range i)]open Finsetnoncomputable def rejectionFailureLaw (i : ι) : Measure ℕ := by  have proof_rejectionWord_range_124 (N : ℕ) (hN : LT.lt.{0} 0 N) :      N ≤ 2 ^ OAI.EditApproximation.rejectionBitCount N ∧ 2 ^ OAI.EditApproximation.rejectionBitCount N < 2 * N := by    constructor    · exact Nat.le_pow_clog (by norm_num) N    · by_cases hNone : N = 1      · subst N        norm_num [OAI.EditApproximation.rejectionBitCount]      · have hN1 : 1 < N := by omega        have hpred := Nat.pow_pred_clog_lt_self (by norm_num : 1 < 2) hN1        have hB := Nat.clog_pos (by norm_num : 1 < 2) hN1        have hpow : 2 ^ OAI.EditApproximation.rejectionBitCount N = 2 ^ (Nat.clog 2 N).pred * 2 := by          rw [OAI.EditApproximation.rejectionBitCount, ← pow_succ]          congr 1          exact (Nat.succ_pred_eq_of_pos hB).symm        rw [hpow]        omega  exact    geometricMeasure (OAI.EditApproximation.rejectionSuccessParameter (range i) (2 ^ OAI.EditApproximation.rejectionBitCount (range i))      (Nat.pos_of_ne_zero (NeZero.ne (range i)))      (proof_rejectionWord_range_124 (range i) (Nat.pos_of_ne_zero (NeZero.ne (range i)))).1)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen MeasureTheory ProbabilityTheoryvariable {ι : Type u_1} [Fintype ι] (range : ι → ℕ) [∀ i, NeZero (range i)]noncomputable def rejectionRuntimeArrayLaw : Measure (OAI.EditApproximation.RejectionRuntimeArray range) :=  (Measure.pi (OAI.EditApproximation.rejectionFailureLaw range)).prod (OAI.EditApproximation.rejectionAcceptedLaw range)noncomputable def rejectionSelectedBits    (selected : ι → (∀ i, Fin (range i)) → Prop) (execution : OAI.EditApproximation.RejectionRuntimeArray range) : ℝ :=  ∑ i, (((execution.1 i : ℝ) + 1) * OAI.EditApproximation.rejectionBitCount (range i)) *    OAI.EditApproximation.selectionIndicator (selected i execution.2)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen MeasureTheory ProbabilityTheoryvariable {α : Type u_1} {M J R : ℕ} [NeZero M] (target : List α) (N P F exponent H Q passes copies : ℕ)abbrev physicalFamilyRange (key : OAI.EditApproximation.PhysicalFamilyScalarKey (M := M) (J := J) (R := R)    target N P F exponent H Q passes copies) : ℕ :=  OAI.EditApproximation.physicalScalarRange M J N target.length exponent F Q R (OAI.EditApproximation.localOnlineMassBound M P H) key.2.2instance physicalFamilyRange_neZero (key : OAI.EditApproximation.PhysicalFamilyScalarKey (M := M) (J := J) (R := R)    target N P F exponent H Q passes copies) :    NeZero (OAI.EditApproximation.physicalFamilyRange target N P F exponent H Q passes copies key) := by  exact OAI.EditApproximation.physicalScalarRangeNeZero M J N target.length exponent F Q R    (OAI.EditApproximation.localOnlineMassBound M P H) key.2.2end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen MeasureTheoryabbrev ComputedPhysicalCoarseDraw (source target : List ℕ) (N : ℕ) :=  OAI.EditApproximation.PhysicalCoarseDraw (M := (OAI.EditApproximation.integerParameters N).M)    (J := OAI.EditApproximation.intervalTreeDepth (OAI.EditApproximation.integerParameters N).M source.length) source target (OAI.EditApproximation.integerParameters N).B (OAI.EditApproximation.computedPhysicalCoarseDepth source target N)abbrev ComputedRejectionRuntime (source target : List ℕ) (N : ℕ) :=  OAI.EditApproximation.RejectionRuntimeArray (OAI.EditApproximation.physicalFamilyRange (M := (OAI.EditApproximation.integerParameters N).M)    (J := OAI.EditApproximation.intervalTreeDepth (OAI.EditApproximation.integerParameters N).M source.length) (R := OAI.EditApproximation.inputHeight N ^ 2)    target N (OAI.EditApproximation.integerParameters N).P (OAI.EditApproximation.inputSmallLog N) (40 * OAI.EditApproximation.smallLogExponent N)    (OAI.EditApproximation.inputHeight N) (OAI.EditApproximation.inputSmallLog N ^ 80) (OAI.EditApproximation.computedSeedPassCount N) (OAI.EditApproximation.inputHeight N ^ 2))noncomputable def computedPhysicalCoarseLaw (source target : List ℕ) (N : ℕ) :    Measure (OAI.EditApproximation.ComputedPhysicalCoarseDraw source target N) :=  OAI.EditApproximation.coarseFullSeedMeasure (OAI.EditApproximation.integerParameters N).B (OAI.EditApproximation.computedPhysicalCoarseDepth source target N)    (fun entry => OAI.EditApproximation.physicalSource source entry.1)    (fun entry => OAI.EditApproximation.substring target entry.2.lo entry.2.hi)abbrev ComputedExecutionOutcome (source target : List ℕ) (N : ℕ) :=  OAI.EditApproximation.ComputedPhysicalCoarseDraw source target N × OAI.EditApproximation.ComputedRejectionRuntime source target Nnoncomputable def computedExecutionLaw (source target : List ℕ) (N : ℕ) :    Measure (OAI.EditApproximation.ComputedExecutionOutcome source target N) :=  (OAI.EditApproximation.computedPhysicalCoarseLaw source target N).prod    (OAI.EditApproximation.rejectionRuntimeArrayLaw (OAI.EditApproximation.physicalFamilyRange (M := (OAI.EditApproximation.integerParameters N).M)      (J := OAI.EditApproximation.intervalTreeDepth (OAI.EditApproximation.integerParameters N).M source.length) (R := OAI.EditApproximation.inputHeight N ^ 2)      target N (OAI.EditApproximation.integerParameters N).P (OAI.EditApproximation.inputSmallLog N) (40 * OAI.EditApproximation.smallLogExponent N)      (OAI.EditApproximation.inputHeight N) (OAI.EditApproximation.inputSmallLog N ^ 80) (OAI.EditApproximation.computedSeedPassCount N) (OAI.EditApproximation.inputHeight N ^ 2)))abbrev ComputedFullOutcome (source target : List ℕ) (N : ℕ) :=  Unit ⊕ OAI.EditApproximation.ComputedExecutionOutcome source target Nend OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen MeasureTheory ProbabilityTheoryvariable {α : Type} [DecidableEq α] {M J R : ℕ} [NeZero M] [NeZero R] (source target : List α) (N P T S H : ℕ)local notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalFamilyRuntime_4) "SeedState" => ClampedPhysicalSeed M J target.length Nlocal notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalFamilyRuntime_5) "ell" => inputSmallLog Nlocal notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalFamilyRuntime_6) "exponent" => (40 * smallLogExponent N : ℕ)local notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalFamilyRuntime_7) "passes" => computedSeedPassCount Nlocal notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalFamilyRuntime_8) "FamilyRange" => physicalFamilyRange (M := M) (J := J) (R := R)  target N P ell exponent H (ell ^ 80) passes (H ^ 2)local notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalFamilyRuntime_9) "Family" => PhysicalFamilyScalarDraw (M := M) (J := J) (R := R)  target N P ell exponent H (ell ^ 80) passes (H ^ 2)abbrev PhysicalFamilyRuntimeOutcome := SeedState × OAI.EditApproximation.RejectionRuntimeArray FamilyRangedef physicalFamilyRuntimeAccepted    (execution : OAI.EditApproximation.PhysicalFamilyRuntimeOutcome (M := M) (J := J) (R := R) target N P H) : SeedState × Family :=  (execution.1, execution.2.2)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen MeasureTheory ProbabilityTheory Filterdef physicalLargeInput (N : ℕ) (epsilon : OAI.EditApproximation.BinaryFraction) : Prop :=  (OAI.EditApproximation.inspectAccuracyWithWork (OAI.EditApproximation.inputHeight N) epsilon).1.isSome = true ∧    OAI.EditApproximation.largeAccuracyInput N epsilon.value ∧    Nat.size (OAI.EditApproximation.localOnlineMassBound (OAI.EditApproximation.integerParameters N).M (OAI.EditApproximation.integerParameters N).P      (OAI.EditApproximation.inputHeight N)) ≤ OAI.EditApproximation.inputHeight Ninstance physicalLargeInput_decidable (N : ℕ) (epsilon : OAI.EditApproximation.BinaryFraction) :    Decidable (OAI.EditApproximation.physicalLargeInput N epsilon) := inferInstanceAs (Decidable (_ ∧ _ ∧ _))end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen MeasureTheory ProbabilityTheoryvariable {α : Type} [DecidableEq α] {M J R : ℕ} [NeZero M] [NeZero R] (source target : List α) (N P T S H : ℕ)local notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalFamilyRejectionWork_4) "SeedState" => ClampedPhysicalSeed M J target.length Nlocal notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalFamilyRejectionWork_5) "ell" => inputSmallLog Nlocal notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalFamilyRejectionWork_6) "exponent" => (40 * smallLogExponent N : ℕ)local notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalFamilyRejectionWork_7) "passes" => computedSeedPassCount Nlocal notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalFamilyRejectionWork_8) "Key" => PhysicalFamilyScalarKey (M := M) (J := J) (R := R)  target N P ell exponent H (ell ^ 80) passes (H ^ 2)local notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalFamilyRejectionWork_9) "Table" => ChargedPhysicalRequest M J target.length (passes + 1) (H ^ 2) T Slocal notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalFamilyRejectionWork_10) "FamilyRange" => physicalFamilyRange (M := M) (J := J) (R := R)  target N P ell exponent H (ell ^ 80) passes (H ^ 2)noncomputable def physicalFamilyMemoBits (hH : 0 < H) (bits : ℕ)    (encode : Sum Key Table → ℕ) (rootQ : OAI.EditApproximation.TargetInterval target.length) (seed : SeedState)    (execution : OAI.EditApproximation.RejectionRuntimeArray FamilyRange) : ℝ :=  OAI.EditApproximation.rejectionSelectedBits FamilyRange (fun key accepted => Sum.inl key ∈    (OAI.EditApproximation.physicalFamilyMemoResult source target N P T S H hH bits encode rootQ (seed, accepted)).freshKeys)    executionend OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen Filter MeasureTheorynoncomputable def computedFamilyResult (source target : List ℕ) (N : ℕ)    (input : OAI.EditApproximation.ComputedFamilyInput source target N) :=  OAI.EditApproximation.physicalFamilyMemoResult source target N (OAI.EditApproximation.integerParameters N).P (OAI.EditApproximation.integerParameters N).T    (OAI.EditApproximation.integerParameters N).S (OAI.EditApproximation.inputHeight N) (Nat.two_pow_pos _)    (16384 * OAI.EditApproximation.inputHeight N + 5) (OAI.EditApproximation.computedFamilyMemoCode source target N (OAI.EditApproximation.inputHeight N ^ 2))    (OAI.EditApproximation.finalTargetState target.length) inputnoncomputable def computedFamilyRejectionWork (source target : List ℕ) (N : ℕ)    (execution : OAI.EditApproximation.PhysicalFamilyRuntimeOutcome (M := (OAI.EditApproximation.integerParameters N).M)      (J := OAI.EditApproximation.intervalTreeDepth (OAI.EditApproximation.integerParameters N).M source.length) (R := OAI.EditApproximation.inputHeight N ^ 2)      target N (OAI.EditApproximation.integerParameters N).P (OAI.EditApproximation.inputHeight N)) : ℝ :=  OAI.EditApproximation.physicalFamilyMemoBits source target N (OAI.EditApproximation.integerParameters N).P (OAI.EditApproximation.integerParameters N).T    (OAI.EditApproximation.integerParameters N).S (OAI.EditApproximation.inputHeight N) (Nat.two_pow_pos _) (16384 * OAI.EditApproximation.inputHeight N + 5)    (OAI.EditApproximation.computedFamilyMemoCode source target N (OAI.EditApproximation.inputHeight N ^ 2)) (OAI.EditApproximation.finalTargetState target.length)    execution.1 execution.2end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen MeasureTheoryvariable {α : Type u_1} [DecidableEq α] {M J R : ℕ} [NeZero M] [NeZero R] (source target : List α) (N P H T S passes copies : ℕ) (factor : ℕ → ℚ) (multiplier : ℕ → ℕ) (tau eta kappa delta : ℚ) (draw : PhysicalFamilyScalarDraw (M := M) (J := J) (R := R)    target N P (inputSmallLog N) (40 * smallLogExponent N) H (inputSmallLog N ^ 80) passes copies) (B : ℕ) [NeZero B] [MeasurableSpace (Fin B)] [MeasurableSingletonClass (Fin B)] (depth : PhysicalEntry M J target.length → ℕ)local notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalFamilyMemoCoarse_5) "ell" => inputSmallLog Nlocal notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalFamilyMemoCoarse_6) "exponent" => (40 * smallLogExponent N : ℕ)local notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalFamilyMemoCoarse_7) "Key" => PhysicalFamilyScalarKey (M := M) (J := J) (R := R)  target N P ell exponent H (ell ^ 80) passes copieslocal notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalFamilyMemoCoarse_8) "Table" => ChargedPhysicalRequest M J target.length (passes + 1) copies T Slocal notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalFamilyMemoCoarse_9) "readGroup" => physicalFamilyGroupRead (M := M) (J := J) (R := R)  target N P ell exponent H (ell ^ 80) passes copieslocal notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalFamilyMemoCoarse_10) "readInteger" => physicalFamilyOnlineRead (M := M) (J := J) (R := R)  target N P ell exponent H (ell ^ 80) passes copieslocal notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalFamilyMemoCoarse_11) "answer" => physicalFamilyAnswer target N P ell exponent H (ell ^ 80) passes copies drawnoncomputable def physicalFamilyMemoCoarseWork (bits : ℕ) (encode : Sum Key Table → ℕ)    (root : Table) (coarse : OAI.EditApproximation.PhysicalCoarseDraw source target B depth) : ℝ :=  let initial := OAI.EditApproximation.clampedSeedNat (OAI.EditApproximation.physicalCoarseSeedTable source target N B depth coarse)  let result := OAI.EditApproximation.chargedRandomMemoEvaluate source target N P ell exponent H (ell ^ 80)    T S (passes + 1) copies factor multiplier tau eta kappa delta readGroup readInteger initial    answer bits encode root  ∑ entry, OAI.EditApproximation.selectionIndicator (Sum.inr (Sum.inl entry) ∈ result.freshKeys) *    (OAI.EditApproximation.coarseInitialArrayWork B (depth entry) (OAI.EditApproximation.initialThresholdQ N) (OAI.EditApproximation.initialLambda N)      (OAI.EditApproximation.physicalSource source entry.1) (OAI.EditApproximation.substring target entry.2.lo entry.2.hi) (coarse entry) : ℝ)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen MeasureTheoryvariable {α : Type} [DecidableEq α] {M J R : ℕ} [NeZero M] [NeZero R] (source target : List α) (N P H B : ℕ) (depth : PhysicalEntry M J target.length → ℕ)abbrev PhysicalCoarseExecution := OAI.EditApproximation.PhysicalCoarseDraw source target B depth ×  OAI.EditApproximation.RejectionRuntimeArray (OAI.EditApproximation.physicalFamilyRange (M := M) (J := J) (R := R)    target N P (OAI.EditApproximation.inputSmallLog N) (40 * OAI.EditApproximation.smallLogExponent N) H      (OAI.EditApproximation.inputSmallLog N ^ 80) (OAI.EditApproximation.computedSeedPassCount N) (H ^ 2))noncomputable def physicalCoarseExecutionProjection    (execution : OAI.EditApproximation.PhysicalCoarseExecution (R := R) source target N P H B depth) :    OAI.EditApproximation.PhysicalFamilyRuntimeOutcome (M := M) (J := J) (R := R) target N P H :=  (OAI.EditApproximation.physicalCoarseSeedTable source target N B depth execution.1, execution.2)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen MeasureTheorynoncomputable def computedExecutionProjection (source target : List ℕ) (N : ℕ) :=  OAI.EditApproximation.physicalCoarseExecutionProjection (M := (OAI.EditApproximation.integerParameters N).M)    (J := OAI.EditApproximation.intervalTreeDepth (OAI.EditApproximation.integerParameters N).M source.length) (R := OAI.EditApproximation.inputHeight N ^ 2)    source target N (OAI.EditApproximation.integerParameters N).P (OAI.EditApproximation.inputHeight N) (OAI.EditApproximation.integerParameters N).B    (OAI.EditApproximation.computedPhysicalCoarseDepth source target N)noncomputable def computedFullLaw (source target : List ℕ) (N : ℕ) (epsilon : OAI.EditApproximation.BinaryFraction) :    Measure (OAI.EditApproximation.ComputedFullOutcome source target N) :=  if OAI.EditApproximation.physicalLargeInput N epsilon then (OAI.EditApproximation.computedExecutionLaw source target N).map Sum.inr  else Measure.dirac (Sum.inl ())end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen MeasureTheory Filternoncomputable def computedExecutionAccepted (source target : List ℕ) (N : ℕ)    (execution : OAI.EditApproximation.ComputedExecutionOutcome source target N) : OAI.EditApproximation.ComputedFamilyInput source target N :=  OAI.EditApproximation.physicalFamilyRuntimeAccepted target N (OAI.EditApproximation.integerParameters N).P (OAI.EditApproximation.inputHeight N)    (OAI.EditApproximation.computedExecutionProjection source target N execution)noncomputable def computedExecutionRejectionWork (source target : List ℕ) (N : ℕ) :    OAI.EditApproximation.ComputedExecutionOutcome source target N → ℝ :=  OAI.EditApproximation.computedFamilyRejectionWork source target N ∘ OAI.EditApproximation.computedExecutionProjection source target Ndef computedFinalRoot (source target : List ℕ) (N : ℕ) : OAI.EditApproximation.ComputedFamilyTableKey source target N :=  OAI.EditApproximation.localFinalRootRequest (M := (OAI.EditApproximation.integerParameters N).M)    (J := OAI.EditApproximation.intervalTreeDepth (OAI.EditApproximation.integerParameters N).M source.length) target N    (OAI.EditApproximation.integerParameters N).T (OAI.EditApproximation.integerParameters N).S (OAI.EditApproximation.inputHeight N) (Nat.two_pow_pos _)    (OAI.EditApproximation.finalTargetState target.length)noncomputable def computedExecutionKernelWork (source target : List ℕ) (N : ℕ)    (cost : OAI.EditApproximation.ComputedFamilyInput source target N → OAI.EditApproximation.ComputedFamilyMemoKey source target N → ℕ)    (execution : OAI.EditApproximation.ComputedExecutionOutcome source target N) : ℝ :=  let input := OAI.EditApproximation.computedExecutionAccepted source target N execution  OAI.EditApproximation.computedFamilyKernelWork source target N input (cost input)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen Filter MeasureTheorynoncomputable def computedExecutionDictionaryWork (source target : List ℕ) (N : ℕ)    (execution : OAI.EditApproximation.ComputedExecutionOutcome source target N) : ℝ :=  (OAI.EditApproximation.computedFamilyResult source target N (OAI.EditApproximation.computedExecutionAccepted source target N execution)).dictionaryVisitsnoncomputable def computedExecutionAddressWork (source target : List ℕ) (N : ℕ)    (execution : OAI.EditApproximation.ComputedExecutionOutcome source target N) : ℝ :=  OAI.EditApproximation.computedFamilyAddressWork source target N (OAI.EditApproximation.computedExecutionAccepted source target N execution)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen MeasureTheory Filtervariable {M J R B : ℕ} [NeZero M] [NeZero R] [NeZero B] (source target : List ℕ) (N : ℕ) (depth : PhysicalEntry M J target.length → ℕ) (encode : Sum (PhysicalFamilyScalarKey (M := M) (J := J) (R := R)    target N (integerParameters N).P (inputSmallLog N) (40 * smallLogExponent N)    (inputHeight N) (inputSmallLog N ^ 80) (computedSeedPassCount N) (inputHeight N ^ 2))    (ChargedPhysicalRequest M J target.length (computedSeedPassCount N + 1)      (inputHeight N ^ 2) (integerParameters N).T (integerParameters N).S) → ℕ)noncomputable def symbolicComputedCoarseWork :=  fun draw => OAI.EditApproximation.physicalFamilyMemoCoarseWork source target N (OAI.EditApproximation.integerParameters N).P    (OAI.EditApproximation.inputHeight N) (OAI.EditApproximation.integerParameters N).T (OAI.EditApproximation.integerParameters N).S (OAI.EditApproximation.computedSeedPassCount N)    (OAI.EditApproximation.inputHeight N ^ 2) (OAI.EditApproximation.scheduledSeedFactor N) (OAI.EditApproximation.scheduledSeedMultiplier N)    (OAI.EditApproximation.rationalParameters (OAI.EditApproximation.inputSmallLog N)).tau (OAI.EditApproximation.rationalParameters (OAI.EditApproximation.inputSmallLog N)).eta    (OAI.EditApproximation.rationalParameters (OAI.EditApproximation.inputSmallLog N)).kappa (OAI.EditApproximation.rationalParameters (OAI.EditApproximation.inputSmallLog N)).delta    draw B depth (16384 * OAI.EditApproximation.inputHeight N + 5) encode    (OAI.EditApproximation.localFinalRootRequest target N (OAI.EditApproximation.integerParameters N).T (OAI.EditApproximation.integerParameters N).S      (OAI.EditApproximation.inputHeight N) (Nat.two_pow_pos _) (OAI.EditApproximation.finalTargetState target.length))noncomputable def symbolicComputedExecutionCoarseWork    (execution : OAI.EditApproximation.PhysicalCoarseExecution (R := R) source target N      (OAI.EditApproximation.integerParameters N).P (OAI.EditApproximation.inputHeight N) B depth) : ℝ :=  OAI.EditApproximation.symbolicComputedCoarseWork source target N depth encode execution.2.2 execution.1end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen MeasureTheory Filternoncomputable def computedExecutionCoarseWork (source target : List ℕ) (N : ℕ) :=  OAI.EditApproximation.symbolicComputedExecutionCoarseWork (M := (OAI.EditApproximation.integerParameters N).M)    (J := OAI.EditApproximation.intervalTreeDepth (OAI.EditApproximation.integerParameters N).M source.length) (R := OAI.EditApproximation.inputHeight N ^ 2)    (B := (OAI.EditApproximation.integerParameters N).B) source target N (OAI.EditApproximation.computedPhysicalCoarseDepth source target N)    (OAI.EditApproximation.computedFamilyMemoCode source target N (OAI.EditApproximation.inputHeight N ^ 2))end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen Filter MeasureTheorynoncomputable def computedExecutionNonlocalWork (source target : List ℕ) (N : ℕ)    (execution : OAI.EditApproximation.ComputedExecutionOutcome source target N) : ℝ :=  OAI.EditApproximation.computedExecutionCoarseWork source target N execution +    OAI.EditApproximation.computedExecutionRejectionWork source target N execution +    OAI.EditApproximation.computedExecutionDictionaryWork source target N execution +    OAI.EditApproximation.computedExecutionAddressWork source target N executionend OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable {M J R B : ℕ} [NeZero M] [NeZero R] [NeZero B] (source target : List ℕ) (N P H T S passes copies : ℕ) (factor : ℕ → ℚ) (multiplier : ℕ → ℕ) (tau eta kappa delta : ℚ) (draw : PhysicalFamilyScalarDraw (M := M) (J := J) (R := R)    target N P (inputSmallLog N) (40 * smallLogExponent N) H (inputSmallLog N ^ 80) passes copies) (depth : PhysicalEntry M J target.length → ℕ)local notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalIndexedCoarseWork_3) "ell" => inputSmallLog Nlocal notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalIndexedCoarseWork_4) "exponent" => (40 * smallLogExponent N : ℕ)local notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalIndexedCoarseWork_5) "Key" => PhysicalFamilyScalarKey (M := M) (J := J) (R := R)  target N P ell exponent H (ell ^ 80) passes copieslocal notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalIndexedCoarseWork_6) "Table" => ChargedPhysicalRequest M J target.length (passes + 1) copies T Slocal notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalIndexedCoarseWork_7) "readGroup" => physicalFamilyGroupRead (M := M) (J := J) (R := R)  target N P ell exponent H (ell ^ 80) passes copieslocal notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalIndexedCoarseWork_8) "readInteger" => physicalFamilyOnlineRead (M := M) (J := J) (R := R)  target N P ell exponent H (ell ^ 80) passes copieslocal notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalIndexedCoarseWork_9) "answer" => physicalFamilyAnswer target N P ell exponent H (ell ^ 80) passes copies drawnoncomputable def physicalFamilyIndexedCoarseWork (bits : ℕ) (encode : Sum Key Table → ℕ)    (root : Table) (coarse : OAI.EditApproximation.PhysicalCoarseDraw source target B depth) : ℝ :=  let initial := OAI.EditApproximation.clampedSeedNat (OAI.EditApproximation.physicalCoarseSeedTable source target N B depth coarse)  let result := OAI.EditApproximation.chargedRandomMemoEvaluate source target N P ell exponent H (ell ^ 80)    T S (passes + 1) copies factor multiplier tau eta kappa delta readGroup readInteger initial    answer bits encode root  OAI.EditApproximation.coarseIndexedEntryCostSum source target N depth coarse    (fun entry => Sum.inr (Sum.inl entry) ∈ result.freshKeys)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen Filter MeasureTheoryvariable {M J R B : ℕ} [NeZero M] [NeZero R] [NeZero B] (source target : List ℕ) (N : ℕ) (depth : PhysicalEntry M J target.length → ℕ) (encode : Sum (PhysicalFamilyScalarKey (M := M) (J := J) (R := R)    target N (integerParameters N).P (inputSmallLog N) (40 * smallLogExponent N)    (inputHeight N) (inputSmallLog N ^ 80) (computedSeedPassCount N) (inputHeight N ^ 2))    (ChargedPhysicalRequest M J target.length (computedSeedPassCount N + 1)      (inputHeight N ^ 2) (integerParameters N).T (integerParameters N).S) → ℕ)noncomputable def symbolicComputedExecutionIndexedCoarseWork    (execution : OAI.EditApproximation.PhysicalCoarseExecution (R := R) source target N      (OAI.EditApproximation.integerParameters N).P (OAI.EditApproximation.inputHeight N) B depth) : ℝ :=  OAI.EditApproximation.physicalFamilyIndexedCoarseWork source target N (OAI.EditApproximation.integerParameters N).P (OAI.EditApproximation.inputHeight N)    (OAI.EditApproximation.integerParameters N).T (OAI.EditApproximation.integerParameters N).S (OAI.EditApproximation.computedSeedPassCount N)    (OAI.EditApproximation.inputHeight N ^ 2) (OAI.EditApproximation.scheduledSeedFactor N) (OAI.EditApproximation.scheduledSeedMultiplier N)    (OAI.EditApproximation.rationalParameters (OAI.EditApproximation.inputSmallLog N)).tau (OAI.EditApproximation.rationalParameters (OAI.EditApproximation.inputSmallLog N)).eta    (OAI.EditApproximation.rationalParameters (OAI.EditApproximation.inputSmallLog N)).kappa (OAI.EditApproximation.rationalParameters (OAI.EditApproximation.inputSmallLog N)).delta    execution.2.2 depth (16384 * OAI.EditApproximation.inputHeight N + 5) encode    (OAI.EditApproximation.localFinalRootRequest target N (OAI.EditApproximation.integerParameters N).T (OAI.EditApproximation.integerParameters N).S      (OAI.EditApproximation.inputHeight N) (Nat.two_pow_pos _) (OAI.EditApproximation.finalTargetState target.length)) execution.1end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen Filter MeasureTheorynoncomputable def computedExecutionIndexedCoarseWork (source target : List ℕ) (N : ℕ) :=  OAI.EditApproximation.symbolicComputedExecutionIndexedCoarseWork (M := (OAI.EditApproximation.integerParameters N).M)    (J := OAI.EditApproximation.intervalTreeDepth (OAI.EditApproximation.integerParameters N).M source.length) (R := OAI.EditApproximation.inputHeight N ^ 2)    (B := (OAI.EditApproximation.integerParameters N).B) source target N (OAI.EditApproximation.computedPhysicalCoarseDepth source target N)    (OAI.EditApproximation.computedFamilyMemoCode source target N (OAI.EditApproximation.inputHeight N ^ 2))end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable {M J R B : ℕ} [NeZero M] [NeZero R] [NeZero B] (source target : List ℕ) (N P H T S passes copies : ℕ) (factor : ℕ → ℚ) (multiplier : ℕ → ℕ) (tau eta kappa delta : ℚ) (draw : PhysicalFamilyScalarDraw (M := M) (J := J) (R := R)    target N P (inputSmallLog N) (40 * smallLogExponent N) H (inputSmallLog N ^ 80) passes copies) (depth : PhysicalEntry M J target.length → ℕ)local notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalCoarseSamplingWork_3) "ell" => inputSmallLog Nlocal notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalCoarseSamplingWork_4) "exponent" => (40 * smallLogExponent N : ℕ)local notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalCoarseSamplingWork_5) "Key" => PhysicalFamilyScalarKey (M := M) (J := J) (R := R)  target N P ell exponent H (ell ^ 80) passes copieslocal notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalCoarseSamplingWork_6) "Table" => ChargedPhysicalRequest M J target.length (passes + 1) copies T Slocal notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalCoarseSamplingWork_7) "readGroup" => physicalFamilyGroupRead (M := M) (J := J) (R := R)  target N P ell exponent H (ell ^ 80) passes copieslocal notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalCoarseSamplingWork_8) "readInteger" => physicalFamilyOnlineRead (M := M) (J := J) (R := R)  target N P ell exponent H (ell ^ 80) passes copieslocal notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalCoarseSamplingWork_9) "answer" => physicalFamilyAnswer target N P ell exponent H (ell ^ 80) passes copies drawnoncomputable def physicalFamilyCoarseSamplingWork (bits : ℕ) (encode : Sum Key Table → ℕ)    (root : Table) (coarse : OAI.EditApproximation.PhysicalCoarseDraw source target B depth) : ℝ :=  let initial := OAI.EditApproximation.clampedSeedNat (OAI.EditApproximation.physicalCoarseSeedTable source target N B depth coarse)  let result := OAI.EditApproximation.chargedRandomMemoEvaluate source target N P ell exponent H (ell ^ 80)    T S (passes + 1) copies factor multiplier tau eta kappa delta readGroup readInteger initial    answer bits encode root  ∑ entry, OAI.EditApproximation.selectionIndicator (Sum.inr (Sum.inl entry) ∈ result.freshKeys) *    ((Nat.size B * OAI.EditApproximation.coarseInitialLabelCount B (depth entry) (OAI.EditApproximation.initialThresholdQ N) (OAI.EditApproximation.initialLambda N)      (OAI.EditApproximation.physicalSource source entry.1) (OAI.EditApproximation.substring target entry.2.lo entry.2.hi) (coarse entry) : ℕ) : ℝ)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen MeasureTheory Filtervariable {M J R B : ℕ} [NeZero M] [NeZero R] [NeZero B] (source target : List ℕ) (N : ℕ) (depth : PhysicalEntry M J target.length → ℕ) (encode : Sum (PhysicalFamilyScalarKey (M := M) (J := J) (R := R)    target N (integerParameters N).P (inputSmallLog N) (40 * smallLogExponent N)    (inputHeight N) (inputSmallLog N ^ 80) (computedSeedPassCount N) (inputHeight N ^ 2))    (ChargedPhysicalRequest M J target.length (computedSeedPassCount N + 1)      (inputHeight N ^ 2) (integerParameters N).T (integerParameters N).S) → ℕ)noncomputable def symbolicComputedExecutionCoarseSamplingWork    (execution : OAI.EditApproximation.PhysicalCoarseExecution (R := R) source target N      (OAI.EditApproximation.integerParameters N).P (OAI.EditApproximation.inputHeight N) B depth) : ℝ :=  OAI.EditApproximation.physicalFamilyCoarseSamplingWork source target N (OAI.EditApproximation.integerParameters N).P (OAI.EditApproximation.inputHeight N)    (OAI.EditApproximation.integerParameters N).T (OAI.EditApproximation.integerParameters N).S (OAI.EditApproximation.computedSeedPassCount N)    (OAI.EditApproximation.inputHeight N ^ 2) (OAI.EditApproximation.scheduledSeedFactor N) (OAI.EditApproximation.scheduledSeedMultiplier N)    (OAI.EditApproximation.rationalParameters (OAI.EditApproximation.inputSmallLog N)).tau (OAI.EditApproximation.rationalParameters (OAI.EditApproximation.inputSmallLog N)).eta    (OAI.EditApproximation.rationalParameters (OAI.EditApproximation.inputSmallLog N)).kappa (OAI.EditApproximation.rationalParameters (OAI.EditApproximation.inputSmallLog N)).delta    execution.2.2 depth (16384 * OAI.EditApproximation.inputHeight N + 5) encode    (OAI.EditApproximation.localFinalRootRequest target N (OAI.EditApproximation.integerParameters N).T (OAI.EditApproximation.integerParameters N).S      (OAI.EditApproximation.inputHeight N) (Nat.two_pow_pos _) (OAI.EditApproximation.finalTargetState target.length)) execution.1end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen MeasureTheory Filternoncomputable def computedExecutionCoarseSamplingWork (source target : List ℕ) (N : ℕ) :=  OAI.EditApproximation.symbolicComputedExecutionCoarseSamplingWork (M := (OAI.EditApproximation.integerParameters N).M)    (J := OAI.EditApproximation.intervalTreeDepth (OAI.EditApproximation.integerParameters N).M source.length) (R := OAI.EditApproximation.inputHeight N ^ 2)    (B := (OAI.EditApproximation.integerParameters N).B) source target N (OAI.EditApproximation.computedPhysicalCoarseDepth source target N)    (OAI.EditApproximation.computedFamilyMemoCode source target N (OAI.EditApproximation.inputHeight N ^ 2))end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable {M J R : ℕ} [NeZero M] [NeZero R] (source target : List ℕ) (N P H T S passes copies : ℕ) (factor : ℕ → ℚ) (multiplier : ℕ → ℕ) (tau eta kappa delta : ℚ) (initial : PhysicalEntry M J target.length → ℕ) (draw : PhysicalFamilyScalarDraw (M := M) (J := J) (R := R)    target N P (inputSmallLog N) (40 * smallLogExponent N) H (inputSmallLog N ^ 80) passes copies)local notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalCoarsePreparation_5) "ell" => inputSmallLog Nlocal notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalCoarsePreparation_6) "exponent" => (40 * smallLogExponent N : ℕ)local notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalCoarsePreparation_7) "Key" => PhysicalFamilyScalarKey (M := M) (J := J) (R := R)  target N P ell exponent H (ell ^ 80) passes copieslocal notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalCoarsePreparation_8) "Table" => ChargedPhysicalRequest M J target.length (passes + 1) copies T Slocal notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalCoarsePreparation_9) "readGroup" => physicalFamilyGroupRead (M := M) (J := J) (R := R)  target N P ell exponent H (ell ^ 80) passes copieslocal notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalCoarsePreparation_10) "readInteger" => physicalFamilyOnlineRead (M := M) (J := J) (R := R)  target N P ell exponent H (ell ^ 80) passes copieslocal notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalCoarsePreparation_11) "answer" => physicalFamilyAnswer target N P ell exponent H (ell ^ 80) passes copies drawnoncomputable def physicalFamilyCoarsePreparationWork (bits : ℕ) (encode : Sum Key Table → ℕ)    (root : Table) : ℝ :=  let result := OAI.EditApproximation.chargedRandomMemoEvaluate source target N P ell exponent H (ell ^ 80)    T S (passes + 1) copies factor multiplier tau eta kappa delta readGroup readInteger initial    answer bits encode root  ∑ entry, OAI.EditApproximation.selectionIndicator (Sum.inr (Sum.inl entry) ∈ result.freshKeys) *    (OAI.EditApproximation.physicalCoarsePreparationCost source target entry : ℝ)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen Filter MeasureTheorynoncomputable def computedFamilyCoarsePreparationWork (source target : List ℕ) (N : ℕ)    (input : OAI.EditApproximation.ComputedFamilyInput source target N) : ℝ :=  OAI.EditApproximation.physicalFamilyCoarsePreparationWork source target N (OAI.EditApproximation.integerParameters N).P (OAI.EditApproximation.inputHeight N)    (OAI.EditApproximation.integerParameters N).T (OAI.EditApproximation.integerParameters N).S (OAI.EditApproximation.computedSeedPassCount N) (OAI.EditApproximation.inputHeight N ^ 2)    (OAI.EditApproximation.scheduledSeedFactor N) (OAI.EditApproximation.scheduledSeedMultiplier N)    (OAI.EditApproximation.rationalParameters (OAI.EditApproximation.inputSmallLog N)).tau (OAI.EditApproximation.rationalParameters (OAI.EditApproximation.inputSmallLog N)).eta    (OAI.EditApproximation.rationalParameters (OAI.EditApproximation.inputSmallLog N)).kappa (OAI.EditApproximation.rationalParameters (OAI.EditApproximation.inputSmallLog N)).delta    (OAI.EditApproximation.clampedSeedNat input.1) input.2 (16384 * OAI.EditApproximation.inputHeight N + 5)    (OAI.EditApproximation.computedFamilyMemoCode source target N (OAI.EditApproximation.inputHeight N ^ 2))    (OAI.EditApproximation.computedFinalRoot source target N)noncomputable def computedExecutionCoarsePreparationWork (source target : List ℕ) (N : ℕ)    (execution : OAI.EditApproximation.ComputedExecutionOutcome source target N) : ℝ :=  OAI.EditApproximation.computedFamilyCoarsePreparationWork source target N (OAI.EditApproximation.computedExecutionAccepted source target N execution)noncomputable def computedExecutionReadChargedWork (source target : List ℕ) (N : ℕ)    (execution : OAI.EditApproximation.ComputedExecutionOutcome source target N) : ℝ :=  OAI.EditApproximation.computedExecutionIndexedCoarseWork source target N execution +    OAI.EditApproximation.computedExecutionCoarseSamplingWork source target N execution +    OAI.EditApproximation.computedExecutionNonlocalWork source target N execution +    OAI.EditApproximation.computedExecutionCoarsePreparationWork source target N executionend OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen MeasureTheory Filternoncomputable def computedExecutionTotalWork (source target : List ℕ) (N : ℕ)    (cost : OAI.EditApproximation.ComputedFamilyInput source target N → OAI.EditApproximation.ComputedFamilyMemoKey source target N → ℕ)    (execution : OAI.EditApproximation.ComputedExecutionOutcome source target N) : ℝ :=  OAI.EditApproximation.computedExecutionReadChargedWork source target N execution +    OAI.EditApproximation.computedExecutionKernelWork source target N cost executionnoncomputable def computedFullOutputWork (source target : List ℕ) (N : ℕ)    (cost : OAI.EditApproximation.ComputedFamilyInput source target N → OAI.EditApproximation.ComputedFamilyMemoKey source target N → ℕ)    (setup : ℝ) (shared : ℕ) (output : OAI.EditApproximation.ComputedFamilyInput source target N → ℕ)    (fallbackOutput : ℕ) : OAI.EditApproximation.ComputedFullOutcome source target N → ℝ  | .inl _ => setup + (OAI.EditApproximation.chargedSuffixDP source target).2 + fallbackOutput  | .inr execution => setup + shared + OAI.EditApproximation.computedExecutionTotalWork source target N cost execution +      output (OAI.EditApproximation.computedExecutionAccepted source target N execution)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen BitQueryvariable {α : Type u_1} {M J R : ℕ} (target : List α) (N P F exponent H Q passes copies pass copy : ℕ)def queryFamilyTagAllocation    (scalar : OAI.EditApproximation.PhysicalScalarKey M J N target.length exponent F Q R (OAI.EditApproximation.localOnlineMassBound M P H)) : ℕ :=  OAI.EditApproximation.binaryNaturalDivAllocation pass (passes + 1) + OAI.EditApproximation.binaryNaturalDivAllocation copy (copies + 1) +    OAI.EditApproximation.physicalScalarCodeAllocation scalar + 9end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.BitQuery.Footprintdef rankedBitMemoCells {κ : Type u_1} (rank : κ → ℕ)    (program : (key : κ) → OAI.EditApproximation.BitQuery {child : κ // rank child < rank key} OAI.EditApproximation.BinaryFraction)    (heap : ∀ key, OAI.EditApproximation.BitQuery.Footprint (program key))    (bits : ℕ) (encode addressCells : κ → ℕ) (key : κ) (memory : OAI.EditApproximation.BinaryMemo OAI.EditApproximation.BinaryFraction) : ℕ :=  let found := memory.lookupCosted (OAI.EditApproximation.binaryMemoKey bits (encode key))  match found.1 with  | some _ => OAI.EditApproximation.memoRequestCells bits (addressCells key)  | none => OAI.EditApproximation.memoRequestCells bits (addressCells key) + (heap key).runCells      (fun child previous => OAI.EditApproximation.rankedBitMemoEvaluate rank program bits encode child.val previous)      (fun child previous => rankedBitMemoCells rank program heap bits encode addressCells child.val previous)      memorytermination_by rank keydecreasing_by exact child.propertyend OAI.EditApproximation.BitQuery.Footprintendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen BitQuerylocal instance queryArityNeZero (N : ℕ) : NeZero (OAI.EditApproximation.integerParameters N).M :=  ⟨by change 2 ^ (OAI.EditApproximation.heightExponent N / 20) ≠ 0; exact Nat.ne_of_gt (Nat.two_pow_pos _)⟩end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen BitQueryattribute [local instance] queryArityNeZero queryRoundsNeZerodef queryInitialGatherFootprint    {ι : Type u_1}    {β : Type u_2}    {n : ℕ}    (N P F exponent : ℕ)    (hP : 0 < P)    (a : OAI.EditApproximation.BinaryFraction)    (q : OAI.EditApproximation.TargetInterval n)    (reader : OAI.EditApproximation.TargetInterval n → OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction)    (hr : (key : OAI.EditApproximation.TargetInterval n) → (reader key).Footprint)    (next : List (OAI.EditApproximation.TargetInterval n) →  List OAI.EditApproximation.BinaryFraction → OAI.EditApproximation.BitQuery ι β)    (hn : (keys : List (OAI.EditApproximation.TargetInterval n)) →  (words : List OAI.EditApproximation.BinaryFraction) → (next keys words).Footprint) : (OAI.EditApproximation.queryInitialGather N P F exponent hP a q reader next).Footprint :=(hr q).bind  (fun (value : OAI.EditApproximation.BinaryFraction) =>    (OAI.EditApproximation.BitQuery.compute          (OAI.EditApproximation.BinaryFraction.queryInitialSupportWithWork N P F exponent hP a value q)).bind      fun (keys : List (OAI.EditApproximation.TargetInterval n)) =>      OAI.EditApproximation.BitQuery.collect reader keys (next keys))  fun (value : OAI.EditApproximation.BinaryFraction) =>  (OAI.EditApproximation.BitQuery.Footprint.computeOf        (OAI.EditApproximation.BinaryFraction.queryInitialSupportWithWork N P F exponent hP a value q)        (OAI.EditApproximation.BinaryFraction.queryInitialSupportAllocation N P F exponent hP a value q)).bind    (fun (keys : List (OAI.EditApproximation.TargetInterval n)) =>      OAI.EditApproximation.BitQuery.collect reader keys (next keys))    fun (keys : List (OAI.EditApproximation.TargetInterval n)) =>    OAI.EditApproximation.BitQuery.Footprint.collect reader hr keys (next keys) (hn keys)def queryBandGatherFootprint    {ι : Type u_1}    {β : Type u_2}    {nx ny : ℕ}    (M : ℕ)    (parent : OAI.EditApproximation.TargetInterval nx)    (N P F exponent : ℕ)    (hP : 0 < P)    (a : OAI.EditApproximation.BinaryFraction)    (initial : OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BinaryFraction × ℕ)    (allocation : OAI.EditApproximation.TargetInterval ny → ℕ)    (q : OAI.EditApproximation.TargetInterval ny)    (massReader initialReader : Fin M × OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction)    (hm : (key : Fin M × OAI.EditApproximation.TargetInterval ny) → (massReader key).Footprint)    (hi : (key : Fin M × OAI.EditApproximation.TargetInterval ny) → (initialReader key).Footprint)    (next : List (Fin M × OAI.EditApproximation.TargetInterval ny) →  List OAI.EditApproximation.BinaryFraction →    List OAI.EditApproximation.BinaryFraction → OAI.EditApproximation.BitQuery ι β)    (hn : (keys : List (Fin M × OAI.EditApproximation.TargetInterval ny)) →  (mass words : List OAI.EditApproximation.BinaryFraction) → (next keys mass words).Footprint) : (OAI.EditApproximation.queryBandGather M parent N P F exponent hP a initial q massReader initialReader next).Footprint :=(OAI.EditApproximation.BitQuery.Footprint.computeOf      (OAI.EditApproximation.BinaryFraction.queryBandInputsWithWork M parent N P F exponent hP a initial q)      (OAI.EditApproximation.BinaryFraction.queryBandInputsAllocation M parent N P F exponent hP a initial allocation        q)).bind  (fun (keys : List (Fin M × OAI.EditApproximation.TargetInterval ny)) =>    OAI.EditApproximation.BitQuery.collect massReader keys fun (mass : List OAI.EditApproximation.BinaryFraction) =>      OAI.EditApproximation.BitQuery.collect initialReader keys (next keys mass))  fun (keys : List (Fin M × OAI.EditApproximation.TargetInterval ny)) =>  OAI.EditApproximation.BitQuery.Footprint.collect massReader hm keys    (fun (mass : List OAI.EditApproximation.BinaryFraction) =>      OAI.EditApproximation.BitQuery.collect initialReader keys (next keys mass))    fun (mass : List OAI.EditApproximation.BinaryFraction) =>    OAI.EditApproximation.BitQuery.Footprint.collect initialReader hi keys (next keys mass) (hn keys mass)def queryGroupSourceGatherFootprint    {ι : Type u_1}    {β : Type u_2}    {n : ℕ}    (M N F Q exponent eM eF : ℕ)    (hM : M = 2 ^ eM)    (hF : F = 2 ^ eF)    (a : OAI.EditApproximation.BinaryFraction)    (initial : OAI.EditApproximation.TargetInterval n → OAI.EditApproximation.BinaryFraction × ℕ)    (allocation : OAI.EditApproximation.TargetInterval n → ℕ)    (q : OAI.EditApproximation.TargetInterval n)    (reader : OAI.EditApproximation.GroupScalarKey M F Q → OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction)    (hr : (key : OAI.EditApproximation.GroupScalarKey M F Q) → (reader key).Footprint)    (next : List (OAI.EditApproximation.GroupScalarKey M F Q) →  List OAI.EditApproximation.BinaryFraction → OAI.EditApproximation.BitQuery ι β)    (hn : (keys : List (OAI.EditApproximation.GroupScalarKey M F Q)) →  (words : List OAI.EditApproximation.BinaryFraction) → (next keys words).Footprint) : (OAI.EditApproximation.queryGroupSourceGather M N F Q exponent eM eF hM hF a initial q reader next).Footprint :=OAI.EditApproximation.BitQuery.Footprint.chargeOf (allocation q)  ((OAI.EditApproximation.BitQuery.Footprint.computeOf        (OAI.EditApproximation.BinaryFraction.queryGroupSourceKeysWithWork M N F Q exponent eM eF hM hF a (initial q).1          q)        (OAI.EditApproximation.BinaryFraction.queryGroupSourceKeysAllocation M N F Q exponent eM eF hM hF a          (initial q).1 q)).bind    (fun (keys : List (OAI.EditApproximation.GroupScalarKey M F Q)) =>      OAI.EditApproximation.BitQuery.collect reader keys (next keys))    fun (keys : List (OAI.EditApproximation.GroupScalarKey M F Q)) =>    OAI.EditApproximation.BitQuery.Footprint.collect reader hr keys (next keys) (hn keys))def queryOnlineSourceGatherFootprint    {ι : Type u_1}    {β : Type u_2}    {nx ny M : ℕ}    (parent : OAI.EditApproximation.TargetInterval nx)    (N P F exponent H : ℕ)    (hP : 0 < P)    (tau a : OAI.EditApproximation.BinaryFraction)    (initial : OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BinaryFraction × ℕ)    (initialAllocation : OAI.EditApproximation.TargetInterval ny → ℕ)    (child : Fin M → OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BinaryFraction × ℕ)    (childAllocation : Fin M → OAI.EditApproximation.TargetInterval ny → ℕ)    (q : OAI.EditApproximation.TargetInterval ny)    (reader : ℕ × OAI.EditApproximation.TargetInterval ny → ℕ → OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction)    (hr : (key : ℕ × OAI.EditApproximation.TargetInterval ny) → (range : ℕ) → (reader key range).Footprint)    (next : List (ℕ × OAI.EditApproximation.TargetInterval ny) →  List OAI.EditApproximation.BinaryFraction → OAI.EditApproximation.BitQuery ι β)    (hn : (keys : List (ℕ × OAI.EditApproximation.TargetInterval ny)) →  (words : List OAI.EditApproximation.BinaryFraction) → (next keys words).Footprint) : (OAI.EditApproximation.queryOnlineSourceGather parent N P F exponent H hP tau a initial child q reader next).Footprint :=OAI.EditApproximation.BitQuery.Footprint.chargeOf (initialAllocation q)  ((OAI.EditApproximation.BitQuery.Footprint.computeOf        (OAI.EditApproximation.BinaryFraction.queryOnlineKeysWithWork N P F hP a (initial q).1 q)        (OAI.EditApproximation.BinaryFraction.queryOnlineKeysAllocation N P F hP a (initial q).1 q)).bind    (fun (keys : List (ℕ × OAI.EditApproximation.TargetInterval ny)) =>      OAI.EditApproximation.BitQuery.collect        (fun (key : ℕ × OAI.EditApproximation.TargetInterval ny) =>          (OAI.EditApproximation.BitQuery.compute                (OAI.EditApproximation.BinaryFraction.queryOnlineRangeWithWork parent P exponent H tau child key)).bind            (reader key))        keys (next keys))    fun (keys : List (ℕ × OAI.EditApproximation.TargetInterval ny)) =>    OAI.EditApproximation.BitQuery.Footprint.collect      (fun (key : ℕ × OAI.EditApproximation.TargetInterval ny) =>        (OAI.EditApproximation.BitQuery.compute              (OAI.EditApproximation.BinaryFraction.queryOnlineRangeWithWork parent P exponent H tau child key)).bind          (reader key))      (fun (key : ℕ × OAI.EditApproximation.TargetInterval ny) =>        (OAI.EditApproximation.BitQuery.Footprint.computeOf              (OAI.EditApproximation.BinaryFraction.queryOnlineRangeWithWork parent P exponent H tau child key)              (OAI.EditApproximation.BinaryFraction.queryOnlineRangeAllocation parent P exponent H tau child                childAllocation key)).bind          (reader key) (hr key))      keys (next keys) (hn keys))def queryPhysicalTableReadFootprint    {M J n : ℕ}    (copies T S : ℕ)    (parent : OAI.EditApproximation.PhysicalTableRequest M J n)    (child : { r : OAI.EditApproximation.PhysicalTableRequest M J n //  OAI.EditApproximation.PhysicalTableRequest.combinedRank T S r <    OAI.EditApproximation.PhysicalTableRequest.combinedRank T S parent }) : (OAI.EditApproximation.queryPhysicalTableRead copies T S parent child).Footprint :=OAI.EditApproximation.BitQuery.Footprint.chargeOf (OAI.EditApproximation.physicalTableCodeAllocation (M := M) (J := J) (n := n) child.val + 1)  (OAI.EditApproximation.BitQuery.Footprint.read child OAI.EditApproximation.BitQuery.done    fun (word : OAI.EditApproximation.BinaryFraction) => OAI.EditApproximation.BitQuery.Footprint.done word)def queryMeanReadFootprint    {ι : Type u_1}    (count : ℕ)    (reader : Fin count → OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction)    (hr : (i : Fin count) → (reader i).Footprint) : (OAI.EditApproximation.queryMeanRead count reader).Footprint :=OAI.EditApproximation.BitQuery.Footprint.chargeOf count  (OAI.EditApproximation.BitQuery.Footprint.collect reader hr (List.ofFn fun (i : Fin count) => i)    (fun (words : List OAI.EditApproximation.BinaryFraction) =>      OAI.EditApproximation.BitQuery.compute (OAI.EditApproximation.BinaryFraction.queryMeanWithWork count words))    fun (words : List OAI.EditApproximation.BinaryFraction) =>    OAI.EditApproximation.BitQuery.Footprint.computeOf      (OAI.EditApproximation.BinaryFraction.queryMeanWithWork count words)      (OAI.EditApproximation.BinaryFraction.sumListAllocation words +          (OAI.EditApproximation.BinaryFraction.sumListWithWork words).1.divAllocation            (OAI.EditApproximation.BinaryFraction.nat count) +        count.size))def queryPhysicalScalarReadFootprint    (M J N n exponent F Q R B : ℕ)    (key : OAI.EditApproximation.PhysicalScalarKey M J N n exponent F Q R B) : (OAI.EditApproximation.queryPhysicalScalarRead M J N n exponent F Q R B key).Footprint :=OAI.EditApproximation.BitQuery.Footprint.chargeOf (OAI.EditApproximation.physicalScalarCodeAllocation key + 1)  (OAI.EditApproximation.BitQuery.Footprint.read key OAI.EditApproximation.BitQuery.done    fun (word : OAI.EditApproximation.BinaryFraction) => OAI.EditApproximation.BitQuery.Footprint.done word)def queryRestrictPhysicalBodyFootprint    {σ : Type u_1}    {M J n : ℕ}    (passes copies T S : ℕ)    (parent : { r : OAI.EditApproximation.PhysicalTableRequest M J n //  OAI.EditApproximation.PhysicalTableRequest.Bounded passes copies T S r })    (program : OAI.EditApproximation.BitQuery (OAI.EditApproximation.QueryPhysicalChild (σ := σ) passes copies T S parent)  OAI.EditApproximation.BinaryFraction)    (heap : program.Footprint) : (OAI.EditApproximation.queryRestrictPhysicalBody passes copies T S parent program).Footprint := by  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_bitOrdering_matches_4 (high : Ordering) (a : Bool) (b : Bool) (x : ℕ) (y : ℕ) (h : OAI.EditApproximation.orderingMatches high x y) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitOrdering high a b) (a.toNat + 2 * x) (b.toNat + 2 * y) := by    rcases h with ⟨rfl, h⟩ | ⟨rfl, rfl⟩ | ⟨rfl, h⟩    · exact Or.inl ⟨rfl, by cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩    · cases a <;> cases b <;> simp [OAI.EditApproximation.bitOrdering, OAI.EditApproximation.orderingMatches]    · exact Or.inr (Or.inr ⟨rfl, by        cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩)  have proof_bitCompareWithWork_matches_5 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitCompareWithWork left right).1 (OAI.EditApproximation.bitWordValue left) (OAI.EditApproximation.bitWordValue right) := by    induction left generalizing right with    | nil =>      simp only [OAI.EditApproximation.bitCompareWithWork]      induction right with      | nil => (simp [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.orderingMatches, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        simpa only [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareNilLeftWithWork bs).1 false b 0 (OAI.EditApproximation.bitWordValue bs) ih    | cons a as ih =>      cases right with      | nil =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as []).1 a false (OAI.EditApproximation.bitWordValue as) 0 (ih [])      | cons b bs =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue] using          proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as bs).1 a b (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs) (ih bs)  have proof_bitCompareWithWork_lt_16 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .lt ↔ OAI.EditApproximation.bitWordValue left < OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_binaryNaturalCompareWithWork_lt_53 (a : ℕ) (b : ℕ) :      (OAI.EditApproximation.binaryNaturalCompareWithWork a b).1 = .lt ↔ a < b := by    simpa only [OAI.EditApproximation.binaryNaturalCompareWithWork, proof_bitWordValue_bits_15] using proof_bitCompareWithWork_lt_16 a.bits b.bits  have proof_wordLEWithWork_value_26 (a : List.{0} Bool) (b : List.{0} Bool) :      (OAI.EditApproximation.wordLEWithWork a b).1 = true ↔ OAI.EditApproximation.bitWordValue a ≤ OAI.EditApproximation.bitWordValue b := by    simp only [OAI.EditApproximation.wordLEWithWork, Bool.not_eq_true', decide_eq_false_iff_not,      proof_bitCompareWithWork_lt_16, not_lt]  have proof_bitAdder_value_1 (a : Bool) (b : Bool) (carry : Bool) :      (OAI.EditApproximation.bitSum a b carry).toNat + 2 * (OAI.EditApproximation.bitCarry a b carry).toNat =        a.toNat + b.toNat + carry.toNat := by    cases a <;> cases b <;> cases carry <;> decide  have proof_bitAddWithWork_value_2 (left : List.{0} Bool) (right : List.{0} Bool) (carry : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitAddWithWork left right carry).1 =        OAI.EditApproximation.bitWordValue left + OAI.EditApproximation.bitWordValue right + carry.toNat := by    induction left generalizing right carry with    | nil =>      simp only [OAI.EditApproximation.bitAddWithWork]      induction right generalizing carry with      | nil => cases carry <;> simp [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue]      | cons b bs ih =>        simp only [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 false b carry        simp only [Bool.toNat_false] at h        omega    | cons a as ih =>      cases right with      | nil =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a false carry        simp only [Bool.toNat_false] at h        omega      | cons b bs =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a b carry        omega  have proof_binaryNaturalAddWithWork_value_52 (a : ℕ) (b : ℕ) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalAddWithWork a b).1 = a + b := by    simp [OAI.EditApproximation.binaryNaturalAddWithWork, proof_bitAddWithWork_value_2, proof_bitWordValue_bits_15]  have proof_queryPhysicalBoundedWithWork_value_109 {M : ℕ} {J : ℕ} {n : ℕ} (passes : ℕ) (copies : ℕ) (T : ℕ) (S : ℕ) (request : OAI.EditApproximation.PhysicalTableRequest M J n) :      (OAI.EditApproximation.queryPhysicalBoundedWithWork passes copies T S request).1 = true ↔        request.Bounded passes copies T S := by    simp only [OAI.EditApproximation.queryPhysicalBoundedWithWork, Bool.and_eq_true, decide_eq_true_eq,      proof_binaryNaturalCompareWithWork_lt_53, proof_wordLEWithWork_value_26, proof_bitWordValue_bits_15,      proof_binaryNaturalAddWithWork_value_52, OAI.EditApproximation.PhysicalTableRequest.Bounded]    tauto  have proof_querySupportedChildWithWork_value_108 {σ : Type u_1} {M : ℕ} {J : ℕ} {n : ℕ} (passes : ℕ) (copies : ℕ) (T : ℕ) (S : ℕ) (parent : Subtype.{1} fun r => OAI.EditApproximation.PhysicalTableRequest.Bounded (M := M) (J := J) (ny := n) passes copies T S r) (key : OAI.EditApproximation.QueryPhysicalChild.{u_1} (σ := σ) passes copies T S parent) :      (OAI.EditApproximation.querySupportedChildWithWork passes copies T S parent key).1 = true ↔        OAI.EditApproximation.SourceRanked.supportedChild (OAI.EditApproximation.PhysicalTableRequest.combinedRank T S)          (OAI.EditApproximation.PhysicalTableRequest.Bounded passes copies T S) parent.val key := by    cases key with    | inl source => exact iff_of_true rfl trivial    | inr child => exact proof_queryPhysicalBoundedWithWork_value_109 passes copies T S child.val  exact    (heap.restrictWithWork _ _ (proof_querySupportedChildWithWork_value_108 passes copies T S parent)      (OAI.EditApproximation.querySupportedChildAllocation passes copies T S parent)      ).mapKeysWithWork _ (fun _ => 1)def queryInitialConeProgramAtFootprint    {ι : Type u_1}    {n : ℕ}    (sourceLength N P F : ℕ)    (A a : OAI.EditApproximation.BinaryFraction)    (reader : OAI.EditApproximation.TargetInterval n → OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction)    (q : OAI.EditApproximation.TargetInterval n)    (hr : (r : OAI.EditApproximation.TargetInterval n) → (reader r).Footprint) : (OAI.EditApproximation.queryInitialConeProgramAt sourceLength N P F A a reader q).Footprint :=(hr q).bind  (fun (value : OAI.EditApproximation.BinaryFraction) =>    (OAI.EditApproximation.BitQuery.compute          (OAI.EditApproximation.BinaryFraction.queryInitialConeCentersWithWork N P A value q)).bind      fun (keys : List (OAI.EditApproximation.TargetInterval n)) =>      OAI.EditApproximation.BitQuery.collect reader keys fun (words : List OAI.EditApproximation.BinaryFraction) =>        OAI.EditApproximation.BitQuery.compute          (OAI.EditApproximation.BinaryFraction.cachedInitialProgramReadWithWork sourceLength N P F A a            (value.queryInitialSeedReadWithWork q keys words) q))  fun (value : OAI.EditApproximation.BinaryFraction) =>  (OAI.EditApproximation.BitQuery.Footprint.computeOf        (OAI.EditApproximation.BinaryFraction.queryInitialConeCentersWithWork N P A value q)        (OAI.EditApproximation.BinaryFraction.queryInitialConeCentersAllocation N P A value q)).bind    (fun (keys : List (OAI.EditApproximation.TargetInterval n)) =>      OAI.EditApproximation.BitQuery.collect reader keys fun (words : List OAI.EditApproximation.BinaryFraction) =>        OAI.EditApproximation.BitQuery.compute          (OAI.EditApproximation.BinaryFraction.cachedInitialProgramReadWithWork sourceLength N P F A a            (value.queryInitialSeedReadWithWork q keys words) q))    fun (keys : List (OAI.EditApproximation.TargetInterval n)) =>    OAI.EditApproximation.BitQuery.Footprint.collect reader hr keys      (fun (words : List OAI.EditApproximation.BinaryFraction) =>        OAI.EditApproximation.BitQuery.compute          (OAI.EditApproximation.BinaryFraction.cachedInitialProgramReadWithWork sourceLength N P F A a            (value.queryInitialSeedReadWithWork q keys words) q))      fun (words : List OAI.EditApproximation.BinaryFraction) =>      OAI.EditApproximation.BitQuery.Footprint.computeOf        (OAI.EditApproximation.BinaryFraction.cachedInitialProgramReadWithWork sourceLength N P F A a          (value.queryInitialSeedReadWithWork q keys words) q)        (OAI.EditApproximation.BinaryFraction.cachedInitialProgramReadAllocation          (value.queryInitialSeedReadWithWork q keys words) (value.queryInitialSeedReadAllocation q keys words)          sourceLength N P F A a q)def queryChargedReadFootprint    {M J n passes copies T S : ℕ}    (parent : { r : OAI.EditApproximation.PhysicalTableRequest M J n //  OAI.EditApproximation.PhysicalTableRequest.Bounded passes copies T S r })    (key : { child : OAI.EditApproximation.ChargedPhysicalRequest M J n passes copies T S //  child.rank < OAI.EditApproximation.ChargedPhysicalRequest.rank (Sum.inr parent) }) : (OAI.EditApproximation.queryChargedRead parent key).Footprint :=OAI.EditApproximation.BitQuery.Footprint.chargeOf (OAI.EditApproximation.chargedPhysicalCodeAllocation (M := M) (J := J) (n := n) (passes := passes) (copies := copies) (T := T) (S := S) key.val + 1)  (OAI.EditApproximation.BitQuery.Footprint.read key OAI.EditApproximation.BitQuery.done    fun (word : OAI.EditApproximation.BinaryFraction) => OAI.EditApproximation.BitQuery.Footprint.done word)def queryWarmupProgramFootprint    {ι : Type u_1}    {nx ny M : ℕ}    (parent : OAI.EditApproximation.TargetInterval nx)    (N P F : ℕ)    (a : OAI.EditApproximation.BinaryFraction)    (initialRead : OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction)    (childRead : Fin M × OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction)    (q : OAI.EditApproximation.TargetInterval ny)    (hi : (r : OAI.EditApproximation.TargetInterval ny) → (initialRead r).Footprint)    (hc : (key : Fin M × OAI.EditApproximation.TargetInterval ny) → (childRead key).Footprint) : (OAI.EditApproximation.queryWarmupProgram parent N P F a initialRead childRead q).Footprint :=(hi q).bind  (fun (value : OAI.EditApproximation.BinaryFraction) =>    (OAI.EditApproximation.BitQuery.compute          (OAI.EditApproximation.BinaryFraction.queryRawCentersWithWork N P F a value q)).bind      fun (centers : List (OAI.EditApproximation.TargetInterval ny)) =>      OAI.EditApproximation.BitQuery.collect initialRead centers        fun (words : List OAI.EditApproximation.BinaryFraction) =>        have initial : OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BinaryFraction × ℕ :=          value.queryOverrideParentReadWithWork q centers words;        (OAI.EditApproximation.BitQuery.compute              (OAI.EditApproximation.BinaryFraction.queryWarmupInputsWithWork M parent N P F a initial q)).bind          fun (inputs : List (Fin M × OAI.EditApproximation.TargetInterval ny)) =>          OAI.EditApproximation.BitQuery.collect childRead inputs            fun (childWords : List OAI.EditApproximation.BinaryFraction) =>            OAI.EditApproximation.BitQuery.compute              (OAI.EditApproximation.BinaryFraction.localWarmupReadKernelWithWork parent N P F a initial                (fun (input : Fin M × OAI.EditApproximation.TargetInterval ny) =>                  OAI.EditApproximation.BinaryFraction.queryChildReadWithWork inputs childWords input.1 input.2)                q))  fun (value : OAI.EditApproximation.BinaryFraction) =>  (OAI.EditApproximation.BitQuery.Footprint.computeOf        (OAI.EditApproximation.BinaryFraction.queryRawCentersWithWork N P F a value q)        (OAI.EditApproximation.BinaryFraction.queryRawCentersAllocation N P F a value q)).bind    (fun (centers : List (OAI.EditApproximation.TargetInterval ny)) =>      OAI.EditApproximation.BitQuery.collect initialRead centers        fun (words : List OAI.EditApproximation.BinaryFraction) =>        have initial : OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BinaryFraction × ℕ :=          value.queryOverrideParentReadWithWork q centers words;        (OAI.EditApproximation.BitQuery.compute              (OAI.EditApproximation.BinaryFraction.queryWarmupInputsWithWork M parent N P F a initial q)).bind          fun (inputs : List (Fin M × OAI.EditApproximation.TargetInterval ny)) =>          OAI.EditApproximation.BitQuery.collect childRead inputs            fun (childWords : List OAI.EditApproximation.BinaryFraction) =>            OAI.EditApproximation.BitQuery.compute              (OAI.EditApproximation.BinaryFraction.localWarmupReadKernelWithWork parent N P F a initial                (fun (input : Fin M × OAI.EditApproximation.TargetInterval ny) =>                  OAI.EditApproximation.BinaryFraction.queryChildReadWithWork inputs childWords input.1 input.2)                q))    fun (centers : List (OAI.EditApproximation.TargetInterval ny)) =>    OAI.EditApproximation.BitQuery.Footprint.collect initialRead hi centers      (fun (words : List OAI.EditApproximation.BinaryFraction) =>        have initial : OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BinaryFraction × ℕ :=          value.queryOverrideParentReadWithWork q centers words;        (OAI.EditApproximation.BitQuery.compute              (OAI.EditApproximation.BinaryFraction.queryWarmupInputsWithWork M parent N P F a initial q)).bind          fun (inputs : List (Fin M × OAI.EditApproximation.TargetInterval ny)) =>          OAI.EditApproximation.BitQuery.collect childRead inputs            fun (childWords : List OAI.EditApproximation.BinaryFraction) =>            OAI.EditApproximation.BitQuery.compute              (OAI.EditApproximation.BinaryFraction.localWarmupReadKernelWithWork parent N P F a initial                (fun (input : Fin M × OAI.EditApproximation.TargetInterval ny) =>                  OAI.EditApproximation.BinaryFraction.queryChildReadWithWork inputs childWords input.1 input.2)                q))      fun (words : List OAI.EditApproximation.BinaryFraction) =>      let initial : OAI.EditApproximation.TargetInterval ny → OAI.EditApproximation.BinaryFraction × ℕ :=        value.queryOverrideParentReadWithWork q centers words;      let allocation : OAI.EditApproximation.TargetInterval ny → ℕ :=        OAI.EditApproximation.BinaryFraction.queryOverrideParentReadAllocation q centers words;      (OAI.EditApproximation.BitQuery.Footprint.computeOf            (OAI.EditApproximation.BinaryFraction.queryWarmupInputsWithWork M parent N P F a initial q)            (OAI.EditApproximation.BinaryFraction.queryWarmupInputsAllocation M parent N P F a initial allocation              q)).bind        (fun (inputs : List (Fin M × OAI.EditApproximation.TargetInterval ny)) =>          OAI.EditApproximation.BitQuery.collect childRead inputs            fun (childWords : List OAI.EditApproximation.BinaryFraction) =>            OAI.EditApproximation.BitQuery.compute              (OAI.EditApproximation.BinaryFraction.localWarmupReadKernelWithWork parent N P F a                (value.queryOverrideParentReadWithWork q centers words)                (fun (input : Fin M × OAI.EditApproximation.TargetInterval ny) =>                  OAI.EditApproximation.BinaryFraction.queryChildReadWithWork inputs childWords input.1 input.2)                q))        fun (inputs : List (Fin M × OAI.EditApproximation.TargetInterval ny)) =>        OAI.EditApproximation.BitQuery.Footprint.collect childRead hc inputs          (fun (childWords : List OAI.EditApproximation.BinaryFraction) =>            OAI.EditApproximation.BitQuery.compute              (OAI.EditApproximation.BinaryFraction.localWarmupReadKernelWithWork parent N P F a                (value.queryOverrideParentReadWithWork q centers words)                (fun (input : Fin M × OAI.EditApproximation.TargetInterval ny) =>                  OAI.EditApproximation.BinaryFraction.queryChildReadWithWork inputs childWords input.1 input.2)                q))          fun (childWords : List OAI.EditApproximation.BinaryFraction) =>          OAI.EditApproximation.BitQuery.Footprint.computeOf            (OAI.EditApproximation.BinaryFraction.localWarmupReadKernelWithWork parent N P F a initial              (fun (input : Fin M × OAI.EditApproximation.TargetInterval ny) =>                OAI.EditApproximation.BinaryFraction.queryChildReadWithWork inputs childWords input.1 input.2)              q)            (OAI.EditApproximation.BinaryFraction.localWarmupReadAllocation parent N P F a initial allocation              (fun (input : Fin M × OAI.EditApproximation.TargetInterval ny) =>                OAI.EditApproximation.BinaryFraction.queryChildReadWithWork inputs childWords input.1 input.2)              (fun (input : Fin M × OAI.EditApproximation.TargetInterval ny) =>                OAI.EditApproximation.BinaryFraction.queryChildReadAllocation inputs childWords input.1 input.2)              q)def queryPhysicalEarlierReadFootprint    {M J n : ℕ}    (copies pass copy T S t : ℕ)    (node : OAI.EditApproximation.PhysicalNode M J)    (hbelow : ↑node.fst < J)    (q : OAI.EditApproximation.TargetInterval n)    (input : Fin M × ℕ × OAI.EditApproximation.TargetInterval n) : (OAI.EditApproximation.queryPhysicalEarlierRead copies pass copy T S t node hbelow q input).Footprint := by  have proof_combinedRank_lt_of_progress_80 {M : ℕ} {J : ℕ} {ny : ℕ} (T : ℕ) (S : ℕ) (first : OAI.EditApproximation.PhysicalTableRequest M J ny) (second : OAI.EditApproximation.PhysicalTableRequest M J ny) (hprogress : LT.lt.{0} second.remainingDepth first.remainingDepth ∧      LE.le.{0} (OAI.EditApproximation.PhysicalTableRequest.rank T S second)        (OAI.EditApproximation.PhysicalTableRequest.rank T S first) ∨    LE.le.{0} second.remainingDepth first.remainingDepth ∧      LT.lt.{0} (OAI.EditApproximation.PhysicalTableRequest.rank T S second)        (OAI.EditApproximation.PhysicalTableRequest.rank T S first)) :      OAI.EditApproximation.PhysicalTableRequest.combinedRank T S second < OAI.EditApproximation.PhysicalTableRequest.combinedRank T S first := by    unfold OAI.EditApproximation.PhysicalTableRequest.combinedRank    rcases hprogress with h | h    · exact Nat.add_lt_add_of_lt_of_le h.1 h.2    · exact Nat.add_lt_add_of_le_of_lt h.1 h.2  have proof_refinement_history_child_progress_96 {M : ℕ} {J : ℕ} {ny : ℕ} (pass : ℕ) (copy : ℕ) (T : ℕ) (S : ℕ) (t : ℕ) (s : ℕ) (node : OAI.EditApproximation.PhysicalNode M J) (hbelow : LT.lt.{0} (↑(Sigma.fst.{0, 0} node)) J) (i : Fin M) (state : OAI.EditApproximation.TargetInterval ny) (previousState : OAI.EditApproximation.TargetInterval ny) (hs : LT.lt.{0} s t) :      (OAI.EditApproximation.PhysicalTableRequest.refinement pass copy (OAI.EditApproximation.physicalChild node hbelow i) T s previousState).remainingDepth <          (OAI.EditApproximation.PhysicalTableRequest.refinement pass copy node T t state).remainingDepth ∧        OAI.EditApproximation.PhysicalTableRequest.rank T S (OAI.EditApproximation.PhysicalTableRequest.refinement pass copy (OAI.EditApproximation.physicalChild node hbelow i) T s previousState) <          OAI.EditApproximation.PhysicalTableRequest.rank T S (OAI.EditApproximation.PhysicalTableRequest.refinement pass copy node T t state) := by    constructor    · unfold OAI.EditApproximation.PhysicalTableRequest.remainingDepth OAI.EditApproximation.PhysicalTableRequest.refinement OAI.EditApproximation.physicalChild      dsimp only      omega    · dsimp only [OAI.EditApproximation.PhysicalTableRequest.rank, OAI.EditApproximation.PhysicalTableRequest.refinement]      omega  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_bitOrdering_matches_4 (high : Ordering) (a : Bool) (b : Bool) (x : ℕ) (y : ℕ) (h : OAI.EditApproximation.orderingMatches high x y) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitOrdering high a b) (a.toNat + 2 * x) (b.toNat + 2 * y) := by    rcases h with ⟨rfl, h⟩ | ⟨rfl, rfl⟩ | ⟨rfl, h⟩    · exact Or.inl ⟨rfl, by cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩    · cases a <;> cases b <;> simp [OAI.EditApproximation.bitOrdering, OAI.EditApproximation.orderingMatches]    · exact Or.inr (Or.inr ⟨rfl, by        cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩)  have proof_bitCompareWithWork_matches_5 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitCompareWithWork left right).1 (OAI.EditApproximation.bitWordValue left) (OAI.EditApproximation.bitWordValue right) := by    induction left generalizing right with    | nil =>      simp only [OAI.EditApproximation.bitCompareWithWork]      induction right with      | nil => (simp [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.orderingMatches, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        simpa only [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareNilLeftWithWork bs).1 false b 0 (OAI.EditApproximation.bitWordValue bs) ih    | cons a as ih =>      cases right with      | nil =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as []).1 a false (OAI.EditApproximation.bitWordValue as) 0 (ih [])      | cons b bs =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue] using          proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as bs).1 a b (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs) (ih bs)  have proof_bitCompareWithWork_lt_16 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .lt ↔ OAI.EditApproximation.bitWordValue left < OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_binaryNaturalCompareWithWork_lt_53 (a : ℕ) (b : ℕ) :      (OAI.EditApproximation.binaryNaturalCompareWithWork a b).1 = .lt ↔ a < b := by    simpa only [OAI.EditApproximation.binaryNaturalCompareWithWork, proof_bitWordValue_bits_15] using proof_bitCompareWithWork_lt_16 a.bits b.bits  refine OAI.EditApproximation.BitQuery.Footprint.chargeOf (input.2.1.bits.length + t.bits.length) ?_  split  · exact OAI.EditApproximation.queryPhysicalTableReadFootprint copies T S _ _  · exact .done _end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen BitQueryattribute [local instance] queryArityNeZero queryRoundsNeZeroopen Finsetdef queryPhysicalScalarOnlineReadFootprint    (M J N n exponent F Q R B : ℕ)    (node : OAI.EditApproximation.PhysicalInternalNode M J)    (time : Fin R)    (key : ℕ × OAI.EditApproximation.TargetInterval n)    (range : ℕ) : (OAI.EditApproximation.queryPhysicalScalarOnlineRead M J N n exponent F Q R B node time key range).Footprint := by  have proof_log_two_add_one_eq_size_103 (N : ℕ) (hN : LT.lt.{0} 0 N) :      Nat.log 2 N + 1 = Nat.size N := by    apply Nat.le_antisymm    · have h := Nat.pow_log_le_self 2 hN.ne'      have hlt : Nat.log 2 N < Nat.size N := Nat.lt_size.mpr h      omega    · exact Nat.size_le.mpr (Nat.lt_pow_succ_log_self (by decide : 1 < 2) N)  have proof_powerTwoWord_value_13 (n : ℕ) : OAI.EditApproximation.bitWordValue (OAI.EditApproximation.powerTwoWord n) = 2 ^ n := by    induction n with    | zero => (simp [OAI.EditApproximation.powerTwoWord, OAI.EditApproximation.bitWordValue])    | succ n ih =>      (simp only [OAI.EditApproximation.powerTwoWord, List.replicate_succ, List.cons_append, OAI.EditApproximation.bitWordValue,        Bool.toNat_false, zero_add] at *)      rw [ih, pow_succ]      omega  have proof_arithmeticMapWithWork_value_70 {α : Type 0} {β : Type 0} (f : α → Prod.{0, 0} β ℕ) (values : List.{0} α) :      (OAI.EditApproximation.arithmeticMapWithWork f values).1 = values.map (fun a => (f a).1) := by    induction values with    | nil => rfl    | cons a rest ih => simp only [OAI.EditApproximation.arithmeticMapWithWork, ih, List.map_cons]  have proof_dyadicScalesWithWork_value_104 (N : ℕ) :      (OAI.EditApproximation.dyadicScalesWithWork N).1 = OAI.EditApproximation.dyadicScales N := by    have hcount : max 1 N.bits.length = Nat.log 2 N + 1 := by      by_cases hz : N = 0      · subst N        decide      · have h := proof_log_two_add_one_eq_size_103 N (Nat.pos_of_ne_zero hz)        have hp := Nat.size_pos.mpr (Nat.pos_of_ne_zero hz)        rw [Nat.size_eq_bits_len, max_eq_right hp, h]    simp only [OAI.EditApproximation.dyadicScalesWithWork, proof_arithmeticMapWithWork_value_70, proof_powerTwoWord_value_13, hcount,      OAI.EditApproximation.dyadicScales]  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_bitOrdering_matches_4 (high : Ordering) (a : Bool) (b : Bool) (x : ℕ) (y : ℕ) (h : OAI.EditApproximation.orderingMatches high x y) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitOrdering high a b) (a.toNat + 2 * x) (b.toNat + 2 * y) := by    rcases h with ⟨rfl, h⟩ | ⟨rfl, rfl⟩ | ⟨rfl, h⟩    · exact Or.inl ⟨rfl, by cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩    · cases a <;> cases b <;> simp [OAI.EditApproximation.bitOrdering, OAI.EditApproximation.orderingMatches]    · exact Or.inr (Or.inr ⟨rfl, by        cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩)  have proof_bitCompareWithWork_matches_5 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitCompareWithWork left right).1 (OAI.EditApproximation.bitWordValue left) (OAI.EditApproximation.bitWordValue right) := by    induction left generalizing right with    | nil =>      simp only [OAI.EditApproximation.bitCompareWithWork]      induction right with      | nil => (simp [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.orderingMatches, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        simpa only [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareNilLeftWithWork bs).1 false b 0 (OAI.EditApproximation.bitWordValue bs) ih    | cons a as ih =>      cases right with      | nil =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as []).1 a false (OAI.EditApproximation.bitWordValue as) 0 (ih [])      | cons b bs =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue] using          proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as bs).1 a b (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs) (ih bs)  have proof_bitCompareWithWork_eq_3 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .eq ↔ OAI.EditApproximation.bitWordValue left = OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_binaryNaturalCompareWithWork_eq_73 (a : ℕ) (b : ℕ) :      (OAI.EditApproximation.binaryNaturalCompareWithWork a b).1 = .eq ↔ a = b := by    simpa only [OAI.EditApproximation.binaryNaturalCompareWithWork, proof_bitWordValue_bits_15] using proof_bitCompareWithWork_eq_3 a.bits b.bits  have proof_naturalEqualWithWork_value_74 (a : ℕ) (b : ℕ) :      (OAI.EditApproximation.naturalEqualWithWork a b).1 = true ↔ a = b := by    simp only [OAI.EditApproximation.naturalEqualWithWork, decide_eq_true_eq, proof_binaryNaturalCompareWithWork_eq_73]  have proof_queryNaturalIndexWithWork_value_105 (a : ℕ) (xs : List.{0} ℕ) :      (OAI.EditApproximation.queryNaturalIndexWithWork a xs).1 = xs.idxOf a := by    induction xs with    | nil => rfl    | cons b xs ih =>      simp only [OAI.EditApproximation.queryNaturalIndexWithWork]      by_cases hab : a = b      · subst b        rw [ite_eq_left ((proof_naturalEqualWithWork_value_74 a a).mpr rfl)]        simp      · rw [ite_eq_right (fun h => hab ((proof_naturalEqualWithWork_value_74 a b).mp h))]        simp only [ih, List.idxOf_cons, beq_iff_eq]        rw [ite_eq_right (Ne.symm hab)]  have proof_queryScaleDispatchWithWork_value_106 (N : ℕ) (b : ℕ) :      (OAI.EditApproximation.queryScaleDispatchWithWork N b).1 = (OAI.EditApproximation.dyadicScales N).idxOf b := by    simp only [OAI.EditApproximation.queryScaleDispatchWithWork, proof_queryNaturalIndexWithWork_value_105, proof_dyadicScalesWithWork_value_104]  have proof_bitCompareWithWork_lt_16 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .lt ↔ OAI.EditApproximation.bitWordValue left < OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_binaryNaturalCompareWithWork_lt_53 (a : ℕ) (b : ℕ) :      (OAI.EditApproximation.binaryNaturalCompareWithWork a b).1 = .lt ↔ a < b := by    simpa only [OAI.EditApproximation.binaryNaturalCompareWithWork, proof_bitWordValue_bits_15] using proof_bitCompareWithWork_lt_16 a.bits b.bits  have proof_queryScalePresentWithWork_value_101 (N : ℕ) (b : ℕ) :      (OAI.EditApproximation.queryScalePresentWithWork N b).1 = true ↔ b ∈ OAI.EditApproximation.dyadicScales N := by    simp only [OAI.EditApproximation.queryScalePresentWithWork, decide_eq_true_eq, proof_binaryNaturalCompareWithWork_lt_53,      proof_queryScaleDispatchWithWork_value_106]    have hl : (OAI.EditApproximation.dyadicScales N).length = max 1 N.bits.length := by      rw [← proof_dyadicScalesWithWork_value_104 N]      (simp only [OAI.EditApproximation.dyadicScalesWithWork, proof_arithmeticMapWithWork_value_70, List.length_map, List.length_range])    rw [← hl]    exact List.idxOf_lt_length_iff  have proof_wordLEWithWork_value_26 (a : List.{0} Bool) (b : List.{0} Bool) :      (OAI.EditApproximation.wordLEWithWork a b).1 = true ↔ OAI.EditApproximation.bitWordValue a ≤ OAI.EditApproximation.bitWordValue b := by    simp only [OAI.EditApproximation.wordLEWithWork, Bool.not_eq_true', decide_eq_false_iff_not,      proof_bitCompareWithWork_lt_16, not_lt]  have proof_queryRangeValidWithWork_value_107 (B : ℕ) (range : ℕ) :      (OAI.EditApproximation.queryRangeValidWithWork B range).1 = true ↔ 0 < range ∧ range ≤ B := by    simp only [OAI.EditApproximation.queryRangeValidWithWork, Bool.and_eq_true, decide_eq_true_eq,      proof_binaryNaturalCompareWithWork_lt_53, proof_wordLEWithWork_value_26, proof_bitWordValue_bits_15]  refine OAI.EditApproximation.BitQuery.Footprint.chargeOf    (OAI.EditApproximation.queryScalePresentAllocation N key.1 + OAI.EditApproximation.queryRangeValidAllocation B range) ?_  split  · split    · exact OAI.EditApproximation.queryPhysicalScalarReadFootprint M J N n exponent F Q R B _    · exact .done _  · exact .done _def queryChargedSeedAtFootprint    {M J n passes copies T S : ℕ}    (parent : { r : OAI.EditApproximation.PhysicalTableRequest M J n //  OAI.EditApproximation.PhysicalTableRequest.Bounded passes copies T S r })    (N : ℕ)    (multiplier : ℕ → ℕ)    (q : OAI.EditApproximation.TargetInterval n) : (OAI.EditApproximation.queryChargedSeedAt parent N multiplier q).Footprint := by  have proof_coarse_rank_lt_100 {M : ℕ} {J : ℕ} {ny : ℕ} {passes : ℕ} {copies : ℕ} {T : ℕ} {S : ℕ} (entry : OAI.EditApproximation.PhysicalEntry M J ny) (request : Subtype.{1} fun request => OAI.EditApproximation.PhysicalTableRequest.Bounded (M := M) (J := J) (ny := ny) passes copies T S request) (hnode : Eq.{1} entry.1 request.val.node) :      OAI.EditApproximation.ChargedPhysicalRequest.rank (Sum.inl entry : OAI.EditApproximation.ChargedPhysicalRequest M J ny passes copies T S) < OAI.EditApproximation.ChargedPhysicalRequest.rank (Sum.inr request) := by    change J - entry.1.1.val + 0 < request.val.remainingDepth + (request.val.rank T S + 1)    rw [hnode]    unfold OAI.EditApproximation.PhysicalTableRequest.remainingDepth    omega  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_bitOrdering_matches_4 (high : Ordering) (a : Bool) (b : Bool) (x : ℕ) (y : ℕ) (h : OAI.EditApproximation.orderingMatches high x y) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitOrdering high a b) (a.toNat + 2 * x) (b.toNat + 2 * y) := by    rcases h with ⟨rfl, h⟩ | ⟨rfl, rfl⟩ | ⟨rfl, h⟩    · exact Or.inl ⟨rfl, by cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩    · cases a <;> cases b <;> simp [OAI.EditApproximation.bitOrdering, OAI.EditApproximation.orderingMatches]    · exact Or.inr (Or.inr ⟨rfl, by        cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩)  have proof_bitCompareWithWork_matches_5 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitCompareWithWork left right).1 (OAI.EditApproximation.bitWordValue left) (OAI.EditApproximation.bitWordValue right) := by    induction left generalizing right with    | nil =>      simp only [OAI.EditApproximation.bitCompareWithWork]      induction right with      | nil => (simp [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.orderingMatches, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        simpa only [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareNilLeftWithWork bs).1 false b 0 (OAI.EditApproximation.bitWordValue bs) ih    | cons a as ih =>      cases right with      | nil =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as []).1 a false (OAI.EditApproximation.bitWordValue as) 0 (ih [])      | cons b bs =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue] using          proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as bs).1 a b (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs) (ih bs)  have proof_bitCompareWithWork_eq_3 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .eq ↔ OAI.EditApproximation.bitWordValue left = OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_binaryNaturalCompareWithWork_eq_73 (a : ℕ) (b : ℕ) :      (OAI.EditApproximation.binaryNaturalCompareWithWork a b).1 = .eq ↔ a = b := by    simpa only [OAI.EditApproximation.binaryNaturalCompareWithWork, proof_bitWordValue_bits_15] using proof_bitCompareWithWork_eq_3 a.bits b.bits  have proof_naturalEqualWithWork_value_74 (a : ℕ) (b : ℕ) :      (OAI.EditApproximation.naturalEqualWithWork a b).1 = true ↔ a = b := by    simp only [OAI.EditApproximation.naturalEqualWithWork, decide_eq_true_eq, proof_binaryNaturalCompareWithWork_eq_73]  have proof_table_rank_lt_99 {M : ℕ} {J : ℕ} {ny : ℕ} {passes : ℕ} {copies : ℕ} {T : ℕ} {S : ℕ} (parent : Subtype.{1} fun request => OAI.EditApproximation.PhysicalTableRequest.Bounded (M := M) (J := J) (ny := ny) passes copies T S request) (child : Subtype.{1} fun request => OAI.EditApproximation.PhysicalTableRequest.Bounded (M := M) (J := J) (ny := ny) passes copies T S request) (h : LT.lt.{0} (OAI.EditApproximation.PhysicalTableRequest.combinedRank T S child.val)    (OAI.EditApproximation.PhysicalTableRequest.combinedRank T S parent.val)) :      OAI.EditApproximation.ChargedPhysicalRequest.rank (Sum.inr child : OAI.EditApproximation.ChargedPhysicalRequest M J ny passes copies T S) < OAI.EditApproximation.ChargedPhysicalRequest.rank (Sum.inr parent) := by    simpa only [OAI.EditApproximation.ChargedPhysicalRequest.rank, OAI.EditApproximation.ChargedPhysicalRequest.depth, OAI.EditApproximation.ChargedPhysicalRequest.index, ← Nat.add_assoc, OAI.EditApproximation.PhysicalTableRequest.combinedRank] using      Nat.add_lt_add_right h 1  have proof_combinedRank_lt_of_progress_80 {M : ℕ} {J : ℕ} {ny : ℕ} (T : ℕ) (S : ℕ) (first : OAI.EditApproximation.PhysicalTableRequest M J ny) (second : OAI.EditApproximation.PhysicalTableRequest M J ny) (hprogress : LT.lt.{0} second.remainingDepth first.remainingDepth ∧      LE.le.{0} (OAI.EditApproximation.PhysicalTableRequest.rank T S second)        (OAI.EditApproximation.PhysicalTableRequest.rank T S first) ∨    LE.le.{0} second.remainingDepth first.remainingDepth ∧      LT.lt.{0} (OAI.EditApproximation.PhysicalTableRequest.rank T S second)        (OAI.EditApproximation.PhysicalTableRequest.rank T S first)) :      OAI.EditApproximation.PhysicalTableRequest.combinedRank T S second < OAI.EditApproximation.PhysicalTableRequest.combinedRank T S first := by    unfold OAI.EditApproximation.PhysicalTableRequest.combinedRank    rcases hprogress with h | h    · exact Nat.add_lt_add_of_lt_of_le h.1 h.2    · exact Nat.add_lt_add_of_le_of_lt h.1 h.2  have proof_rank_lt_previous_pass_98 {M : ℕ} {J : ℕ} {ny : ℕ} (T : ℕ) (S : ℕ) (first : OAI.EditApproximation.PhysicalTableRequest M J ny) (second : OAI.EditApproximation.PhysicalTableRequest M J ny) (hpass : LT.lt.{0} second.pass first.pass) (hindex : LE.le.{0} second.index (HAdd.hAdd.{0, 0, 0} T S)) :      OAI.EditApproximation.PhysicalTableRequest.rank T S second < OAI.EditApproximation.PhysicalTableRequest.rank T S first := by    have hblock : second.pass * (T + S + 1) + second.index <        (second.pass + 1) * (T + S + 1) := by      nlinarith only [hindex]    have hnext := Nat.mul_le_mul_right (T + S + 1) (Nat.succ_le_of_lt hpass)    exact hblock.trans_le (hnext.trans (Nat.le_add_right _ _))  have proof_previousPassRequest_progress_97 {M : ℕ} {J : ℕ} {ny : ℕ} (T : ℕ) (S : ℕ) (copy : ℕ) (parent : OAI.EditApproximation.PhysicalTableRequest M J ny) (hpass : LT.lt.{0} 0 parent.pass) (state : OAI.EditApproximation.TargetInterval ny) :      (OAI.EditApproximation.previousPassRequest T S copy parent state).remainingDepth = parent.remainingDepth ∧        (OAI.EditApproximation.previousPassRequest T S copy parent state).rank T S < parent.rank T S := by    refine ⟨rfl, ?_⟩    exact proof_rank_lt_previous_pass_98 T S parent _ (by      change parent.pass - 1 < parent.pass      omega) le_rfl  refine OAI.EditApproximation.BitQuery.Footprint.chargeOf (OAI.EditApproximation.naturalEqualAllocation parent.val.pass 0) ?_  split  · exact OAI.EditApproximation.queryChargedReadFootprint parent _  · refine OAI.EditApproximation.BitQuery.Footprint.chargeOf copies ?_    refine OAI.EditApproximation.BitQuery.Footprint.collect _ (fun _ => OAI.EditApproximation.queryChargedReadFootprint parent _) _ _ fun words => ?_    let factor := multiplier (parent.val.pass - 1)    exact OAI.EditApproximation.BitQuery.Footprint.computeOf (OAI.EditApproximation.BinaryFraction.querySeedMedianWithWork N factor words)      (OAI.EditApproximation.BinaryFraction.seedMedianAllocation N factor words +        (OAI.EditApproximation.BinaryFraction.seedMedianWithWork N factor words).1.length + 1)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen BitQueryattribute [local instance] queryArityNeZero queryRoundsNeZerodef queryFamilyOnlineReadFootprint    {α : Type u_1}    {M J R : ℕ}    (target : List α)    (N P F exponent H Q passes copies pass copy : ℕ)    (node : OAI.EditApproximation.PhysicalInternalNode M J)    (time : Fin R)    (key : ℕ × OAI.EditApproximation.TargetInterval target.length)    (range : ℕ) : (OAI.EditApproximation.queryFamilyOnlineRead target N P F exponent H Q passes copies pass copy node time key    range).Footprint :=OAI.EditApproximation.BitQuery.Footprint.mapKeysWithWork  (OAI.EditApproximation.queryFamilyTagWithWork target N P F exponent H Q passes copies pass copy)  (OAI.EditApproximation.queryFamilyTagAllocation target N P F exponent H Q passes copies pass copy)  (OAI.EditApproximation.queryPhysicalScalarOnlineReadFootprint M J N target.length exponent F Q R    (OAI.EditApproximation.localOnlineMassBound M P H) node time key range)def queryPhysicalInitialFootprint    (source target : List ℕ)    {M J passes copies T S : ℕ}    (N P F : ℕ)    (A a : OAI.EditApproximation.BinaryFraction)    (multiplier : ℕ → ℕ)    (parent : { r : OAI.EditApproximation.PhysicalTableRequest M J target.length //  OAI.EditApproximation.PhysicalTableRequest.Bounded passes copies T S r })    (occurrence : OAI.EditApproximation.BinaryMemo OAI.EditApproximation.PositionCounts)    (symbolBits positionBits : ℕ)    (q : OAI.EditApproximation.TargetInterval target.length) : (OAI.EditApproximation.queryPhysicalInitial source target N P F A a multiplier parent occurrence symbolBits positionBits    q).Footprint := by  let interval := OAI.EditApproximation.physicalSourceInterval source.length parent.val.node  refine OAI.EditApproximation.BitQuery.Footprint.chargeOf (OAI.EditApproximation.saturatingSubtractAllocation interval.hi interval.lo +    OAI.EditApproximation.naturalWordLEAllocation (OAI.EditApproximation.saturatingSubtractWithWork interval.hi interval.lo).1 [true]) ?_  split  · exact OAI.EditApproximation.BitQuery.Footprint.computeOf _      (OAI.EditApproximation.queryIndexedSliceAllocation source interval target.length q occurrence symbolBits positionBits)  · exact OAI.EditApproximation.queryInitialConeProgramAtFootprint _ N P F A a (OAI.EditApproximation.queryChargedSeedAt parent N multiplier) q      (OAI.EditApproximation.queryChargedSeedAtFootprint parent N multiplier)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen BitQueryattribute [local instance] queryArityNeZero queryRoundsNeZeroopen Finsetopen MeasureTheory ProbabilityTheorydef queryPhysicalScalarGroupQueriesFootprint (M J N n exponent F Q R B : ℕ)    (node : OAI.EditApproximation.PhysicalInternalNode M J) (time : Fin R) (b : ℕ) (cell : ℕ × ℕ) :    ∀ s j, OAI.EditApproximation.BitQuery.Footprint      (OAI.EditApproximation.queryPhysicalScalarGroupQueries M J N n exponent F Q R B node time b cell s j) := by  have proof_log_two_add_one_eq_size_103 (N : ℕ) (hN : LT.lt.{0} 0 N) :      Nat.log 2 N + 1 = Nat.size N := by    apply Nat.le_antisymm    · have h := Nat.pow_log_le_self 2 hN.ne'      have hlt : Nat.log 2 N < Nat.size N := Nat.lt_size.mpr h      omega    · exact Nat.size_le.mpr (Nat.lt_pow_succ_log_self (by decide : 1 < 2) N)  have proof_powerTwoWord_value_13 (n : ℕ) : OAI.EditApproximation.bitWordValue (OAI.EditApproximation.powerTwoWord n) = 2 ^ n := by    induction n with    | zero => (simp [OAI.EditApproximation.powerTwoWord, OAI.EditApproximation.bitWordValue])    | succ n ih =>      (simp only [OAI.EditApproximation.powerTwoWord, List.replicate_succ, List.cons_append, OAI.EditApproximation.bitWordValue,        Bool.toNat_false, zero_add] at *)      rw [ih, pow_succ]      omega  have proof_arithmeticMapWithWork_value_70 {α : Type 0} {β : Type 0} (f : α → Prod.{0, 0} β ℕ) (values : List.{0} α) :      (OAI.EditApproximation.arithmeticMapWithWork f values).1 = values.map (fun a => (f a).1) := by    induction values with    | nil => rfl    | cons a rest ih => simp only [OAI.EditApproximation.arithmeticMapWithWork, ih, List.map_cons]  have proof_dyadicScalesWithWork_value_104 (N : ℕ) :      (OAI.EditApproximation.dyadicScalesWithWork N).1 = OAI.EditApproximation.dyadicScales N := by    have hcount : max 1 N.bits.length = Nat.log 2 N + 1 := by      by_cases hz : N = 0      · subst N        decide      · have h := proof_log_two_add_one_eq_size_103 N (Nat.pos_of_ne_zero hz)        have hp := Nat.size_pos.mpr (Nat.pos_of_ne_zero hz)        rw [Nat.size_eq_bits_len, max_eq_right hp, h]    simp only [OAI.EditApproximation.dyadicScalesWithWork, proof_arithmeticMapWithWork_value_70, proof_powerTwoWord_value_13, hcount,      OAI.EditApproximation.dyadicScales]  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_bitOrdering_matches_4 (high : Ordering) (a : Bool) (b : Bool) (x : ℕ) (y : ℕ) (h : OAI.EditApproximation.orderingMatches high x y) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitOrdering high a b) (a.toNat + 2 * x) (b.toNat + 2 * y) := by    rcases h with ⟨rfl, h⟩ | ⟨rfl, rfl⟩ | ⟨rfl, h⟩    · exact Or.inl ⟨rfl, by cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩    · cases a <;> cases b <;> simp [OAI.EditApproximation.bitOrdering, OAI.EditApproximation.orderingMatches]    · exact Or.inr (Or.inr ⟨rfl, by        cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩)  have proof_bitCompareWithWork_matches_5 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitCompareWithWork left right).1 (OAI.EditApproximation.bitWordValue left) (OAI.EditApproximation.bitWordValue right) := by    induction left generalizing right with    | nil =>      simp only [OAI.EditApproximation.bitCompareWithWork]      induction right with      | nil => (simp [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.orderingMatches, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        simpa only [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareNilLeftWithWork bs).1 false b 0 (OAI.EditApproximation.bitWordValue bs) ih    | cons a as ih =>      cases right with      | nil =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as []).1 a false (OAI.EditApproximation.bitWordValue as) 0 (ih [])      | cons b bs =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue] using          proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as bs).1 a b (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs) (ih bs)  have proof_bitCompareWithWork_eq_3 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .eq ↔ OAI.EditApproximation.bitWordValue left = OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_binaryNaturalCompareWithWork_eq_73 (a : ℕ) (b : ℕ) :      (OAI.EditApproximation.binaryNaturalCompareWithWork a b).1 = .eq ↔ a = b := by    simpa only [OAI.EditApproximation.binaryNaturalCompareWithWork, proof_bitWordValue_bits_15] using proof_bitCompareWithWork_eq_3 a.bits b.bits  have proof_naturalEqualWithWork_value_74 (a : ℕ) (b : ℕ) :      (OAI.EditApproximation.naturalEqualWithWork a b).1 = true ↔ a = b := by    simp only [OAI.EditApproximation.naturalEqualWithWork, decide_eq_true_eq, proof_binaryNaturalCompareWithWork_eq_73]  have proof_queryNaturalIndexWithWork_value_105 (a : ℕ) (xs : List.{0} ℕ) :      (OAI.EditApproximation.queryNaturalIndexWithWork a xs).1 = xs.idxOf a := by    induction xs with    | nil => rfl    | cons b xs ih =>      simp only [OAI.EditApproximation.queryNaturalIndexWithWork]      by_cases hab : a = b      · subst b        rw [ite_eq_left ((proof_naturalEqualWithWork_value_74 a a).mpr rfl)]        simp      · rw [ite_eq_right (fun h => hab ((proof_naturalEqualWithWork_value_74 a b).mp h))]        simp only [ih, List.idxOf_cons, beq_iff_eq]        rw [ite_eq_right (Ne.symm hab)]  have proof_queryScaleDispatchWithWork_value_106 (N : ℕ) (b : ℕ) :      (OAI.EditApproximation.queryScaleDispatchWithWork N b).1 = (OAI.EditApproximation.dyadicScales N).idxOf b := by    simp only [OAI.EditApproximation.queryScaleDispatchWithWork, proof_queryNaturalIndexWithWork_value_105, proof_dyadicScalesWithWork_value_104]  have proof_bitCompareWithWork_lt_16 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .lt ↔ OAI.EditApproximation.bitWordValue left < OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_binaryNaturalCompareWithWork_lt_53 (a : ℕ) (b : ℕ) :      (OAI.EditApproximation.binaryNaturalCompareWithWork a b).1 = .lt ↔ a < b := by    simpa only [OAI.EditApproximation.binaryNaturalCompareWithWork, proof_bitWordValue_bits_15] using proof_bitCompareWithWork_lt_16 a.bits b.bits  have proof_queryScalePresentWithWork_value_101 (N : ℕ) (b : ℕ) :      (OAI.EditApproximation.queryScalePresentWithWork N b).1 = true ↔ b ∈ OAI.EditApproximation.dyadicScales N := by    simp only [OAI.EditApproximation.queryScalePresentWithWork, decide_eq_true_eq, proof_binaryNaturalCompareWithWork_lt_53,      proof_queryScaleDispatchWithWork_value_106]    have hl : (OAI.EditApproximation.dyadicScales N).length = max 1 N.bits.length := by      rw [← proof_dyadicScalesWithWork_value_104 N]      (simp only [OAI.EditApproximation.dyadicScalesWithWork, proof_arithmeticMapWithWork_value_70, List.length_map, List.length_range])    rw [← hl]    exact List.idxOf_lt_length_iff  have proof_wordLEWithWork_value_26 (a : List.{0} Bool) (b : List.{0} Bool) :      (OAI.EditApproximation.wordLEWithWork a b).1 = true ↔ OAI.EditApproximation.bitWordValue a ≤ OAI.EditApproximation.bitWordValue b := by    simp only [OAI.EditApproximation.wordLEWithWork, Bool.not_eq_true', decide_eq_false_iff_not,      proof_bitCompareWithWork_lt_16, not_lt]  have proof_bitAdder_value_1 (a : Bool) (b : Bool) (carry : Bool) :      (OAI.EditApproximation.bitSum a b carry).toNat + 2 * (OAI.EditApproximation.bitCarry a b carry).toNat =        a.toNat + b.toNat + carry.toNat := by    cases a <;> cases b <;> cases carry <;> decide  have proof_bitAddWithWork_value_2 (left : List.{0} Bool) (right : List.{0} Bool) (carry : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitAddWithWork left right carry).1 =        OAI.EditApproximation.bitWordValue left + OAI.EditApproximation.bitWordValue right + carry.toNat := by    induction left generalizing right carry with    | nil =>      simp only [OAI.EditApproximation.bitAddWithWork]      induction right generalizing carry with      | nil => cases carry <;> simp [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue]      | cons b bs ih =>        simp only [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 false b carry        simp only [Bool.toNat_false] at h        omega    | cons a as ih =>      cases right with      | nil =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a false carry        simp only [Bool.toNat_false] at h        omega      | cons b bs =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a b carry        omega  have proof_bitMulWithWork_value_0 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitMulWithWork left right).1 = OAI.EditApproximation.bitWordValue left * OAI.EditApproximation.bitWordValue right := by    induction left with    | nil => simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue]    | cons bit bits ih =>      cases bit <;> simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue, proof_bitAddWithWork_value_2, ih] <;> ring  have proof_binaryNaturalMulWithWork_value_55 (a : ℕ) (b : ℕ) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalMulWithWork a b).1 = a * b := by    simp [OAI.EditApproximation.binaryNaturalMulWithWork, proof_bitMulWithWork_value_0, proof_bitWordValue_bits_15]  have proof_queryCellValidWithWork_value_102 (n : ℕ) (exponent : ℕ) (cell : Prod.{0, 0} ℕ ℕ) :      (OAI.EditApproximation.queryCellValidWithWork n exponent cell).1 = true ↔        cell.1 ≤ n * 2 ^ exponent ∧ cell.2 ≤ n * 2 ^ exponent := by    simp only [OAI.EditApproximation.queryCellValidWithWork, Bool.and_eq_true, proof_wordLEWithWork_value_26, proof_bitWordValue_bits_15,      proof_binaryNaturalMulWithWork_value_55, proof_powerTwoWord_value_13]  have proof_physicalScaleIndex_get_93 (N : ℕ) (b : ℕ) (hb : Membership.mem.{0, 0} (OAI.EditApproximation.dyadicScales N) b) :      (OAI.EditApproximation.dyadicScales N).get (OAI.EditApproximation.physicalScaleIndex N b hb) = b :=    List.getElem_idxOf (List.idxOf_lt_length_of_mem hb)  have groupTransport (b c : ℕ) (h : b = c)      (actual : OAI.EditApproximation.BitPhysicalGroupQueries M J N n exponent F Q R B b)      (heap : ∀ s j, OAI.EditApproximation.BitQuery.Footprint (actual s j)) :      ∀ s j, OAI.EditApproximation.BitQuery.Footprint        ((Eq.mp (congrArg (OAI.EditApproximation.BitPhysicalGroupQueries M J N n exponent F Q R B) h) actual) s j) := by    cases h    exact heap  intro s j  unfold OAI.EditApproximation.queryPhysicalScalarGroupQueries  split  · rename_i hb    split    · exact groupTransport _ _        (proof_physicalScaleIndex_get_93 N b ((proof_queryScalePresentWithWork_value_101 N b).mp hb)) _        (fun _ _ => OAI.EditApproximation.queryPhysicalScalarReadFootprint M J N n exponent F Q R B _) s j    · exact .done _  · exact .done _end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen BitQueryattribute [local instance] queryArityNeZero queryRoundsNeZerodef queryPhysicalScalarGroupReadFootprint    (M J N n exponent F Q R B : ℕ)    (node : OAI.EditApproximation.PhysicalInternalNode M J)    (time : Fin R)    (key : OAI.EditApproximation.GroupScalarKey M F Q) : (OAI.EditApproximation.queryPhysicalScalarGroupRead M J N n exponent F Q R B node time key).Footprint :=OAI.EditApproximation.BitQuery.Footprint.chargeOf  (OAI.EditApproximation.queryScalePresentAllocation N key.fst.1 +    OAI.EditApproximation.queryCellValidAllocation n exponent key.fst.2)  (OAI.EditApproximation.queryPhysicalScalarGroupQueriesFootprint M J N n exponent F Q R B node time key.fst.1 key.fst.2    key.snd.fst key.snd.snd)def queryFamilyGroupReadFootprint    {α : Type u_1}    {M J R : ℕ}    (target : List α)    (N P F exponent H Q passes copies pass copy : ℕ)    (node : OAI.EditApproximation.PhysicalInternalNode M J)    (time : Fin R)    (key : OAI.EditApproximation.GroupScalarKey M F Q) : (OAI.EditApproximation.queryFamilyGroupRead target N P F exponent H Q passes copies pass copy node time key).Footprint :=OAI.EditApproximation.BitQuery.Footprint.mapKeysWithWork  (OAI.EditApproximation.queryFamilyTagWithWork target N P F exponent H Q passes copies pass copy)  (OAI.EditApproximation.queryFamilyTagAllocation target N P F exponent H Q passes copies pass copy)  (OAI.EditApproximation.queryPhysicalScalarGroupReadFootprint M J N target.length exponent F Q R    (OAI.EditApproximation.localOnlineMassBound M P H) node time key)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen BitQueryattribute [local instance] queryArityNeZero queryRoundsNeZeroopen Finsetdef queryChargedWarmupFootprint    (source target : List ℕ)    {M J passes copies T S : ℕ}    (N P F : ℕ)    (A a : OAI.EditApproximation.BinaryFraction)    (multiplier : ℕ → ℕ)    (parent : { r : OAI.EditApproximation.PhysicalTableRequest M J target.length //  OAI.EditApproximation.PhysicalTableRequest.Bounded passes copies T S r })    (occurrence : OAI.EditApproximation.BinaryMemo OAI.EditApproximation.PositionCounts)    (symbolBits positionBits : ℕ) : (OAI.EditApproximation.queryChargedWarmup source target N P F A a multiplier parent occurrence symbolBits    positionBits).Footprint := by  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_bitOrdering_matches_4 (high : Ordering) (a : Bool) (b : Bool) (x : ℕ) (y : ℕ) (h : OAI.EditApproximation.orderingMatches high x y) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitOrdering high a b) (a.toNat + 2 * x) (b.toNat + 2 * y) := by    rcases h with ⟨rfl, h⟩ | ⟨rfl, rfl⟩ | ⟨rfl, h⟩    · exact Or.inl ⟨rfl, by cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩    · cases a <;> cases b <;> simp [OAI.EditApproximation.bitOrdering, OAI.EditApproximation.orderingMatches]    · exact Or.inr (Or.inr ⟨rfl, by        cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩)  have proof_bitCompareWithWork_matches_5 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitCompareWithWork left right).1 (OAI.EditApproximation.bitWordValue left) (OAI.EditApproximation.bitWordValue right) := by    induction left generalizing right with    | nil =>      simp only [OAI.EditApproximation.bitCompareWithWork]      induction right with      | nil => (simp [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.orderingMatches, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        simpa only [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareNilLeftWithWork bs).1 false b 0 (OAI.EditApproximation.bitWordValue bs) ih    | cons a as ih =>      cases right with      | nil =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as []).1 a false (OAI.EditApproximation.bitWordValue as) 0 (ih [])      | cons b bs =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue] using          proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as bs).1 a b (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs) (ih bs)  have proof_bitCompareWithWork_lt_16 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .lt ↔ OAI.EditApproximation.bitWordValue left < OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_binaryNaturalCompareWithWork_lt_53 (a : ℕ) (b : ℕ) :      (OAI.EditApproximation.binaryNaturalCompareWithWork a b).1 = .lt ↔ a < b := by    simpa only [OAI.EditApproximation.binaryNaturalCompareWithWork, proof_bitWordValue_bits_15] using proof_bitCompareWithWork_lt_16 a.bits b.bits  have proof_bitCompareWithWork_eq_3 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .eq ↔ OAI.EditApproximation.bitWordValue left = OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_binaryNaturalCompareWithWork_eq_73 (a : ℕ) (b : ℕ) :      (OAI.EditApproximation.binaryNaturalCompareWithWork a b).1 = .eq ↔ a = b := by    simpa only [OAI.EditApproximation.binaryNaturalCompareWithWork, proof_bitWordValue_bits_15] using proof_bitCompareWithWork_eq_3 a.bits b.bits  have proof_naturalEqualWithWork_value_74 (a : ℕ) (b : ℕ) :      (OAI.EditApproximation.naturalEqualWithWork a b).1 = true ↔ a = b := by    simp only [OAI.EditApproximation.naturalEqualWithWork, decide_eq_true_eq, proof_binaryNaturalCompareWithWork_eq_73]  have proof_table_rank_lt_99 {M : ℕ} {J : ℕ} {ny : ℕ} {passes : ℕ} {copies : ℕ} {T : ℕ} {S : ℕ} (parent : Subtype.{1} fun request => OAI.EditApproximation.PhysicalTableRequest.Bounded (M := M) (J := J) (ny := ny) passes copies T S request) (child : Subtype.{1} fun request => OAI.EditApproximation.PhysicalTableRequest.Bounded (M := M) (J := J) (ny := ny) passes copies T S request) (h : LT.lt.{0} (OAI.EditApproximation.PhysicalTableRequest.combinedRank T S child.val)    (OAI.EditApproximation.PhysicalTableRequest.combinedRank T S parent.val)) :      OAI.EditApproximation.ChargedPhysicalRequest.rank (Sum.inr child : OAI.EditApproximation.ChargedPhysicalRequest M J ny passes copies T S) < OAI.EditApproximation.ChargedPhysicalRequest.rank (Sum.inr parent) := by    simpa only [OAI.EditApproximation.ChargedPhysicalRequest.rank, OAI.EditApproximation.ChargedPhysicalRequest.depth, OAI.EditApproximation.ChargedPhysicalRequest.index, ← Nat.add_assoc, OAI.EditApproximation.PhysicalTableRequest.combinedRank] using      Nat.add_lt_add_right h 1  have proof_combinedRank_lt_of_progress_80 {M : ℕ} {J : ℕ} {ny : ℕ} (T : ℕ) (S : ℕ) (first : OAI.EditApproximation.PhysicalTableRequest M J ny) (second : OAI.EditApproximation.PhysicalTableRequest M J ny) (hprogress : LT.lt.{0} second.remainingDepth first.remainingDepth ∧      LE.le.{0} (OAI.EditApproximation.PhysicalTableRequest.rank T S second)        (OAI.EditApproximation.PhysicalTableRequest.rank T S first) ∨    LE.le.{0} second.remainingDepth first.remainingDepth ∧      LT.lt.{0} (OAI.EditApproximation.PhysicalTableRequest.rank T S second)        (OAI.EditApproximation.PhysicalTableRequest.rank T S first)) :      OAI.EditApproximation.PhysicalTableRequest.combinedRank T S second < OAI.EditApproximation.PhysicalTableRequest.combinedRank T S first := by    unfold OAI.EditApproximation.PhysicalTableRequest.combinedRank    rcases hprogress with h | h    · exact Nat.add_lt_add_of_lt_of_le h.1 h.2    · exact Nat.add_lt_add_of_le_of_lt h.1 h.2  have proof_warmup_previous_child_progress_81 {M : ℕ} {J : ℕ} {ny : ℕ} (pass : ℕ) (copy : ℕ) (T : ℕ) (S : ℕ) (j : ℕ) (node : OAI.EditApproximation.PhysicalNode M J) (hbelow : LT.lt.{0} (↑(Sigma.fst.{0, 0} node)) J) (i : Fin M) (state : OAI.EditApproximation.TargetInterval ny) (previousState : OAI.EditApproximation.TargetInterval ny) (hj : LT.lt.{0} 0 j) :      (OAI.EditApproximation.PhysicalTableRequest.warmup pass copy (OAI.EditApproximation.physicalChild node hbelow i) (j - 1) previousState).remainingDepth <          (OAI.EditApproximation.PhysicalTableRequest.warmup pass copy node j state).remainingDepth ∧        OAI.EditApproximation.PhysicalTableRequest.rank T S (OAI.EditApproximation.PhysicalTableRequest.warmup pass copy (OAI.EditApproximation.physicalChild node hbelow i) (j - 1) previousState) <          OAI.EditApproximation.PhysicalTableRequest.rank T S (OAI.EditApproximation.PhysicalTableRequest.warmup pass copy node j state) := by    constructor    · unfold OAI.EditApproximation.PhysicalTableRequest.remainingDepth OAI.EditApproximation.PhysicalTableRequest.warmup OAI.EditApproximation.physicalChild      dsimp only      omega    · dsimp only [OAI.EditApproximation.PhysicalTableRequest.rank, OAI.EditApproximation.PhysicalTableRequest.warmup]      omega  have proof_combinedRank_warmup_child_79 {M : ℕ} {J : ℕ} {ny : ℕ} (pass : ℕ) (copy : ℕ) (T : ℕ) (S : ℕ) (j : ℕ) (node : OAI.EditApproximation.PhysicalNode M J) (hbelow : LT.lt.{0} (↑(Sigma.fst.{0, 0} node)) J) (i : Fin M) (state : OAI.EditApproximation.TargetInterval ny) (previousState : OAI.EditApproximation.TargetInterval ny) (hj : LT.lt.{0} 0 j) :      OAI.EditApproximation.PhysicalTableRequest.combinedRank T S (OAI.EditApproximation.PhysicalTableRequest.warmup pass copy (OAI.EditApproximation.physicalChild node hbelow i) (j - 1) previousState) <        OAI.EditApproximation.PhysicalTableRequest.combinedRank T S (OAI.EditApproximation.PhysicalTableRequest.warmup pass copy node j state) :=    proof_combinedRank_lt_of_progress_80 T S _ _ (Or.inr      ⟨(proof_warmup_previous_child_progress_81 pass copy T S j node hbelow i state previousState hj).1.le,        (proof_warmup_previous_child_progress_81 pass copy T S j node hbelow i state previousState hj).2⟩)  have hinit := OAI.EditApproximation.queryPhysicalInitialFootprint source target N P F A a multiplier parent occurrence    symbolBits positionBits  unfold OAI.EditApproximation.queryChargedWarmup  refine OAI.EditApproximation.BitQuery.Footprint.chargeOf (OAI.EditApproximation.naturalEqualAllocation parent.val.index 0) ?_  split  · exact hinit _  · refine OAI.EditApproximation.BitQuery.Footprint.chargeOf (parent.val.node.1.val.bits.length + J.bits.length) ?_    split    · let interval := OAI.EditApproximation.physicalSourceInterval source.length parent.val.node      refine OAI.EditApproximation.BitQuery.Footprint.chargeOf (OAI.EditApproximation.saturatingSubtractAllocation interval.hi interval.lo +        OAI.EditApproximation.naturalWordLEAllocation (OAI.EditApproximation.saturatingSubtractWithWork interval.hi interval.lo).1 [true]) ?_      split      · exact hinit _      · apply OAI.EditApproximation.queryWarmupProgramFootprint        · exact hinit        · intro input          exact OAI.EditApproximation.queryChargedReadFootprint parent _    · exact hinit _end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.BinaryFractionvariable {α : Type u_4} (source target : List α) {M : ℕ} (parent : TargetInterval source.length) (P F exponent Q eM eF : ℕ) (hM : M = 2 ^ eM) (hF : F = 2 ^ eF) (hP : 0 < P) (tau a : BinaryFraction) (parentInitial : TargetInterval target.length → BinaryFraction × ℕ) (child initial current : Fin M → TargetInterval target.length → BinaryFraction × ℕ) (R : ℕ) (hc : ∀ i q, (child i q).2 ≤ R) (hi : ∀ i q, (initial i q).2 ≤ R)open Finsetdef preparedComputedCellSourceWithWorkRawBand (b eb : ℕ) (hb : b = 2 ^ eb)    (draw : ∀ t : Fin (OAI.EditApproximation.groupDyadicScales M b (OAI.EditApproximation.BinaryFraction.nat F).value).length,      Fin (OAI.EditApproximation.groupSampleCount M Q b (OAI.EditApproximation.groupDyadicScaleAt M b (OAI.EditApproximation.BinaryFraction.nat F).value t)) → Fin M × ℕ)    (cell : ℕ × ℕ) :    Option (OAI.EditApproximation.BinaryBellmanAction (OAI.EditApproximation.TargetInterval target.length)      (Fin M × OAI.EditApproximation.TargetInterval target.length) M) × ℕ := by  have proof_representation_value_32 (a : OAI.EditApproximation.BinaryFraction) : a.representation.value = a.value := rfl  have proof_eq_of_num_den_33 {a : OAI.EditApproximation.UnreducedRational} {b : OAI.EditApproximation.UnreducedRational} (hnum : Eq.{1} a.num b.num) (hden : Eq.{1} a.den b.den) : a = b := by    cases a    cases b    cases hnum    cases hden    rfl  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_value_ofInt_46 (a : ℤ) : (OAI.EditApproximation.SignedBinary.ofInt a).value = a := by    by_cases h : a < 0    · simpa only [OAI.EditApproximation.SignedBinary.ofInt, OAI.EditApproximation.SignedBinary.value, proof_bitWordValue_bits_15, OAI.EditApproximation.signedMagnitude, h, decide_true,        ↓reduceIte] using (Int.eq_neg_natAbs_of_nonpos (le_of_lt h)).symm    · simpa only [OAI.EditApproximation.SignedBinary.ofInt, OAI.EditApproximation.SignedBinary.value, proof_bitWordValue_bits_15, OAI.EditApproximation.signedMagnitude, h, decide_false,        Bool.false_eq_true, ↓reduceIte] using (Int.eq_natAbs_of_nonneg (le_of_not_gt h)).symm  have proof_nat_representation_47 (n : ℕ) : (OAI.EditApproximation.BinaryFraction.nat n).representation = OAI.EditApproximation.UnreducedRational.nat n := by    apply proof_eq_of_num_den_33    · change (OAI.EditApproximation.SignedBinary.ofInt (n : ℤ)).value = (n : ℤ)      exact proof_value_ofInt_46 _    · rfl  have proof_value_nat_48 (n : ℕ) : (OAI.EditApproximation.UnreducedRational.nat n).value = n := by (simp [OAI.EditApproximation.UnreducedRational.nat, OAI.EditApproximation.UnreducedRational.value])  have proof_nat_value_49 (n : ℕ) : (OAI.EditApproximation.BinaryFraction.nat n).value = (n : ℚ) := by    rw [← proof_representation_value_32, proof_nat_representation_47, proof_value_nat_48]  have proof_arithmeticMapWithWork_value_70 {α : Type 0} {β : Type 0} (f : α → Prod.{0, 0} β ℕ) (values : List.{0} α) :      (OAI.EditApproximation.arithmeticMapWithWork f values).1 = values.map (fun a => (f a).1) := by    induction values with    | nil => rfl    | cons a rest ih => simp only [OAI.EditApproximation.arithmeticMapWithWork, ih, List.map_cons]  have proof_powerTwoWord_value_13 (n : ℕ) : OAI.EditApproximation.bitWordValue (OAI.EditApproximation.powerTwoWord n) = 2 ^ n := by    induction n with    | zero => (simp [OAI.EditApproximation.powerTwoWord, OAI.EditApproximation.bitWordValue])    | succ n ih =>      (simp only [OAI.EditApproximation.powerTwoWord, List.replicate_succ, List.cons_append, OAI.EditApproximation.bitWordValue,        Bool.toNat_false, zero_add] at *)      rw [ih, pow_succ]      omega  have proof_inversePowerTwo_value_89 (n : ℕ) : (OAI.EditApproximation.BinaryFraction.inversePowerTwo n).value = (2 : ℚ) ^ (-(n : ℤ)) := by    (simp only [OAI.EditApproximation.BinaryFraction.inversePowerTwo, OAI.EditApproximation.BinaryFraction.value, OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, Bool.false_eq_true,      ↓reduceIte, OAI.EditApproximation.bitWordValue, Bool.toNat_true,      Int.cast_natCast, proof_powerTwoWord_value_13, Nat.cast_pow, Nat.cast_ofNat, zpow_neg, zpow_natCast])    norm_num [one_div]  have proof_signedPowerTwoWithWork_value_90 (e : ℤ) :      (OAI.EditApproximation.BinaryFraction.signedPowerTwoWithWork e).1.value = (2 : ℚ) ^ e := by    unfold OAI.EditApproximation.BinaryFraction.signedPowerTwoWithWork    split_ifs with h    · change (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.powerTwoWord e.toNat) : ℚ) / 1 = (2 : ℚ) ^ e      rw [div_one, proof_powerTwoWord_value_13, Nat.cast_pow, Nat.cast_ofNat, ← zpow_natCast,        Int.toNat_of_nonneg h]    · rw [proof_inversePowerTwo_value_89, Int.toNat_of_nonneg        (show 0 ≤ -e from neg_nonneg.mpr (le_of_lt (lt_of_not_ge h))), neg_neg]  have proof_groupScalesWithWork_value_91 (eM : ℕ) (eb : ℕ) (eF : ℕ) :      ((OAI.EditApproximation.BinaryFraction.groupScalesWithWork eM eb eF).1.map OAI.EditApproximation.BinaryFraction.value) =        OAI.EditApproximation.groupDyadicScales (2 ^ eM) (2 ^ eb) ((2 : ℚ) ^ eF) := by    have hlower : ((2 ^ eb : ℕ) : ℚ) / (2 ^ eM : ℕ) = (2 : ℚ) ^ ((eb : ℤ) - eM) := by      rw [Nat.cast_pow, Nat.cast_pow, Nat.cast_ofNat, zpow_sub₀ (by norm_num : (2 : ℚ) ≠ 0),        zpow_natCast, zpow_natCast]    have hupper : (64 : ℚ) * (2 : ℚ) ^ eF * (2 ^ eb : ℕ) =        (2 : ℚ) ^ ((6 + eF + eb : ℕ) : ℤ) := by      rw [Nat.cast_pow, Nat.cast_ofNat, zpow_natCast, pow_add, pow_add]      norm_num    have hlog : Int.log 2 ((2 : ℚ) ^ ((6 + eF + eb : ℕ) : ℤ)) = ((6 + eF + eb : ℕ) : ℤ) := by      simpa only [Nat.cast_ofNat] using Int.log_zpow (R := ℚ) (by decide : 1 < 2) ((6 + eF + eb : ℕ) : ℤ)    have hclog : Int.clog 2 ((2 : ℚ) ^ ((eb : ℤ) - eM)) = (eb : ℤ) - eM := by      simpa only [Nat.cast_ofNat] using Int.clog_zpow (R := ℚ) (by decide : 1 < 2) ((eb : ℤ) - eM)    simp only [OAI.EditApproximation.BinaryFraction.groupScalesWithWork, proof_arithmeticMapWithWork_value_70, List.map_map,      Function.comp_def, proof_signedPowerTwoWithWork_value_90, OAI.EditApproximation.groupDyadicScales, hlower, hupper, hlog, hclog]  have proof_computedGroupScales_value_87 (M : ℕ) (b : ℕ) (F : ℕ) (eM : ℕ) (eb : ℕ) (eF : ℕ) (hM : Eq.{1} M (HPow.hPow.{0, 0, 0} 2 eM)) (hb : Eq.{1} b (HPow.hPow.{0, 0, 0} 2 eb)) (hF : Eq.{1} F (HPow.hPow.{0, 0, 0} 2 eF)) :      (OAI.EditApproximation.BinaryFraction.groupScalesWithWork eM eb eF).1.map OAI.EditApproximation.BinaryFraction.value = OAI.EditApproximation.groupDyadicScales M b (OAI.EditApproximation.BinaryFraction.nat F).value := by    rw [proof_nat_value_49, hM, hb, hF, Nat.cast_pow, Nat.cast_ofNat]    exact proof_groupScalesWithWork_value_91 eM eb eF  exact    let scales := OAI.EditApproximation.BinaryFraction.groupScalesWithWork eM eb eF    let result := OAI.EditApproximation.BinaryFraction.preparedCellGroupSourceWithWorkRaw source target parent b P F exponent Q      (by rw [hb]; exact Nat.two_pow_pos eb) hP tau a parentInitial child initial current      R R hc hi scales.1 (proof_computedGroupScales_value_87 M b F eM eb eF hM hb hF) draw cell    (result.1, scales.2 + result.2 + 1)def preparedLocalGroupScaleSourceWithWorkRawBand (eb : ℕ)    (draw : OAI.EditApproximation.CellGroupReadDraws M F Q) (query : OAI.EditApproximation.TargetInterval target.length) :    List (OAI.EditApproximation.BinaryBellmanAction (OAI.EditApproximation.TargetInterval target.length)      (Fin M × OAI.EditApproximation.TargetInterval target.length) M) × ℕ := by  have proof_representation_value_32 (a : OAI.EditApproximation.BinaryFraction) : a.representation.value = a.value := rfl  have proof_eq_of_num_den_33 {a : OAI.EditApproximation.UnreducedRational} {b : OAI.EditApproximation.UnreducedRational} (hnum : Eq.{1} a.num b.num) (hden : Eq.{1} a.den b.den) : a = b := by    cases a    cases b    cases hnum    cases hden    rfl  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_value_ofInt_46 (a : ℤ) : (OAI.EditApproximation.SignedBinary.ofInt a).value = a := by    by_cases h : a < 0    · simpa only [OAI.EditApproximation.SignedBinary.ofInt, OAI.EditApproximation.SignedBinary.value, proof_bitWordValue_bits_15, OAI.EditApproximation.signedMagnitude, h, decide_true,        ↓reduceIte] using (Int.eq_neg_natAbs_of_nonpos (le_of_lt h)).symm    · simpa only [OAI.EditApproximation.SignedBinary.ofInt, OAI.EditApproximation.SignedBinary.value, proof_bitWordValue_bits_15, OAI.EditApproximation.signedMagnitude, h, decide_false,        Bool.false_eq_true, ↓reduceIte] using (Int.eq_natAbs_of_nonneg (le_of_not_gt h)).symm  have proof_nat_representation_47 (n : ℕ) : (OAI.EditApproximation.BinaryFraction.nat n).representation = OAI.EditApproximation.UnreducedRational.nat n := by    apply proof_eq_of_num_den_33    · change (OAI.EditApproximation.SignedBinary.ofInt (n : ℤ)).value = (n : ℤ)      exact proof_value_ofInt_46 _    · rfl  have proof_value_nat_48 (n : ℕ) : (OAI.EditApproximation.UnreducedRational.nat n).value = n := by (simp [OAI.EditApproximation.UnreducedRational.nat, OAI.EditApproximation.UnreducedRational.value])  have proof_nat_value_49 (n : ℕ) : (OAI.EditApproximation.BinaryFraction.nat n).value = (n : ℚ) := by    rw [← proof_representation_value_32, proof_nat_representation_47, proof_value_nat_48]  exact    let b := 2 ^ eb    let word := parentInitial query    let side := OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.inversePowerTwo exponent) (OAI.EditApproximation.BinaryFraction.nat b)    let radius := OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork word.1    let cells := OAI.EditApproximation.BinaryFraction.targetCellsWithWork side.1 (OAI.EditApproximation.bitWordValue radius.1) query    let selected := OAI.EditApproximation.filterMapWithWork (fun cell =>      OAI.EditApproximation.BinaryFraction.preparedComputedCellSourceWithWorkRawBand source target parent P F exponent Q eM eF hM hF hP tau a        parentInitial child initial current R hc hi b eb rfl        (Eq.mpr (congrArg (OAI.EditApproximation.cellScaleReadDraw M b Q) (proof_nat_value_49 F)) (draw b cell)) cell) cells.1    (selected.1, word.2 + side.2 + radius.2 + cells.2 + selected.2 + eb + 4)end OAI.EditApproximation.BinaryFractionendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.BinaryFractionvariable {α : Type u_4} (source target : List α) {M : ℕ} (parent : TargetInterval source.length) (P F exponent Q eM eF : ℕ) (hM : M = 2 ^ eM) (hF : F = 2 ^ eF) (hP : 0 < P) (tau a : BinaryFraction) (parentInitial : TargetInterval target.length → BinaryFraction × ℕ) (child initial current : Fin M → TargetInterval target.length → BinaryFraction × ℕ) (R : ℕ) (hc : ∀ i q, (child i q).2 ≤ R) (hi : ∀ i q, (initial i q).2 ≤ R)def preparedLocalCellGroupsSourceWithWorkRawBand (N : ℕ)    (draw : OAI.EditApproximation.CellGroupReadDraws M F Q) (query : OAI.EditApproximation.TargetInterval target.length) :    List (OAI.EditApproximation.BinaryBellmanAction (OAI.EditApproximation.TargetInterval target.length)      (Fin M × OAI.EditApproximation.TargetInterval target.length) M) × ℕ :=  let count := max 1 N.bits.length  let word := parentInitial query  let groups := OAI.EditApproximation.arithmeticFlatMapWithWork (fun eb =>    let guard := OAI.EditApproximation.BinaryFraction.refinementScaleGuardWithWork F (2 ^ eb) a word.1    if guard.1 then      let selected := OAI.EditApproximation.BinaryFraction.preparedLocalGroupScaleSourceWithWorkRawBand source target parent P F exponent Q eM eF        hM hF hP tau a parentInitial child initial current R hc hi eb draw query      (selected.1, guard.2 + selected.2 + eb + 4)    else ([], guard.2 + eb + 4)) (List.range count)  (groups.1, word.2 + groups.2 + count + N.bits.length + 2)end OAI.EditApproximation.BinaryFractionendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.BinaryFractionvariable {α : Type u_4} (source target : List α) {M : ℕ} (parent : TargetInterval source.length) (P F exponent H : ℕ) (hP : 0 < P) (tau a eta kappa : BinaryFraction) (parentInitial : TargetInterval target.length → BinaryFraction × ℕ) (child initial : Fin M → TargetInterval target.length → BinaryFraction × ℕ) (table : ℕ → Fin M × TargetInterval target.length → BinaryFraction × ℕ) (R : ℕ) (hc : ∀ i q, (child i q).2 ≤ R) (hi : ∀ i q, (initial i q).2 ≤ R) (t : ℕ) (integer : ℕ → TargetInterval target.length → ℕ × ℕ)def preparedLocalOnlineScaleSourceWithWorkRawBand (e : ℕ) (query : OAI.EditApproximation.TargetInterval target.length) :    Option (OAI.EditApproximation.BinaryBellmanAction (OAI.EditApproximation.TargetInterval target.length)      (Fin M × OAI.EditApproximation.TargetInterval target.length) M) × ℕ := by  have proof_bitOrdering_matches_4 (high : Ordering) (a : Bool) (b : Bool) (x : ℕ) (y : ℕ) (h : OAI.EditApproximation.orderingMatches high x y) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitOrdering high a b) (a.toNat + 2 * x) (b.toNat + 2 * y) := by    rcases h with ⟨rfl, h⟩ | ⟨rfl, rfl⟩ | ⟨rfl, h⟩    · exact Or.inl ⟨rfl, by cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩    · cases a <;> cases b <;> simp [OAI.EditApproximation.bitOrdering, OAI.EditApproximation.orderingMatches]    · exact Or.inr (Or.inr ⟨rfl, by        cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩)  have proof_bitCompareWithWork_matches_5 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitCompareWithWork left right).1 (OAI.EditApproximation.bitWordValue left) (OAI.EditApproximation.bitWordValue right) := by    induction left generalizing right with    | nil =>      simp only [OAI.EditApproximation.bitCompareWithWork]      induction right with      | nil => (simp [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.orderingMatches, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        simpa only [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareNilLeftWithWork bs).1 false b 0 (OAI.EditApproximation.bitWordValue bs) ih    | cons a as ih =>      cases right with      | nil =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as []).1 a false (OAI.EditApproximation.bitWordValue as) 0 (ih [])      | cons b bs =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue] using          proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as bs).1 a b (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs) (ih bs)  have proof_bitCompareWithWork_lt_16 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .lt ↔ OAI.EditApproximation.bitWordValue left < OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_bitSubtractor_value_17 (a : Bool) (b : Bool) (borrow : Bool) :      a.toNat + 2 * (OAI.EditApproximation.bitBorrow a b borrow).toNat =        b.toNat + borrow.toNat + (OAI.EditApproximation.bitDifference a b borrow).toNat := by    cases a <;> cases b <;> cases borrow <;> decide  have proof_bitSubtractionRippleEquation_18 (a : ℕ) (b : ℕ) (borrow : ℕ) (nextBorrow : ℕ) (difference : ℕ) (left : ℕ) (right : ℕ) (result : ℕ) (tail : ℕ) (htail : Eq.{1} (HAdd.hAdd.{0, 0, 0} (HAdd.hAdd.{0, 0, 0} result right) nextBorrow) (HAdd.hAdd.{0, 0, 0} left tail)) (hbit : Eq.{1} (HAdd.hAdd.{0, 0, 0} a (HMul.hMul.{0, 0, 0} 2 nextBorrow))    (HAdd.hAdd.{0, 0, 0} (HAdd.hAdd.{0, 0, 0} b borrow) difference)) :      (difference + 2 * result) + (b + 2 * right) + borrow =        (a + 2 * left) + 2 * tail := by    omega  have proof_bitSubtractWithWork_value_19 (left : List.{0} Bool) (right : List.{0} Bool) (borrow : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork left right borrow).1 + OAI.EditApproximation.bitWordValue right + borrow.toNat =        OAI.EditApproximation.bitWordValue left + 2 ^ max left.length right.length *          (OAI.EditApproximation.bitSubtractWithWork left right borrow).2.1.toNat := by    induction left generalizing right borrow with    | nil =>      induction right generalizing borrow with      | nil => (simp [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitSubtractNilLeftWithWork, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        have h := ih (OAI.EditApproximation.bitBorrow false b borrow)        have hb := proof_bitSubtractor_value_17 false b borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitSubtractNilLeftWithWork, OAI.EditApproximation.bitWordValue,          List.length_nil, List.length_cons, Nat.zero_max, pow_succ, Bool.toNat_false] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 0 b.toNat borrow.toNat (OAI.EditApproximation.bitBorrow false b borrow).toNat          (OAI.EditApproximation.bitDifference false b borrow).toNat 0 (OAI.EditApproximation.bitWordValue bs)          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractNilLeftWithWork bs (OAI.EditApproximation.bitBorrow false b borrow)).1)          (2 ^ bs.length * (OAI.EditApproximation.bitSubtractNilLeftWithWork bs (OAI.EditApproximation.bitBorrow false b borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_zero, Nat.add_zero, Nat.zero_add, Nat.mul_assoc,          Nat.mul_left_comm] using hs    | cons a as ih =>      cases right with      | nil =>        have h := ih [] (OAI.EditApproximation.bitBorrow a false borrow)        have hb := proof_bitSubtractor_value_17 a false borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitWordValue, List.length_nil, List.length_cons,          Nat.max_zero, pow_succ, Bool.toNat_false] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 a.toNat 0 borrow.toNat (OAI.EditApproximation.bitBorrow a false borrow).toNat          (OAI.EditApproximation.bitDifference a false borrow).toNat (OAI.EditApproximation.bitWordValue as) 0          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork as [] (OAI.EditApproximation.bitBorrow a false borrow)).1)          (2 ^ as.length * (OAI.EditApproximation.bitSubtractWithWork as [] (OAI.EditApproximation.bitBorrow a false borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_zero, Nat.add_zero, Nat.zero_add, Nat.mul_assoc,          Nat.mul_left_comm] using hs      | cons b bs =>        have h := ih bs (OAI.EditApproximation.bitBorrow a b borrow)        have hb := proof_bitSubtractor_value_17 a b borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitWordValue, List.length_cons, Nat.succ_max_succ,          pow_succ] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 a.toNat b.toNat borrow.toNat (OAI.EditApproximation.bitBorrow a b borrow).toNat          (OAI.EditApproximation.bitDifference a b borrow).toNat (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs)          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork as bs (OAI.EditApproximation.bitBorrow a b borrow)).1)          (2 ^ max as.length bs.length * (OAI.EditApproximation.bitSubtractWithWork as bs (OAI.EditApproximation.bitBorrow a b borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_assoc, Nat.mul_left_comm] using hs  have proof_bitWordValue_lt_pow_length_20 (bits : List.{0} Bool) : OAI.EditApproximation.bitWordValue bits < 2 ^ bits.length := by    induction bits with    | nil => (simp [OAI.EditApproximation.bitWordValue])    | cons bit bits ih =>      cases bit <;> (simp only [OAI.EditApproximation.bitWordValue, List.length_cons, pow_succ, Bool.toNat_false, Bool.toNat_true]) <;> omega  have proof_bitSubtractWithWork_length_21 (left : List.{0} Bool) (right : List.{0} Bool) (borrow : Bool) :      (OAI.EditApproximation.bitSubtractWithWork left right borrow).1.length = max left.length right.length := by    induction left generalizing right borrow with    | nil =>      simp only [OAI.EditApproximation.bitSubtractWithWork]      induction right generalizing borrow with      | nil => simp [OAI.EditApproximation.bitSubtractNilLeftWithWork]      | cons b bs ih => simp [OAI.EditApproximation.bitSubtractNilLeftWithWork, ih]    | cons a as ih =>      cases right with      | nil => simp [OAI.EditApproximation.bitSubtractWithWork, ih]      | cons b bs => simp [OAI.EditApproximation.bitSubtractWithWork, ih, Nat.succ_max_succ]  have proof_bitSubtractWithWork_sub_22 (left : List.{0} Bool) (right : List.{0} Bool) (h : LE.le.{0} (OAI.EditApproximation.bitWordValue right) (OAI.EditApproximation.bitWordValue left)) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork left right false).1 = OAI.EditApproximation.bitWordValue left - OAI.EditApproximation.bitWordValue right := by    have hvalue := proof_bitSubtractWithWork_value_19 left right false    have hlt := proof_bitWordValue_lt_pow_length_20 (OAI.EditApproximation.bitSubtractWithWork left right false).1    rw [proof_bitSubtractWithWork_length_21] at hlt    cases hb : (OAI.EditApproximation.bitSubtractWithWork left right false).2.1    · simp only [hb, Bool.toNat_false, Nat.mul_zero, Nat.add_zero] at hvalue      omega    · simp only [hb, Bool.toNat_true, Bool.toNat_false, Nat.mul_one, Nat.add_zero] at hvalue      omega  have proof_bitDivModWithWork_value_23 (divisor : List.{0} Bool) (bits : List.{0} Bool) (hd : LT.lt.{0} 0 (OAI.EditApproximation.bitWordValue divisor)) :      OAI.EditApproximation.bitWordValue bits = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).1 +        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 ∧        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 < OAI.EditApproximation.bitWordValue divisor := by    induction bits with    | nil => (simp [OAI.EditApproximation.bitDivModWithWork, OAI.EditApproximation.bitWordValue, hd])    | cons bit bits ih =>      let previous := OAI.EditApproximation.bitDivModWithWork divisor bits      let candidate := bit :: previous.2.1      have hp : OAI.EditApproximation.bitWordValue bits = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue previous.1 +          OAI.EditApproximation.bitWordValue previous.2.1 := ih.1      have hr : OAI.EditApproximation.bitWordValue previous.2.1 < OAI.EditApproximation.bitWordValue divisor := ih.2      have hc : OAI.EditApproximation.bitWordValue candidate < 2 * OAI.EditApproximation.bitWordValue divisor := by        dsimp only [candidate, OAI.EditApproximation.bitWordValue]        cases bit <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega      by_cases hlt : (OAI.EditApproximation.bitCompareWithWork candidate divisor).1 = .lt      · have hv := (proof_bitCompareWithWork_lt_16 candidate divisor).1 hlt        simp only [OAI.EditApproximation.bitDivModWithWork, show (OAI.EditApproximation.bitCompareWithWork (bit :: (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1)          divisor).1 = .lt from hlt, ↓reduceIte]        change OAI.EditApproximation.bitWordValue (bit :: bits) = OAI.EditApproximation.bitWordValue divisor *          OAI.EditApproximation.bitWordValue (false :: previous.1) + OAI.EditApproximation.bitWordValue candidate ∧ OAI.EditApproximation.bitWordValue candidate < _        constructor        · (simp only [OAI.EditApproximation.bitWordValue, Bool.toNat_false])          dsimp only [candidate, OAI.EditApproximation.bitWordValue]          nlinarith only [hp]        · exact hv      · have hv : OAI.EditApproximation.bitWordValue divisor ≤ OAI.EditApproximation.bitWordValue candidate := by          exact Nat.le_of_not_gt (fun h => hlt ((proof_bitCompareWithWork_lt_16 candidate divisor).2 h))        have hs := proof_bitSubtractWithWork_sub_22 candidate divisor hv        simp only [OAI.EditApproximation.bitDivModWithWork, show (OAI.EditApproximation.bitCompareWithWork (bit :: (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1)          divisor).1 ≠ .lt from hlt, ↓reduceIte]        change OAI.EditApproximation.bitWordValue (bit :: bits) = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue (true :: previous.1) +          OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork candidate divisor false).1 ∧          OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork candidate divisor false).1 < _        rw [hs]        constructor        · (simp only [OAI.EditApproximation.bitWordValue, Bool.toNat_true])          have he := Nat.sub_add_cancel hv          dsimp only [candidate, OAI.EditApproximation.bitWordValue] at he ⊢          nlinarith only [hp, he]        · omega  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_binaryNaturalDivModWithWork_spec_24 (n : ℕ) (d : ℕ) (hd : LT.lt.{0} 0 d) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalDivModWithWork n d).1 = n / d ∧        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalDivModWithWork n d).2.1 = n % d := by    have h := proof_bitDivModWithWork_value_23 d.bits n.bits (by simpa only [proof_bitWordValue_bits_15] using hd)    simp only [proof_bitWordValue_bits_15] at h    have hmod : n % d = OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork d.bits n.bits).2.1 := by      conv_lhs => rw [h.1]      simp only [Nat.add_mod, Nat.mul_mod_right, Nat.zero_add, Nat.mod_eq_of_lt h.2]    have hdiv : n / d = OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork d.bits n.bits).1 := by      conv_lhs => rw [h.1]      rw [Nat.mul_add_div hd, Nat.div_eq_of_lt h.2, Nat.add_zero]    exact ⟨hdiv.symm, hmod.symm⟩  have proof_wordLEWithWork_value_26 (a : List.{0} Bool) (b : List.{0} Bool) :      (OAI.EditApproximation.wordLEWithWork a b).1 = true ↔ OAI.EditApproximation.bitWordValue a ≤ OAI.EditApproximation.bitWordValue b := by    simp only [OAI.EditApproximation.wordLEWithWork, Bool.not_eq_true', decide_eq_false_iff_not,      proof_bitCompareWithWork_lt_16, not_lt]  have proof_seedGridSpacingWithWork_value_86 (b : ℕ) (P : ℕ) (hP : LT.lt.{0} 0 P) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.seedGridSpacingWithWork b P).1 = OAI.EditApproximation.seedGridSpacing b P := by    have hv := (proof_binaryNaturalDivModWithWork_spec_24 b P hP).1    unfold OAI.EditApproximation.seedGridSpacingWithWork OAI.EditApproximation.seedGridSpacing    dsimp only    split_ifs with ht    · have hq : b / P ≤ 1 := by        have h := (proof_wordLEWithWork_value_26 _ _).mp ht        change OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalDivModWithWork b P).1 ≤ 1 at h        rwa [hv] at h      rw [max_eq_left hq]      rfl    · have hq : 1 ≤ b / P := by        have h := mt (proof_wordLEWithWork_value_26 _ _).mpr ht        change ¬ OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalDivModWithWork b P).1 ≤ 1 at h        rw [hv] at h        exact Nat.le_of_lt (Nat.lt_of_not_ge h)      rw [max_eq_right hq]      exact hv  have proof_seedGridSpacingWithWork_pos_85 (b : ℕ) (P : ℕ) (hP : LT.lt.{0} 0 P) :      0 < OAI.EditApproximation.bitWordValue (OAI.EditApproximation.seedGridSpacingWithWork b P).1 := by    rw [proof_seedGridSpacingWithWork_value_86 b P hP]    unfold OAI.EditApproximation.seedGridSpacing    omega  exact    let b := 2 ^ e    let spacing := OAI.EditApproximation.seedGridSpacingWithWork b P    let center := OAI.EditApproximation.roundStateWithWork (OAI.EditApproximation.bitWordValue spacing.1) (proof_seedGridSpacingWithWork_pos_85 b P hP) query    let word := parentInitial center.1    let eligible := OAI.EditApproximation.BinaryFraction.centerEligibilityWithWork b F a word.1    if eligible.1 then      let sample := integer b center.1      let selected := OAI.EditApproximation.BinaryFraction.preparedOnlineReadWithWorkRaw source target parent P F exponent H b (Nat.two_pow_pos e) hP        tau eta kappa child initial table R hc hi t center.1 sample.1      (selected.1, spacing.2 + center.2 + word.2 + eligible.2 + selected.2 + sample.2 + e + 5)    else (none, spacing.2 + center.2 + word.2 + eligible.2 + e + 3)def preparedLocalOnlineActionsSourceWithWorkRawBand (N : ℕ) (query : OAI.EditApproximation.TargetInterval target.length) :    List (OAI.EditApproximation.BinaryBellmanAction (OAI.EditApproximation.TargetInterval target.length)      (Fin M × OAI.EditApproximation.TargetInterval target.length) M) × ℕ :=  let word := parentInitial query  let scales := OAI.EditApproximation.BinaryFraction.queryExponentsWithWork N F a word.1  let selected := OAI.EditApproximation.filterMapWithWork    (fun e => OAI.EditApproximation.BinaryFraction.preparedLocalOnlineScaleSourceWithWorkRawBand source target parent P F exponent H hP tau a eta kappa      parentInitial child initial table R hc hi t integer e query) scales.1  (selected.1, word.2 + scales.2 + selected.2 + 1)end OAI.EditApproximation.BinaryFractionendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.BinaryFractionvariable {α : Type u_4} (source target : List α) {M : ℕ} (parent : TargetInterval source.length) (N P F exponent H Q eM eF : ℕ) (hP : 0 < P) (hM : M = 2 ^ eM) (hF : F = 2 ^ eF) (tau a eta kappa : BinaryFraction) (parentInitial : TargetInterval target.length → BinaryFraction × ℕ) (child initial : Fin M → TargetInterval target.length → BinaryFraction × ℕ) (R : ℕ) (hc : ∀ i r, (child i r).2 ≤ R) (hi : ∀ i r, (initial i r).2 ≤ R)def queryOnlineSelectWithWorkRawBand (t : ℕ)    (integer : ℕ → OAI.EditApproximation.TargetInterval target.length → ℕ × ℕ)    (keys : List (Fin M × ℕ × OAI.EditApproximation.TargetInterval target.length)) (words : List OAI.EditApproximation.BinaryFraction)    (q : OAI.EditApproximation.TargetInterval target.length) :=  OAI.EditApproximation.BinaryFraction.preparedLocalOnlineActionsSourceWithWorkRawBand source target parent P F exponent H hP tau a eta kappa    parentInitial child initial (OAI.EditApproximation.BinaryFraction.queryHistoryReadWithWork keys words) R hc hi (t - 1) integer N qdef queryGroupSelectWithWorkRawBand (draw : OAI.EditApproximation.CountedCellGroupDraws M F Q)    (keys : List (Fin M × OAI.EditApproximation.TargetInterval target.length)) (words : List OAI.EditApproximation.BinaryFraction)    (q : OAI.EditApproximation.TargetInterval target.length) :=  OAI.EditApproximation.BinaryFraction.preparedLocalCellGroupsSourceWithWorkRawBand source target parent P F exponent Q eM eF hM hF hP tau a    parentInitial child initial (OAI.EditApproximation.BinaryFraction.queryChildReadWithWork keys words) R hc hi N draw qend OAI.EditApproximation.BinaryFractionendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable {ι : Type u_4} {α : Type u_5} (source target : List α) {M : ℕ} (parent : TargetInterval source.length) (N P F exponent H Q eM eF : ℕ) (hP : 0 < P) (hM : M = 2 ^ eM) (hF : F = 2 ^ eF) (tau a eta kappa delta : BinaryFraction) (t : ℕ) (parentInitial : TargetInterval target.length → BinaryFraction × ℕ) (child initial : Fin M → TargetInterval target.length → BinaryFraction × ℕ) (R : ℕ) (hc : ∀ i r, (child i r).2 ≤ R) (hi : ∀ i r, (initial i r).2 ≤ R) (draw : CountedCellGroupDraws M F Q) (integer : ℕ → TargetInterval target.length → ℕ × ℕ) (q : TargetInterval target.length) (readEarlier : (Fin M × ℕ × TargetInterval target.length) → BitQuery ι BinaryFraction) (readCurrent : (Fin M × TargetInterval target.length) → BitQuery ι BinaryFraction)def queryLocalRefinementRawBand : OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction :=  OAI.EditApproximation.queryRefinementGather source target parent N P F exponent Q eM eF hP hM hF a t parentInitial draw q    readEarlier readCurrent    (fun keys words => OAI.EditApproximation.BinaryFraction.queryOnlineSelectWithWorkRawBand source target parent N P F exponent H hP      tau a eta kappa parentInitial child initial R hc hi t integer keys words q)    (fun keys words => OAI.EditApproximation.BinaryFraction.queryGroupSelectWithWorkRawBand source target parent N P F exponent Q      eM eF hP hM hF tau a parentInitial child initial R hc hi draw keys words q)    (fun earlierKeys earlierWords groups online currentKeys currentWords =>      OAI.EditApproximation.BitQuery.compute (OAI.EditApproximation.BinaryFraction.queryRefinementFinishWithWork parent N P F a delta parentInitial        t earlierKeys earlierWords groups online currentKeys currentWords q))end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable {ι : Type u_4} {α : Type u_5} (source target : List α) {M : ℕ} [NeZero M] (parent : TargetInterval source.length) (N P F exponent H Q eM eF : ℕ) (hP : 0 < P) (hM : M = 2 ^ eM) (hF : F = 2 ^ eF) (tau a eta kappa delta : BinaryFraction) (t : ℕ) (parentInitial : TargetInterval target.length → BinaryFraction × ℕ) (child initial : Fin M → TargetInterval target.length → BinaryFraction × ℕ) (R : ℕ) (hc : ∀ i r, (child i r).2 ≤ R) (hi : ∀ i r, (initial i r).2 ≤ R) (q : TargetInterval target.length) (readGroup : GroupScalarKey M F Q → BitQuery ι BinaryFraction) (readInteger : (ℕ × TargetInterval target.length) → ℕ → BitQuery ι BinaryFraction) (readEarlier : (Fin M × ℕ × TargetInterval target.length) → BitQuery ι BinaryFraction) (readCurrent : (Fin M × TargetInterval target.length) → BitQuery ι BinaryFraction)def queryLocalRandomSourcesRawBand : OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction :=  OAI.EditApproximation.queryGroupSourceGather M N F Q exponent eM eF hM hF a parentInitial q readGroup    fun groupKeys groupWords =>      OAI.EditApproximation.queryOnlineSourceGather parent N P F exponent H hP tau a parentInitial child q readInteger        fun onlineKeys onlineWords =>          OAI.EditApproximation.queryLocalRefinementRawBand source target parent N P F exponent H Q eM eF hP hM hF            tau a eta kappa delta t parentInitial child initial R hc hi            (OAI.EditApproximation.BinaryFraction.queryGroupDrawReadWithWork groupKeys groupWords)            (OAI.EditApproximation.BinaryFraction.queryOnlineIntegerReadWithWork onlineKeys onlineWords)            q readEarlier readCurrentend OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable {ι : Type u_4} {α : Type u_5} (source target : List α) {M : ℕ} [NeZero M] (parent : TargetInterval source.length) (N P F exponent H Q eM eF : ℕ) (hP : 0 < P) (hM : M = 2 ^ eM) (hF : F = 2 ^ eF) (tau a eta kappa delta : BinaryFraction) (t : ℕ) (parentInitial : TargetInterval target.length → BinaryFraction × ℕ) (readMass readInitial : (Fin M × TargetInterval target.length) → BitQuery ι BinaryFraction) (readGroup : GroupScalarKey M F Q → BitQuery ι BinaryFraction) (readInteger : (ℕ × TargetInterval target.length) → ℕ → BitQuery ι BinaryFraction) (q : TargetInterval target.length) (readEarlier : (Fin M × ℕ × TargetInterval target.length) → BitQuery ι BinaryFraction) (readCurrent : (Fin M × TargetInterval target.length) → BitQuery ι BinaryFraction)open Finsetdef queryLocalBandRawBand : OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction := by  have proof_gatheredWordLookupWithWork_cost_132 {κ : Type 0} (equal : κ → κ → Prod.{0, 0} Bool ℕ) (C : ℕ) (hC : ∀ (a b : κ), LE.le.{0} (equal a b).2 C) (keys : List.{0} κ) (values : List.{0} OAI.EditApproximation.BinaryFraction) (query : κ) :      (OAI.EditApproximation.BinaryFraction.gatheredWordLookupWithWork equal keys values query).2 ≤ 1 + keys.length * (C + 1) := by    induction keys generalizing values with    | nil => simp only [OAI.EditApproximation.BinaryFraction.gatheredWordLookupWithWork, List.length_nil, Nat.zero_mul, Nat.add_zero, le_rfl]    | cons key keys ih =>      cases values with      | nil => simp only [OAI.EditApproximation.BinaryFraction.gatheredWordLookupWithWork]; omega      | cons value values =>        have hc := hC query key        have hi := ih values        simp only [OAI.EditApproximation.BinaryFraction.gatheredWordLookupWithWork]        split_ifs <;> simp only [List.length_cons, Nat.add_mul, Nat.one_mul] <;> omega  have proof_bitCompareWithWork_cost_133 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).2 ≤ 4 * (left.length + right.length) + 1 := by    induction left generalizing right with    | nil =>      simp only [OAI.EditApproximation.bitCompareWithWork]      induction right with      | nil => simp [OAI.EditApproximation.bitCompareNilLeftWithWork]      | cons b bs ih =>        simp only [OAI.EditApproximation.bitCompareNilLeftWithWork, List.length_cons, List.length_nil] at *        omega    | cons a as ih =>      cases right with      | nil =>        have h := ih []        simp only [OAI.EditApproximation.bitCompareWithWork, List.length_cons, List.length_nil] at *        omega      | cons b bs =>        have h := ih bs        simp only [OAI.EditApproximation.bitCompareWithWork, List.length_cons] at *        omega  have proof_binaryNaturalCompareWithWork_cost_134 (a : ℕ) (b : ℕ) :      (OAI.EditApproximation.binaryNaturalCompareWithWork a b).2 ≤ 4 * (Nat.size a + Nat.size b) + 1 := by    simpa only [OAI.EditApproximation.binaryNaturalCompareWithWork, Nat.size_eq_bits_len] using proof_bitCompareWithWork_cost_133 a.bits b.bits  have proof_naturalEqualWithWork_cost_135 (a : ℕ) (b : ℕ) (B : ℕ) (ha : LE.le.{0} a.size B) (hb : LE.le.{0} b.size B) :      (OAI.EditApproximation.naturalEqualWithWork a b).2 ≤ 8 * B + 2 := by    have h := proof_binaryNaturalCompareWithWork_cost_134 a b    change (OAI.EditApproximation.binaryNaturalCompareWithWork a b).2 + 1 ≤ _    omega  have proof_coordinateEqualWithWork_cost_136 {M : ℕ} {n : ℕ} (a : Prod.{0, 0} (Fin M) (OAI.EditApproximation.TargetInterval n)) (b : Prod.{0, 0} (Fin M) (OAI.EditApproximation.TargetInterval n)) (B : ℕ) (hM : LE.le.{0} M.size B) (hn : LE.le.{0} n.size B) :      (OAI.EditApproximation.coordinateEqualWithWork a b).2 ≤ 24 * B + 8 := by    have hc := proof_naturalEqualWithWork_cost_135 a.1.val b.1.val B      ((Nat.size_le_size a.1.isLt.le).trans hM) ((Nat.size_le_size b.1.isLt.le).trans hM)    have hl := proof_naturalEqualWithWork_cost_135 a.2.lo b.2.lo B      ((Nat.size_le_size (a.2.ordered.trans a.2.valid)).trans hn)      ((Nat.size_le_size (b.2.ordered.trans b.2.valid)).trans hn)    have hh := proof_naturalEqualWithWork_cost_135 a.2.hi b.2.hi B      ((Nat.size_le_size a.2.valid).trans hn) ((Nat.size_le_size b.2.valid).trans hn)    change _ + _ + _ + 2 ≤ _    omega  have proof_queryChildReadWithWork_cost_137 {M : ℕ} {n : ℕ} (keys : List.{0} (Prod.{0, 0} (Fin M) (OAI.EditApproximation.TargetInterval n))) (values : List.{0} OAI.EditApproximation.BinaryFraction) (i : Fin M) (q : OAI.EditApproximation.TargetInterval n) (B : ℕ) (hM : LE.le.{0} M.size B) (hn : LE.le.{0} n.size B) :      (OAI.EditApproximation.BinaryFraction.queryChildReadWithWork keys values i q).2 ≤ 1 + keys.length * (24 * B + 9) := by    exact proof_gatheredWordLookupWithWork_cost_132 OAI.EditApproximation.coordinateEqualWithWork (24 * B + 8)      (fun a b => proof_coordinateEqualWithWork_cost_136 a b B hM hn) keys values (i, q)  have proof_queryChildReadWithWork_budget_131 {M : ℕ} {n : ℕ} (keys : List.{0} (Prod.{0, 0} (Fin M) (OAI.EditApproximation.TargetInterval n))) (words : List.{0} OAI.EditApproximation.BinaryFraction) (i : Fin M) (r : OAI.EditApproximation.TargetInterval n) :      (OAI.EditApproximation.BinaryFraction.queryChildReadWithWork keys words i r).2 ≤ OAI.EditApproximation.BinaryFraction.queryDataReadBudget M n keys := by    exact proof_queryChildReadWithWork_cost_137 keys words i r _ (Nat.le_max_left _ _) (Nat.le_max_right _ _)  exact    OAI.EditApproximation.queryBandGather M parent N P F exponent hP a parentInitial q readMass readInitial      fun keys massWords initialWords =>        OAI.EditApproximation.queryLocalRandomSourcesRawBand source target parent N P F exponent H Q eM eF hP hM hF          tau a eta kappa delta t parentInitial          (OAI.EditApproximation.BinaryFraction.queryChildReadWithWork keys massWords)          (OAI.EditApproximation.BinaryFraction.queryChildReadWithWork keys initialWords)          (OAI.EditApproximation.BinaryFraction.queryDataReadBudget M target.length keys)          (proof_queryChildReadWithWork_budget_131 keys massWords)          (proof_queryChildReadWithWork_budget_131 keys initialWords)          q readGroup readInteger readEarlier readCurrentend OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable {ι : Type u_4} {α : Type u_5} (source target : List α) {M : ℕ} [NeZero M] (parent : TargetInterval source.length) (N P F exponent H Q eM eF : ℕ) (hP : 0 < P) (hM : M = 2 ^ eM) (hF : F = 2 ^ eF) (tau a eta kappa delta : BinaryFraction) (t : ℕ) (readParent : TargetInterval target.length → BitQuery ι BinaryFraction) (readMass readInitial : (Fin M × TargetInterval target.length) → BitQuery ι BinaryFraction) (readGroup : GroupScalarKey M F Q → BitQuery ι BinaryFraction) (readInteger : (ℕ × TargetInterval target.length) → ℕ → BitQuery ι BinaryFraction) (q : TargetInterval target.length) (readEarlier : (Fin M × ℕ × TargetInterval target.length) → BitQuery ι BinaryFraction) (readCurrent : (Fin M × TargetInterval target.length) → BitQuery ι BinaryFraction)def queryLocalProgramRawBand : OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction :=  OAI.EditApproximation.queryInitialGather N P F exponent hP a q readParent fun keys words =>    OAI.EditApproximation.queryLocalBandRawBand source target parent N P F exponent H Q eM eF hP hM hF      tau a eta kappa delta t (OAI.EditApproximation.BinaryFraction.queryParentReadWithWork keys words)      readMass readInitial readGroup readInteger q readEarlier readCurrentend OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable {σ : Type u_4} {α : Type u_5} (source target : List α) {M J : ℕ} [NeZero M] (N P F exponent H Q eM eF : ℕ) (hP : 0 < P) (hM : M = 2 ^ eM) (hF : F = 2 ^ eF) (tau a eta kappa delta : BinaryFraction) (copies pass copy T S t : ℕ) (ht : 0 < t) (node : PhysicalNode M J) (hbelow : node.1.val < J) (readGroup : GroupScalarKey M F Q → BitQuery σ BinaryFraction) (readInteger : (ℕ × TargetInterval target.length) → ℕ → BitQuery σ BinaryFraction) (q : TargetInterval target.length)def queryPhysicalRandomDataRequestRawBand :    OAI.EditApproximation.BitQuery (Sum σ {child : OAI.EditApproximation.PhysicalTableRequest M J target.length //      child.combinedRank T S < (OAI.EditApproximation.PhysicalTableRequest.refinement pass copy node T t q).combinedRank T S})      OAI.EditApproximation.BinaryFraction :=  OAI.EditApproximation.queryLocalProgramRawBand source target (OAI.EditApproximation.physicalSourceInterval source.length node)    N P F exponent H Q eM eF hP hM hF tau a eta kappa delta t    (fun r => OAI.EditApproximation.BitQuery.mapKeysWithWork (fun key => (Sum.inr key, 1))      (OAI.EditApproximation.queryPhysicalWarmupRead copies pass copy T S t ht node q node le_rfl 0 (Nat.zero_le T) r))    (fun input => OAI.EditApproximation.BitQuery.mapKeysWithWork (fun key => (Sum.inr key, 1))      (OAI.EditApproximation.queryPhysicalMassRead copies pass copy T S t ht node hbelow q input))    (fun input => OAI.EditApproximation.BitQuery.mapKeysWithWork (fun key => (Sum.inr key, 1))      (OAI.EditApproximation.queryPhysicalWarmupRead copies pass copy T S t ht node q        (OAI.EditApproximation.physicalChild node hbelow input.1) (by change node.1.val ≤ node.1.val + 1; omega)        0 (Nat.zero_le T) input.2))    (fun key => OAI.EditApproximation.BitQuery.mapKeysWithWork (fun key => (Sum.inl key, 1)) (readGroup key))    (fun key range => OAI.EditApproximation.BitQuery.mapKeysWithWork (fun key => (Sum.inl key, 1)) (readInteger key range)) q    (fun input => OAI.EditApproximation.BitQuery.mapKeysWithWork (fun key => (Sum.inr key, 1))      (OAI.EditApproximation.queryPhysicalEarlierRead copies pass copy T S t node hbelow q input))    (fun input => OAI.EditApproximation.BitQuery.mapKeysWithWork (fun key => (Sum.inr key, 1))      (OAI.EditApproximation.queryPhysicalCurrentRead copies pass copy T S t node hbelow q input))end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable {α : Type u_4} {M J R : ℕ} [NeZero M] (source target : List α) (N P F exponent H Q eM eF : ℕ) (hP : 0 < P) (hM : M = 2 ^ eM) (hF : F = 2 ^ eF) (tau a eta kappa delta : BinaryFraction) (passes copies pass copy T S t : ℕ) (ht : 0 < t) (node : PhysicalNode M J) (hbelow : node.1.val < J) (time : Fin R) (q : TargetInterval target.length)def queryFamilyRefinementRawBand :    OAI.EditApproximation.BitQuery (Sum (OAI.EditApproximation.PhysicalFamilyScalarKey (M := M) (J := J) (R := R)      target N P F exponent H Q passes copies)      {child : OAI.EditApproximation.PhysicalTableRequest M J target.length // child.combinedRank T S <        (OAI.EditApproximation.PhysicalTableRequest.refinement pass copy node T t q).combinedRank T S}) OAI.EditApproximation.BinaryFraction :=  OAI.EditApproximation.queryPhysicalRandomDataRequestRawBand source target N P F exponent H Q eM eF hP hM hF    tau a eta kappa delta copies pass copy T S t ht node hbelow    (OAI.EditApproximation.queryFamilyGroupRead target N P F exponent H Q passes copies pass copy ⟨node, hbelow⟩ time)    (OAI.EditApproximation.queryFamilyOnlineRead target N P F exponent H Q passes copies pass copy ⟨node, hbelow⟩ time) qend OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable {α : Type u_4} [DecidableEq α] {M J R : ℕ} [NeZero M] [NeZero R] (source target : List α) (N P F exponent H Q eM eF : ℕ) (hP : 0 < P) (hM : M = 2 ^ eM) (hF : F = 2 ^ eF) (tau a eta kappa delta : BinaryFraction) (T S passes copies : ℕ) (request : PhysicalTableRequest M J target.length) (hindex : T < request.index) (hbelow : request.node.1.val < J)def queryFamilyActiveRawBand :    OAI.EditApproximation.BitQuery (Sum (OAI.EditApproximation.PhysicalFamilyScalarKey (M := M) (J := J) (R := R)      target N P F exponent H Q passes copies)      {child : OAI.EditApproximation.PhysicalTableRequest M J target.length //        child.combinedRank T S < request.combinedRank T S}) OAI.EditApproximation.BinaryFraction := by  have proof_active_request_eq_139 {α : Type u_4} {M : ℕ} {J : ℕ} (target : List.{u_4} α) (T : ℕ) (request : OAI.EditApproximation.PhysicalTableRequest M J (List.length.{u_4} target)) (hindex : LT.lt.{0} T request.index) :      OAI.EditApproximation.PhysicalTableRequest.refinement request.pass request.copy request.node T (request.index - T)        request.state = request := by    have hi : T + (request.index - T) = request.index := by omega    unfold OAI.EditApproximation.PhysicalTableRequest.refinement    rw [hi]  have proof_active_request_eqRawBand_138 {α : Type u_4} {M : ℕ} {J : ℕ} (target : List.{u_4} α) (T : ℕ) (request : OAI.EditApproximation.PhysicalTableRequest M J (List.length.{u_4} target)) (hindex : LT.lt.{0} T request.index) :      OAI.EditApproximation.PhysicalTableRequest.refinement request.pass request.copy request.node T (request.index - T)        request.state = request := by    have hi : T + (request.index - T) = request.index := by omega    unfold OAI.EditApproximation.PhysicalTableRequest.refinement    rw [hi]  exact    OAI.EditApproximation.BitQuery.mapKeysWithWork      (fun key => (Sum.map id (fun child => ⟨child.val, by        simpa only [proof_active_request_eqRawBand_138 (target := target) (T := T) (request := request) (hindex := hindex)] using child.property⟩) key, 1))      (OAI.EditApproximation.queryFamilyRefinementRawBand (R := R) source target N P F exponent H Q eM eF hP hM hF tau a eta kappa delta        passes copies request.pass request.copy T S (request.index - T) (Nat.sub_pos_of_lt hindex)        request.node hbelow (Fin.ofNat R (request.index - T - 1)) request.state)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable {α : Type u_4} [DecidableEq α] {M J R : ℕ} [NeZero M] [NeZero R] (source target : List α) (N P F exponent H Q eM eF : ℕ) (hP : 0 < P) (hM : M = 2 ^ eM) (hF : F = 2 ^ eF) (tau a eta kappa delta : BinaryFraction) (T S passes copies : ℕ) (parent : {r : PhysicalTableRequest M J target.length // r.Bounded (passes + 1) copies T S}) (hindex : T < parent.val.index) (hbelow : parent.val.node.1.val < J)def queryFamilyBoundedActiveRawBand :    OAI.EditApproximation.BitQuery (Sum (OAI.EditApproximation.PhysicalFamilyScalarKey (M := M) (J := J) (R := R)      target N P F exponent H Q passes copies)      {child : {r : OAI.EditApproximation.PhysicalTableRequest M J target.length // r.Bounded (passes + 1) copies T S} //        child.val.combinedRank T S < parent.val.combinedRank T S}) OAI.EditApproximation.BinaryFraction :=  OAI.EditApproximation.queryRestrictPhysicalBody (passes + 1) copies T S parent    (OAI.EditApproximation.queryFamilyActiveRawBand (R := R) source target N P F exponent H Q eM eF hP hM hF tau a eta kappa delta      T S passes copies parent.val hindex hbelow)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable {M J R passes copies T S : ℕ} [NeZero M] [NeZero R] (source target : List ℕ) (N P F exponent H Q eM eF : ℕ) (hP : 0 < P) (hM : M = 2 ^ eM) (hF : F = 2 ^ eF) (A a : ℕ → BinaryFraction) (tau eta kappa delta : BinaryFraction) (multiplier : ℕ → ℕ) (occurrence : BinaryMemo PositionCounts) (symbolBits positionBits : ℕ)def queryChargedFamilyTableRawBand    (parent : {r : OAI.EditApproximation.PhysicalTableRequest M J target.length // r.Bounded (passes + 1) copies T S}) :    OAI.EditApproximation.BitQuery (OAI.EditApproximation.ChargedFamilyQueryKey (R := R) target N P F exponent H Q (.inr parent)) OAI.EditApproximation.BinaryFraction := by  have proof_table_rank_lt_99 {M : ℕ} {J : ℕ} {ny : ℕ} {passes : ℕ} {copies : ℕ} {T : ℕ} {S : ℕ} (parent : Subtype.{1} fun request => OAI.EditApproximation.PhysicalTableRequest.Bounded (M := M) (J := J) (ny := ny) passes copies T S request) (child : Subtype.{1} fun request => OAI.EditApproximation.PhysicalTableRequest.Bounded (M := M) (J := J) (ny := ny) passes copies T S request) (h : LT.lt.{0} (OAI.EditApproximation.PhysicalTableRequest.combinedRank T S child.val)    (OAI.EditApproximation.PhysicalTableRequest.combinedRank T S parent.val)) :      OAI.EditApproximation.ChargedPhysicalRequest.rank (Sum.inr child : OAI.EditApproximation.ChargedPhysicalRequest M J ny passes copies T S) < OAI.EditApproximation.ChargedPhysicalRequest.rank (Sum.inr parent) := by    simpa only [OAI.EditApproximation.ChargedPhysicalRequest.rank, OAI.EditApproximation.ChargedPhysicalRequest.depth, OAI.EditApproximation.ChargedPhysicalRequest.index, ← Nat.add_assoc, OAI.EditApproximation.PhysicalTableRequest.combinedRank] using      Nat.add_lt_add_right h 1  have proof_bitOrdering_matches_4 (high : Ordering) (a : Bool) (b : Bool) (x : ℕ) (y : ℕ) (h : OAI.EditApproximation.orderingMatches high x y) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitOrdering high a b) (a.toNat + 2 * x) (b.toNat + 2 * y) := by    rcases h with ⟨rfl, h⟩ | ⟨rfl, rfl⟩ | ⟨rfl, h⟩    · exact Or.inl ⟨rfl, by cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩    · cases a <;> cases b <;> simp [OAI.EditApproximation.bitOrdering, OAI.EditApproximation.orderingMatches]    · exact Or.inr (Or.inr ⟨rfl, by        cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩)  have proof_bitCompareWithWork_matches_5 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitCompareWithWork left right).1 (OAI.EditApproximation.bitWordValue left) (OAI.EditApproximation.bitWordValue right) := by    induction left generalizing right with    | nil =>      simp only [OAI.EditApproximation.bitCompareWithWork]      induction right with      | nil => (simp [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.orderingMatches, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        simpa only [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareNilLeftWithWork bs).1 false b 0 (OAI.EditApproximation.bitWordValue bs) ih    | cons a as ih =>      cases right with      | nil =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as []).1 a false (OAI.EditApproximation.bitWordValue as) 0 (ih [])      | cons b bs =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue] using          proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as bs).1 a b (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs) (ih bs)  have proof_bitCompareWithWork_lt_16 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .lt ↔ OAI.EditApproximation.bitWordValue left < OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_wordLEWithWork_value_26 (a : List.{0} Bool) (b : List.{0} Bool) :      (OAI.EditApproximation.wordLEWithWork a b).1 = true ↔ OAI.EditApproximation.bitWordValue a ≤ OAI.EditApproximation.bitWordValue b := by    simp only [OAI.EditApproximation.wordLEWithWork, Bool.not_eq_true', decide_eq_false_iff_not,      proof_bitCompareWithWork_lt_16, not_lt]  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_queryNaturalLEWithWork_value_140 (a : ℕ) (b : ℕ) :      (OAI.EditApproximation.wordLEWithWork a.bits b.bits).1 = true ↔ a ≤ b := by    simp only [proof_wordLEWithWork_value_26, proof_bitWordValue_bits_15]  have proof_binaryNaturalCompareWithWork_lt_53 (a : ℕ) (b : ℕ) :      (OAI.EditApproximation.binaryNaturalCompareWithWork a b).1 = .lt ↔ a < b := by    simpa only [OAI.EditApproximation.binaryNaturalCompareWithWork, proof_bitWordValue_bits_15] using proof_bitCompareWithWork_lt_16 a.bits b.bits  exact    let index := OAI.EditApproximation.wordLEWithWork parent.val.index.bits T.bits    .charge (index.2 + 1)      (if hi : index.1 = true then        OAI.EditApproximation.BitQuery.mapKeysWithWork (fun key => (Sum.inr key, 1))          (OAI.EditApproximation.queryChargedWarmup source target N P F (A parent.val.pass) (a parent.val.pass) multiplier            parent occurrence symbolBits positionBits)      else let depth := OAI.EditApproximation.binaryNaturalCompareWithWork parent.val.node.1.val J        .charge (depth.2 + 1)          (if hb : depth.1 = .lt then            let interval := OAI.EditApproximation.physicalSourceInterval source.length parent.val.node            let length := OAI.EditApproximation.saturatingSubtractWithWork interval.hi interval.lo            let short := OAI.EditApproximation.wordLEWithWork length.1 [true]            .charge (length.2 + short.2 + 1)              (if short.1 then                OAI.EditApproximation.BitQuery.mapKeysWithWork (fun key => (Sum.inr key, 1))                  (OAI.EditApproximation.queryPhysicalInitial source target N P F (A parent.val.pass) (a parent.val.pass)                    multiplier parent occurrence symbolBits positionBits parent.val.state)              else OAI.EditApproximation.BitQuery.mapKeysWithWork                (fun key => (Sum.map id (fun child =>                  ⟨Sum.inr child.val, proof_table_rank_lt_99 parent child.val child.property⟩)                  key, 1))                (OAI.EditApproximation.queryFamilyBoundedActiveRawBand (R := R) source target N P F exponent H Q eM eF hP hM hF                  tau (a parent.val.pass) eta kappa delta T S passes copies parent                  (Nat.lt_of_not_ge (fun h => hi ((proof_queryNaturalLEWithWork_value_140 parent.val.index T).mpr h)))                  ((proof_binaryNaturalCompareWithWork_lt_53 _ _).mp hb)))          else OAI.EditApproximation.BitQuery.mapKeysWithWork (fun key => (Sum.inr key, 1))            (OAI.EditApproximation.queryPhysicalInitial source target N P F (A parent.val.pass) (a parent.val.pass)              multiplier parent occurrence symbolBits positionBits parent.val.state)))def queryChargedFamilyGlobalRawBand    (coarse : OAI.EditApproximation.PhysicalEntry M J target.length → OAI.EditApproximation.BinaryFraction × ℕ)    (request : OAI.EditApproximation.ChargedPhysicalRequest M J target.length (passes + 1) copies T S) :    OAI.EditApproximation.BitQuery (OAI.EditApproximation.ChargedFamilyQueryKey (R := R) target N P F exponent H Q request) OAI.EditApproximation.BinaryFraction :=  match request with  | .inl entry => OAI.EditApproximation.BitQuery.compute (coarse entry)  | .inr parent => OAI.EditApproximation.queryChargedFamilyTableRawBand (R := R) source target N P F exponent H Q eM eF hP hM hF      A a tau eta kappa delta multiplier occurrence symbolBits positionBits parentend OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationvariable {M J R passes copies T S : ℕ} [NeZero M] [NeZero R] (source target : List ℕ) (N P F exponent H Q eM eF : ℕ) (hP : 0 < P) (hM : M = 2 ^ eM) (hF : F = 2 ^ eF) (A a : ℕ → BinaryFraction) (tau eta kappa delta : BinaryFraction) (multiplier : ℕ → ℕ) (occurrence : BinaryMemo PositionCounts) (symbolBits positionBits : ℕ) (coarse : PhysicalEntry M J target.length → BinaryFraction × ℕ) (draw : PhysicalFamilyScalarDraw (M := M) (J := J) (R := R)    target N P F exponent H Q passes copies)def queryFamilyMemoRawRawBand (key : OAI.EditApproximation.QueryFamilyMemoKey (M := M) (J := J) (R := R) (passes := passes) (copies := copies) (T := T) (S := S) target N P F exponent H Q) :=  OAI.EditApproximation.SourceRanked.bitBody OAI.EditApproximation.ChargedPhysicalRequest.rank    (OAI.EditApproximation.queryChargedFamilyGlobalRawBand (R := R) source target N P F exponent H Q eM eF hP hM hF      A a tau eta kappa delta multiplier occurrence symbolBits positionBits coarse)    (OAI.EditApproximation.queryFamilySourceWordWithWork target N P F exponent H Q draw) keyend OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen MeasureTheory ProbabilityTheorydef computedQueryMemoRawRawBand (source target : List ℕ) (N : ℕ)    (occurrence : OAI.EditApproximation.BinaryMemo OAI.EditApproximation.PositionCounts) (symbolBits positionBits : ℕ)    (input : OAI.EditApproximation.ComputedFamilyInput source target N) (key : OAI.EditApproximation.ComputedFamilyMemoKey source target N) := by  have proof_computedParameterP_pos_141 (N : ℕ) : 0 < (OAI.EditApproximation.integerParameters N).P :=    Nat.pow_pos (Nat.two_pow_pos _)  exact    OAI.EditApproximation.queryFamilyMemoRawRawBand source target N (OAI.EditApproximation.integerParameters N).P (OAI.EditApproximation.inputSmallLog N)      (40 * OAI.EditApproximation.smallLogExponent N) (OAI.EditApproximation.inputHeight N) (OAI.EditApproximation.inputSmallLog N ^ 80)      (OAI.EditApproximation.heightExponent N / 20) (OAI.EditApproximation.smallLogExponent N) (proof_computedParameterP_pos_141 N) rfl rfl      (fun pass => (OAI.EditApproximation.scheduledSeedWordWithWork N pass).1)      (fun pass => (OAI.EditApproximation.computedQueryParameters N pass).factor)      (OAI.EditApproximation.computedQueryParameters N 0).tau (OAI.EditApproximation.computedQueryParameters N 0).eta      (OAI.EditApproximation.computedQueryParameters N 0).kappa (OAI.EditApproximation.computedQueryParameters N 0).delta      (OAI.EditApproximation.scheduledSeedMultiplier N) occurrence symbolBits positionBits      (fun entry => (OAI.EditApproximation.BinaryFraction.nat (OAI.EditApproximation.clampedSeedNat input.1 entry), 0)) input.2 keyend OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationdef computedQueryMemoNormalizedRawBand (source target : List ℕ) (N : ℕ)    (occurrence : OAI.EditApproximation.BinaryMemo OAI.EditApproximation.PositionCounts) (symbolBits positionBits : ℕ)    (input : OAI.EditApproximation.ComputedFamilyInput source target N) :    (key : OAI.EditApproximation.ComputedFamilyMemoKey source target N) → OAI.EditApproximation.BitQuery      {child : OAI.EditApproximation.ComputedFamilyMemoKey source target N //        OAI.EditApproximation.SourceRanked.rank OAI.EditApproximation.ChargedPhysicalRequest.rank child < OAI.EditApproximation.SourceRanked.rank OAI.EditApproximation.ChargedPhysicalRequest.rank key}      OAI.EditApproximation.BinaryFraction := by  have proof_trimBitWordWithWork_value_6 (bits : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.trimBitWordWithWork bits).1 = OAI.EditApproximation.bitWordValue bits := by    induction bits with    | nil => rfl    | cons bit bits ih =>      simp only [OAI.EditApproximation.trimBitWordWithWork]      split_ifs with h      · have ht : OAI.EditApproximation.bitWordValue bits = 0 := by rw [← ih, h.1]; rfl        simp [h.2, OAI.EditApproximation.bitWordValue, ht]      · (simp only [OAI.EditApproximation.bitWordValue, ih])  have proof_bitAdder_value_1 (a : Bool) (b : Bool) (carry : Bool) :      (OAI.EditApproximation.bitSum a b carry).toNat + 2 * (OAI.EditApproximation.bitCarry a b carry).toNat =        a.toNat + b.toNat + carry.toNat := by    cases a <;> cases b <;> cases carry <;> decide  have proof_bitAddWithWork_value_2 (left : List.{0} Bool) (right : List.{0} Bool) (carry : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitAddWithWork left right carry).1 =        OAI.EditApproximation.bitWordValue left + OAI.EditApproximation.bitWordValue right + carry.toNat := by    induction left generalizing right carry with    | nil =>      simp only [OAI.EditApproximation.bitAddWithWork]      induction right generalizing carry with      | nil => cases carry <;> simp [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue]      | cons b bs ih =>        simp only [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 false b carry        simp only [Bool.toNat_false] at h        omega    | cons a as ih =>      cases right with      | nil =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a false carry        simp only [Bool.toNat_false] at h        omega      | cons b bs =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a b carry        omega  have proof_bitMulWithWork_value_0 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitMulWithWork left right).1 = OAI.EditApproximation.bitWordValue left * OAI.EditApproximation.bitWordValue right := by    induction left with    | nil => simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue]    | cons bit bits ih =>      cases bit <;> simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue, proof_bitAddWithWork_value_2, ih] <;> ring  have proof_bitPowerWithWork_value_76 (base : List.{0} Bool) (n : ℕ) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitPowerWithWork base n).1 = OAI.EditApproximation.bitWordValue base ^ n := by    induction n with    | zero => (simp [OAI.EditApproximation.bitPowerWithWork, OAI.EditApproximation.bitWordValue])    | succ n ih =>      simp only [OAI.EditApproximation.bitPowerWithWork, proof_trimBitWordWithWork_value_6, proof_bitMulWithWork_value_0, ih, pow_succ]  have proof_refinementBaseWithWork_value_143 (ell : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.refinementBaseWithWork ell).1 = OAI.EditApproximation.bitWordValue ell ^ 10 + 1 := by    (simp only [OAI.EditApproximation.refinementBaseWithWork, proof_trimBitWordWithWork_value_6, proof_bitAddWithWork_value_2,      proof_bitPowerWithWork_value_76, OAI.EditApproximation.bitWordValue, Bool.toNat_true, Bool.toNat_false])  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_computedQueryBase_value_144 (N : ℕ) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.computedQueryBase N) = OAI.EditApproximation.inputSmallLog N ^ 10 + 1 := by    simp only [OAI.EditApproximation.computedQueryBase, proof_refinementBaseWithWork_value_143, proof_bitWordValue_bits_15]  have proof_computedQueryBase_pos_142 (N : ℕ) : 0 < OAI.EditApproximation.bitWordValue (OAI.EditApproximation.computedQueryBase N) := by    rw [proof_computedQueryBase_value_144]    omega  exact    OAI.EditApproximation.rankedNormalizeBody (OAI.EditApproximation.SourceRanked.rank OAI.EditApproximation.ChargedPhysicalRequest.rank)      (OAI.EditApproximation.computedQueryMemoRawRawBand source target N occurrence symbolBits positionBits input)      (OAI.EditApproximation.computedQueryBase N) (proof_computedQueryBase_pos_142 N)      (OAI.EditApproximation.queryFamilyMemoRemaining target N (OAI.EditApproximation.integerParameters N).P (OAI.EditApproximation.inputSmallLog N)        (40 * OAI.EditApproximation.smallLogExponent N) (OAI.EditApproximation.inputHeight N) (OAI.EditApproximation.inputSmallLog N ^ 80))end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationattribute [local instance] queryRoundsNeZerodef computedQueryMemoResultRawBand (source target : List ℕ) (N : ℕ)    (occurrence : OAI.EditApproximation.BinaryMemo OAI.EditApproximation.PositionCounts) (symbolBits positionBits : ℕ)    (input : OAI.EditApproximation.ComputedFamilyInput source target N) :=  OAI.EditApproximation.rankedBitMemoEvaluate (OAI.EditApproximation.SourceRanked.rank OAI.EditApproximation.ChargedPhysicalRequest.rank)    (OAI.EditApproximation.computedQueryMemoNormalizedRawBand source target N occurrence symbolBits positionBits input)    (16384 * OAI.EditApproximation.inputHeight N + 5) (OAI.EditApproximation.computedFamilyMemoCode source target N (OAI.EditApproximation.inputHeight N ^ 2))    (.inr (OAI.EditApproximation.localFinalRootRequest target N (OAI.EditApproximation.integerParameters N).T (OAI.EditApproximation.integerParameters N).S      (OAI.EditApproximation.inputHeight N) (Nat.two_pow_pos _) (OAI.EditApproximation.finalTargetState target.length))) .emptydef computedQueryLocalWorkRawBand (source target : List ℕ) (N : ℕ)    (occurrence : OAI.EditApproximation.BinaryMemo OAI.EditApproximation.PositionCounts) (symbolBits positionBits : ℕ)    (input : OAI.EditApproximation.ComputedFamilyInput source target N) : OAI.EditApproximation.ComputedFamilyMemoKey source target N → ℕ :=  OAI.EditApproximation.rankedBitLocalWork (OAI.EditApproximation.SourceRanked.rank OAI.EditApproximation.ChargedPhysicalRequest.rank)    (OAI.EditApproximation.computedQueryMemoNormalizedRawBand source target N occurrence symbolBits positionBits input)def computedQueryAnswerWithWorkRawBand (source target : List ℕ) (N : ℕ)    (occurrence : OAI.EditApproximation.BinaryMemo OAI.EditApproximation.PositionCounts) (symbolBits positionBits : ℕ)    (input : OAI.EditApproximation.ComputedFamilyInput source target N) : List Bool × ℕ :=  if source = target then ([], source.length + target.length + 1)  else let result := OAI.EditApproximation.computedQueryMemoResultRawBand source target N occurrence symbolBits positionBits input    let answer := OAI.EditApproximation.BinaryFraction.finalAnswerWithWork N result.value    (answer.1, answer.2 + source.length + target.length + 1)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen Filter MeasureTheorydef integerQueryLocalWorkRawBand (source target : List ℤ) (N : ℕ) :=  OAI.EditApproximation.computedQueryLocalWorkRawBand (source.map OAI.EditApproximation.integerSymbolCode) (target.map OAI.EditApproximation.integerSymbolCode) N    (OAI.EditApproximation.integerOccurrenceIndex source target) (OAI.EditApproximation.integerInputSymbolBits source target) (OAI.EditApproximation.integerInputPositionBits target)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationdef integerBinaryOutputRawBand (source target : List ℤ) (N : ℕ)    (input : OAI.EditApproximation.ComputedFamilyInput (source.map OAI.EditApproximation.integerSymbolCode) (target.map OAI.EditApproximation.integerSymbolCode) N) :=  OAI.EditApproximation.computedQueryAnswerWithWorkRawBand (source.map OAI.EditApproximation.integerSymbolCode) (target.map OAI.EditApproximation.integerSymbolCode) N    (OAI.EditApproximation.integerOccurrenceIndex source target) (OAI.EditApproximation.integerInputSymbolBits source target) (OAI.EditApproximation.integerInputPositionBits target) inputend OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen MeasureTheorynoncomputable def integerBinaryAnswerRawBand (source target : List ℤ) (N : ℕ) (epsilon : OAI.EditApproximation.BinaryFraction)    (outcome : OAI.EditApproximation.ComputedFullOutcome (source.map OAI.EditApproximation.integerSymbolCode) (target.map OAI.EditApproximation.integerSymbolCode) N) : ℕ :=  if OAI.EditApproximation.physicalLargeInput N epsilon then    match outcome with    | .inl _ => OAI.EditApproximation.exactSuffixAnswer (source.map OAI.EditApproximation.integerSymbolCode) (target.map OAI.EditApproximation.integerSymbolCode)    | .inr execution => OAI.EditApproximation.bitWordValue (OAI.EditApproximation.integerBinaryOutputRawBand source target N        (OAI.EditApproximation.computedExecutionAccepted _ _ N execution)).1  else OAI.EditApproximation.exactSuffixAnswer (source.map OAI.EditApproximation.integerSymbolCode) (target.map OAI.EditApproximation.integerSymbolCode)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.BinaryFractionvariable {α : Type u_4} (source target : List α) {M : ℕ} (parent : TargetInterval source.length) (P F exponent Q eM eF : ℕ) (hM : M = 2 ^ eM) (hF : F = 2 ^ eF) (hP : 0 < P) (tau a : BinaryFraction) (parentInitial : TargetInterval target.length → BinaryFraction × ℕ) (child initial current : Fin M → TargetInterval target.length → BinaryFraction × ℕ) (R : ℕ) (hc : ∀ i q, (child i q).2 ≤ R) (hi : ∀ i q, (initial i q).2 ≤ R) (parentAllocation : TargetInterval target.length → ℕ) (childAllocation initialAllocation currentAllocation : Fin M → TargetInterval target.length → ℕ)open Finsetdef preparedComputedCellSourceAllocationRawBand (b eb : ℕ) (hb : b = 2 ^ eb)    (draw : OAI.EditApproximation.cellScaleReadDraw M b Q (OAI.EditApproximation.BinaryFraction.nat F).value)    (drawAllocation : ∀ t : Fin (OAI.EditApproximation.groupDyadicScales M b (OAI.EditApproximation.BinaryFraction.nat F).value).length,      Fin (OAI.EditApproximation.groupSampleCount M Q b (OAI.EditApproximation.groupDyadicScaleAt M b (OAI.EditApproximation.BinaryFraction.nat F).value t)) → ℕ)    (cell : ℕ × ℕ) : ℕ := by  have proof_representation_value_32 (a : OAI.EditApproximation.BinaryFraction) : a.representation.value = a.value := rfl  have proof_eq_of_num_den_33 {a : OAI.EditApproximation.UnreducedRational} {b : OAI.EditApproximation.UnreducedRational} (hnum : Eq.{1} a.num b.num) (hden : Eq.{1} a.den b.den) : a = b := by    cases a    cases b    cases hnum    cases hden    rfl  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_value_ofInt_46 (a : ℤ) : (OAI.EditApproximation.SignedBinary.ofInt a).value = a := by    by_cases h : a < 0    · simpa only [OAI.EditApproximation.SignedBinary.ofInt, OAI.EditApproximation.SignedBinary.value, proof_bitWordValue_bits_15, OAI.EditApproximation.signedMagnitude, h, decide_true,        ↓reduceIte] using (Int.eq_neg_natAbs_of_nonpos (le_of_lt h)).symm    · simpa only [OAI.EditApproximation.SignedBinary.ofInt, OAI.EditApproximation.SignedBinary.value, proof_bitWordValue_bits_15, OAI.EditApproximation.signedMagnitude, h, decide_false,        Bool.false_eq_true, ↓reduceIte] using (Int.eq_natAbs_of_nonneg (le_of_not_gt h)).symm  have proof_nat_representation_47 (n : ℕ) : (OAI.EditApproximation.BinaryFraction.nat n).representation = OAI.EditApproximation.UnreducedRational.nat n := by    apply proof_eq_of_num_den_33    · change (OAI.EditApproximation.SignedBinary.ofInt (n : ℤ)).value = (n : ℤ)      exact proof_value_ofInt_46 _    · rfl  have proof_value_nat_48 (n : ℕ) : (OAI.EditApproximation.UnreducedRational.nat n).value = n := by (simp [OAI.EditApproximation.UnreducedRational.nat, OAI.EditApproximation.UnreducedRational.value])  have proof_nat_value_49 (n : ℕ) : (OAI.EditApproximation.BinaryFraction.nat n).value = (n : ℚ) := by    rw [← proof_representation_value_32, proof_nat_representation_47, proof_value_nat_48]  have proof_arithmeticMapWithWork_value_70 {α : Type 0} {β : Type 0} (f : α → Prod.{0, 0} β ℕ) (values : List.{0} α) :      (OAI.EditApproximation.arithmeticMapWithWork f values).1 = values.map (fun a => (f a).1) := by    induction values with    | nil => rfl    | cons a rest ih => simp only [OAI.EditApproximation.arithmeticMapWithWork, ih, List.map_cons]  have proof_powerTwoWord_value_13 (n : ℕ) : OAI.EditApproximation.bitWordValue (OAI.EditApproximation.powerTwoWord n) = 2 ^ n := by    induction n with    | zero => (simp [OAI.EditApproximation.powerTwoWord, OAI.EditApproximation.bitWordValue])    | succ n ih =>      (simp only [OAI.EditApproximation.powerTwoWord, List.replicate_succ, List.cons_append, OAI.EditApproximation.bitWordValue,        Bool.toNat_false, zero_add] at *)      rw [ih, pow_succ]      omega  have proof_inversePowerTwo_value_89 (n : ℕ) : (OAI.EditApproximation.BinaryFraction.inversePowerTwo n).value = (2 : ℚ) ^ (-(n : ℤ)) := by    (simp only [OAI.EditApproximation.BinaryFraction.inversePowerTwo, OAI.EditApproximation.BinaryFraction.value, OAI.EditApproximation.SignedBinary.value, OAI.EditApproximation.signedMagnitude, Bool.false_eq_true,      ↓reduceIte, OAI.EditApproximation.bitWordValue, Bool.toNat_true,      Int.cast_natCast, proof_powerTwoWord_value_13, Nat.cast_pow, Nat.cast_ofNat, zpow_neg, zpow_natCast])    norm_num [one_div]  have proof_signedPowerTwoWithWork_value_90 (e : ℤ) :      (OAI.EditApproximation.BinaryFraction.signedPowerTwoWithWork e).1.value = (2 : ℚ) ^ e := by    unfold OAI.EditApproximation.BinaryFraction.signedPowerTwoWithWork    split_ifs with h    · change (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.powerTwoWord e.toNat) : ℚ) / 1 = (2 : ℚ) ^ e      rw [div_one, proof_powerTwoWord_value_13, Nat.cast_pow, Nat.cast_ofNat, ← zpow_natCast,        Int.toNat_of_nonneg h]    · rw [proof_inversePowerTwo_value_89, Int.toNat_of_nonneg        (show 0 ≤ -e from neg_nonneg.mpr (le_of_lt (lt_of_not_ge h))), neg_neg]  have proof_groupScalesWithWork_value_91 (eM : ℕ) (eb : ℕ) (eF : ℕ) :      ((OAI.EditApproximation.BinaryFraction.groupScalesWithWork eM eb eF).1.map OAI.EditApproximation.BinaryFraction.value) =        OAI.EditApproximation.groupDyadicScales (2 ^ eM) (2 ^ eb) ((2 : ℚ) ^ eF) := by    have hlower : ((2 ^ eb : ℕ) : ℚ) / (2 ^ eM : ℕ) = (2 : ℚ) ^ ((eb : ℤ) - eM) := by      rw [Nat.cast_pow, Nat.cast_pow, Nat.cast_ofNat, zpow_sub₀ (by norm_num : (2 : ℚ) ≠ 0),        zpow_natCast, zpow_natCast]    have hupper : (64 : ℚ) * (2 : ℚ) ^ eF * (2 ^ eb : ℕ) =        (2 : ℚ) ^ ((6 + eF + eb : ℕ) : ℤ) := by      rw [Nat.cast_pow, Nat.cast_ofNat, zpow_natCast, pow_add, pow_add]      norm_num    have hlog : Int.log 2 ((2 : ℚ) ^ ((6 + eF + eb : ℕ) : ℤ)) = ((6 + eF + eb : ℕ) : ℤ) := by      simpa only [Nat.cast_ofNat] using Int.log_zpow (R := ℚ) (by decide : 1 < 2) ((6 + eF + eb : ℕ) : ℤ)    have hclog : Int.clog 2 ((2 : ℚ) ^ ((eb : ℤ) - eM)) = (eb : ℤ) - eM := by      simpa only [Nat.cast_ofNat] using Int.clog_zpow (R := ℚ) (by decide : 1 < 2) ((eb : ℤ) - eM)    simp only [OAI.EditApproximation.BinaryFraction.groupScalesWithWork, proof_arithmeticMapWithWork_value_70, List.map_map,      Function.comp_def, proof_signedPowerTwoWithWork_value_90, OAI.EditApproximation.groupDyadicScales, hlower, hupper, hlog, hclog]  have proof_computedGroupScales_value_87 (M : ℕ) (b : ℕ) (F : ℕ) (eM : ℕ) (eb : ℕ) (eF : ℕ) (hM : Eq.{1} M (HPow.hPow.{0, 0, 0} 2 eM)) (hb : Eq.{1} b (HPow.hPow.{0, 0, 0} 2 eb)) (hF : Eq.{1} F (HPow.hPow.{0, 0, 0} 2 eF)) :      (OAI.EditApproximation.BinaryFraction.groupScalesWithWork eM eb eF).1.map OAI.EditApproximation.BinaryFraction.value = OAI.EditApproximation.groupDyadicScales M b (OAI.EditApproximation.BinaryFraction.nat F).value := by    rw [proof_nat_value_49, hM, hb, hF, Nat.cast_pow, Nat.cast_ofNat]    exact proof_groupScalesWithWork_value_91 eM eb eF  exact    OAI.EditApproximation.BinaryFraction.groupScalesAllocation eM eb eF +      OAI.EditApproximation.BinaryFraction.preparedCellGroupSourceAllocationRaw source target parent b P F exponent Q        (by rw [hb]; exact Nat.two_pow_pos eb) hP tau a parentInitial child initial current        R R hc hi (OAI.EditApproximation.BinaryFraction.groupScalesWithWork eM eb eF).1 (proof_computedGroupScales_value_87 M b F eM eb eF hM hb hF)        draw parentAllocation childAllocation initialAllocation currentAllocation drawAllocation cellend OAI.EditApproximation.BinaryFractionendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.BinaryFractionvariable {α : Type*} (source target : List α) {M : ℕ} (parent : TargetInterval source.length) (P F exponent Q eM eF : ℕ) (hM : M = 2 ^ eM) (hF : F = 2 ^ eF) (hP : 0 < P) (tau a : BinaryFraction) (parentInitial : TargetInterval target.length → BinaryFraction × ℕ) (child initial current : Fin M → TargetInterval target.length → BinaryFraction × ℕ) (R : ℕ) (hc : ∀ i q, (child i q).2 ≤ R) (hi : ∀ i q, (initial i q).2 ≤ R) (parentAllocation : TargetInterval target.length → ℕ) (childAllocation initialAllocation currentAllocation : Fin M → TargetInterval target.length → ℕ)variable (draw : CellGroupReadDraws M F Q) (drawAllocation : CellGroupSourceAllocations M F Q)open Finsetdef castGroupSourceAllocationRawBand (b : ℕ) (cell : ℕ × ℕ) :    ∀ t : Fin (OAI.EditApproximation.groupDyadicScales M b (OAI.EditApproximation.BinaryFraction.nat F).value).length,      Fin (OAI.EditApproximation.groupSampleCount M Q b (OAI.EditApproximation.groupDyadicScaleAt M b (OAI.EditApproximation.BinaryFraction.nat F).value t)) → ℕ := by  have proof_representation_value_32 (a : OAI.EditApproximation.BinaryFraction) : a.representation.value = a.value := rfl  have proof_eq_of_num_den_33 {a : OAI.EditApproximation.UnreducedRational} {b : OAI.EditApproximation.UnreducedRational} (hnum : Eq.{1} a.num b.num) (hden : Eq.{1} a.den b.den) : a = b := by    cases a    cases b    cases hnum    cases hden    rfl  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_value_ofInt_46 (a : ℤ) : (OAI.EditApproximation.SignedBinary.ofInt a).value = a := by    by_cases h : a < 0    · simpa only [OAI.EditApproximation.SignedBinary.ofInt, OAI.EditApproximation.SignedBinary.value, proof_bitWordValue_bits_15, OAI.EditApproximation.signedMagnitude, h, decide_true,        ↓reduceIte] using (Int.eq_neg_natAbs_of_nonpos (le_of_lt h)).symm    · simpa only [OAI.EditApproximation.SignedBinary.ofInt, OAI.EditApproximation.SignedBinary.value, proof_bitWordValue_bits_15, OAI.EditApproximation.signedMagnitude, h, decide_false,        Bool.false_eq_true, ↓reduceIte] using (Int.eq_natAbs_of_nonneg (le_of_not_gt h)).symm  have proof_nat_representation_47 (n : ℕ) : (OAI.EditApproximation.BinaryFraction.nat n).representation = OAI.EditApproximation.UnreducedRational.nat n := by    apply proof_eq_of_num_den_33    · change (OAI.EditApproximation.SignedBinary.ofInt (n : ℤ)).value = (n : ℤ)      exact proof_value_ofInt_46 _    · rfl  have proof_value_nat_48 (n : ℕ) : (OAI.EditApproximation.UnreducedRational.nat n).value = n := by (simp [OAI.EditApproximation.UnreducedRational.nat, OAI.EditApproximation.UnreducedRational.value])  have proof_nat_value_49 (n : ℕ) : (OAI.EditApproximation.BinaryFraction.nat n).value = (n : ℚ) := by    rw [← proof_representation_value_32, proof_nat_representation_47, proof_value_nat_48]  exact    Eq.mpr (congrArg (fun f => ∀ t : Fin (OAI.EditApproximation.groupDyadicScales M b f).length,      Fin (OAI.EditApproximation.groupSampleCount M Q b (OAI.EditApproximation.groupDyadicScaleAt M b f t)) → ℕ) (proof_nat_value_49 F)) (drawAllocation b cell)end OAI.EditApproximation.BinaryFractionendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.BinaryFractionvariable {α : Type u_4} (source target : List α) {M : ℕ} (parent : TargetInterval source.length) (P F exponent Q eM eF : ℕ) (hM : M = 2 ^ eM) (hF : F = 2 ^ eF) (hP : 0 < P) (tau a : BinaryFraction) (parentInitial : TargetInterval target.length → BinaryFraction × ℕ) (child initial current : Fin M → TargetInterval target.length → BinaryFraction × ℕ) (R : ℕ) (hc : ∀ i q, (child i q).2 ≤ R) (hi : ∀ i q, (initial i q).2 ≤ R) (parentAllocation : TargetInterval target.length → ℕ) (childAllocation initialAllocation currentAllocation : Fin M → TargetInterval target.length → ℕ)variable (draw : CellGroupReadDraws M F Q) (drawAllocation : CellGroupSourceAllocations M F Q)open Finsetdef preparedLocalGroupScaleSourceAllocationRawBand (eb : ℕ) (query : OAI.EditApproximation.TargetInterval target.length) : ℕ := by  have proof_representation_value_32 (a : OAI.EditApproximation.BinaryFraction) : a.representation.value = a.value := rfl  have proof_eq_of_num_den_33 {a : OAI.EditApproximation.UnreducedRational} {b : OAI.EditApproximation.UnreducedRational} (hnum : Eq.{1} a.num b.num) (hden : Eq.{1} a.den b.den) : a = b := by    cases a    cases b    cases hnum    cases hden    rfl  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_value_ofInt_46 (a : ℤ) : (OAI.EditApproximation.SignedBinary.ofInt a).value = a := by    by_cases h : a < 0    · simpa only [OAI.EditApproximation.SignedBinary.ofInt, OAI.EditApproximation.SignedBinary.value, proof_bitWordValue_bits_15, OAI.EditApproximation.signedMagnitude, h, decide_true,        ↓reduceIte] using (Int.eq_neg_natAbs_of_nonpos (le_of_lt h)).symm    · simpa only [OAI.EditApproximation.SignedBinary.ofInt, OAI.EditApproximation.SignedBinary.value, proof_bitWordValue_bits_15, OAI.EditApproximation.signedMagnitude, h, decide_false,        Bool.false_eq_true, ↓reduceIte] using (Int.eq_natAbs_of_nonneg (le_of_not_gt h)).symm  have proof_nat_representation_47 (n : ℕ) : (OAI.EditApproximation.BinaryFraction.nat n).representation = OAI.EditApproximation.UnreducedRational.nat n := by    apply proof_eq_of_num_den_33    · change (OAI.EditApproximation.SignedBinary.ofInt (n : ℤ)).value = (n : ℤ)      exact proof_value_ofInt_46 _    · rfl  have proof_value_nat_48 (n : ℕ) : (OAI.EditApproximation.UnreducedRational.nat n).value = n := by (simp [OAI.EditApproximation.UnreducedRational.nat, OAI.EditApproximation.UnreducedRational.value])  have proof_nat_value_49 (n : ℕ) : (OAI.EditApproximation.BinaryFraction.nat n).value = (n : ℚ) := by    rw [← proof_representation_value_32, proof_nat_representation_47, proof_value_nat_48]  exact    let b := 2 ^ eb    let side := (OAI.EditApproximation.BinaryFraction.canonicalMulWithWork (OAI.EditApproximation.BinaryFraction.inversePowerTwo exponent) (OAI.EditApproximation.BinaryFraction.nat b)).1    let radius := (OAI.EditApproximation.BinaryFraction.naturalCeilingWithWork (parentInitial query).1).1    let cells := (OAI.EditApproximation.BinaryFraction.targetCellsWithWork side (OAI.EditApproximation.bitWordValue radius) query).1    parentAllocation query + OAI.EditApproximation.BinaryFraction.canonicalMulAllocation (OAI.EditApproximation.BinaryFraction.inversePowerTwo exponent) (OAI.EditApproximation.BinaryFraction.nat b) +      OAI.EditApproximation.BinaryFraction.naturalCeilingAllocation (parentInitial query).1 + OAI.EditApproximation.BinaryFraction.targetCellsAllocation side (OAI.EditApproximation.bitWordValue radius) query +      OAI.EditApproximation.filterMapAllocation (fun cell =>        OAI.EditApproximation.BinaryFraction.preparedComputedCellSourceWithWorkRawBand source target parent P F exponent Q eM eF hM hF hP tau a          parentInitial child initial current R hc hi b eb rfl          (Eq.mpr (congrArg (OAI.EditApproximation.cellScaleReadDraw M b Q) (proof_nat_value_49 F)) (draw b cell)) cell)        (fun cell => OAI.EditApproximation.BinaryFraction.preparedComputedCellSourceAllocationRawBand source target parent P F exponent Q eM eF hM hF hP tau a          parentInitial child initial current R hc hi parentAllocation childAllocation initialAllocation currentAllocation          b eb rfl (Eq.mpr (congrArg (OAI.EditApproximation.cellScaleReadDraw M b Q) (proof_nat_value_49 F)) (draw b cell))          (OAI.EditApproximation.BinaryFraction.castGroupSourceAllocationRawBand F Q drawAllocation b cell) cell) cells + ebend OAI.EditApproximation.BinaryFractionendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.BinaryFractionvariable {α : Type u_4} (source target : List α) {M : ℕ} (parent : TargetInterval source.length) (P F exponent Q eM eF : ℕ) (hM : M = 2 ^ eM) (hF : F = 2 ^ eF) (hP : 0 < P) (tau a : BinaryFraction) (parentInitial : TargetInterval target.length → BinaryFraction × ℕ) (child initial current : Fin M → TargetInterval target.length → BinaryFraction × ℕ) (R : ℕ) (hc : ∀ i q, (child i q).2 ≤ R) (hi : ∀ i q, (initial i q).2 ≤ R) (parentAllocation : TargetInterval target.length → ℕ) (childAllocation initialAllocation currentAllocation : Fin M → TargetInterval target.length → ℕ)variable (draw : CellGroupReadDraws M F Q) (drawAllocation : CellGroupSourceAllocations M F Q)def localGroupSourceScaleBlockRawBand (eb : ℕ) (query : OAI.EditApproximation.TargetInterval target.length) :    List (OAI.EditApproximation.BinaryBellmanAction (OAI.EditApproximation.TargetInterval target.length) (Fin M × OAI.EditApproximation.TargetInterval target.length) M) × ℕ :=  let guard := OAI.EditApproximation.BinaryFraction.refinementScaleGuardWithWork F (2 ^ eb) a (parentInitial query).1  if guard.1 then    let selected := OAI.EditApproximation.BinaryFraction.preparedLocalGroupScaleSourceWithWorkRawBand source target parent P F exponent Q eM eF      hM hF hP tau a parentInitial child initial current R hc hi eb draw query    (selected.1, guard.2 + selected.2 + eb + 4)  else ([], guard.2 + eb + 4)def localGroupSourceScaleBlockAllocationRawBand (eb : ℕ) (query : OAI.EditApproximation.TargetInterval target.length) : ℕ :=  OAI.EditApproximation.BinaryFraction.refinementScaleGuardAllocation F (2 ^ eb) a (parentInitial query).1 + eb +    if (OAI.EditApproximation.BinaryFraction.refinementScaleGuardWithWork F (2 ^ eb) a (parentInitial query).1).1 then      OAI.EditApproximation.BinaryFraction.preparedLocalGroupScaleSourceAllocationRawBand source target parent P F exponent Q eM eF hM hF hP tau a        parentInitial child initial current R hc hi parentAllocation childAllocation initialAllocation currentAllocation        draw drawAllocation eb query    else 0def preparedLocalCellGroupsSourceAllocationRawBand (N : ℕ) (query : OAI.EditApproximation.TargetInterval target.length) : ℕ :=  let count := max 1 N.bits.length  parentAllocation query + count + N.bits.length +    OAI.EditApproximation.arithmeticFlatMapAllocation      (fun eb => OAI.EditApproximation.BinaryFraction.localGroupSourceScaleBlockRawBand source target parent P F exponent Q eM eF hM hF hP tau a        parentInitial child initial current R hc hi draw eb query)      (fun eb => OAI.EditApproximation.BinaryFraction.localGroupSourceScaleBlockAllocationRawBand source target parent P F exponent Q eM eF hM hF hP tau a        parentInitial child initial current R hc hi parentAllocation childAllocation initialAllocation currentAllocation        draw drawAllocation eb query) (List.range count)end OAI.EditApproximation.BinaryFractionendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.BinaryFractionvariable {α : Type u_4} (source target : List α) {M : ℕ} (parent : TargetInterval source.length) (P F exponent H : ℕ) (hP : 0 < P) (tau a eta kappa : BinaryFraction) (parentInitial : TargetInterval target.length → BinaryFraction × ℕ) (child initial : Fin M → TargetInterval target.length → BinaryFraction × ℕ) (table : ℕ → Fin M × TargetInterval target.length → BinaryFraction × ℕ) (R : ℕ) (hc : ∀ i q, (child i q).2 ≤ R) (hi : ∀ i q, (initial i q).2 ≤ R) (t : ℕ) (integer : ℕ → TargetInterval target.length → ℕ × ℕ) (parentAllocation : TargetInterval target.length → ℕ) (childAllocation initialAllocation : Fin M → TargetInterval target.length → ℕ) (tableAllocation : ℕ → Fin M × TargetInterval target.length → ℕ) (integerAllocation : ℕ → TargetInterval target.length → ℕ)def preparedLocalOnlineScaleSourceAllocationRawBand (e : ℕ) (query : OAI.EditApproximation.TargetInterval target.length) : ℕ := by  have proof_bitOrdering_matches_4 (high : Ordering) (a : Bool) (b : Bool) (x : ℕ) (y : ℕ) (h : OAI.EditApproximation.orderingMatches high x y) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitOrdering high a b) (a.toNat + 2 * x) (b.toNat + 2 * y) := by    rcases h with ⟨rfl, h⟩ | ⟨rfl, rfl⟩ | ⟨rfl, h⟩    · exact Or.inl ⟨rfl, by cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩    · cases a <;> cases b <;> simp [OAI.EditApproximation.bitOrdering, OAI.EditApproximation.orderingMatches]    · exact Or.inr (Or.inr ⟨rfl, by        cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩)  have proof_bitCompareWithWork_matches_5 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitCompareWithWork left right).1 (OAI.EditApproximation.bitWordValue left) (OAI.EditApproximation.bitWordValue right) := by    induction left generalizing right with    | nil =>      simp only [OAI.EditApproximation.bitCompareWithWork]      induction right with      | nil => (simp [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.orderingMatches, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        simpa only [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareNilLeftWithWork bs).1 false b 0 (OAI.EditApproximation.bitWordValue bs) ih    | cons a as ih =>      cases right with      | nil =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as []).1 a false (OAI.EditApproximation.bitWordValue as) 0 (ih [])      | cons b bs =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue] using          proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as bs).1 a b (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs) (ih bs)  have proof_bitCompareWithWork_lt_16 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .lt ↔ OAI.EditApproximation.bitWordValue left < OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_bitSubtractor_value_17 (a : Bool) (b : Bool) (borrow : Bool) :      a.toNat + 2 * (OAI.EditApproximation.bitBorrow a b borrow).toNat =        b.toNat + borrow.toNat + (OAI.EditApproximation.bitDifference a b borrow).toNat := by    cases a <;> cases b <;> cases borrow <;> decide  have proof_bitSubtractionRippleEquation_18 (a : ℕ) (b : ℕ) (borrow : ℕ) (nextBorrow : ℕ) (difference : ℕ) (left : ℕ) (right : ℕ) (result : ℕ) (tail : ℕ) (htail : Eq.{1} (HAdd.hAdd.{0, 0, 0} (HAdd.hAdd.{0, 0, 0} result right) nextBorrow) (HAdd.hAdd.{0, 0, 0} left tail)) (hbit : Eq.{1} (HAdd.hAdd.{0, 0, 0} a (HMul.hMul.{0, 0, 0} 2 nextBorrow))    (HAdd.hAdd.{0, 0, 0} (HAdd.hAdd.{0, 0, 0} b borrow) difference)) :      (difference + 2 * result) + (b + 2 * right) + borrow =        (a + 2 * left) + 2 * tail := by    omega  have proof_bitSubtractWithWork_value_19 (left : List.{0} Bool) (right : List.{0} Bool) (borrow : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork left right borrow).1 + OAI.EditApproximation.bitWordValue right + borrow.toNat =        OAI.EditApproximation.bitWordValue left + 2 ^ max left.length right.length *          (OAI.EditApproximation.bitSubtractWithWork left right borrow).2.1.toNat := by    induction left generalizing right borrow with    | nil =>      induction right generalizing borrow with      | nil => (simp [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitSubtractNilLeftWithWork, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        have h := ih (OAI.EditApproximation.bitBorrow false b borrow)        have hb := proof_bitSubtractor_value_17 false b borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitSubtractNilLeftWithWork, OAI.EditApproximation.bitWordValue,          List.length_nil, List.length_cons, Nat.zero_max, pow_succ, Bool.toNat_false] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 0 b.toNat borrow.toNat (OAI.EditApproximation.bitBorrow false b borrow).toNat          (OAI.EditApproximation.bitDifference false b borrow).toNat 0 (OAI.EditApproximation.bitWordValue bs)          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractNilLeftWithWork bs (OAI.EditApproximation.bitBorrow false b borrow)).1)          (2 ^ bs.length * (OAI.EditApproximation.bitSubtractNilLeftWithWork bs (OAI.EditApproximation.bitBorrow false b borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_zero, Nat.add_zero, Nat.zero_add, Nat.mul_assoc,          Nat.mul_left_comm] using hs    | cons a as ih =>      cases right with      | nil =>        have h := ih [] (OAI.EditApproximation.bitBorrow a false borrow)        have hb := proof_bitSubtractor_value_17 a false borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitWordValue, List.length_nil, List.length_cons,          Nat.max_zero, pow_succ, Bool.toNat_false] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 a.toNat 0 borrow.toNat (OAI.EditApproximation.bitBorrow a false borrow).toNat          (OAI.EditApproximation.bitDifference a false borrow).toNat (OAI.EditApproximation.bitWordValue as) 0          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork as [] (OAI.EditApproximation.bitBorrow a false borrow)).1)          (2 ^ as.length * (OAI.EditApproximation.bitSubtractWithWork as [] (OAI.EditApproximation.bitBorrow a false borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_zero, Nat.add_zero, Nat.zero_add, Nat.mul_assoc,          Nat.mul_left_comm] using hs      | cons b bs =>        have h := ih bs (OAI.EditApproximation.bitBorrow a b borrow)        have hb := proof_bitSubtractor_value_17 a b borrow        (simp only [OAI.EditApproximation.bitSubtractWithWork, OAI.EditApproximation.bitWordValue, List.length_cons, Nat.succ_max_succ,          pow_succ] at h hb ⊢)        have hs := proof_bitSubtractionRippleEquation_18 a.toNat b.toNat borrow.toNat (OAI.EditApproximation.bitBorrow a b borrow).toNat          (OAI.EditApproximation.bitDifference a b borrow).toNat (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs)          (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork as bs (OAI.EditApproximation.bitBorrow a b borrow)).1)          (2 ^ max as.length bs.length * (OAI.EditApproximation.bitSubtractWithWork as bs (OAI.EditApproximation.bitBorrow a b borrow)).2.1.toNat)          h hb        simpa only [Nat.mul_assoc, Nat.mul_left_comm] using hs  have proof_bitWordValue_lt_pow_length_20 (bits : List.{0} Bool) : OAI.EditApproximation.bitWordValue bits < 2 ^ bits.length := by    induction bits with    | nil => (simp [OAI.EditApproximation.bitWordValue])    | cons bit bits ih =>      cases bit <;> (simp only [OAI.EditApproximation.bitWordValue, List.length_cons, pow_succ, Bool.toNat_false, Bool.toNat_true]) <;> omega  have proof_bitSubtractWithWork_length_21 (left : List.{0} Bool) (right : List.{0} Bool) (borrow : Bool) :      (OAI.EditApproximation.bitSubtractWithWork left right borrow).1.length = max left.length right.length := by    induction left generalizing right borrow with    | nil =>      simp only [OAI.EditApproximation.bitSubtractWithWork]      induction right generalizing borrow with      | nil => simp [OAI.EditApproximation.bitSubtractNilLeftWithWork]      | cons b bs ih => simp [OAI.EditApproximation.bitSubtractNilLeftWithWork, ih]    | cons a as ih =>      cases right with      | nil => simp [OAI.EditApproximation.bitSubtractWithWork, ih]      | cons b bs => simp [OAI.EditApproximation.bitSubtractWithWork, ih, Nat.succ_max_succ]  have proof_bitSubtractWithWork_sub_22 (left : List.{0} Bool) (right : List.{0} Bool) (h : LE.le.{0} (OAI.EditApproximation.bitWordValue right) (OAI.EditApproximation.bitWordValue left)) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork left right false).1 = OAI.EditApproximation.bitWordValue left - OAI.EditApproximation.bitWordValue right := by    have hvalue := proof_bitSubtractWithWork_value_19 left right false    have hlt := proof_bitWordValue_lt_pow_length_20 (OAI.EditApproximation.bitSubtractWithWork left right false).1    rw [proof_bitSubtractWithWork_length_21] at hlt    cases hb : (OAI.EditApproximation.bitSubtractWithWork left right false).2.1    · simp only [hb, Bool.toNat_false, Nat.mul_zero, Nat.add_zero] at hvalue      omega    · simp only [hb, Bool.toNat_true, Bool.toNat_false, Nat.mul_one, Nat.add_zero] at hvalue      omega  have proof_bitDivModWithWork_value_23 (divisor : List.{0} Bool) (bits : List.{0} Bool) (hd : LT.lt.{0} 0 (OAI.EditApproximation.bitWordValue divisor)) :      OAI.EditApproximation.bitWordValue bits = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).1 +        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 ∧        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1 < OAI.EditApproximation.bitWordValue divisor := by    induction bits with    | nil => (simp [OAI.EditApproximation.bitDivModWithWork, OAI.EditApproximation.bitWordValue, hd])    | cons bit bits ih =>      let previous := OAI.EditApproximation.bitDivModWithWork divisor bits      let candidate := bit :: previous.2.1      have hp : OAI.EditApproximation.bitWordValue bits = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue previous.1 +          OAI.EditApproximation.bitWordValue previous.2.1 := ih.1      have hr : OAI.EditApproximation.bitWordValue previous.2.1 < OAI.EditApproximation.bitWordValue divisor := ih.2      have hc : OAI.EditApproximation.bitWordValue candidate < 2 * OAI.EditApproximation.bitWordValue divisor := by        dsimp only [candidate, OAI.EditApproximation.bitWordValue]        cases bit <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega      by_cases hlt : (OAI.EditApproximation.bitCompareWithWork candidate divisor).1 = .lt      · have hv := (proof_bitCompareWithWork_lt_16 candidate divisor).1 hlt        simp only [OAI.EditApproximation.bitDivModWithWork, show (OAI.EditApproximation.bitCompareWithWork (bit :: (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1)          divisor).1 = .lt from hlt, ↓reduceIte]        change OAI.EditApproximation.bitWordValue (bit :: bits) = OAI.EditApproximation.bitWordValue divisor *          OAI.EditApproximation.bitWordValue (false :: previous.1) + OAI.EditApproximation.bitWordValue candidate ∧ OAI.EditApproximation.bitWordValue candidate < _        constructor        · (simp only [OAI.EditApproximation.bitWordValue, Bool.toNat_false])          dsimp only [candidate, OAI.EditApproximation.bitWordValue]          nlinarith only [hp]        · exact hv      · have hv : OAI.EditApproximation.bitWordValue divisor ≤ OAI.EditApproximation.bitWordValue candidate := by          exact Nat.le_of_not_gt (fun h => hlt ((proof_bitCompareWithWork_lt_16 candidate divisor).2 h))        have hs := proof_bitSubtractWithWork_sub_22 candidate divisor hv        simp only [OAI.EditApproximation.bitDivModWithWork, show (OAI.EditApproximation.bitCompareWithWork (bit :: (OAI.EditApproximation.bitDivModWithWork divisor bits).2.1)          divisor).1 ≠ .lt from hlt, ↓reduceIte]        change OAI.EditApproximation.bitWordValue (bit :: bits) = OAI.EditApproximation.bitWordValue divisor * OAI.EditApproximation.bitWordValue (true :: previous.1) +          OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork candidate divisor false).1 ∧          OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitSubtractWithWork candidate divisor false).1 < _        rw [hs]        constructor        · (simp only [OAI.EditApproximation.bitWordValue, Bool.toNat_true])          have he := Nat.sub_add_cancel hv          dsimp only [candidate, OAI.EditApproximation.bitWordValue] at he ⊢          nlinarith only [hp, he]        · omega  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_binaryNaturalDivModWithWork_spec_24 (n : ℕ) (d : ℕ) (hd : LT.lt.{0} 0 d) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalDivModWithWork n d).1 = n / d ∧        OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalDivModWithWork n d).2.1 = n % d := by    have h := proof_bitDivModWithWork_value_23 d.bits n.bits (by simpa only [proof_bitWordValue_bits_15] using hd)    simp only [proof_bitWordValue_bits_15] at h    have hmod : n % d = OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork d.bits n.bits).2.1 := by      conv_lhs => rw [h.1]      simp only [Nat.add_mod, Nat.mul_mod_right, Nat.zero_add, Nat.mod_eq_of_lt h.2]    have hdiv : n / d = OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitDivModWithWork d.bits n.bits).1 := by      conv_lhs => rw [h.1]      rw [Nat.mul_add_div hd, Nat.div_eq_of_lt h.2, Nat.add_zero]    exact ⟨hdiv.symm, hmod.symm⟩  have proof_wordLEWithWork_value_26 (a : List.{0} Bool) (b : List.{0} Bool) :      (OAI.EditApproximation.wordLEWithWork a b).1 = true ↔ OAI.EditApproximation.bitWordValue a ≤ OAI.EditApproximation.bitWordValue b := by    simp only [OAI.EditApproximation.wordLEWithWork, Bool.not_eq_true', decide_eq_false_iff_not,      proof_bitCompareWithWork_lt_16, not_lt]  have proof_seedGridSpacingWithWork_value_86 (b : ℕ) (P : ℕ) (hP : LT.lt.{0} 0 P) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.seedGridSpacingWithWork b P).1 = OAI.EditApproximation.seedGridSpacing b P := by    have hv := (proof_binaryNaturalDivModWithWork_spec_24 b P hP).1    unfold OAI.EditApproximation.seedGridSpacingWithWork OAI.EditApproximation.seedGridSpacing    dsimp only    split_ifs with ht    · have hq : b / P ≤ 1 := by        have h := (proof_wordLEWithWork_value_26 _ _).mp ht        change OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalDivModWithWork b P).1 ≤ 1 at h        rwa [hv] at h      rw [max_eq_left hq]      rfl    · have hq : 1 ≤ b / P := by        have h := mt (proof_wordLEWithWork_value_26 _ _).mpr ht        change ¬ OAI.EditApproximation.bitWordValue (OAI.EditApproximation.binaryNaturalDivModWithWork b P).1 ≤ 1 at h        rw [hv] at h        exact Nat.le_of_lt (Nat.lt_of_not_ge h)      rw [max_eq_right hq]      exact hv  have proof_seedGridSpacingWithWork_pos_85 (b : ℕ) (P : ℕ) (hP : LT.lt.{0} 0 P) :      0 < OAI.EditApproximation.bitWordValue (OAI.EditApproximation.seedGridSpacingWithWork b P).1 := by    rw [proof_seedGridSpacingWithWork_value_86 b P hP]    unfold OAI.EditApproximation.seedGridSpacing    omega  exact    let b := 2 ^ e    let center := (OAI.EditApproximation.roundStateWithWork (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.seedGridSpacingWithWork b P).1)      (proof_seedGridSpacingWithWork_pos_85 b P hP) query).1    OAI.EditApproximation.seedGridSpacingAllocation b P + OAI.EditApproximation.roundStateAllocation (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.seedGridSpacingWithWork b P).1) query +      parentAllocation center + OAI.EditApproximation.BinaryFraction.centerEligibilityAllocation b F a (parentInitial center).1 + e +      if (OAI.EditApproximation.BinaryFraction.centerEligibilityWithWork b F a (parentInitial center).1).1 then        integerAllocation b center + OAI.EditApproximation.BinaryFraction.preparedOnlineReadAllocationRaw source target parent P F exponent H b          (Nat.two_pow_pos e) hP tau eta kappa child initial table R hc hi          childAllocation initialAllocation tableAllocation t center (integer b center).1      else 0def preparedLocalOnlineActionsSourceAllocationRawBand (N : ℕ) (query : OAI.EditApproximation.TargetInterval target.length) : ℕ :=  parentAllocation query + OAI.EditApproximation.BinaryFraction.queryExponentsAllocation N F a (parentInitial query).1 +    OAI.EditApproximation.filterMapAllocation      (fun e => OAI.EditApproximation.BinaryFraction.preparedLocalOnlineScaleSourceWithWorkRawBand source target parent P F exponent H hP tau a eta kappa        parentInitial child initial table R hc hi t integer e query)      (fun e => OAI.EditApproximation.BinaryFraction.preparedLocalOnlineScaleSourceAllocationRawBand source target parent P F exponent H hP tau a eta kappa        parentInitial child initial table R hc hi t integer parentAllocation childAllocation initialAllocation        tableAllocation integerAllocation e query)      (OAI.EditApproximation.BinaryFraction.queryExponentsWithWork N F a (parentInitial query).1).1end OAI.EditApproximation.BinaryFractionendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximation.BinaryFractionvariable {α : Type u_4} (source target : List α) {M : ℕ} (parent : TargetInterval source.length) (N P F exponent H Q eM eF : ℕ) (hP : 0 < P) (hM : M = 2 ^ eM) (hF : F = 2 ^ eF) (tau a eta kappa : BinaryFraction) (parentInitial : TargetInterval target.length → BinaryFraction × ℕ) (child initial : Fin M → TargetInterval target.length → BinaryFraction × ℕ) (R : ℕ) (hc : ∀ i r, (child i r).2 ≤ R) (hi : ∀ i r, (initial i r).2 ≤ R) (parentAllocation : TargetInterval target.length → ℕ) (childAllocation initialAllocation : Fin M → TargetInterval target.length → ℕ)def queryOnlineSelectAllocationRawBand (t : ℕ)    (integer : ℕ → OAI.EditApproximation.TargetInterval target.length → ℕ × ℕ)    (integerAllocation : ℕ → OAI.EditApproximation.TargetInterval target.length → ℕ)    (keys : List (Fin M × ℕ × OAI.EditApproximation.TargetInterval target.length)) (words : List OAI.EditApproximation.BinaryFraction)    (q : OAI.EditApproximation.TargetInterval target.length) : ℕ :=  OAI.EditApproximation.BinaryFraction.preparedLocalOnlineActionsSourceAllocationRawBand source target parent P F exponent H hP tau a eta kappa    parentInitial child initial (OAI.EditApproximation.BinaryFraction.queryHistoryReadWithWork keys words) R hc hi (t - 1) integer    parentAllocation childAllocation initialAllocation (OAI.EditApproximation.BinaryFraction.queryHistoryReadAllocation keys words)    integerAllocation N qdef queryGroupSelectAllocationRawBand (draw : OAI.EditApproximation.CountedCellGroupDraws M F Q)    (drawAllocation : OAI.EditApproximation.CellGroupSourceAllocations M F Q)    (keys : List (Fin M × OAI.EditApproximation.TargetInterval target.length)) (words : List OAI.EditApproximation.BinaryFraction)    (q : OAI.EditApproximation.TargetInterval target.length) : ℕ :=  OAI.EditApproximation.BinaryFraction.preparedLocalCellGroupsSourceAllocationRawBand source target parent P F exponent Q eM eF hM hF hP tau a    parentInitial child initial (OAI.EditApproximation.BinaryFraction.queryChildReadWithWork keys words) R hc hi    parentAllocation childAllocation initialAllocation (OAI.EditApproximation.BinaryFraction.queryChildReadAllocation keys words)    draw drawAllocation N qend OAI.EditApproximation.BinaryFractionendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen Filter MeasureTheorynoncomputable def integerBinaryWorkRawBand (source target : List ℤ) (N : ℕ) (epsilon : OAI.EditApproximation.BinaryFraction) :=  OAI.EditApproximation.computedFullOutputWork (source.map OAI.EditApproximation.integerSymbolCode) (target.map OAI.EditApproximation.integerSymbolCode) N    (OAI.EditApproximation.integerQueryLocalWorkRawBand source target N) (OAI.EditApproximation.integerPreevaluationWork source target N epsilon)    (OAI.EditApproximation.computedQuerySetupWithWork N).2 (fun input => (OAI.EditApproximation.integerBinaryOutputRawBand source target N input).2)    (N + 1)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen Filterdef integerFinalAllocationRawBand (source target : List ℤ) (N : ℕ)    (input : OAI.EditApproximation.ComputedFamilyInput (source.map OAI.EditApproximation.integerSymbolCode) (target.map OAI.EditApproximation.integerSymbolCode) N) : ℕ :=  if source.map OAI.EditApproximation.integerSymbolCode = target.map OAI.EditApproximation.integerSymbolCode then 0 else    OAI.EditApproximation.BinaryFraction.finalAnswerAllocation N      (OAI.EditApproximation.computedQueryMemoResultRawBand (source.map OAI.EditApproximation.integerSymbolCode) (target.map OAI.EditApproximation.integerSymbolCode) N        (OAI.EditApproximation.integerOccurrenceIndex source target) (OAI.EditApproximation.integerInputSymbolBits source target)        (OAI.EditApproximation.integerInputPositionBits target) input).valueend OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen BitQueryattribute [local instance] queryArityNeZero queryRoundsNeZerodef queryLocalRefinementFootprintRawBand    {ι : Type u_1}    {α : Type u_2}    (source target : List α)    {M : ℕ}    (parent : OAI.EditApproximation.TargetInterval source.length)    (N P F exponent H Q eM eF : ℕ)    (hP : 0 < P)    (hM : M = 2 ^ eM)    (hF : F = 2 ^ eF)    (tau a eta kappa delta : OAI.EditApproximation.BinaryFraction)    (t : ℕ)    (parentInitial : OAI.EditApproximation.TargetInterval target.length → OAI.EditApproximation.BinaryFraction × ℕ)    (child initial : Fin M → OAI.EditApproximation.TargetInterval target.length → OAI.EditApproximation.BinaryFraction × ℕ)    (R : ℕ)    (hc : ∀ (i : Fin M) (r : OAI.EditApproximation.TargetInterval target.length), (child i r).2 ≤ R)    (hi : ∀ (i : Fin M) (r : OAI.EditApproximation.TargetInterval target.length), (initial i r).2 ≤ R)    (draw : OAI.EditApproximation.CountedCellGroupDraws M F Q)    (integer : ℕ → OAI.EditApproximation.TargetInterval target.length → ℕ × ℕ)    (parentAllocation : OAI.EditApproximation.TargetInterval target.length → ℕ)    (childAllocation initialAllocation : Fin M → OAI.EditApproximation.TargetInterval target.length → ℕ)    (drawAllocation : OAI.EditApproximation.CountedCellGroupAllocations M F Q)    (integerAllocation : ℕ → OAI.EditApproximation.TargetInterval target.length → ℕ)    (q : OAI.EditApproximation.TargetInterval target.length)    (readEarlier : Fin M × ℕ × OAI.EditApproximation.TargetInterval target.length →  OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction)    (readCurrent : Fin M × OAI.EditApproximation.TargetInterval target.length →  OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction)    (he : (key : Fin M × ℕ × OAI.EditApproximation.TargetInterval target.length) → (readEarlier key).Footprint)    (hr : (key : Fin M × OAI.EditApproximation.TargetInterval target.length) → (readCurrent key).Footprint) : (OAI.EditApproximation.queryLocalRefinementRawBand source target parent N P F exponent H Q eM eF hP hM hF tau a eta kappa delta    t parentInitial child initial R hc hi draw integer q readEarlier readCurrent).Footprint :=(OAI.EditApproximation.BitQuery.Footprint.computeOf      (OAI.EditApproximation.BinaryFraction.queryEarlierInputsWithWork M parent N P F exponent t hP a parentInitial q)      (OAI.EditApproximation.BinaryFraction.queryEarlierInputsAllocation M parent N P F exponent t hP a parentInitial        parentAllocation q)).bind  (fun (earlierKeys : List (Fin M × ℕ × OAI.EditApproximation.TargetInterval target.length)) =>    OAI.EditApproximation.BitQuery.collect readEarlier earlierKeys      fun (earlierWords : List OAI.EditApproximation.BinaryFraction) =>      (OAI.EditApproximation.BitQuery.compute            (OAI.EditApproximation.BinaryFraction.queryOnlineSelectWithWorkRawBand source target parent N P F exponent H hP tau              a eta kappa parentInitial child initial R hc hi t integer earlierKeys earlierWords q)).bind        fun          (onlineActions :            List              (OAI.EditApproximation.BinaryBellmanAction (OAI.EditApproximation.TargetInterval target.length)                (Fin M × OAI.EditApproximation.TargetInterval target.length) M)) =>        have word : OAI.EditApproximation.BinaryFraction × ℕ := parentInitial q;        OAI.EditApproximation.BitQuery.charge word.2          ((OAI.EditApproximation.BitQuery.compute                (OAI.EditApproximation.BinaryFraction.querySharedInputsWithWork M N F Q exponent eM eF hM hF parent a                  word.1 q draw)).bind            fun (sharedKeys : List (Fin M × OAI.EditApproximation.TargetInterval target.length)) =>            OAI.EditApproximation.BitQuery.collect readCurrent sharedKeys              fun (sharedWords : List OAI.EditApproximation.BinaryFraction) =>              (OAI.EditApproximation.BitQuery.compute                    (OAI.EditApproximation.BinaryFraction.queryGroupSelectWithWorkRawBand source target parent N P F exponent Q                      eM eF hP hM hF tau a parentInitial child initial R hc hi draw sharedKeys sharedWords q)).bind                fun                  (selectedActions :                    List                      (OAI.EditApproximation.BinaryBellmanAction (OAI.EditApproximation.TargetInterval target.length)                        (Fin M × OAI.EditApproximation.TargetInterval target.length) M)) =>                (OAI.EditApproximation.BitQuery.compute                      (OAI.EditApproximation.queryNeededInputsWithWork selectedActions onlineActions)).bind                  fun (currentKeys : List (Fin M × OAI.EditApproximation.TargetInterval target.length)) =>                  OAI.EditApproximation.BitQuery.collect readCurrent currentKeys                    fun (currentWords : List OAI.EditApproximation.BinaryFraction) =>                    OAI.EditApproximation.BitQuery.compute                      (OAI.EditApproximation.BinaryFraction.queryRefinementFinishWithWork parent N P F a delta                        parentInitial t earlierKeys earlierWords selectedActions onlineActions currentKeys currentWords                        q)))  fun (earlierKeys : List (Fin M × ℕ × OAI.EditApproximation.TargetInterval target.length)) =>  OAI.EditApproximation.BitQuery.Footprint.collect readEarlier he earlierKeys    (fun (earlierWords : List OAI.EditApproximation.BinaryFraction) =>      (OAI.EditApproximation.BitQuery.compute            (OAI.EditApproximation.BinaryFraction.queryOnlineSelectWithWorkRawBand source target parent N P F exponent H hP tau              a eta kappa parentInitial child initial R hc hi t integer earlierKeys earlierWords q)).bind        fun          (onlineActions :            List              (OAI.EditApproximation.BinaryBellmanAction (OAI.EditApproximation.TargetInterval target.length)                (Fin M × OAI.EditApproximation.TargetInterval target.length) M)) =>        have word : OAI.EditApproximation.BinaryFraction × ℕ := parentInitial q;        OAI.EditApproximation.BitQuery.charge word.2          ((OAI.EditApproximation.BitQuery.compute                (OAI.EditApproximation.BinaryFraction.querySharedInputsWithWork M N F Q exponent eM eF hM hF parent a                  word.1 q draw)).bind            fun (sharedKeys : List (Fin M × OAI.EditApproximation.TargetInterval target.length)) =>            OAI.EditApproximation.BitQuery.collect readCurrent sharedKeys              fun (sharedWords : List OAI.EditApproximation.BinaryFraction) =>              (OAI.EditApproximation.BitQuery.compute                    (OAI.EditApproximation.BinaryFraction.queryGroupSelectWithWorkRawBand source target parent N P F exponent Q                      eM eF hP hM hF tau a parentInitial child initial R hc hi draw sharedKeys sharedWords q)).bind                fun                  (selectedActions :                    List                      (OAI.EditApproximation.BinaryBellmanAction (OAI.EditApproximation.TargetInterval target.length)                        (Fin M × OAI.EditApproximation.TargetInterval target.length) M)) =>                (OAI.EditApproximation.BitQuery.compute                      (OAI.EditApproximation.queryNeededInputsWithWork selectedActions onlineActions)).bind                  fun (currentKeys : List (Fin M × OAI.EditApproximation.TargetInterval target.length)) =>                  OAI.EditApproximation.BitQuery.collect readCurrent currentKeys                    fun (currentWords : List OAI.EditApproximation.BinaryFraction) =>                    OAI.EditApproximation.BitQuery.compute                      (OAI.EditApproximation.BinaryFraction.queryRefinementFinishWithWork parent N P F a delta                        parentInitial t earlierKeys earlierWords selectedActions onlineActions currentKeys currentWords                        q)))    fun (earlierWords : List OAI.EditApproximation.BinaryFraction) =>    (OAI.EditApproximation.BitQuery.Footprint.compute          (OAI.EditApproximation.BinaryFraction.queryOnlineSelectWithWorkRawBand source target parent N P F exponent H hP tau a            eta kappa parentInitial child initial R hc hi t integer earlierKeys earlierWords q)          (OAI.EditApproximation.BinaryFraction.queryOnlineSelectAllocationRawBand source target parent N P F exponent H hP tau            a eta kappa parentInitial child initial R hc hi parentAllocation childAllocation initialAllocation t integer            integerAllocation earlierKeys earlierWords q)).bind      (fun          (onlineActions :            List              (OAI.EditApproximation.BinaryBellmanAction (OAI.EditApproximation.TargetInterval target.length)                (Fin M × OAI.EditApproximation.TargetInterval target.length) M)) =>        have word : OAI.EditApproximation.BinaryFraction × ℕ := parentInitial q;        OAI.EditApproximation.BitQuery.charge word.2          ((OAI.EditApproximation.BitQuery.compute                (OAI.EditApproximation.BinaryFraction.querySharedInputsWithWork M N F Q exponent eM eF hM hF parent a                  word.1 q draw)).bind            fun (sharedKeys : List (Fin M × OAI.EditApproximation.TargetInterval target.length)) =>            OAI.EditApproximation.BitQuery.collect readCurrent sharedKeys              fun (sharedWords : List OAI.EditApproximation.BinaryFraction) =>              (OAI.EditApproximation.BitQuery.compute                    (OAI.EditApproximation.BinaryFraction.queryGroupSelectWithWorkRawBand source target parent N P F exponent Q                      eM eF hP hM hF tau a parentInitial child initial R hc hi draw sharedKeys sharedWords q)).bind                fun                  (selectedActions :                    List                      (OAI.EditApproximation.BinaryBellmanAction (OAI.EditApproximation.TargetInterval target.length)                        (Fin M × OAI.EditApproximation.TargetInterval target.length) M)) =>                (OAI.EditApproximation.BitQuery.compute                      (OAI.EditApproximation.queryNeededInputsWithWork selectedActions onlineActions)).bind                  fun (currentKeys : List (Fin M × OAI.EditApproximation.TargetInterval target.length)) =>                  OAI.EditApproximation.BitQuery.collect readCurrent currentKeys                    fun (currentWords : List OAI.EditApproximation.BinaryFraction) =>                    OAI.EditApproximation.BitQuery.compute                      (OAI.EditApproximation.BinaryFraction.queryRefinementFinishWithWork parent N P F a delta                        parentInitial t earlierKeys earlierWords selectedActions onlineActions currentKeys currentWords                        q)))      fun        (online :          List            (OAI.EditApproximation.BinaryBellmanAction (OAI.EditApproximation.TargetInterval target.length)              (Fin M × OAI.EditApproximation.TargetInterval target.length) M)) =>      OAI.EditApproximation.BitQuery.Footprint.chargeOf (parentAllocation q)        ((OAI.EditApproximation.BitQuery.Footprint.computeOf              (OAI.EditApproximation.BinaryFraction.querySharedInputsWithWork M N F Q exponent eM eF hM hF parent a                (parentInitial q).1 q draw)              (OAI.EditApproximation.BinaryFraction.querySharedInputsAllocation M N F Q exponent eM eF hM hF parent a                (parentInitial q).1 q draw drawAllocation)).bind          (fun (sharedKeys : List (Fin M × OAI.EditApproximation.TargetInterval target.length)) =>            OAI.EditApproximation.BitQuery.collect readCurrent sharedKeys              fun (sharedWords : List OAI.EditApproximation.BinaryFraction) =>              (OAI.EditApproximation.BitQuery.compute                    (OAI.EditApproximation.BinaryFraction.queryGroupSelectWithWorkRawBand source target parent N P F exponent Q                      eM eF hP hM hF tau a parentInitial child initial R hc hi draw sharedKeys sharedWords q)).bind                fun                  (selectedActions :                    List                      (OAI.EditApproximation.BinaryBellmanAction (OAI.EditApproximation.TargetInterval target.length)                        (Fin M × OAI.EditApproximation.TargetInterval target.length) M)) =>                (OAI.EditApproximation.BitQuery.compute                      (OAI.EditApproximation.queryNeededInputsWithWork selectedActions online)).bind                  fun (currentKeys : List (Fin M × OAI.EditApproximation.TargetInterval target.length)) =>                  OAI.EditApproximation.BitQuery.collect readCurrent currentKeys                    fun (currentWords : List OAI.EditApproximation.BinaryFraction) =>                    OAI.EditApproximation.BitQuery.compute                      (OAI.EditApproximation.BinaryFraction.queryRefinementFinishWithWork parent N P F a delta                        parentInitial t earlierKeys earlierWords selectedActions online currentKeys currentWords q))          fun (sharedKeys : List (Fin M × OAI.EditApproximation.TargetInterval target.length)) =>          OAI.EditApproximation.BitQuery.Footprint.collect readCurrent hr sharedKeys            (fun (sharedWords : List OAI.EditApproximation.BinaryFraction) =>              (OAI.EditApproximation.BitQuery.compute                    (OAI.EditApproximation.BinaryFraction.queryGroupSelectWithWorkRawBand source target parent N P F exponent Q                      eM eF hP hM hF tau a parentInitial child initial R hc hi draw sharedKeys sharedWords q)).bind                fun                  (selectedActions :                    List                      (OAI.EditApproximation.BinaryBellmanAction (OAI.EditApproximation.TargetInterval target.length)                        (Fin M × OAI.EditApproximation.TargetInterval target.length) M)) =>                (OAI.EditApproximation.BitQuery.compute                      (OAI.EditApproximation.queryNeededInputsWithWork selectedActions online)).bind                  fun (currentKeys : List (Fin M × OAI.EditApproximation.TargetInterval target.length)) =>                  OAI.EditApproximation.BitQuery.collect readCurrent currentKeys                    fun (currentWords : List OAI.EditApproximation.BinaryFraction) =>                    OAI.EditApproximation.BitQuery.compute                      (OAI.EditApproximation.BinaryFraction.queryRefinementFinishWithWork parent N P F a delta                        parentInitial t earlierKeys earlierWords selectedActions online currentKeys currentWords q))            fun (sharedWords : List OAI.EditApproximation.BinaryFraction) =>            (OAI.EditApproximation.BitQuery.Footprint.computeOf                  (OAI.EditApproximation.BinaryFraction.queryGroupSelectWithWorkRawBand source target parent N P F exponent Q                    eM eF hP hM hF tau a parentInitial child initial R hc hi draw sharedKeys sharedWords q)                  (OAI.EditApproximation.BinaryFraction.queryGroupSelectAllocationRawBand source target parent N P F exponent Q                    eM eF hP hM hF tau a parentInitial child initial R hc hi parentAllocation childAllocation                    initialAllocation draw drawAllocation sharedKeys sharedWords q)).bind              (fun                  (selectedActions :                    List                      (OAI.EditApproximation.BinaryBellmanAction (OAI.EditApproximation.TargetInterval target.length)                        (Fin M × OAI.EditApproximation.TargetInterval target.length) M)) =>                (OAI.EditApproximation.BitQuery.compute                      (OAI.EditApproximation.queryNeededInputsWithWork selectedActions online)).bind                  fun (currentKeys : List (Fin M × OAI.EditApproximation.TargetInterval target.length)) =>                  OAI.EditApproximation.BitQuery.collect readCurrent currentKeys                    fun (currentWords : List OAI.EditApproximation.BinaryFraction) =>                    OAI.EditApproximation.BitQuery.compute                      (OAI.EditApproximation.BinaryFraction.queryRefinementFinishWithWork parent N P F a delta                        parentInitial t earlierKeys earlierWords selectedActions online currentKeys currentWords q))              fun                (groups :                  List                    (OAI.EditApproximation.BinaryBellmanAction (OAI.EditApproximation.TargetInterval target.length)                      (Fin M × OAI.EditApproximation.TargetInterval target.length) M)) =>              (OAI.EditApproximation.BitQuery.Footprint.computeOf                    (OAI.EditApproximation.queryNeededInputsWithWork groups online)                    (OAI.EditApproximation.queryNeededInputsAllocation groups online)).bind                (fun (currentKeys : List (Fin M × OAI.EditApproximation.TargetInterval target.length)) =>                  OAI.EditApproximation.BitQuery.collect readCurrent currentKeys                    fun (currentWords : List OAI.EditApproximation.BinaryFraction) =>                    OAI.EditApproximation.BitQuery.compute                      (OAI.EditApproximation.BinaryFraction.queryRefinementFinishWithWork parent N P F a delta                        parentInitial t earlierKeys earlierWords groups online currentKeys currentWords q))                fun (currentKeys : List (Fin M × OAI.EditApproximation.TargetInterval target.length)) =>                OAI.EditApproximation.BitQuery.Footprint.collect readCurrent hr currentKeys                  (fun (currentWords : List OAI.EditApproximation.BinaryFraction) =>                    OAI.EditApproximation.BitQuery.compute                      (OAI.EditApproximation.BinaryFraction.queryRefinementFinishWithWork parent N P F a delta                        parentInitial t earlierKeys earlierWords groups online currentKeys currentWords q))                  fun (currentWords : List OAI.EditApproximation.BinaryFraction) =>                  OAI.EditApproximation.BitQuery.Footprint.computeOf                    (OAI.EditApproximation.BinaryFraction.queryRefinementFinishWithWork parent N P F a delta                      parentInitial t earlierKeys earlierWords groups online currentKeys currentWords q)                    (OAI.EditApproximation.BinaryFraction.queryRefinementFinishAllocation parent N P F a delta                      parentInitial parentAllocation t earlierKeys earlierWords groups online currentKeys currentWords                      q))def queryLocalRandomSourcesFootprintRawBand    {ι : Type u_1}    {α : Type u_2}    (source target : List α)    {M : ℕ}    [NeZero M]    (parent : OAI.EditApproximation.TargetInterval source.length)    (N P F exponent H Q eM eF : ℕ)    (hP : 0 < P)    (hM : M = 2 ^ eM)    (hF : F = 2 ^ eF)    (tau a eta kappa delta : OAI.EditApproximation.BinaryFraction)    (t : ℕ)    (parentInitial : OAI.EditApproximation.TargetInterval target.length → OAI.EditApproximation.BinaryFraction × ℕ)    (child initial : Fin M → OAI.EditApproximation.TargetInterval target.length → OAI.EditApproximation.BinaryFraction × ℕ)    (R : ℕ)    (hc : ∀ (i : Fin M) (r : OAI.EditApproximation.TargetInterval target.length), (child i r).2 ≤ R)    (hi : ∀ (i : Fin M) (r : OAI.EditApproximation.TargetInterval target.length), (initial i r).2 ≤ R)    (parentAllocation : OAI.EditApproximation.TargetInterval target.length → ℕ)    (childAllocation initialAllocation : Fin M → OAI.EditApproximation.TargetInterval target.length → ℕ)    (q : OAI.EditApproximation.TargetInterval target.length)    (readGroup : OAI.EditApproximation.GroupScalarKey M F Q → OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction)    (readInteger : ℕ × OAI.EditApproximation.TargetInterval target.length →  ℕ → OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction)    (readEarlier : Fin M × ℕ × OAI.EditApproximation.TargetInterval target.length →  OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction)    (readCurrent : Fin M × OAI.EditApproximation.TargetInterval target.length →  OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction)    (hg : (key : OAI.EditApproximation.GroupScalarKey M F Q) → (readGroup key).Footprint)    (hz : (key : ℕ × OAI.EditApproximation.TargetInterval target.length) → (range : ℕ) → (readInteger key range).Footprint)    (he : (key : Fin M × ℕ × OAI.EditApproximation.TargetInterval target.length) → (readEarlier key).Footprint)    (hr : (key : Fin M × OAI.EditApproximation.TargetInterval target.length) → (readCurrent key).Footprint) : (OAI.EditApproximation.queryLocalRandomSourcesRawBand source target parent N P F exponent H Q eM eF hP hM hF tau a eta kappa    delta t parentInitial child initial R hc hi q readGroup readInteger readEarlier readCurrent).Footprint :=OAI.EditApproximation.queryGroupSourceGatherFootprint M N F Q exponent eM eF hM hF a parentInitial parentAllocation q  readGroup hg  (fun (groupKeys : List (OAI.EditApproximation.GroupScalarKey M F Q))      (groupWords : List OAI.EditApproximation.BinaryFraction) =>    OAI.EditApproximation.queryOnlineSourceGather parent N P F exponent H hP tau a parentInitial child q readInteger      fun (onlineKeys : List (ℕ × OAI.EditApproximation.TargetInterval target.length))        (onlineWords : List OAI.EditApproximation.BinaryFraction) =>      OAI.EditApproximation.queryLocalRefinementRawBand source target parent N P F exponent H Q eM eF hP hM hF tau a eta kappa        delta t parentInitial child initial R hc hi        (OAI.EditApproximation.BinaryFraction.queryGroupDrawReadWithWork groupKeys groupWords)        (OAI.EditApproximation.BinaryFraction.queryOnlineIntegerReadWithWork onlineKeys onlineWords) q readEarlier        readCurrent)  fun (groupKeys : List (OAI.EditApproximation.GroupScalarKey M F Q))    (groupWords : List OAI.EditApproximation.BinaryFraction) =>  OAI.EditApproximation.queryOnlineSourceGatherFootprint parent N P F exponent H hP tau a parentInitial parentAllocation    child childAllocation q readInteger hz    (fun (onlineKeys : List (ℕ × OAI.EditApproximation.TargetInterval target.length))        (onlineWords : List OAI.EditApproximation.BinaryFraction) =>      OAI.EditApproximation.queryLocalRefinementRawBand source target parent N P F exponent H Q eM eF hP hM hF tau a eta kappa        delta t parentInitial child initial R hc hi        (OAI.EditApproximation.BinaryFraction.queryGroupDrawReadWithWork groupKeys groupWords)        (OAI.EditApproximation.BinaryFraction.queryOnlineIntegerReadWithWork onlineKeys onlineWords) q readEarlier        readCurrent)    fun (onlineKeys : List (ℕ × OAI.EditApproximation.TargetInterval target.length))      (onlineWords : List OAI.EditApproximation.BinaryFraction) =>    OAI.EditApproximation.queryLocalRefinementFootprintRawBand source target parent N P F exponent H Q eM eF hP hM hF tau a eta      kappa delta t parentInitial child initial R hc hi      (OAI.EditApproximation.BinaryFraction.queryGroupDrawReadWithWork groupKeys groupWords)      (OAI.EditApproximation.BinaryFraction.queryOnlineIntegerReadWithWork onlineKeys onlineWords) parentAllocation      childAllocation initialAllocation      (OAI.EditApproximation.BinaryFraction.queryGroupDrawReadAllocation groupKeys groupWords)      (OAI.EditApproximation.BinaryFraction.queryOnlineIntegerReadAllocation onlineKeys onlineWords) q readEarlier      readCurrent he hrend OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen BitQueryattribute [local instance] queryArityNeZero queryRoundsNeZeroopen Finsetdef queryLocalBandFootprintRawBand    {ι : Type u_1}    {α : Type u_2}    (source target : List α)    {M : ℕ}    [NeZero M]    (parent : OAI.EditApproximation.TargetInterval source.length)    (N P F exponent H Q eM eF : ℕ)    (hP : 0 < P)    (hM : M = 2 ^ eM)    (hF : F = 2 ^ eF)    (tau a eta kappa delta : OAI.EditApproximation.BinaryFraction)    (t : ℕ)    (parentInitial : OAI.EditApproximation.TargetInterval target.length → OAI.EditApproximation.BinaryFraction × ℕ)    (parentAllocation : OAI.EditApproximation.TargetInterval target.length → ℕ)    (readMass readInitial : Fin M × OAI.EditApproximation.TargetInterval target.length →  OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction)    (readGroup : OAI.EditApproximation.GroupScalarKey M F Q → OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction)    (readInteger : ℕ × OAI.EditApproximation.TargetInterval target.length →  ℕ → OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction)    (q : OAI.EditApproximation.TargetInterval target.length)    (readEarlier : Fin M × ℕ × OAI.EditApproximation.TargetInterval target.length →  OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction)    (readCurrent : Fin M × OAI.EditApproximation.TargetInterval target.length →  OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction)    (hm : (key : Fin M × OAI.EditApproximation.TargetInterval target.length) → (readMass key).Footprint)    (hi : (key : Fin M × OAI.EditApproximation.TargetInterval target.length) → (readInitial key).Footprint)    (hg : (key : OAI.EditApproximation.GroupScalarKey M F Q) → (readGroup key).Footprint)    (hz : (key : ℕ × OAI.EditApproximation.TargetInterval target.length) → (range : ℕ) → (readInteger key range).Footprint)    (he : (key : Fin M × ℕ × OAI.EditApproximation.TargetInterval target.length) → (readEarlier key).Footprint)    (hr : (key : Fin M × OAI.EditApproximation.TargetInterval target.length) → (readCurrent key).Footprint) : (OAI.EditApproximation.queryLocalBandRawBand source target parent N P F exponent H Q eM eF hP hM hF tau a eta kappa delta t    parentInitial readMass readInitial readGroup readInteger q readEarlier readCurrent).Footprint := by  have proof_gatheredWordLookupWithWork_cost_132 {κ : Type 0} (equal : κ → κ → Prod.{0, 0} Bool ℕ) (C : ℕ) (hC : ∀ (a b : κ), LE.le.{0} (equal a b).2 C) (keys : List.{0} κ) (values : List.{0} OAI.EditApproximation.BinaryFraction) (query : κ) :      (OAI.EditApproximation.BinaryFraction.gatheredWordLookupWithWork equal keys values query).2 ≤ 1 + keys.length * (C + 1) := by    induction keys generalizing values with    | nil => simp only [OAI.EditApproximation.BinaryFraction.gatheredWordLookupWithWork, List.length_nil, Nat.zero_mul, Nat.add_zero, le_rfl]    | cons key keys ih =>      cases values with      | nil => simp only [OAI.EditApproximation.BinaryFraction.gatheredWordLookupWithWork]; omega      | cons value values =>        have hc := hC query key        have hi := ih values        simp only [OAI.EditApproximation.BinaryFraction.gatheredWordLookupWithWork]        split_ifs <;> simp only [List.length_cons, Nat.add_mul, Nat.one_mul] <;> omega  have proof_bitCompareWithWork_cost_133 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).2 ≤ 4 * (left.length + right.length) + 1 := by    induction left generalizing right with    | nil =>      simp only [OAI.EditApproximation.bitCompareWithWork]      induction right with      | nil => simp [OAI.EditApproximation.bitCompareNilLeftWithWork]      | cons b bs ih =>        simp only [OAI.EditApproximation.bitCompareNilLeftWithWork, List.length_cons, List.length_nil] at *        omega    | cons a as ih =>      cases right with      | nil =>        have h := ih []        simp only [OAI.EditApproximation.bitCompareWithWork, List.length_cons, List.length_nil] at *        omega      | cons b bs =>        have h := ih bs        simp only [OAI.EditApproximation.bitCompareWithWork, List.length_cons] at *        omega  have proof_binaryNaturalCompareWithWork_cost_134 (a : ℕ) (b : ℕ) :      (OAI.EditApproximation.binaryNaturalCompareWithWork a b).2 ≤ 4 * (Nat.size a + Nat.size b) + 1 := by    simpa only [OAI.EditApproximation.binaryNaturalCompareWithWork, Nat.size_eq_bits_len] using proof_bitCompareWithWork_cost_133 a.bits b.bits  have proof_naturalEqualWithWork_cost_135 (a : ℕ) (b : ℕ) (B : ℕ) (ha : LE.le.{0} a.size B) (hb : LE.le.{0} b.size B) :      (OAI.EditApproximation.naturalEqualWithWork a b).2 ≤ 8 * B + 2 := by    have h := proof_binaryNaturalCompareWithWork_cost_134 a b    change (OAI.EditApproximation.binaryNaturalCompareWithWork a b).2 + 1 ≤ _    omega  have proof_coordinateEqualWithWork_cost_136 {M : ℕ} {n : ℕ} (a : Prod.{0, 0} (Fin M) (OAI.EditApproximation.TargetInterval n)) (b : Prod.{0, 0} (Fin M) (OAI.EditApproximation.TargetInterval n)) (B : ℕ) (hM : LE.le.{0} M.size B) (hn : LE.le.{0} n.size B) :      (OAI.EditApproximation.coordinateEqualWithWork a b).2 ≤ 24 * B + 8 := by    have hc := proof_naturalEqualWithWork_cost_135 a.1.val b.1.val B      ((Nat.size_le_size a.1.isLt.le).trans hM) ((Nat.size_le_size b.1.isLt.le).trans hM)    have hl := proof_naturalEqualWithWork_cost_135 a.2.lo b.2.lo B      ((Nat.size_le_size (a.2.ordered.trans a.2.valid)).trans hn)      ((Nat.size_le_size (b.2.ordered.trans b.2.valid)).trans hn)    have hh := proof_naturalEqualWithWork_cost_135 a.2.hi b.2.hi B      ((Nat.size_le_size a.2.valid).trans hn) ((Nat.size_le_size b.2.valid).trans hn)    change _ + _ + _ + 2 ≤ _    omega  have proof_queryChildReadWithWork_cost_137 {M : ℕ} {n : ℕ} (keys : List.{0} (Prod.{0, 0} (Fin M) (OAI.EditApproximation.TargetInterval n))) (values : List.{0} OAI.EditApproximation.BinaryFraction) (i : Fin M) (q : OAI.EditApproximation.TargetInterval n) (B : ℕ) (hM : LE.le.{0} M.size B) (hn : LE.le.{0} n.size B) :      (OAI.EditApproximation.BinaryFraction.queryChildReadWithWork keys values i q).2 ≤ 1 + keys.length * (24 * B + 9) := by    exact proof_gatheredWordLookupWithWork_cost_132 OAI.EditApproximation.coordinateEqualWithWork (24 * B + 8)      (fun a b => proof_coordinateEqualWithWork_cost_136 a b B hM hn) keys values (i, q)  have proof_queryChildReadWithWork_budget_131 {M : ℕ} {n : ℕ} (keys : List.{0} (Prod.{0, 0} (Fin M) (OAI.EditApproximation.TargetInterval n))) (words : List.{0} OAI.EditApproximation.BinaryFraction) (i : Fin M) (r : OAI.EditApproximation.TargetInterval n) :      (OAI.EditApproximation.BinaryFraction.queryChildReadWithWork keys words i r).2 ≤ OAI.EditApproximation.BinaryFraction.queryDataReadBudget M n keys := by    exact proof_queryChildReadWithWork_cost_137 keys words i r _ (Nat.le_max_left _ _) (Nat.le_max_right _ _)  exact    OAI.EditApproximation.queryBandGatherFootprint M parent N P F exponent hP a parentInitial parentAllocation q readMass      readInitial hm hi      (fun (keys : List (Fin M × OAI.EditApproximation.TargetInterval target.length))          (massWords initialWords : List OAI.EditApproximation.BinaryFraction) =>        OAI.EditApproximation.queryLocalRandomSourcesRawBand source target parent N P F exponent H Q eM eF hP hM hF tau a eta kappa          delta t parentInitial (OAI.EditApproximation.BinaryFraction.queryChildReadWithWork keys massWords)          (OAI.EditApproximation.BinaryFraction.queryChildReadWithWork keys initialWords)          (OAI.EditApproximation.BinaryFraction.queryDataReadBudget M target.length keys) (proof_queryChildReadWithWork_budget_131 keys massWords) (proof_queryChildReadWithWork_budget_131 keys initialWords) q readGroup          readInteger readEarlier readCurrent)      fun (keys : List (Fin M × OAI.EditApproximation.TargetInterval target.length))        (massWords initialWords : List OAI.EditApproximation.BinaryFraction) =>      OAI.EditApproximation.queryLocalRandomSourcesFootprintRawBand source target parent N P F exponent H Q eM eF hP hM hF tau a        eta kappa delta t parentInitial (OAI.EditApproximation.BinaryFraction.queryChildReadWithWork keys massWords)        (OAI.EditApproximation.BinaryFraction.queryChildReadWithWork keys initialWords)        (OAI.EditApproximation.BinaryFraction.queryDataReadBudget M target.length keys) (proof_queryChildReadWithWork_budget_131 keys massWords) (proof_queryChildReadWithWork_budget_131 keys initialWords)        parentAllocation (OAI.EditApproximation.BinaryFraction.queryChildReadAllocation keys massWords)        (OAI.EditApproximation.BinaryFraction.queryChildReadAllocation keys initialWords) q readGroup readInteger        readEarlier readCurrent hg hz he hrend OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen BitQueryattribute [local instance] queryArityNeZero queryRoundsNeZerodef queryLocalProgramFootprintRawBand    {ι : Type u_1}    {α : Type u_2}    (source target : List α)    {M : ℕ}    [NeZero M]    (parent : OAI.EditApproximation.TargetInterval source.length)    (N P F exponent H Q eM eF : ℕ)    (hP : 0 < P)    (hM : M = 2 ^ eM)    (hF : F = 2 ^ eF)    (tau a eta kappa delta : OAI.EditApproximation.BinaryFraction)    (t : ℕ)    (readParent : OAI.EditApproximation.TargetInterval target.length →  OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction)    (readMass readInitial : Fin M × OAI.EditApproximation.TargetInterval target.length →  OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction)    (readGroup : OAI.EditApproximation.GroupScalarKey M F Q → OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction)    (readInteger : ℕ × OAI.EditApproximation.TargetInterval target.length →  ℕ → OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction)    (q : OAI.EditApproximation.TargetInterval target.length)    (readEarlier : Fin M × ℕ × OAI.EditApproximation.TargetInterval target.length →  OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction)    (readCurrent : Fin M × OAI.EditApproximation.TargetInterval target.length →  OAI.EditApproximation.BitQuery ι OAI.EditApproximation.BinaryFraction)    (hp : (key : OAI.EditApproximation.TargetInterval target.length) → (readParent key).Footprint)    (hm : (key : Fin M × OAI.EditApproximation.TargetInterval target.length) → (readMass key).Footprint)    (hi : (key : Fin M × OAI.EditApproximation.TargetInterval target.length) → (readInitial key).Footprint)    (hg : (key : OAI.EditApproximation.GroupScalarKey M F Q) → (readGroup key).Footprint)    (hz : (key : ℕ × OAI.EditApproximation.TargetInterval target.length) → (range : ℕ) → (readInteger key range).Footprint)    (he : (key : Fin M × ℕ × OAI.EditApproximation.TargetInterval target.length) → (readEarlier key).Footprint)    (hr : (key : Fin M × OAI.EditApproximation.TargetInterval target.length) → (readCurrent key).Footprint) : (OAI.EditApproximation.queryLocalProgramRawBand source target parent N P F exponent H Q eM eF hP hM hF tau a eta kappa delta t    readParent readMass readInitial readGroup readInteger q readEarlier readCurrent).Footprint :=OAI.EditApproximation.queryInitialGatherFootprint N P F exponent hP a q readParent hp  (fun (keys : List (OAI.EditApproximation.TargetInterval target.length))      (words : List OAI.EditApproximation.BinaryFraction) =>    OAI.EditApproximation.queryLocalBandRawBand source target parent N P F exponent H Q eM eF hP hM hF tau a eta kappa delta t      (OAI.EditApproximation.BinaryFraction.queryParentReadWithWork keys words) readMass readInitial readGroup      readInteger q readEarlier readCurrent)  fun (keys : List (OAI.EditApproximation.TargetInterval target.length))    (words : List OAI.EditApproximation.BinaryFraction) =>  OAI.EditApproximation.queryLocalBandFootprintRawBand source target parent N P F exponent H Q eM eF hP hM hF tau a eta kappa    delta t (OAI.EditApproximation.BinaryFraction.queryParentReadWithWork keys words)    (OAI.EditApproximation.BinaryFraction.queryParentReadAllocation keys words) readMass readInitial readGroup    readInteger q readEarlier readCurrent hm hi hg hz he hrdef queryPhysicalRandomDataRequestFootprintRawBand    {σ : Type u_1}    {α : Type u_2}    (source target : List α)    {M J : ℕ}    [NeZero M]    (N P F exponent H Q eM eF : ℕ)    (hP : 0 < P)    (hM : M = 2 ^ eM)    (hF : F = 2 ^ eF)    (tau a eta kappa delta : OAI.EditApproximation.BinaryFraction)    (copies pass copy T S t : ℕ)    (ht : 0 < t)    (node : OAI.EditApproximation.PhysicalNode M J)    (hbelow : ↑node.fst < J)    (readGroup : OAI.EditApproximation.GroupScalarKey M F Q → OAI.EditApproximation.BitQuery σ OAI.EditApproximation.BinaryFraction)    (readInteger : ℕ × OAI.EditApproximation.TargetInterval target.length →  ℕ → OAI.EditApproximation.BitQuery σ OAI.EditApproximation.BinaryFraction)    (q : OAI.EditApproximation.TargetInterval target.length)    (hg : (key : OAI.EditApproximation.GroupScalarKey M F Q) → (readGroup key).Footprint)    (hz : (key : ℕ × OAI.EditApproximation.TargetInterval target.length) → (range : ℕ) → (readInteger key range).Footprint) : (OAI.EditApproximation.queryPhysicalRandomDataRequestRawBand source target N P F exponent H Q eM eF hP hM hF tau a eta kappa    delta copies pass copy T S t ht node hbelow readGroup readInteger q).Footprint := by  have proof_combinedRank_lt_of_progress_80 {M : ℕ} {J : ℕ} {ny : ℕ} (T : ℕ) (S : ℕ) (first : OAI.EditApproximation.PhysicalTableRequest M J ny) (second : OAI.EditApproximation.PhysicalTableRequest M J ny) (hprogress : LT.lt.{0} second.remainingDepth first.remainingDepth ∧      LE.le.{0} (OAI.EditApproximation.PhysicalTableRequest.rank T S second)        (OAI.EditApproximation.PhysicalTableRequest.rank T S first) ∨    LE.le.{0} second.remainingDepth first.remainingDepth ∧      LT.lt.{0} (OAI.EditApproximation.PhysicalTableRequest.rank T S second)        (OAI.EditApproximation.PhysicalTableRequest.rank T S first)) :      OAI.EditApproximation.PhysicalTableRequest.combinedRank T S second < OAI.EditApproximation.PhysicalTableRequest.combinedRank T S first := by    unfold OAI.EditApproximation.PhysicalTableRequest.combinedRank    rcases hprogress with h | h    · exact Nat.add_lt_add_of_lt_of_le h.1 h.2    · exact Nat.add_lt_add_of_le_of_lt h.1 h.2  have proof_sameIndexChild_progress_95 {M : ℕ} {J : ℕ} {ny : ℕ} (T : ℕ) (S : ℕ) (request : OAI.EditApproximation.PhysicalTableRequest M J ny) (hbelow : LT.lt.{0} (↑(Sigma.fst.{0, 0} request.node)) J) (i : Fin M) (state : OAI.EditApproximation.TargetInterval ny) :      (OAI.EditApproximation.PhysicalTableRequest.sameIndexChild request hbelow i state).remainingDepth < request.remainingDepth ∧        OAI.EditApproximation.PhysicalTableRequest.rank T S (OAI.EditApproximation.PhysicalTableRequest.sameIndexChild request hbelow i state) ≤ OAI.EditApproximation.PhysicalTableRequest.rank T S request := by    constructor    · unfold OAI.EditApproximation.PhysicalTableRequest.remainingDepth OAI.EditApproximation.PhysicalTableRequest.sameIndexChild OAI.EditApproximation.physicalChild      dsimp only      omega    · exact le_rfl  have proof_combinedRank_sameIndexChild_94 {M : ℕ} {J : ℕ} {ny : ℕ} (T : ℕ) (S : ℕ) (request : OAI.EditApproximation.PhysicalTableRequest M J ny) (hbelow : LT.lt.{0} (↑(Sigma.fst.{0, 0} request.node)) J) (i : Fin M) (state : OAI.EditApproximation.TargetInterval ny) :      OAI.EditApproximation.PhysicalTableRequest.combinedRank T S (OAI.EditApproximation.PhysicalTableRequest.sameIndexChild request hbelow i state) < OAI.EditApproximation.PhysicalTableRequest.combinedRank T S request :=    proof_combinedRank_lt_of_progress_80 T S request _ (Or.inl (proof_sameIndexChild_progress_95 T S request hbelow i state))  unfold OAI.EditApproximation.queryPhysicalRandomDataRequestRawBand  apply OAI.EditApproximation.queryLocalProgramFootprintRawBand  · intro r    exact (OAI.EditApproximation.queryPhysicalTableReadFootprint copies T S _ _).mapKeysWithWork _ (fun _ => 1)  · intro input    apply OAI.EditApproximation.BitQuery.Footprint.mapKeysWithWork _ (fun _ => 1)    apply OAI.EditApproximation.queryMeanReadFootprint    intro j    exact OAI.EditApproximation.queryPhysicalTableReadFootprint copies T S _ _  · intro input    exact (OAI.EditApproximation.queryPhysicalTableReadFootprint copies T S _ _).mapKeysWithWork _ (fun _ => 1)  · intro key    exact (hg key).mapKeysWithWork _ (fun _ => 1)  · intro key range    exact (hz key range).mapKeysWithWork _ (fun _ => 1)  · intro input    exact (OAI.EditApproximation.queryPhysicalEarlierReadFootprint copies pass copy T S t node hbelow q input).mapKeysWithWork _      (fun _ => 1)  · intro input    exact (OAI.EditApproximation.queryPhysicalTableReadFootprint copies T S _ _).mapKeysWithWork _ (fun _ => 1)def queryFamilyRefinementFootprintRawBand    {α : Type u_1}    {M J R : ℕ}    [NeZero M]    (source target : List α)    (N P F exponent H Q eM eF : ℕ)    (hP : 0 < P)    (hM : M = 2 ^ eM)    (hF : F = 2 ^ eF)    (tau a eta kappa delta : OAI.EditApproximation.BinaryFraction)    (passes copies pass copy T S t : ℕ)    (ht : 0 < t)    (node : OAI.EditApproximation.PhysicalNode M J)    (hbelow : ↑node.fst < J)    (time : Fin R)    (q : OAI.EditApproximation.TargetInterval target.length) : (OAI.EditApproximation.queryFamilyRefinementRawBand source target N P F exponent H Q eM eF hP hM hF tau a eta kappa delta    passes copies pass copy T S t ht node hbelow time q).Footprint :=OAI.EditApproximation.queryPhysicalRandomDataRequestFootprintRawBand source target N P F exponent H Q eM eF hP hM hF tau a eta  kappa delta copies pass copy T S t ht node hbelow  (OAI.EditApproximation.queryFamilyGroupRead target N P F exponent H Q passes copies pass copy ⟨node, hbelow⟩ time)  (OAI.EditApproximation.queryFamilyOnlineRead target N P F exponent H Q passes copies pass copy ⟨node, hbelow⟩ time) q  (OAI.EditApproximation.queryFamilyGroupReadFootprint target N P F exponent H Q passes copies pass copy ⟨node, hbelow⟩    time)  (OAI.EditApproximation.queryFamilyOnlineReadFootprint target N P F exponent H Q passes copies pass copy ⟨node, hbelow⟩    time)def queryFamilyActiveFootprintRawBand    {α : Type u_1}    {M J R : ℕ}    [NeZero M]    [NeZero R]    (source target : List α)    (N P F exponent H Q eM eF : ℕ)    (hP : 0 < P)    (hM : M = 2 ^ eM)    (hF : F = 2 ^ eF)    (tau a eta kappa delta : OAI.EditApproximation.BinaryFraction)    (T S passes copies : ℕ)    (request : OAI.EditApproximation.PhysicalTableRequest M J target.length)    (hindex : T < request.index)    (hbelow : ↑request.node.fst < J) : (OAI.EditApproximation.queryFamilyActiveRawBand (R := R) source target N P F exponent H Q eM eF hP hM hF tau a eta kappa delta T S    passes copies request hindex hbelow).Footprint := by  have proof_active_request_eq_145 {α : Type u_1} {M : ℕ} {J : ℕ} (target : List.{u_1} α) (T : ℕ) (request : OAI.EditApproximation.PhysicalTableRequest M J (List.length.{u_1} target)) (hindex : LT.lt.{0} T request.index) :      OAI.EditApproximation.PhysicalTableRequest.refinement request.pass request.copy request.node T (request.index - T)        request.state = request := by    have hi : T + (request.index - T) = request.index := by omega    unfold OAI.EditApproximation.PhysicalTableRequest.refinement    rw [hi]  exact    (OAI.EditApproximation.queryFamilyRefinementFootprintRawBand source target N P F exponent H Q eM eF hP hM hF tau a eta kappa delta      passes copies request.pass request.copy T S (request.index - T) (Nat.sub_pos_of_lt hindex)      request.node hbelow (Fin.ofNat R (request.index - T - 1)) request.state).mapKeysWithWork _ (fun _ => 1)def queryFamilyBoundedActiveFootprintRawBand    {α : Type u_1}    {M J R : ℕ}    [NeZero M]    [NeZero R]    (source target : List α)    (N P F exponent H Q eM eF : ℕ)    (hP : 0 < P)    (hM : M = 2 ^ eM)    (hF : F = 2 ^ eF)    (tau a eta kappa delta : OAI.EditApproximation.BinaryFraction)    (T S passes copies : ℕ)    (parent : { r : OAI.EditApproximation.PhysicalTableRequest M J target.length //  OAI.EditApproximation.PhysicalTableRequest.Bounded (passes + 1) copies T S r })    (hindex : T < parent.val.index)    (hbelow : ↑parent.val.node.fst < J) : (OAI.EditApproximation.queryFamilyBoundedActiveRawBand (R := R) source target N P F exponent H Q eM eF hP hM hF tau a eta kappa delta T    S passes copies parent hindex hbelow).Footprint :=  OAI.EditApproximation.queryRestrictPhysicalBodyFootprint (passes + 1) copies T S parent _    (OAI.EditApproximation.queryFamilyActiveFootprintRawBand (R := R) source target N P F exponent H Q eM eF hP hM hF      tau a eta kappa delta T S passes copies parent.val hindex hbelow)def queryChargedFamilyTableFootprintRawBand    {M J R passes copies T S : ℕ}    [NeZero M]    [NeZero R]    (source target : List ℕ)    (N P F exponent H Q eM eF : ℕ)    (hP : 0 < P)    (hM : M = 2 ^ eM)    (hF : F = 2 ^ eF)    (A a : ℕ → OAI.EditApproximation.BinaryFraction)    (tau eta kappa delta : OAI.EditApproximation.BinaryFraction)    (multiplier : ℕ → ℕ)    (occurrence : OAI.EditApproximation.BinaryMemo OAI.EditApproximation.PositionCounts)    (symbolBits positionBits : ℕ)    (parent : { r : OAI.EditApproximation.PhysicalTableRequest M J target.length //  OAI.EditApproximation.PhysicalTableRequest.Bounded (passes + 1) copies T S r }) : (OAI.EditApproximation.queryChargedFamilyTableRawBand (R := R) source target N P F exponent H Q eM eF hP hM hF A a tau eta kappa delta    multiplier occurrence symbolBits positionBits parent).Footprint := by  have proof_table_rank_lt_99 {M : ℕ} {J : ℕ} {ny : ℕ} {passes : ℕ} {copies : ℕ} {T : ℕ} {S : ℕ} (parent : Subtype.{1} fun request => OAI.EditApproximation.PhysicalTableRequest.Bounded (M := M) (J := J) (ny := ny) passes copies T S request) (child : Subtype.{1} fun request => OAI.EditApproximation.PhysicalTableRequest.Bounded (M := M) (J := J) (ny := ny) passes copies T S request) (h : LT.lt.{0} (OAI.EditApproximation.PhysicalTableRequest.combinedRank T S child.val)    (OAI.EditApproximation.PhysicalTableRequest.combinedRank T S parent.val)) :      OAI.EditApproximation.ChargedPhysicalRequest.rank (Sum.inr child : OAI.EditApproximation.ChargedPhysicalRequest M J ny passes copies T S) < OAI.EditApproximation.ChargedPhysicalRequest.rank (Sum.inr parent) := by    simpa only [OAI.EditApproximation.ChargedPhysicalRequest.rank, OAI.EditApproximation.ChargedPhysicalRequest.depth, OAI.EditApproximation.ChargedPhysicalRequest.index, ← Nat.add_assoc, OAI.EditApproximation.PhysicalTableRequest.combinedRank] using      Nat.add_lt_add_right h 1  have proof_bitOrdering_matches_4 (high : Ordering) (a : Bool) (b : Bool) (x : ℕ) (y : ℕ) (h : OAI.EditApproximation.orderingMatches high x y) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitOrdering high a b) (a.toNat + 2 * x) (b.toNat + 2 * y) := by    rcases h with ⟨rfl, h⟩ | ⟨rfl, rfl⟩ | ⟨rfl, h⟩    · exact Or.inl ⟨rfl, by cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩    · cases a <;> cases b <;> simp [OAI.EditApproximation.bitOrdering, OAI.EditApproximation.orderingMatches]    · exact Or.inr (Or.inr ⟨rfl, by        cases a <;> cases b <;> simp only [Bool.toNat_false, Bool.toNat_true] <;> omega⟩)  have proof_bitCompareWithWork_matches_5 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.orderingMatches (OAI.EditApproximation.bitCompareWithWork left right).1 (OAI.EditApproximation.bitWordValue left) (OAI.EditApproximation.bitWordValue right) := by    induction left generalizing right with    | nil =>      simp only [OAI.EditApproximation.bitCompareWithWork]      induction right with      | nil => (simp [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.orderingMatches, OAI.EditApproximation.bitWordValue])      | cons b bs ih =>        simpa only [OAI.EditApproximation.bitCompareNilLeftWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareNilLeftWithWork bs).1 false b 0 (OAI.EditApproximation.bitWordValue bs) ih    | cons a as ih =>      cases right with      | nil =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue, Bool.toNat_false, Nat.add_zero, Nat.mul_zero,          Nat.zero_add] using proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as []).1 a false (OAI.EditApproximation.bitWordValue as) 0 (ih [])      | cons b bs =>        simpa only [OAI.EditApproximation.bitCompareWithWork, OAI.EditApproximation.bitWordValue] using          proof_bitOrdering_matches_4 (OAI.EditApproximation.bitCompareWithWork as bs).1 a b (OAI.EditApproximation.bitWordValue as) (OAI.EditApproximation.bitWordValue bs) (ih bs)  have proof_bitCompareWithWork_lt_16 (left : List.{0} Bool) (right : List.{0} Bool) :      (OAI.EditApproximation.bitCompareWithWork left right).1 = .lt ↔ OAI.EditApproximation.bitWordValue left < OAI.EditApproximation.bitWordValue right := by    have h := proof_bitCompareWithWork_matches_5 left right    rcases h with ⟨h, hv⟩ | ⟨h, hv⟩ | ⟨h, hv⟩ <;> rw [h] <;> simp_all    all_goals omega  have proof_wordLEWithWork_value_26 (a : List.{0} Bool) (b : List.{0} Bool) :      (OAI.EditApproximation.wordLEWithWork a b).1 = true ↔ OAI.EditApproximation.bitWordValue a ≤ OAI.EditApproximation.bitWordValue b := by    simp only [OAI.EditApproximation.wordLEWithWork, Bool.not_eq_true', decide_eq_false_iff_not,      proof_bitCompareWithWork_lt_16, not_lt]  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_queryNaturalLEWithWork_value_140 (a : ℕ) (b : ℕ) :      (OAI.EditApproximation.wordLEWithWork a.bits b.bits).1 = true ↔ a ≤ b := by    simp only [proof_wordLEWithWork_value_26, proof_bitWordValue_bits_15]  have proof_binaryNaturalCompareWithWork_lt_53 (a : ℕ) (b : ℕ) :      (OAI.EditApproximation.binaryNaturalCompareWithWork a b).1 = .lt ↔ a < b := by    simpa only [OAI.EditApproximation.binaryNaturalCompareWithWork, proof_bitWordValue_bits_15] using proof_bitCompareWithWork_lt_16 a.bits b.bits  have hinit := OAI.EditApproximation.queryPhysicalInitialFootprint source target N P F (A parent.val.pass) (a parent.val.pass)    multiplier parent occurrence symbolBits positionBits parent.val.state  unfold OAI.EditApproximation.queryChargedFamilyTableRawBand  refine OAI.EditApproximation.BitQuery.Footprint.chargeOf (OAI.EditApproximation.naturalWordLEAllocation parent.val.index.bits T.bits) ?_  split  · exact (OAI.EditApproximation.queryChargedWarmupFootprint source target N P F (A parent.val.pass) (a parent.val.pass)      multiplier parent occurrence symbolBits positionBits).mapKeysWithWork _ (fun _ => 1)  · refine OAI.EditApproximation.BitQuery.Footprint.chargeOf (parent.val.node.1.val.bits.length + J.bits.length) ?_    split    · let interval := OAI.EditApproximation.physicalSourceInterval source.length parent.val.node      refine OAI.EditApproximation.BitQuery.Footprint.chargeOf (OAI.EditApproximation.saturatingSubtractAllocation interval.hi interval.lo +        OAI.EditApproximation.naturalWordLEAllocation (OAI.EditApproximation.saturatingSubtractWithWork interval.hi interval.lo).1 [true]) ?_      split      · exact hinit.mapKeysWithWork _ (fun _ => 1)      · exact (OAI.EditApproximation.queryFamilyBoundedActiveFootprintRawBand (R := R) source target N P F exponent H Q eM eF hP hM hF          tau (a parent.val.pass) eta kappa delta T S passes copies parent _ _).mapKeysWithWork _          (fun _ => 1)    · exact hinit.mapKeysWithWork _ (fun _ => 1)def queryChargedFamilyGlobalFootprintRawBand    {M J R passes copies T S : ℕ}    [NeZero M]    [NeZero R]    (source target : List ℕ)    (N P F exponent H Q eM eF : ℕ)    (hP : 0 < P)    (hM : M = 2 ^ eM)    (hF : F = 2 ^ eF)    (A a : ℕ → OAI.EditApproximation.BinaryFraction)    (tau eta kappa delta : OAI.EditApproximation.BinaryFraction)    (multiplier : ℕ → ℕ)    (occurrence : OAI.EditApproximation.BinaryMemo OAI.EditApproximation.PositionCounts)    (symbolBits positionBits : ℕ)    (coarse : OAI.EditApproximation.PhysicalEntry M J target.length → OAI.EditApproximation.BinaryFraction × ℕ)    (allocation : OAI.EditApproximation.PhysicalEntry M J target.length → ℕ)    (request : OAI.EditApproximation.ChargedPhysicalRequest M J target.length (passes + 1) copies T S) : (OAI.EditApproximation.queryChargedFamilyGlobalRawBand (R := R) source target N P F exponent H Q eM eF hP hM hF A a tau eta kappa delta    multiplier occurrence symbolBits positionBits coarse request).Footprint := by  cases request with  | inl entry => exact OAI.EditApproximation.BitQuery.Footprint.compute (coarse entry) (allocation entry)  | inr parent =>    exact OAI.EditApproximation.queryChargedFamilyTableFootprintRawBand (R := R) source target N P F exponent H Q eM eF hP hM hF      A a tau eta kappa delta multiplier occurrence symbolBits positionBits parentdef queryFamilyMemoRawFootprintRawBand    {M J R passes copies T S : ℕ}    [NeZero M]    [NeZero R]    (source target : List ℕ)    (N P F exponent H Q eM eF : ℕ)    (hP : 0 < P)    (hM : M = 2 ^ eM)    (hF : F = 2 ^ eF)    (A a : ℕ → OAI.EditApproximation.BinaryFraction)    (tau eta kappa delta : OAI.EditApproximation.BinaryFraction)    (multiplier : ℕ → ℕ)    (occurrence : OAI.EditApproximation.BinaryMemo OAI.EditApproximation.PositionCounts)    (symbolBits positionBits : ℕ)    (coarse : OAI.EditApproximation.PhysicalEntry M J target.length → OAI.EditApproximation.BinaryFraction × ℕ)    (allocation : OAI.EditApproximation.PhysicalEntry M J target.length → ℕ)    (draw : OAI.EditApproximation.PhysicalFamilyScalarDraw (M := M) (J := J) (R := R) target N P F exponent H Q passes copies)    (key : OAI.EditApproximation.QueryFamilyMemoKey (M := M) (J := J) (R := R) (passes := passes) (copies := copies) (T := T) (S := S) target N P F exponent H Q) : (OAI.EditApproximation.queryFamilyMemoRawRawBand (R := R) source target N P F exponent H Q eM eF hP hM hF A a tau eta kappa delta    multiplier occurrence symbolBits positionBits coarse draw key).Footprint := by  cases key with  | inl scalar =>    exact OAI.EditApproximation.BitQuery.Footprint.computeOf (OAI.EditApproximation.queryFamilySourceWordWithWork target N P F exponent H Q draw scalar)      (Nat.size (draw scalar).val + 2)  | inr request =>    exact (OAI.EditApproximation.queryChargedFamilyGlobalFootprintRawBand source target N P F exponent H Q eM eF hP hM hF      A a tau eta kappa delta multiplier occurrence symbolBits positionBits coarse allocation request).mapKeysWithWork        _ (fun _ => 1)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen BitQueryattribute [local instance] queryArityNeZero queryRoundsNeZeroopen MeasureTheory ProbabilityTheorydef computedQueryMemoRawFootprintRawBand    (source target : List ℕ)    (N : ℕ)    (occurrence : OAI.EditApproximation.BinaryMemo OAI.EditApproximation.PositionCounts)    (symbolBits positionBits : ℕ)    (input : OAI.EditApproximation.ComputedFamilyInput source target N)    (key : OAI.EditApproximation.ComputedFamilyMemoKey source target N) : (OAI.EditApproximation.computedQueryMemoRawRawBand source target N occurrence symbolBits positionBits input key).Footprint := by  have proof_computedParameterP_pos_141 (N : ℕ) : 0 < (OAI.EditApproximation.integerParameters N).P :=    Nat.pow_pos (Nat.two_pow_pos _)  exact    OAI.EditApproximation.queryFamilyMemoRawFootprintRawBand source target N (OAI.EditApproximation.integerParameters N).P (OAI.EditApproximation.inputSmallLog N)      (40 * OAI.EditApproximation.smallLogExponent N) (OAI.EditApproximation.inputHeight N) (OAI.EditApproximation.inputSmallLog N ^ 80)      (OAI.EditApproximation.heightExponent N / 20) (OAI.EditApproximation.smallLogExponent N) (proof_computedParameterP_pos_141 N) rfl rfl      (fun pass => (OAI.EditApproximation.scheduledSeedWordWithWork N pass).1)      (fun pass => (OAI.EditApproximation.computedQueryParameters N pass).factor)      (OAI.EditApproximation.computedQueryParameters N 0).tau (OAI.EditApproximation.computedQueryParameters N 0).eta      (OAI.EditApproximation.computedQueryParameters N 0).kappa (OAI.EditApproximation.computedQueryParameters N 0).delta      (OAI.EditApproximation.scheduledSeedMultiplier N) occurrence symbolBits positionBits      (fun entry => (OAI.EditApproximation.BinaryFraction.nat (OAI.EditApproximation.clampedSeedNat input.1 entry), 0))      (fun _ => 0) input.2 keyend OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen BitQueryattribute [local instance] queryArityNeZero queryRoundsNeZerodef computedQueryMemoFootprintRawBand    (source target : List ℕ)    (N : ℕ)    (occurrence : OAI.EditApproximation.BinaryMemo OAI.EditApproximation.PositionCounts)    (symbolBits positionBits : ℕ)    (input : OAI.EditApproximation.ComputedFamilyInput source target N)    (key : OAI.EditApproximation.ComputedFamilyMemoKey source target N) : (OAI.EditApproximation.computedQueryMemoNormalizedRawBand source target N occurrence symbolBits positionBits input    key).Footprint := by  have proof_trimBitWordWithWork_value_6 (bits : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.trimBitWordWithWork bits).1 = OAI.EditApproximation.bitWordValue bits := by    induction bits with    | nil => rfl    | cons bit bits ih =>      simp only [OAI.EditApproximation.trimBitWordWithWork]      split_ifs with h      · have ht : OAI.EditApproximation.bitWordValue bits = 0 := by rw [← ih, h.1]; rfl        simp [h.2, OAI.EditApproximation.bitWordValue, ht]      · (simp only [OAI.EditApproximation.bitWordValue, ih])  have proof_bitAdder_value_1 (a : Bool) (b : Bool) (carry : Bool) :      (OAI.EditApproximation.bitSum a b carry).toNat + 2 * (OAI.EditApproximation.bitCarry a b carry).toNat =        a.toNat + b.toNat + carry.toNat := by    cases a <;> cases b <;> cases carry <;> decide  have proof_bitAddWithWork_value_2 (left : List.{0} Bool) (right : List.{0} Bool) (carry : Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitAddWithWork left right carry).1 =        OAI.EditApproximation.bitWordValue left + OAI.EditApproximation.bitWordValue right + carry.toNat := by    induction left generalizing right carry with    | nil =>      simp only [OAI.EditApproximation.bitAddWithWork]      induction right generalizing carry with      | nil => cases carry <;> simp [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue]      | cons b bs ih =>        simp only [OAI.EditApproximation.bitAddNilLeftWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 false b carry        simp only [Bool.toNat_false] at h        omega    | cons a as ih =>      cases right with      | nil =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a false carry        simp only [Bool.toNat_false] at h        omega      | cons b bs =>        simp only [OAI.EditApproximation.bitAddWithWork, OAI.EditApproximation.bitWordValue, ih]        have h := proof_bitAdder_value_1 a b carry        omega  have proof_bitMulWithWork_value_0 (left : List.{0} Bool) (right : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitMulWithWork left right).1 = OAI.EditApproximation.bitWordValue left * OAI.EditApproximation.bitWordValue right := by    induction left with    | nil => simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue]    | cons bit bits ih =>      cases bit <;> simp [OAI.EditApproximation.bitMulWithWork, OAI.EditApproximation.bitWordValue, proof_bitAddWithWork_value_2, ih] <;> ring  have proof_bitPowerWithWork_value_76 (base : List.{0} Bool) (n : ℕ) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.bitPowerWithWork base n).1 = OAI.EditApproximation.bitWordValue base ^ n := by    induction n with    | zero => (simp [OAI.EditApproximation.bitPowerWithWork, OAI.EditApproximation.bitWordValue])    | succ n ih =>      simp only [OAI.EditApproximation.bitPowerWithWork, proof_trimBitWordWithWork_value_6, proof_bitMulWithWork_value_0, ih, pow_succ]  have proof_refinementBaseWithWork_value_143 (ell : List.{0} Bool) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.refinementBaseWithWork ell).1 = OAI.EditApproximation.bitWordValue ell ^ 10 + 1 := by    (simp only [OAI.EditApproximation.refinementBaseWithWork, proof_trimBitWordWithWork_value_6, proof_bitAddWithWork_value_2,      proof_bitPowerWithWork_value_76, OAI.EditApproximation.bitWordValue, Bool.toNat_true, Bool.toNat_false])  have proof_bitWordValue_bits_15 (n : ℕ) : OAI.EditApproximation.bitWordValue n.bits = n := by    induction n using Nat.binaryRec' with    | zero => simp [OAI.EditApproximation.bitWordValue]    | bit bit n h ih =>      rw [Nat.bits_append_bit n bit h]      cases bit <;> simp [OAI.EditApproximation.bitWordValue, ih, Nat.bit, Nat.add_comm]  have proof_computedQueryBase_value_144 (N : ℕ) :      OAI.EditApproximation.bitWordValue (OAI.EditApproximation.computedQueryBase N) = OAI.EditApproximation.inputSmallLog N ^ 10 + 1 := by    simp only [OAI.EditApproximation.computedQueryBase, proof_refinementBaseWithWork_value_143, proof_bitWordValue_bits_15]  have proof_computedQueryBase_pos_142 (N : ℕ) : 0 < OAI.EditApproximation.bitWordValue (OAI.EditApproximation.computedQueryBase N) := by    rw [proof_computedQueryBase_value_144]    omega  exact    (OAI.EditApproximation.computedQueryMemoRawFootprintRawBand source target N occurrence symbolBits positionBits input          key).normalize      (OAI.EditApproximation.computedQueryBase N) (proof_computedQueryBase_pos_142 N)      (OAI.EditApproximation.queryFamilyMemoRemaining target N (OAI.EditApproximation.integerParameters N).P        (OAI.EditApproximation.inputSmallLog N) (40 * OAI.EditApproximation.smallLogExponent N)        (OAI.EditApproximation.inputHeight N) (OAI.EditApproximation.inputSmallLog N ^ 80) key)end OAI.EditApproximationendsectionuniverse u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8namespace OAI.EditApproximationopen Filter MeasureTheoryattribute [local instance] queryRoundsNeZerodef computedQueryTemporaryCellsFootprintRawBand (source target : List ℕ) (N : ℕ)    (occurrence : OAI.EditApproximation.BinaryMemo OAI.EditApproximation.PositionCounts) (symbolBits positionBits : ℕ)    (input : OAI.EditApproximation.ComputedFamilyInput source target N) : ℕ :=  OAI.EditApproximation.BitQuery.Footprint.rankedBitMemoCells (OAI.EditApproximation.SourceRanked.rank OAI.EditApproximation.ChargedPhysicalRequest.rank)    (OAI.EditApproximation.computedQueryMemoNormalizedRawBand source target N occurrence symbolBits positionBits input)    (OAI.EditApproximation.computedQueryMemoFootprintRawBand source target N occurrence symbolBits positionBits input)    (16384 * OAI.EditApproximation.inputHeight N + 5) (OAI.EditApproximation.computedFamilyMemoCode source target N (OAI.EditApproximation.inputHeight N ^ 2))    (fun key => (OAI.EditApproximation.computedFamilyMemoCodeWithWork source target N (OAI.EditApproximation.inputHeight N ^ 2) key).2)    (.inr (OAI.EditApproximation.localFinalRootRequest target N (OAI.EditApproximation.integerParameters N).T (OAI.EditApproximation.integerParameters N).S      (OAI.EditApproximation.inputHeight N) (Nat.two_pow_pos _) (OAI.EditApproximation.finalTargetState target.length))) .emptynoncomputable def integerAcceptedSpaceTermsFootprintRawBand (source target : List ℤ) (N : ℕ)    (epsilon : OAI.EditApproximation.BinaryFraction)    (input : OAI.EditApproximation.ComputedFamilyInput (source.map OAI.EditApproximation.integerSymbolCode) (target.map OAI.EditApproximation.integerSymbolCode) N) : List ℕ :=  let x := source.map OAI.EditApproximation.integerSymbolCode  let y := target.map OAI.EditApproximation.integerSymbolCode  [8 * OAI.EditApproximation.integerPreevaluationWork source target N epsilon,   2 * OAI.EditApproximation.integerStoredDataSpace source target,   OAI.EditApproximation.computedQuerySetupAllocation N,   (OAI.EditApproximation.computedQueryMemoResultRawBand x y N (OAI.EditApproximation.integerOccurrenceIndex source target)     (OAI.EditApproximation.integerInputSymbolBits source target) (OAI.EditApproximation.integerInputPositionBits target) input).memory.fractionStorage,   OAI.EditApproximation.computedQueryTemporaryCellsFootprintRawBand x y N (OAI.EditApproximation.integerOccurrenceIndex source target)     (OAI.EditApproximation.integerInputSymbolBits source target) (OAI.EditApproximation.integerInputPositionBits target) input,   OAI.EditApproximation.computedFamilyCoarseCopyStorage x y N input,   OAI.EditApproximation.computedFamilyCoarseArrayCapacity x y N input,   OAI.EditApproximation.computedFamilyCoarseScratchCapacity x y N input,   OAI.EditApproximation.computedFamilyCoarseControlCapacity x y N input,   4 * (OAI.EditApproximation.inputHeight N + (OAI.EditApproximation.integerParameters N).B + 4),   OAI.EditApproximation.integerFinalAllocationRawBand source target N input,   8 * (N + 1)]noncomputable def integerBinarySpaceFootprintRawBand (source target : List ℤ) (N : ℕ) (epsilon : OAI.EditApproximation.BinaryFraction)    (outcome : OAI.EditApproximation.ComputedFullOutcome (source.map OAI.EditApproximation.integerSymbolCode) (target.map OAI.EditApproximation.integerSymbolCode) N) : ℕ :=  if OAI.EditApproximation.physicalLargeInput N epsilon then    match outcome with    | .inl _ => 8 * OAI.EditApproximation.integerPreevaluationWork source target N epsilon +        2 * OAI.EditApproximation.integerStoredDataSpace source target +        OAI.EditApproximation.suffixDPAllocation (source.map OAI.EditApproximation.integerSymbolCode) (target.map OAI.EditApproximation.integerSymbolCode) + 8 * (N + 1)    | .inr execution => (OAI.EditApproximation.integerAcceptedSpaceTermsFootprintRawBand source target N epsilon        (OAI.EditApproximation.computedExecutionAccepted _ _ N execution)).sum  else 8 * OAI.EditApproximation.integerPreevaluationWork source target N epsilon +    2 * OAI.EditApproximation.integerStoredDataSpace source target +    OAI.EditApproximation.suffixDPAllocation (source.map OAI.EditApproximation.integerSymbolCode) (target.map OAI.EditApproximation.integerSymbolCode) + 8 * (N + 1)theorem almostLinearEditDistanceRawBand (epsilon : OAI.EditApproximation.BinaryFraction)    (hepsilon : 0 < epsilon.value) (_hepsilonOne : epsilon.value < 1)    :    (∀ (source target : List ℤ) (N : ℕ), source.length + target.length ≤ N →      (2 / 3 : ℝ) ≤ (OAI.EditApproximation.computedFullLaw (source.map OAI.EditApproximation.integerSymbolCode) (target.map OAI.EditApproximation.integerSymbolCode) N epsilon).real        {outcome | EditDistortion.edit source target ≤ OAI.EditApproximation.integerBinaryAnswerRawBand source target N epsilon outcome ∧          (OAI.EditApproximation.integerBinaryAnswerRawBand source target N epsilon outcome : ℝ) ≤            (1 + (epsilon.value : ℝ)) * OAI.EditDistortion.edit source target}) ∧    (∀ (source target : List ℤ) (N : ℕ), source = target → ∀ outcome,      OAI.EditApproximation.integerBinaryAnswerRawBand source target N epsilon outcome = 0) ∧    (∀ (C : ℕ) (eta : ℝ), 0 < eta → ∀ᶠ N : ℕ in atTop,      ∀ source target : List ℤ, source.length + target.length ≤ N →        (∀ z ∈ source ++ target, z.natAbs ≤ (N + 2) ^ C) →        (∫ outcome, OAI.EditApproximation.integerBinaryWorkRawBand source target N epsilon outcome          ∂OAI.EditApproximation.computedFullLaw (source.map OAI.EditApproximation.integerSymbolCode) (target.map OAI.EditApproximation.integerSymbolCode) N epsilon) ≤            (N + 2 : ℝ) ^ (1 + eta)) ∧    (∀ C : ℕ, ∀ᶠ N : ℕ in atTop, ∀ source target : List ℤ,      source.length + target.length ≤ N →        (∀ z ∈ source ++ target, z.natAbs ≤ (N + 2) ^ C) →        ∀ outcome, OAI.EditApproximation.integerBinarySpaceFootprintRawBand source target N epsilon outcome ≤ (N + 2) ^ (C + 65564)) := by  sorryend OAI.EditApproximationend