import Mathlib

namespace OAI.EditDistortion
end OAI.EditDistortion

/-! A uniform almost-linear approximation scheme for edit distance.
The statement retains the concrete binary algorithm and its exact resource accounting. -/

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation


def bitWordValue : List Bool → ℕ
  | [] => 0
  | bit :: bits => bit.toNat + 2 * bitWordValue bits

def bitSum (a b carry : Bool) : Bool := xor (xor a b) carry

def bitCarry (a b carry : Bool) : Bool := (a && b) || (a && carry) || (b && carry)

structure UnreducedRational where
  num : ℤ
  den : ℕ
  den_pos : 0 < den

def 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 .lt

def bitDifference (a b borrow : Bool) : Bool := xor (xor a b) borrow

def bitBorrow (a b borrow : Bool) : Bool := ((!a) && (b || borrow)) || (b && borrow)

structure SignedBinary where
  negative : Bool
  bits : List Bool

def signedMagnitude (negative : Bool) (magnitude : ℕ) : ℤ :=
  if negative then -(magnitude : ℤ) else magnitude

def 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 / M

def 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 → Child

def 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 * i

def scaledSeedValue (U : ℕ) (a gap : ℚ) : ℚ :=
  max (⌈(U : ℚ) / a⌉₊ : ℚ) |gap|

def dyadicScales (N : ℕ) : List ℕ :=
  (List.range (Nat.log 2 N + 1)).map fun k => 2 ^ k

def 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 tail

def 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) 0

def 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 * i

def 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
  | _, _, _ => 0

def 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 + 1

inductive 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.length

def 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 n
decreasing_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) + 64

def arithmeticMapAllocation {α : Type u_1} (allocation : α → ℕ) : List α → ℕ
  | [] => 0
  | a :: rest => allocation a + arithmeticMapAllocation allocation rest + 1

def arithmeticFlatMapAllocation {α : Type u_1} {β : Type u_2} (f : α → List β × ℕ)
    (allocation : α → ℕ) : List α → ℕ
  | [] => 0
  | x :: xs => allocation x + arithmeticFlatMapAllocation f allocation xs + (f x).1.length

def filterAllocation {α : Type u_1} (test : α → Bool × ℕ) (allocation : α → ℕ) : List α → ℕ
  | [] => 0
  | x :: xs => allocation x + filterAllocation test allocation xs + if (test x).1 then 1 else 0

def 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 0

def naturalEqualAllocation (a b : ℕ) : ℕ := a.bits.length + b.bits.length + 1

def memberByAllocation {α : Type u_1} (allocation : α → α → ℕ) (a : α) : List α → ℕ
  | [] => 0
  | b :: rest => allocation a b + memberByAllocation allocation a rest + 1

def naturalWordLEAllocation (a b : List Bool) : ℕ := a.length + b.length + 1

def vectorMapAllocation (d : ℕ) (allocation : Fin d → ℕ) : ℕ :=
  (∑ i, allocation i) + 3 * d

def allAllocation {α : Type u_1} (allocation : α → ℕ) : List α → ℕ
  | [] => 0
  | x :: xs => allocation x + allAllocation allocation xs + 1

def 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 + 1

def wordLEAllocation (_a _b : List Bool) : ℕ := 0

def indexedLeafAllocation (symbolBits positionBits : ℕ) (symbol : Option ℕ) (lo hi : ℕ) : ℕ :=
  match symbol with
  | none => 1
  | some _ => if lo = hi then 1 else symbolBits + 2 * positionBits + 4

def storedNaturalBits (values : List ℕ) : ℕ :=
  1 + (values.map fun a => Nat.size a + 1).sum

def coarseHistoryKeyCost {α : Type u_1} {β : Type u_2} {ι : Type u_3} (cost : ι → ℕ) : Sum α (Sum ι β) → ℕ
  | .inr (.inl entry) => cost entry
  | _ => 0

def 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 right

def 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 right

def 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 right

structure BinaryFraction where
  numerator : OAI.EditApproximation.SignedBinary
  denominator : List Bool
  denominator_pos : 0 < OAI.EditApproximation.bitWordValue denominator

def 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 N

def 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.length

def 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) + 1
termination_by structural right

def bitSubtractNilLeftAllocation (right : List Bool) (borrow : Bool) : ℕ :=
  match right with
  | [] => 0
  | b :: bs => bitSubtractNilLeftAllocation bs (OAI.EditApproximation.bitBorrow false b borrow) + 1
termination_by structural right

def trimBitWordAllocation : List Bool → ℕ
  | [] => 0
  | bit :: bits => trimBitWordAllocation bits +
      if (OAI.EditApproximation.trimBitWordWithWork bits).1 = [] ∧ bit = false then 0 else 1

def 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 1

def dyadicScalesAllocation (N : ℕ) : ℕ :=
  OAI.EditApproximation.arithmeticMapAllocation (fun e => e + 1) (List.range (max 1 N.bits.length)) + N.bits.length + max 1 N.bits.length

def queryRangeValidAllocation (B range : ℕ) : ℕ :=
  (0 : ℕ).bits.length + range.bits.length + OAI.EditApproximation.naturalWordLEAllocation range.bits B.bits

def 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 1

def 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).1

def 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 left

def 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 left

def 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 left

def 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 N

structure BinaryBellmanAction (Parent : Type u_1) (Child : Type u_2) (M : ℕ) where
  center : Parent
  connection : OAI.EditApproximation.BinaryFraction
  childState : Fin M → Child

def 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 : ℚ) ^ 4

def 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.BinaryFraction

def 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) + 1
termination_by structural left

def 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) + 1
termination_by structural left

def 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).1

def binaryNaturalAddWithWork (a b : ℕ) : List Bool × ℕ :=
  OAI.EditApproximation.bitAddWithWork a.bits b.bits false

def 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.bits

def 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 N

def 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 : ℚ) * epsilon

def 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 false

def 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).1

def 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) actions

def binaryNaturalMulWithWork (a b : ℕ) : List Bool × ℕ := OAI.EditApproximation.bitMulWithWork a.bits b.bits

def binaryNaturalDivModWithWork (n d : ℕ) : List Bool × List Bool × ℕ :=
  OAI.EditApproximation.bitDivModWithWork d.bits n.bits

def 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 0

def 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 false

def 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 false

def 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 0

def 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 + 1

def 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).1

def 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] false

def binaryNaturalMulAllocation (a b : ℕ) : ℕ := OAI.EditApproximation.bitMulAllocation a.bits b.bits

def binaryNaturalDivAllocation (a b : ℕ) : ℕ := OAI.EditApproximation.bitDivModAllocation b.bits a.bits

def 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).bits

def 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).1

def 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) indices

def 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] + 1

def 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 + 1

def 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) b

def binaryGridRoundAllocation (spacing position : ℕ) : ℕ :=
  OAI.EditApproximation.binaryNaturalDivAllocation position spacing +
    OAI.EditApproximation.bitMulAllocation spacing.bits (OAI.EditApproximation.binaryNaturalDivModWithWork position spacing).1

def wordSortAllocation : List (List Bool) → ℕ
  | [] => 0
  | a :: rest => wordSortAllocation rest +
    OAI.EditApproximation.wordInsertAllocation a (OAI.EditApproximation.wordSortWithWork rest).1 + 0

def reduceOnlineIntegerAllocation (K integer : ℕ) : ℕ :=
  OAI.EditApproximation.triangularMassAllocation K +
    OAI.EditApproximation.bitDivModAllocation (OAI.EditApproximation.bitWordValue (OAI.EditApproximation.triangularMassWithWork K).1).bits integer.bits + Nat.size integer

def 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 y


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open Finset

def 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 0

def 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 N

def 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 M

def 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 value

def listedBandCoordinates {M : ℕ} {σ : Type u_1} [DecidableEq σ]
    (band : List (Fin M → σ)) : List (Fin M × σ) :=
  (band.flatMap fun action => List.ofFn fun child => (child, action child)).dedup

def childGain {β : Type u_1} {σ : Type u_2} (mass : β → ℚ) (table : ℕ → β × σ → ℚ)
    (t : ℕ) (i : β × σ) : ℚ := -table t i / mass i.1

def childDecrement {β : Type u_1} {σ : Type u_2} (mass : β → ℚ) (table : ℕ → β × σ → ℚ)
    (t : ℕ) (i : β × σ) : ℚ := (table t i - table (t + 1) i) / mass i.1

def 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).childState

def 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 0

def 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) ^ D

def rationalSmoothedGradient {ι : Type u_1} (G : ℕ) (linear p : ι → ℚ) (i : ι) : ℚ :=
  -OAI.EditApproximation.rationalLogApproximation (p i + 1 / (G : ℚ) ^ 50) (G ^ 60) - 1 + linear i

def 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.val

def 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 i

instance physicalNodeFintype (M J : ℕ) : Fintype (OAI.EditApproximation.PhysicalNode M J) := inferInstance

abbrev 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).val


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.BinaryFraction


def width (a : OAI.EditApproximation.BinaryFraction) : ℕ := max a.numerator.bits.length a.denominator.length

def 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 d

def 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.denominator

def invAllocation (a : OAI.EditApproximation.BinaryFraction) : ℕ :=
  if (OAI.EditApproximation.bitCompareWithWork a.numerator.bits []).1 = .eq then 1 else 0

def naturalCeilingAllocation (a : OAI.EditApproximation.BinaryFraction) : ℕ :=
  if a.numerator.negative then 0 else OAI.EditApproximation.bitCeilDivAllocation a.denominator a.numerator.bits

def 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
  | _, _, _ => 0

def naturalFloorAllocation (a : OAI.EditApproximation.BinaryFraction) : ℕ :=
  if a.numerator.negative then 0 else OAI.EditApproximation.bitDivModAllocation a.denominator a.numerator.bits

def signedPowerTwoAllocation (e : ℤ) : ℕ :=
  if 0 ≤ e then e.toNat + 2 else (-e).toNat + 2

def 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 raw

def 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 + 1

def 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 remaining


end OAI.EditApproximation.BinaryFraction
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation


def 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.1

def 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 + 1

def physicalNodeCode {M J : ℕ} (node : OAI.EditApproximation.PhysicalNode M J) : ℕ :=
  OAI.EditApproximation.treeLayerCode M node.1.val node.2 + M ^ J * node.1.val

def 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.length

def 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.length


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open MeasureTheory ProbabilityTheory

def 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) pass

def 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 B

def 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.SignedBinary


def 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 false

def mulAllocation (a b : OAI.EditApproximation.SignedBinary) : ℕ := OAI.EditApproximation.bitMulAllocation a.bits b.bits

def 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.SignedBinary
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.BinaryFraction


def value (a : OAI.EditApproximation.BinaryFraction) : ℚ := (a.numerator.value : ℚ) / OAI.EditApproximation.bitWordValue a.denominator

def 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.denominator

def mulAllocation (a b : OAI.EditApproximation.BinaryFraction) : ℕ :=
  a.numerator.mulAllocation b.numerator + OAI.EditApproximation.bitMulAllocation a.denominator b.denominator

def ltAllocation (a b : OAI.EditApproximation.BinaryFraction) : ℕ :=
  a.numerator.mulAllocation b.denominatorInteger +
  b.numerator.mulAllocation a.denominatorInteger

def 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 1

def 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).1

def canonicalMulAllocation (a b : OAI.EditApproximation.BinaryFraction) : ℕ :=
  a.mulAllocation b + OAI.EditApproximation.BinaryFraction.canonicalizeAllocation (a.mulWithWork b).1

def minAllocation (a b : OAI.EditApproximation.BinaryFraction) : ℕ := OAI.EditApproximation.BinaryFraction.ltAllocation a b

def maxAllocation (a b : OAI.EditApproximation.BinaryFraction) : ℕ := OAI.EditApproximation.BinaryFraction.ltAllocation a b

def leAllocation (a b : OAI.EditApproximation.BinaryFraction) : ℕ := OAI.EditApproximation.BinaryFraction.ltAllocation b a

def 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 0

def equalAllocation (a b : OAI.EditApproximation.BinaryFraction) : ℕ :=
  OAI.EditApproximation.BinaryFraction.ltAllocation b a + OAI.EditApproximation.BinaryFraction.ltAllocation a b + 0

def 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.1

def subAllocation (a b : OAI.EditApproximation.BinaryFraction) : ℕ := OAI.EditApproximation.BinaryFraction.canonicalAddAllocation a b.neg

def 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)).1

def dyadicCeilingAllocation (a : OAI.EditApproximation.BinaryFraction) : ℕ :=
  OAI.EditApproximation.BinaryFraction.dyadicScanAllocation a (OAI.EditApproximation.BinaryFraction.inversePowerTwo a.width) (2 * a.width) + a.width + 2

def 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).1

def 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 + 1

def 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) indices

def 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 rest

def coarseMinimumWithWork : List OAI.EditApproximation.BinaryFraction → OAI.EditApproximation.BinaryFraction × ℕ
  | [] => (OAI.EditApproximation.BinaryFraction.nat 0, 1)
  | a :: rest => OAI.EditApproximation.BinaryFraction.minimumWithWork a rest

def powAllocation (a : OAI.EditApproximation.BinaryFraction) : ℕ → ℕ
  | 0 => 0
  | n + 1 => powAllocation a n + OAI.EditApproximation.BinaryFraction.canonicalMulAllocation (OAI.EditApproximation.BinaryFraction.powWithWork a n).1 a

def 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).1

def 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).1

def 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).1

def distanceAllocation (a b : OAI.EditApproximation.BinaryFraction) : ℕ := OAI.EditApproximation.BinaryFraction.subAllocation a b + 0

def 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) + 1

def 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 tolerance

def 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 M

def 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 b

def 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 U

def 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 + 2

def 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 F

def 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 F

def 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 radius

def 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 g

def 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 N

def 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 b

def 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 clipped

def 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 + 0

def 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) + 0

def 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) + 0

def 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) + 1

def bandMassAllocation {M : ℕ} (mass : Vector OAI.EditApproximation.BinaryFraction M) : ℕ :=
  OAI.EditApproximation.BinaryFraction.dotListAllocation mass (Vector.replicate M OAI.EditApproximation.BinaryFraction.one) (List.finRange M) + 2 * M

def 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.length

def 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 radius

def 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.length

def 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 + 0

def onlineMinimumAllocation : List OAI.EditApproximation.BinaryFraction → ℕ
  | [] => 0
  | first :: rest => OAI.EditApproximation.BinaryFraction.minimumAllocation first rest

def 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 + 0

def 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).1

def 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).1

def 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 + 1

def 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.BinaryFraction
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.BinaryFraction
open Finset

def 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)) indices

def 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.BinaryFraction
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.BitQuery


def 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 next

def 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 next

def 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.BitQuery
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open EditDistortion

def substring {α : Type u} (word : List α) (lo hi : ℕ) : List α :=
  (word.take hi).drop lo

structure TargetInterval (length : ℕ) where
  lo : ℕ
  hi : ℕ
  ordered : lo ≤ hi
  valid : hi ≤ length

def occurrenceDeficit {α : Type u} [DecidableEq α] (a : α) (word : List α) : ℕ :=
  word.length - if a ∈ word then 1 else 0

def 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) none

def 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 finish

def singletonCost {α : Type u} [DecidableEq α] (a : α) (word : List α) : ℕ :=
  if word = [] then 1 else OAI.EditApproximation.occurrenceDeficit a word

def makeTargetState (n lo hi : ℕ) : Option (OAI.EditApproximation.TargetInterval n) :=
  if h : lo ≤ hi ∧ hi ≤ n then some ⟨lo, hi, h.1, h.2⟩ else none

def targetEndpointDistance {n : ℕ} (q r : OAI.EditApproximation.TargetInterval n) : ℕ :=
  Nat.dist q.lo r.lo + Nat.dist q.hi r.hi

def 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 hi

def shortSourceCost {α : Type u_1} [DecidableEq α] (source target : List α) : ℕ :=
  match source with
  | [] => target.length
  | a :: _ => OAI.EditApproximation.singletonCost a target

def 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 0


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation


def 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 hi

def rationalStateGap {α : Type u_1} (source target : List α) (q : OAI.EditApproximation.TargetInterval target.length) : ℚ :=
  (q.hi : ℚ) - q.lo - source.length

def 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 t

abbrev PhysicalEntry (M J ny : ℕ) := OAI.EditApproximation.PhysicalNode M J × OAI.EditApproximation.TargetInterval ny

def 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 hi

def 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 hi

abbrev 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) M

def 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 key
decreasing_by exact child.property

def 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 + 2

def queryIntervalEqualAllocation {n : ℕ} (a b : OAI.EditApproximation.TargetInterval n) : ℕ :=
  OAI.EditApproximation.naturalEqualAllocation a.lo b.lo + OAI.EditApproximation.naturalEqualAllocation a.hi b.hi + 1

def 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) + 2

def 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 + 1

def 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 + 2

def 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.2

def 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 center

def 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 q

def 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) inputs

def 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.1

def 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 + 1

def queryOnlineKeyEqualAllocation {n : ℕ} (a b : ℕ × OAI.EditApproximation.TargetInterval n) : ℕ :=
  OAI.EditApproximation.naturalEqualAllocation a.1 b.1 + OAI.EditApproximation.queryIntervalEqualAllocation a.2 b.2 + 1

def 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) left

def 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)).1

def 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) inputs

def 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 rest

def 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 left

def 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.2

def 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) inputs

def 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)).1

def 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) inputs

def 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).hi

def 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).2

def 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.get


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.BinaryFraction


def 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 r

def 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 + 3

def 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.hi

def 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 sourceLength

def 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 word

def 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 raw

def 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 + 1

def 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 radius

def 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 + 0

def 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) left

def 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) left

def 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 centers

def 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).1

def 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 + 1

def 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 + M

def 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 + M

def 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 + 2

def 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 + 0

def 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 r

def 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 + 0

def 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 0

def 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) active

def 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 + 0

def coordinateVectorAllocation {M n : ℕ} (band : List (Fin M → OAI.EditApproximation.TargetInterval n)) : ℕ :=
  OAI.EditApproximation.BinaryFraction.bandCoordinatesAllocation band + (OAI.EditApproximation.BinaryFraction.bandCoordinatesWithWork band).1.length

def 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 + d

def 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 80

def 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 + 2

def 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 + 2

def 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 + 2

def 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).1

def 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) states

def 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 members

def 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 children

def 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.length

def 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).1

def 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 r

def 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 + M

def 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 * M

def 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 selected

def 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.length

def 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).1

def 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 scores

def 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 scores

def 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 onlineMin

def endpointActionAllocation {ny M : ℕ} (center : OAI.EditApproximation.TargetInterval ny)
    (states : Fin M → OAI.EditApproximation.TargetInterval ny) : ℕ := OAI.EditApproximation.BinaryFraction.endpointConnectionAllocation center states + M + 1

def 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)) vertices

def 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.lo

def 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.BinaryFraction
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open Finset

def rationalConnectionBudget {n : ℕ} (start : ℚ) : List (OAI.EditApproximation.TargetInterval n) → ℚ → ℚ
  | [], finish => |start - finish|
  | state :: rest, finish => |start - state.lo| + rationalConnectionBudget state.hi rest finish

def 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.TargetInterval

def 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 0

def 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).toNat

def 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open Filter

def 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.hi

def 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).sum

def parameterSqrtWithWork (n : ℕ) : ℕ × ℕ := OAI.EditApproximation.parameterRootSearch n n

def 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation


structure PhysicalTableRequest (M J ny : ℕ) where
  pass : ℕ
  copy : ℕ
  node : OAI.EditApproximation.PhysicalNode M J
  index : ℕ
  state : OAI.EditApproximation.TargetInterval ny

deriving DecidableEq

def 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).eraseDups

def 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)).eraseDups

def 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)).2

def 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 + 20

def 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).1

def 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.PhysicalTableRequest
variable {M J ny : ℕ}

def remainingDepth (request : OAI.EditApproximation.PhysicalTableRequest M J ny) : ℕ :=
  J - request.node.1.val

def rank (T S : ℕ) (request : OAI.EditApproximation.PhysicalTableRequest M J ny) : ℕ :=
  request.pass * (T + S + 1) + request.index

def Bounded (passes copies T S : ℕ) (request : OAI.EditApproximation.PhysicalTableRequest M J ny) : Prop :=
  request.pass < passes ∧ request.copy < copies ∧ request.index ≤ T + S

def 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 S


end OAI.EditApproximation.PhysicalTableRequest
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation


def 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)⟩ .done

def 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⟩ .done

def 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 0

def 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⟩ .done

def 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⟩)⟩ .done

abbrev 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).S

def 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.remainingDepth

def 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 + 2

def 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open Finset MeasureTheory ProbabilityTheory

def 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 0

def 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 : ℚ) ^ exponent

def 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 0

noncomputable 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.BinaryFraction


def 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 eF

def 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 0

def 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 + 1

def 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).1

def 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).1


end OAI.EditApproximation.BinaryFraction
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.FiniteQuery


def 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.memory

def 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.FiniteQuery
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation


def 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 0


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.UnreducedRational


def value (a : OAI.EditApproximation.UnreducedRational) : ℚ := (a.num : ℚ) / a.den

def 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.inv


end OAI.EditApproximation.UnreducedRational
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open Finset EditDistortion

inductive 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 none

def 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.hi

def 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.BinaryFraction
open Finset

def 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.BinaryFraction
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.BinaryFraction


def 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 + 0

def 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 spatial

def 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 k

def 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 bound

def 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)) representatives

def 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 + 0

def 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).1

def 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) representatives

def 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 0

def 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 online

def 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 actions

def 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 query

def 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) 0

def 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.BinaryFraction
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.PositionCounts


def count : OAI.EditApproximation.PositionCounts → ℕ
  | .empty => 0
  | .node n _ _ => n

def left : OAI.EditApproximation.PositionCounts → OAI.EditApproximation.PositionCounts
  | .empty => .empty
  | .node _ l _ => l

def right : OAI.EditApproximation.PositionCounts → OAI.EditApproximation.PositionCounts
  | .empty => .empty
  | .node _ _ r => r

def storageBits : OAI.EditApproximation.PositionCounts → ℕ
  | .empty => 0
  | .node n l r => Nat.size n + 3 + l.storageBits + r.storageBits

def 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.PositionCounts
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.BitQuery.Footprint


def 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 tail

def 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 memory

def computeOf {ι : Type u_1} {β : Type u_2} (execution : β × ℕ) (allocation : ℕ) :
    OAI.EditApproximation.BitQuery.Footprint (OAI.EditApproximation.BitQuery.compute (ι := ι) execution) :=
  OAI.EditApproximation.BitQuery.Footprint.compute execution allocation

def 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.Footprint
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation


def 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 / M

def 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 rest

instance 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_instance

def 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open Finset

def 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 draw

def 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 i

def 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 + 2

def 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 none

def 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 none


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.BinaryMemo
variable {α : Type u_1}

def value : OAI.EditApproximation.BinaryMemo α → Option α
  | .empty => none
  | .node v _ _ => v

def left : OAI.EditApproximation.BinaryMemo α → OAI.EditApproximation.BinaryMemo α
  | .empty => .empty
  | .node _ l _ => l

def right : OAI.EditApproximation.BinaryMemo α → OAI.EditApproximation.BinaryMemo α
  | .empty => .empty
  | .node _ _ r => r

def lookup (tree : OAI.EditApproximation.BinaryMemo α) : List Bool → Option α
  | [] => tree.value
  | false :: rest => tree.left.lookup rest
  | true :: rest => tree.right.lookup rest

def 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.BinaryMemo
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation


def 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 key
decreasing_by exact child.property

def 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 key
decreasing_by exact child.property

def 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 q

def 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).zipIdx

def 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).zipIdx

def 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 key
termination_by rank key
decreasing_by exact child.property

def 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) memory
termination_by rank key
decreasing_by exact child.property

def 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open MeasureTheory ProbabilityTheory

abbrev PhysicalLocalOnlineKey (M J N n : ℕ) :=
  OAI.EditApproximation.PhysicalInternalNode M J × Fin (OAI.EditApproximation.dyadicScales N).length × OAI.EditApproximation.TargetInterval n

abbrev 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).val


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation

open Finset

def 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 localCells


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.BinaryFraction

open Finset

def 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.BinaryFraction
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.BinaryFraction


def 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 j

def 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 t

def 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 t

def 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 + 1


end OAI.EditApproximation.BinaryFraction
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.SourceRanked
variable {σ : Type u_1} {κ : Type u_2}

def rank (tableRank : κ → ℕ) : Sum σ κ → ℕ
  | .inl _ => 0
  | .inr key => tableRank key + 1

def keyCode (sourceCode : σ → ℕ) (tableCode : κ → ℕ) : Sum σ κ → ℕ
  | .inl source => 2 * sourceCode source
  | .inr table => 2 * tableCode table + 1

def 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.SourceRanked
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.ChargedPhysicalRequest


def 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.remainingDepth

def 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 + 1

def rank {M J ny passes copies T S : ℕ}
    (request : OAI.EditApproximation.ChargedPhysicalRequest M J ny passes copies T S) : ℕ :=
  request.depth + request.index


end OAI.EditApproximation.ChargedPhysicalRequest
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation


def 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⟩⟩ .done

def 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⟩ .done

def 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 0

def 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open EditDistortion Finset MeasureTheory ProbabilityTheory

abbrev coarseEntryWidth {α : Type u} (x y : List α) : ℕ := max x.length y.length

abbrev CoarseGuessIndex (n : ℕ) := Fin (Nat.clog 2 n + 1)

def coarseGuess (n : ℕ) (i : OAI.EditApproximation.CoarseGuessIndex n) : ℕ := 2 ^ i.val

def 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 D


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open Finset MeasureTheory ProbabilityTheory

def 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 rest

abbrev 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open MeasureTheory ProbabilityTheory
variable {ι : 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))).toMeasure

abbrev RejectionRuntimeArray := (ι → ℕ) × (∀ i, Fin (range i))


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.BinaryMemo


def 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.fractionStorage

def 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 r


end OAI.EditApproximation.BinaryMemo
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open Filter

def 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 hi

def 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 target


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation


def 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 + 2

def 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.hi


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.BinaryFraction
variable {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) points

def 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 center

def 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) active

def 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 N

def 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).1

def 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) 0


end OAI.EditApproximation.BinaryFraction
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.BinaryFraction
open BinaryFraction

def onlineParametersAllocation (word : List Bool) : ℕ :=
  OAI.EditApproximation.bitPowerAllocation word 5 + OAI.EditApproximation.bitPowerAllocation word 4 + 2

def refinementDecrementAllocation (word : List Bool) : ℕ := OAI.EditApproximation.bitPowerAllocation word 10 + 1


end OAI.EditApproximation.BinaryFraction
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open BinaryFraction

def 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 2

def 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 + 2

def refinementParameterAllocation (N pass : ℕ) (word : List Bool) : ℕ :=
  OAI.EditApproximation.BinaryFraction.onlineParametersAllocation word + OAI.EditApproximation.scheduledRefinementAllocation N pass +
    OAI.EditApproximation.BinaryFraction.refinementDecrementAllocation word + 5

def 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 + 2

def 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 + 5


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.UnreducedRational
open Finset

def nat (n : ℕ) : OAI.EditApproximation.UnreducedRational := ⟨n, 1, by decide⟩


end OAI.EditApproximation.UnreducedRational
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.BinaryFraction

open Finset

def 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.length

def 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.BinaryFraction
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.BinaryFraction


def 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).1

def 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 0

def 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.BinaryFraction
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.BinaryFraction
variable {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 drawAllocation

def 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.get


end OAI.EditApproximation.BinaryFraction
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.BinaryFraction

open Finset

def 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 0


end OAI.EditApproximation.BinaryFraction
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditDistortion


inductive 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 z

noncomputable def edit {Alpha : Type u} (x y : List Alpha) : ℕ :=
  sInf {n | Script true n x y}


end OAI.EditDistortion
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditDistortion
variable {Alpha : Type u} {s : Bool}

noncomputable def cost (s : Bool) (x y : List Alpha) : ℕ := sInf {n | Script s n x y}


end OAI.EditDistortion
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.CoarseSourceTree
open Finset EditDistortion

def word {B : ℕ} {α : Type u} : {D : ℕ} → OAI.EditApproximation.CoarseSourceTree B α D → List α
  | _, .leaf letter => letter.toList
  | _, .branch children => (List.ofFn fun i => word (children i)).flatten


end OAI.EditApproximation.CoarseSourceTree
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation


def 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).2

def 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open Finset EditDistortion

def 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) shift

def 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 shift


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open Finset
open EditDistortion

instance 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.UnskippedBand
open Finset

def 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 : ℤ))) child

def 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 i

def 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 initial

def 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.UnskippedBand
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open Finset MeasureTheory ProbabilityTheory
variable {α : 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)) draw


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open Finset MeasureTheory ProbabilityTheory
variable {α : 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 i


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation


abbrev 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 M

abbrev 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 F

def 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 + 4


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.BinaryFraction

open Finset

def 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.length

def 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)) indices

def 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) indices


end OAI.EditApproximation.BinaryFraction
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.BinaryFraction


def 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).bits

def 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).1

def 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 inputs

def 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 + 1

def 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.BinaryFraction
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open Finset

def 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) shift

def 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 shift


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open MeasureTheory ProbabilityTheory

abbrev 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 key

instance 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_instance

def 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 _ => M

instance 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_instance


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation


def 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 + 25


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable (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 0

def 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⟩⟩ .done


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable (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.BinaryFraction

def 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open Finset MeasureTheory ProbabilityTheory
variable {α : 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 draw

def 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open Finset

def 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).rationalAction


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable {α : 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable {ι : 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable {ι : 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 readCurrent


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable {ι : 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.BinaryFraction
variable {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.BinaryFraction
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable {ι : 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 readCurrent


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable {ι : 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 readCurrent


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable {ι : 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 readCurrent


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable {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))))) + 1


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable (M J N n exponent F Q R B : ℕ) [NeZero M]
open MeasureTheory ProbabilityTheory

def 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 0


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable (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.2


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable {σ : 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable {σ : 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable {σ : 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.PhysicalTableRequest


def 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.PhysicalTableRequest
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.SourceRanked
variable {σ : 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.val

def 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.SourceRanked
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable {σ : 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) request

noncomputable 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable {α : 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable {α : 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).val

def 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable {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 request


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open Filter MeasureTheory

abbrev 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 N

abbrev 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 N


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable {α : 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 copies

def physicalFamilyCode (key : Key) : ℕ :=
  Nat.pair key.1.val (Nat.pair key.2.1.val (OAI.EditApproximation.physicalScalarCode key.2.2))


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.ChargedPhysicalRequest


def 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 + 1


end OAI.EditApproximation.ChargedPhysicalRequest
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation


abbrev 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.code


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open EditDistortion Finset MeasureTheory ProbabilityTheory

def 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open Finset MeasureTheory ProbabilityTheory

def 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open Filter
open scoped Topology

def 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 + 1


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open Filter

abbrev 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).2


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable {α : 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation


def 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable (M J N n exponent F Q R B : ℕ)
open Finset
open MeasureTheory ProbabilityTheory

def 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable (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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable (M J N n exponent F Q R B : ℕ)
open Finset

def 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable {α : 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable {σ : 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.val

def 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable {ι : 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable {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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable {M J n passes copies T S : ℕ} (parent : {r : PhysicalTableRequest M J n // r.Bounded passes copies T S})
open Finset

def 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable (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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable {ι : 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable {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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable (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 Finset

def 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable {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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable {κ : 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable {σ : 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) .empty


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable {α : 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)
    initial


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open MeasureTheory ProbabilityTheory
variable {α : 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open MeasureTheory ProbabilityTheory
variable {α : Type u_1} [DecidableEq α] {M J : ℕ} (source target : List α) (N B : ℕ) (depth : PhysicalEntry M J target.length → ℕ)
open EditDistortion Finset MeasureTheory ProbabilityTheory
open Finset MeasureTheory ProbabilityTheory

noncomputable 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open MeasureTheory ProbabilityTheory
variable {α : 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 N

def 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open Filter

noncomputable 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))) .empty

noncomputable 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))) .empty

noncomputable 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open MeasureTheory ProbabilityTheory
variable {α : 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 N
local notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalFamilyMemo_5) "ell" => inputSmallLog N
local notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalFamilyMemo_6) "exponent" => (40 * smallLogExponent N : ℕ)
local notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalFamilyMemo_7) "passes" => computedSeedPassCount N
local 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 S

noncomputable 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open MeasureTheory ProbabilityTheory Finset
attribute [local instance] Classical.propDecidable

noncomputable def selectionIndicator (p : Prop) : ℝ := if p then 1 else 0


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation


noncomputable 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.val


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open MeasureTheory ProbabilityTheory
variable {ι : Type u_1} [Fintype ι] (range : ι → ℕ) [∀ i, NeZero (range i)]
open Finset

noncomputable 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open MeasureTheory ProbabilityTheory
variable {ι : 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open MeasureTheory ProbabilityTheory
variable {α : 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.2

instance 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.2


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open MeasureTheory

abbrev 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 N

noncomputable 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 N


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open MeasureTheory ProbabilityTheory
variable {α : 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 N
local notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalFamilyRuntime_5) "ell" => inputSmallLog N
local notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalFamilyRuntime_6) "exponent" => (40 * smallLogExponent N : ℕ)
local notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalFamilyRuntime_7) "passes" => computedSeedPassCount N
local 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 FamilyRange

def physicalFamilyRuntimeAccepted
    (execution : OAI.EditApproximation.PhysicalFamilyRuntimeOutcome (M := M) (J := J) (R := R) target N P H) : SeedState × Family :=
  (execution.1, execution.2.2)


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open MeasureTheory ProbabilityTheory Filter

def 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 N

instance physicalLargeInput_decidable (N : ℕ) (epsilon : OAI.EditApproximation.BinaryFraction) :
    Decidable (OAI.EditApproximation.physicalLargeInput N epsilon) := inferInstanceAs (Decidable (_ ∧ _ ∧ _))


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open MeasureTheory ProbabilityTheory
variable {α : 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 N
local notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalFamilyRejectionWork_5) "ell" => inputSmallLog N
local notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalFamilyRejectionWork_6) "exponent" => (40 * smallLogExponent N : ℕ)
local notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalFamilyRejectionWork_7) "passes" => computedSeedPassCount N
local 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 S
local 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)
    execution


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open Filter MeasureTheory

noncomputable 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) input

noncomputable 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.2


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open MeasureTheory
variable {α : 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 N
local 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 copies
local notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalFamilyMemoCoarse_8) "Table" => ChargedPhysicalRequest M J target.length (passes + 1) copies T S
local 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 copies
local 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 copies
local notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalFamilyMemoCoarse_11) "answer" => physicalFamilyAnswer target N P ell exponent H (ell ^ 80) passes copies draw

noncomputable 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open MeasureTheory
variable {α : 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open MeasureTheory

noncomputable 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open MeasureTheory Filter

noncomputable 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 N

def 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open Filter MeasureTheory

noncomputable 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)).dictionaryVisits

noncomputable 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open MeasureTheory Filter
variable {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.1


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open MeasureTheory Filter

noncomputable 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open Filter MeasureTheory

noncomputable 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 execution


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable {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 N
local 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 copies
local notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalIndexedCoarseWork_6) "Table" => ChargedPhysicalRequest M J target.length (passes + 1) copies T S
local 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 copies
local 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 copies
local notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalIndexedCoarseWork_9) "answer" => physicalFamilyAnswer target N P ell exponent H (ell ^ 80) passes copies draw

noncomputable 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open Filter MeasureTheory
variable {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.1


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open Filter MeasureTheory

noncomputable 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable {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 N
local 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 copies
local notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalCoarseSamplingWork_6) "Table" => ChargedPhysicalRequest M J target.length (passes + 1) copies T S
local 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 copies
local 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 copies
local notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalCoarseSamplingWork_9) "answer" => physicalFamilyAnswer target N P ell exponent H (ell ^ 80) passes copies draw

noncomputable 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open MeasureTheory Filter
variable {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.1


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open MeasureTheory Filter

noncomputable 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable {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 N
local 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 copies
local notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalCoarsePreparation_8) "Table" => ChargedPhysicalRequest M J target.length (passes + 1) copies T S
local 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 copies
local 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 copies
local notation (name := source_Combinatorics_EditApproximation_Refinement_PhysicalCoarsePreparation_11) "answer" => physicalFamilyAnswer target N P ell exponent H (ell ^ 80) passes copies draw

noncomputable 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open Filter MeasureTheory

noncomputable 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 execution


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open MeasureTheory Filter

noncomputable 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 execution

noncomputable 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open BitQuery
variable {α : 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 + 9


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.BitQuery.Footprint


def 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)
      memory
termination_by rank key
decreasing_by exact child.property


end OAI.EditApproximation.BitQuery.Footprint
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open BitQuery

local 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open BitQuery
attribute [local instance] queryArityNeZero queryRoundsNeZero

def 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open BitQuery
attribute [local instance] queryArityNeZero queryRoundsNeZero
open Finset

def 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open BitQuery
attribute [local instance] queryArityNeZero queryRoundsNeZero

def 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open BitQuery
attribute [local instance] queryArityNeZero queryRoundsNeZero
open Finset
open MeasureTheory ProbabilityTheory

def 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open BitQuery
attribute [local instance] queryArityNeZero queryRoundsNeZero

def 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open BitQuery
attribute [local instance] queryArityNeZero queryRoundsNeZero
open Finset

def 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.BinaryFraction
variable {α : 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 Finset

def 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.BinaryFraction
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.BinaryFraction
variable {α : 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.BinaryFraction
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.BinaryFraction
variable {α : 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.BinaryFraction
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.BinaryFraction
variable {α : 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 q

def 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 q


end OAI.EditApproximation.BinaryFraction
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable {ι : 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable {ι : 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 readCurrent


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable {ι : 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 Finset

def 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 readCurrent


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable {ι : 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 readCurrent


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable {σ : 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable {α : 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) q


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable {α : 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable {α : 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable {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 parent


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
variable {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) key


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation

open MeasureTheory ProbabilityTheory

def 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 key


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation


def 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
attribute [local instance] queryRoundsNeZero

def 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))) .empty

def 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open Filter MeasureTheory

def 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation


def 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) input


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open MeasureTheory

noncomputable 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.BinaryFraction
variable {α : 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 Finset

def 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 cell


end OAI.EditApproximation.BinaryFraction
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.BinaryFraction
variable {α : 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 Finset

def 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.BinaryFraction
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.BinaryFraction
variable {α : 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 Finset

def 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 + eb


end OAI.EditApproximation.BinaryFraction
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.BinaryFraction
variable {α : 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 0

def 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.BinaryFraction
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.BinaryFraction
variable {α : 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 0

def 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).1


end OAI.EditApproximation.BinaryFraction
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation.BinaryFraction
variable {α : 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 q

def 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 q


end OAI.EditApproximation.BinaryFraction
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open Filter MeasureTheory

noncomputable 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open Filter

def 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).value


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open BitQuery
attribute [local instance] queryArityNeZero queryRoundsNeZero

def 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 hr


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open BitQuery
attribute [local instance] queryArityNeZero queryRoundsNeZero
open Finset

def 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 hr


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open BitQuery
attribute [local instance] queryArityNeZero queryRoundsNeZero

def 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 hr

def 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 parent

def 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open BitQuery
attribute [local instance] queryArityNeZero queryRoundsNeZero
open MeasureTheory ProbabilityTheory

def 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 key


end OAI.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open BitQuery
attribute [local instance] queryArityNeZero queryRoundsNeZero

def 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.EditApproximation
end

section
universe u v w u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8
namespace OAI.EditApproximation
open Filter MeasureTheory
attribute [local instance] queryRoundsNeZero

def 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))) .empty

noncomputable 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
  sorry

end OAI.EditApproximation
end