| import OAI.Computability.BinPacking.Arithmetic.NatExpression |
| import OAI.Computability.BinPacking.Inventory.InventoryPrefixConservation |
|
|
| namespace OAI |
|
|
| namespace BinPackingGap.InventoryData |
|
|
| open IntegerPackingArithmetic |
|
|
| variable (D : InventoryData) |
|
|
| def coordinateDenominator : ℕ := |
| geomDenominator D.graph.edges.length D.R D.geometryBound D.L |
|
|
| theorem coordinateDenominator_pos : 0 < D.coordinateDenominator := |
| geomDenominator_pos _ _ _ _ |
|
|
| def treeBaselineInteger : D.TreeRow → ℤ |
| | .inl (node, _) => |
| treeRightNumerator D.graph.edges.length D.R D.geometryBound D.L .plus node.val |
| | .inr (.inl (node, _)) => |
| treeRightNumerator D.graph.edges.length D.R D.geometryBound D.L .minus node.val |
| | .inr (.inr _) => D.coordinateDenominator |
|
|
| def rowBaselineInteger {v : D.Vertex} : D.RowAt v → ℤ |
| | .inl r => D.treeBaselineInteger r |
| | .inr (_, j) => baselineNumerator D.graph.edges.length D.R D.geometryBound D.L |
| (D.jobPosition j) |
|
|
| def treeDeadlineInteger : D.TreeRow → ℤ |
| | .inl (node, _) => |
| if node.val ∈ D.plus.leaves then |
| treeLeftNumerator D.graph.edges.length D.R D.geometryBound D.L .plus node.val |
| else treeRightNumerator D.graph.edges.length D.R D.geometryBound D.L .plus node.val |
| | .inr (.inl (node, _)) => |
| if node.val ∈ D.minus.leaves then |
| treeLeftNumerator D.graph.edges.length D.R D.geometryBound D.L .minus node.val |
| else treeRightNumerator D.graph.edges.length D.R D.geometryBound D.L .minus node.val |
| | .inr (.inr _) => D.coordinateDenominator |
|
|
| def deadlineInteger {v : D.Vertex} : D.MBase v → ℤ |
| | .inl r => D.treeDeadlineInteger r |
| | .inr j => baselineNumerator D.graph.edges.length D.R D.geometryBound D.L |
| (D.jobPosition j) - 1 |
|
|
| def rowIntegerCoordinate {v : D.Vertex} (r : D.RowAt v) : ℤ := |
| D.rowBaselineInteger r - if D.rowShort r then 1 else 0 |
|
|
| def anchorIntegerCoordinate {v : D.Vertex} : D.AnchorAt v → ℤ |
| | .inl z => -D.deadlineInteger z |
| | .inr j => |
| -baselineNumerator D.graph.edges.length D.R D.geometryBound D.L (D.jobPosition j) - |
| betaNumerator D.graph.edges.length D.R D.geometryBound D.L (D.jobPosition j).1 |
|
|
| def globalIntegerCoordinate : D.GlobalCopy → ℤ |
| | ⟨.up one, _⟩ => -(if one then (D.coordinateDenominator : ℤ) else 0) |
| | ⟨.um one, _⟩ => -(if one then (D.coordinateDenominator : ℤ) else 0) |
| | ⟨.edge e permit, _⟩ => |
| betaNumerator D.graph.edges.length D.R D.geometryBound D.L e + |
| if permit then 0 else 1 |
|
|
| def localIntegerCoordinate {v : D.Vertex} : D.LocalAt v → ℤ |
| | .inl (.inl ⟨ell, _⟩) => -(localNumerator D.geometryBound D.L ell.val : ℤ) |
| | _ => 0 |
|
|
| def itemIntegerCoordinate : D.Item → ℤ |
| | ⟨.x, ⟨_, r⟩⟩ => D.rowIntegerCoordinate r |
| | ⟨.anchor, ⟨_, a⟩⟩ => D.anchorIntegerCoordinate a |
| | ⟨.«global», u⟩ => D.globalIntegerCoordinate u |
| | ⟨.«local», ⟨_, l⟩⟩ => D.localIntegerCoordinate l |
| | ⟨.flag, _⟩ => 0 |
|
|
| variable (hplus : D.plus.height ≤ D.L) (hminus : D.minus.height ≤ D.L) |
|
|
| include hplus hminus in |
| theorem coordinateDenominator_mul_treeBaseline (r : D.TreeRow) : |
| (D.coordinateDenominator : ℚ) * D.treeBaseline r = |
| (D.treeBaselineInteger r : ℚ) := by |
| rcases r with ⟨node, j⟩ | (⟨node, j⟩ | j) |
| · simpa only [treeBaseline, treeBaselineInteger, Int.cast_natCast, |
| coordinateDenominator] using |
| geomDenominator_mul_treeRight D.graph.edges.length D.R D.geometryBound D.L |
| .plus node.val ((D.plus.length_le_height node.property).trans hplus) |
| · simpa only [treeBaseline, treeBaselineInteger, Int.cast_natCast, |
| coordinateDenominator] using |
| geomDenominator_mul_treeRight D.graph.edges.length D.R D.geometryBound D.L |
| .minus node.val ((D.minus.length_le_height node.property).trans hminus) |
| · simp [treeBaseline, treeBaselineInteger] |
|
|
| include hplus hminus in |
| theorem coordinateDenominator_mul_rowBaseline {v : D.Vertex} (r : D.RowAt v) : |
| (D.coordinateDenominator : ℚ) * D.rowBaseline r = |
| (D.rowBaselineInteger r : ℚ) := by |
| rcases r with r | ⟨b, j⟩ |
| · exact D.coordinateDenominator_mul_treeBaseline hplus hminus r |
| · exact geomDenominator_mul_baseline _ _ _ _ _ |
|
|
| include hplus hminus in |
| theorem coordinateDenominator_mul_treeDeadline (r : D.TreeRow) : |
| (D.coordinateDenominator : ℚ) * D.treeDeadline r = |
| (D.treeDeadlineInteger r : ℚ) := by |
| rcases r with ⟨node, j⟩ | (⟨node, j⟩ | j) |
| · have hn := (D.plus.length_le_height node.property).trans hplus |
| by_cases hl : node.val ∈ D.plus.leaves |
| · simpa only [treeDeadline, treeDeadlineInteger, hl, ite_true, Int.cast_natCast, |
| coordinateDenominator] using |
| geomDenominator_mul_treeLeft D.graph.edges.length D.R D.geometryBound D.L |
| .plus node.val hn |
| · simpa only [treeDeadline, treeDeadlineInteger, hl, ite_false, Int.cast_natCast, |
| coordinateDenominator] using |
| geomDenominator_mul_treeRight D.graph.edges.length D.R D.geometryBound D.L |
| .plus node.val hn |
| · have hn := (D.minus.length_le_height node.property).trans hminus |
| by_cases hl : node.val ∈ D.minus.leaves |
| · simpa only [treeDeadline, treeDeadlineInteger, hl, ite_true, Int.cast_natCast, |
| coordinateDenominator] using |
| geomDenominator_mul_treeLeft D.graph.edges.length D.R D.geometryBound D.L |
| .minus node.val hn |
| · simpa only [treeDeadline, treeDeadlineInteger, hl, ite_false, Int.cast_natCast, |
| coordinateDenominator] using |
| geomDenominator_mul_treeRight D.graph.edges.length D.R D.geometryBound D.L |
| .minus node.val hn |
| · simp [treeDeadline, treeDeadlineInteger] |
|
|
| include hplus hminus in |
| theorem coordinateDenominator_mul_deadline {v : D.Vertex} (r : D.MBase v) : |
| (D.coordinateDenominator : ℚ) * D.deadline r = |
| (D.deadlineInteger r : ℚ) := by |
| rcases r with r | j |
| · exact D.coordinateDenominator_mul_treeDeadline hplus hminus r |
| · simp only [deadline, deadlineInteger, Geometry.jobLeft, mul_sub, Int.cast_sub, |
| Int.cast_one, coordinateDenominator, geomDenominator_mul_baseline, |
| geomDenominator_mul_delta] |
|
|
| include hplus hminus in |
| theorem coordinateDenominator_mul_rowCoordinate {v : D.Vertex} (r : D.RowAt v) : |
| (D.coordinateDenominator : ℚ) * D.rowCoordinate r = |
| (D.rowIntegerCoordinate r : ℚ) := by |
| have hb := D.coordinateDenominator_mul_rowBaseline hplus hminus r |
| simp only [coordinateDenominator] at hb |
| have hd := geomDenominator_mul_delta D.graph.edges.length D.R D.geometryBound D.L |
| cases hs : D.rowShort r <;> |
| simp [rowCoordinate, rowIntegerCoordinate, hs, mul_sub, hb, |
| coordinateDenominator, hd] |
| |
| include hplus hminus in |
| theorem coordinateDenominator_mul_anchorCoordinate {v : D.Vertex} (r : D.AnchorAt v) : |
| (D.coordinateDenominator : ℚ) * D.anchorCoordinate r = |
| (D.anchorIntegerCoordinate r : ℚ) := by |
| rcases r with r | j |
| · simp only [anchorCoordinate, anchorIntegerCoordinate, mul_neg, Int.cast_neg, |
| D.coordinateDenominator_mul_deadline hplus hminus r] |
| · simp only [anchorCoordinate, anchorIntegerCoordinate, mul_sub, mul_neg, |
| Int.cast_sub, Int.cast_neg, coordinateDenominator, geomDenominator_mul_baseline, |
| geomDenominator_mul_beta] |
|
|
| theorem coordinateDenominator_mul_globalCoordinate (r : D.GlobalCopy) : |
| (D.coordinateDenominator : ℚ) * D.globalCoordinate r = |
| (D.globalIntegerCoordinate r : ℚ) := by |
| rcases r with ⟨species, j⟩ |
| cases species with |
| | up b => |
| cases b <;> simp [globalCoordinate, globalIntegerCoordinate, coordinateDenominator] |
| | um b => |
| cases b <;> simp [globalCoordinate, globalIntegerCoordinate, coordinateDenominator] |
| | edge e b => |
| cases b <;> |
| simp [globalCoordinate, globalIntegerCoordinate, mul_add, coordinateDenominator, |
| geomDenominator_mul_beta, geomDenominator_mul_delta] |
| |
| theorem coordinateDenominator_mul_localCoordinate {v : D.Vertex} (r : D.LocalAt v) : |
| (D.coordinateDenominator : ℚ) * D.localCoordinate r = |
| (D.localIntegerCoordinate r : ℚ) := by |
| rcases r with (⟨ell, j⟩ | j) | j |
| · have hell : ell.val ≤ D.L := (Finset.mem_Icc.mp ell.property).2 |
| simp only [localCoordinate, localLength, localIntegerCoordinate, mul_neg, |
| Int.cast_neg, Int.cast_natCast, coordinateDenominator, |
| geomDenominator_mul_lambda D.graph.edges.length D.R D.geometryBound D.L ell.val hell] |
| · simp [localCoordinate, localLength, localIntegerCoordinate] |
| · simp [localCoordinate, localLength, localIntegerCoordinate] |
|
|
| include hplus hminus in |
| theorem coordinateDenominator_mul_itemCoordinate (i : D.Item) : |
| (D.coordinateDenominator : ℚ) * D.itemCoordinate i = |
| (D.itemIntegerCoordinate i : ℚ) := by |
| rcases i with ⟨r, i⟩ |
| cases r with |
| | x => exact D.coordinateDenominator_mul_rowCoordinate hplus hminus i.2 |
| | anchor => exact D.coordinateDenominator_mul_anchorCoordinate hplus hminus i.2 |
| | «global» => exact D.coordinateDenominator_mul_globalCoordinate i |
| | «local» => exact D.coordinateDenominator_mul_localCoordinate i.2 |
| | flag => simp [itemCoordinate, itemIntegerCoordinate] |
|
|
| include hplus hminus in |
| theorem itemIntegerCoordinate_ratio (i : D.Item) : |
| (D.itemIntegerCoordinate i : ℚ) / D.coordinateDenominator = D.itemCoordinate i := by |
| have hd : (D.coordinateDenominator : ℚ) ≠ 0 := by |
| exact_mod_cast D.coordinateDenominator_pos.ne' |
| apply (div_eq_iff hd).mpr |
| simpa only [mul_comm] using |
| (D.coordinateDenominator_mul_itemCoordinate hplus hminus i).symm |
|
|
| def itemRawPair (i : D.Item) : ℕ × ℕ := |
| rawItem D.coordinateDenominator (D.itemSubclass i) (D.itemLabel i) |
| (D.itemIntegerCoordinate i) |
|
|
| include hplus hminus in |
| theorem itemRawPair_valid (i : D.Item) : |
| 0 < (D.itemRawPair i).1 ∧ (D.itemRawPair i).1 < (D.itemRawPair i).2 := by |
| apply rawItem_valid D.coordinateDenominator D.coordinateDenominator_pos |
| rw [D.itemIntegerCoordinate_ratio hplus hminus i] |
| exact D.itemCoordinate_abs_le_six i |
|
|
| include hplus hminus in |
| theorem itemRawPair_ratio (i : D.Item) : |
| ((D.itemRawPair i).1 : ℚ) / (D.itemRawPair i).2 = D.itemSize i := by |
| have hW : |(D.itemIntegerCoordinate i : ℚ) / D.coordinateDenominator| ≤ 6 := by |
| rw [D.itemIntegerCoordinate_ratio hplus hminus i] |
| exact D.itemCoordinate_abs_le_six i |
| change ((rawItem _ _ _ _).1 : ℚ) / (rawItem _ _ _ _).2 = _ |
| rw [rawItem_ratio D.coordinateDenominator D.coordinateDenominator_pos _ _ _ hW, |
| D.itemIntegerCoordinate_ratio hplus hminus i] |
| rfl |
|
|
| end BinPackingGap.InventoryData |
|
|
| namespace BinPackingGap.NaturalPackingNumerator |
|
|
| open IntegerPackingArithmetic |
|
|
| structure NatDifference where |
| pos : Nat |
| neg : Nat |
| deriving DecidableEq |
|
|
| namespace NatDifference |
|
|
| def eval (a : NatDifference) : Int := (a.pos : Int) - a.neg |
|
|
| def ofNat (n : Nat) : NatDifference := ⟨n, 0⟩ |
|
|
| def ofInt (z : Int) : NatDifference := ⟨z.toNat, (-z).toNat⟩ |
|
|
| def negate (a : NatDifference) : NatDifference := ⟨a.neg, a.pos⟩ |
|
|
| def add (a b : NatDifference) : NatDifference := ⟨a.pos + b.pos, a.neg + b.neg⟩ |
|
|
| def sub (a b : NatDifference) : NatDifference := ⟨a.pos + b.neg, a.neg + b.pos⟩ |
|
|
| def scale (n : Nat) (a : NatDifference) : NatDifference := ⟨n * a.pos, n * a.neg⟩ |
|
|
| def toNat (a : NatDifference) : Nat := a.pos - a.neg |
|
|
| @[simp] theorem eval_ofNat (n : Nat) : (ofNat n).eval = (n : Int) := by |
| simp [ofNat, eval] |
|
|
| @[simp] theorem eval_ofInt (z : Int) : (ofInt z).eval = z := |
| Int.toNat_sub_toNat_neg z |
|
|
| @[simp] theorem eval_negate (a : NatDifference) : a.negate.eval = -a.eval := by |
| simp only [negate, eval] |
| ring |
|
|
| @[simp] theorem eval_add (a b : NatDifference) : (a.add b).eval = a.eval + b.eval := by |
| simp only [add, eval, Nat.cast_add] |
| ring |
|
|
| @[simp] theorem eval_sub (a b : NatDifference) : (a.sub b).eval = a.eval - b.eval := by |
| simp only [sub, eval, Nat.cast_add] |
| ring |
|
|
| @[simp] theorem eval_scale (n : Nat) (a : NatDifference) : |
| (scale n a).eval = (n : Int) * a.eval := by |
| simp only [scale, eval, Nat.cast_mul] |
| ring |
|
|
| theorem toNat_eq (a : NatDifference) : a.toNat = a.eval.toNat := by |
| unfold toNat eval |
| omega |
|
|
| end NatDifference |
|
|
| def baselineParts (m R D L : Nat) (r : Geometry.Position m R) : NatDifference := |
| ⟨80 * (R + 1) ^ m * widthRadix D ^ L + |
| 10 * widthRadix D ^ L * (r.2.val + 1) * (R + 1) ^ r.1.val, |
| 10 * widthRadix D ^ L⟩ |
|
|
| def betaParts (m R D L : Nat) (edge : Fin m) : NatDifference := |
| ⟨10 * widthRadix D ^ L * (R + 1) ^ edge.val, 10 * widthRadix D ^ L⟩ |
|
|
| @[simp] theorem eval_baselineParts (m R D L : Nat) (r : Geometry.Position m R) : |
| (baselineParts m R D L r).eval = baselineNumerator m R D L r := by |
| simp only [baselineParts, NatDifference.eval, baselineNumerator, Nat.cast_add, |
| Nat.cast_mul, Nat.cast_pow, Nat.cast_ofNat, Nat.cast_one] |
| ring |
|
|
| @[simp] theorem eval_betaParts (m R D L : Nat) (edge : Fin m) : |
| (betaParts m R D L edge).eval = betaNumerator m R D L edge := by |
| simp only [betaParts, NatDifference.eval, betaNumerator, Nat.cast_add, |
| Nat.cast_mul, Nat.cast_pow, Nat.cast_ofNat, Nat.cast_one] |
| ring |
|
|
| section Coordinates |
|
|
| variable (D : InventoryData) |
|
|
| def treeBaselineParts : D.TreeRow → NatDifference |
| | .inl (node, _) => NatDifference.ofNat |
| (treeRightNumerator D.graph.edges.length D.R D.geometryBound D.L .plus node.val) |
| | .inr (.inl (node, _)) => NatDifference.ofNat |
| (treeRightNumerator D.graph.edges.length D.R D.geometryBound D.L .minus node.val) |
| | .inr (.inr _) => NatDifference.ofNat D.coordinateDenominator |
|
|
| def rowBaselineParts {v : D.Vertex} : D.RowAt v → NatDifference |
| | .inl r => treeBaselineParts D r |
| | .inr (_, j) => baselineParts D.graph.edges.length D.R D.geometryBound D.L (D.jobPosition j) |
|
|
| def treeDeadlineParts : D.TreeRow → NatDifference |
| | .inl (node, _) => NatDifference.ofNat |
| (if node.val ∈ D.plus.leaves then |
| treeLeftNumerator D.graph.edges.length D.R D.geometryBound D.L .plus node.val |
| else treeRightNumerator D.graph.edges.length D.R D.geometryBound D.L .plus node.val) |
| | .inr (.inl (node, _)) => NatDifference.ofNat |
| (if node.val ∈ D.minus.leaves then |
| treeLeftNumerator D.graph.edges.length D.R D.geometryBound D.L .minus node.val |
| else treeRightNumerator D.graph.edges.length D.R D.geometryBound D.L .minus node.val) |
| | .inr (.inr _) => NatDifference.ofNat D.coordinateDenominator |
|
|
| def deadlineParts {v : D.Vertex} : D.MBase v → NatDifference |
| | .inl r => treeDeadlineParts D r |
| | .inr j => (baselineParts D.graph.edges.length D.R D.geometryBound D.L |
| (D.jobPosition j)).sub (NatDifference.ofNat 1) |
|
|
| def rowParts {v : D.Vertex} (r : D.RowAt v) : NatDifference := |
| (rowBaselineParts D r).sub (NatDifference.ofNat (if D.rowShort r then 1 else 0)) |
|
|
| def anchorParts {v : D.Vertex} : D.AnchorAt v → NatDifference |
| | .inl z => (deadlineParts D z).negate |
| | .inr j => (baselineParts D.graph.edges.length D.R D.geometryBound D.L |
| (D.jobPosition j)).negate.sub |
| (betaParts D.graph.edges.length D.R D.geometryBound D.L (D.jobPosition j).1) |
|
|
| def globalParts : D.GlobalCopy → NatDifference |
| | ⟨.up one, _⟩ => (NatDifference.ofNat (if one then D.coordinateDenominator else 0)).negate |
| | ⟨.um one, _⟩ => (NatDifference.ofNat (if one then D.coordinateDenominator else 0)).negate |
| | ⟨.edge edge permit, _⟩ => |
| (betaParts D.graph.edges.length D.R D.geometryBound D.L edge).add |
| (NatDifference.ofNat (if permit then 0 else 1)) |
|
|
| def localParts {v : D.Vertex} : D.LocalAt v → NatDifference |
| | .inl (.inl ⟨ell, _⟩) => |
| (NatDifference.ofNat (localNumerator D.geometryBound D.L ell.val)).negate |
| | _ => NatDifference.ofNat 0 |
|
|
| def coordinateParts : D.Item → NatDifference |
| | ⟨.x, ⟨_, r⟩⟩ => rowParts D r |
| | ⟨.anchor, ⟨_, a⟩⟩ => anchorParts D a |
| | ⟨.«global», u⟩ => globalParts D u |
| | ⟨.«local», ⟨_, l⟩⟩ => localParts D l |
| | ⟨.flag, _⟩ => NatDifference.ofNat 0 |
|
|
| @[simp] theorem eval_treeBaselineParts (r : D.TreeRow) : |
| (treeBaselineParts D r).eval = D.treeBaselineInteger r := by |
| rcases r with ⟨node, j⟩ | (⟨node, j⟩ | j) <;> |
| simp [treeBaselineParts, InventoryData.treeBaselineInteger] |
| |
| @[simp] theorem eval_rowBaselineParts {v : D.Vertex} (r : D.RowAt v) : |
| (rowBaselineParts D r).eval = D.rowBaselineInteger r := by |
| rcases r with r | ⟨b, j⟩ <;> |
| simp [rowBaselineParts, InventoryData.rowBaselineInteger] |
| |
| @[simp] theorem eval_treeDeadlineParts (r : D.TreeRow) : |
| (treeDeadlineParts D r).eval = D.treeDeadlineInteger r := by |
| rcases r with ⟨node, j⟩ | (⟨node, j⟩ | j) |
| · by_cases h : node.val ∈ D.plus.leaves <;> |
| simp [treeDeadlineParts, InventoryData.treeDeadlineInteger, h] |
| · by_cases h : node.val ∈ D.minus.leaves <;> |
| simp [treeDeadlineParts, InventoryData.treeDeadlineInteger, h] |
| · simp [treeDeadlineParts, InventoryData.treeDeadlineInteger] |
| |
| @[simp] theorem eval_deadlineParts {v : D.Vertex} (r : D.MBase v) : |
| (deadlineParts D r).eval = D.deadlineInteger r := by |
| rcases r with r | j <;> |
| simp [deadlineParts, InventoryData.deadlineInteger] |
| |
| @[simp] theorem eval_rowParts {v : D.Vertex} (r : D.RowAt v) : |
| (rowParts D r).eval = D.rowIntegerCoordinate r := by |
| cases h : D.rowShort r <;> |
| simp [rowParts, InventoryData.rowIntegerCoordinate, h] |
| |
| @[simp] theorem eval_anchorParts {v : D.Vertex} (r : D.AnchorAt v) : |
| (anchorParts D r).eval = D.anchorIntegerCoordinate r := by |
| rcases r with r | j <;> |
| simp [anchorParts, InventoryData.anchorIntegerCoordinate] |
| |
| @[simp] theorem eval_globalParts (r : D.GlobalCopy) : |
| (globalParts D r).eval = D.globalIntegerCoordinate r := by |
| rcases r with ⟨species, j⟩ |
| cases species with |
| | up b => cases b <;> simp [globalParts, InventoryData.globalIntegerCoordinate] |
| | um b => cases b <;> simp [globalParts, InventoryData.globalIntegerCoordinate] |
| | edge e b => cases b <;> simp [globalParts, InventoryData.globalIntegerCoordinate] |
| |
| @[simp] theorem eval_localParts {v : D.Vertex} (r : D.LocalAt v) : |
| (localParts D r).eval = D.localIntegerCoordinate r := by |
| rcases r with (⟨ell, j⟩ | j) | j <;> |
| simp [localParts, InventoryData.localIntegerCoordinate] |
| |
| @[simp] theorem eval_coordinateParts (i : D.Item) : |
| (coordinateParts D i).eval = D.itemIntegerCoordinate i := by |
| rcases i with ⟨role, i⟩ |
| cases role with |
| | x => exact eval_rowParts D i.2 |
| | anchor => exact eval_anchorParts D i.2 |
| | «global» => exact eval_globalParts D i |
| | «local» => exact eval_localParts D i.2 |
| | flag => simp [coordinateParts, InventoryData.itemIntegerCoordinate] |
|
|
| end Coordinates |
|
|
| def primaryParts (subclass : Subclass) : NatDifference := NatDifference.ofInt (primaryScore subclass) |
|
|
| @[simp] theorem eval_primaryParts (subclass : Subclass) : |
| (primaryParts subclass).eval = primaryScore subclass := |
| NatDifference.eval_ofInt _ |
|
|
| def labelPower {n : Nat} (label : Option (Fin n)) : Nat := |
| label.elim 0 (fun v => 3 ^ (v.val + 1)) |
|
|
| def secondaryParts {n : Nat} (subclass : Subclass) (label : Option (Fin n)) : NatDifference := |
| match subclass.role with |
| | .x => NatDifference.ofNat (labelPower label) |
| | .anchor => (NatDifference.ofNat (2 * labelPower label)).negate |
| | .«global» => NatDifference.ofNat 0 |
| | .«local» => NatDifference.ofNat (labelPower label) |
| | .flag => NatDifference.ofNat 0 |
|
|
| @[simp] theorem eval_secondaryParts {n : Nat} (subclass : Subclass) (label : Option (Fin n)) : |
| (secondaryParts subclass label).eval = secondaryScore subclass label := by |
| cases label <;> cases h : subclass.role <;> |
| simp [secondaryParts, secondaryScore, labelPower, labelWeight, h] |
| |
| def signedParts (n geom : Nat) (p q W : NatDifference) : NatDifference := |
| (((NatDifference.ofNat (200000000 * primaryBound * 3 ^ n * geom)).add |
| (NatDifference.scale (1000000 * 3 ^ n * geom) p)).add |
| (NatDifference.scale (1000 * geom) q)).add W |
|
|
| @[simp] theorem signedParts_pos (n geom : Nat) (p q W : NatDifference) : |
| (signedParts n geom p q W).pos = |
| 200000000 * primaryBound * 3 ^ n * geom + |
| (1000000 * 3 ^ n * geom) * p.pos + (1000 * geom) * q.pos + W.pos := rfl |
|
|
| @[simp] theorem signedParts_neg (n geom : Nat) (p q W : NatDifference) : |
| (signedParts n geom p q W).neg = |
| (1000000 * 3 ^ n * geom) * p.neg + (1000 * geom) * q.neg + W.neg := by |
| simp [signedParts, NatDifference.ofNat, NatDifference.add, NatDifference.scale] |
|
|
| theorem signedParts_toNat (n geom : Nat) (p q W : NatDifference) : |
| (signedParts n geom p q W).toNat = |
| (200000000 * primaryBound * 3 ^ n * geom + |
| (1000000 * 3 ^ n * geom) * p.pos + (1000 * geom) * q.pos + W.pos) - |
| ((1000000 * 3 ^ n * geom) * p.neg + (1000 * geom) * q.neg + W.neg) := by |
| simp only [NatDifference.toNat, signedParts_pos, signedParts_neg] |
|
|
| @[simp] theorem eval_signedParts (n geom : Nat) (p q W : NatDifference) : |
| (signedParts n geom p q W).eval = signedNumerator n geom p.eval q.eval W.eval := by |
| simp only [signedParts, NatDifference.eval_add, NatDifference.eval_ofNat, |
| NatDifference.eval_scale, signedNumerator, Nat.cast_mul, Nat.cast_pow, Nat.cast_ofNat] |
|
|
| def numeratorParts {n : Nat} (geom : Nat) (subclass : Subclass) (label : Option (Fin n)) |
| (W : NatDifference) : NatDifference := |
| signedParts n geom (primaryParts subclass) (secondaryParts subclass label) W |
|
|
| @[simp] theorem eval_numeratorParts {n : Nat} (geom : Nat) (subclass : Subclass) |
| (label : Option (Fin n)) (W : NatDifference) : |
| (numeratorParts geom subclass label W).eval = itemNumerator geom subclass label W.eval := by |
| simp [numeratorParts, itemNumerator] |
|
|
| theorem numeratorParts_toNat {n : Nat} (geom : Nat) (subclass : Subclass) |
| (label : Option (Fin n)) (W : NatDifference) : |
| (numeratorParts geom subclass label W).toNat = (itemNumerator geom subclass label W.eval).toNat := by |
| rw [NatDifference.toNat_eq, eval_numeratorParts] |
|
|
| def inventoryParts (D : InventoryData) (i : D.Item) : NatDifference := |
| numeratorParts D.coordinateDenominator (D.itemSubclass i) (D.itemLabel i) |
| (coordinateParts D i) |
|
|
| def inventoryNumerator (D : InventoryData) (i : D.Item) : Nat := |
| (inventoryParts D i).toNat |
|
|
| theorem inventoryNumerator_eq (D : InventoryData) (i : D.Item) : |
| inventoryNumerator D i = |
| (itemNumerator D.coordinateDenominator (D.itemSubclass i) (D.itemLabel i) |
| (D.itemIntegerCoordinate i)).toNat := by |
| simp only [inventoryNumerator, inventoryParts, numeratorParts_toNat, eval_coordinateParts] |
|
|
| def naturalRawItem (D : InventoryData) (i : D.Item) : Nat × Nat := |
| (inventoryNumerator D i, sizeDenominator D.graph.n D.coordinateDenominator) |
|
|
| theorem naturalRawItem_eq (D : InventoryData) (i : D.Item) : |
| naturalRawItem D i = D.itemRawPair i := by |
| simp only [naturalRawItem, InventoryData.itemRawPair, rawItem, inventoryNumerator_eq] |
|
|
| end BinPackingGap.NaturalPackingNumerator |
|
|
| namespace BinPackingGap.PackingCoordinateExpression |
|
|
| open IntegerPackingArithmetic |
| open NaturalPackingNumerator |
| open NatExpressionCompiler |
|
|
| inductive Input |
| | geometryDg |
| | totalPowerA |
| | edgePower |
| | repetitionOne |
| deriving DecidableEq |
|
|
| instance : Fintype Input where |
| elems := {.geometryDg, .totalPowerA, .edgePower, .repetitionOne} |
| complete i := by cases i <;> simp |
| |
| structure Parts where |
| pos : Expr Input |
| neg : Expr Input |
|
|
| namespace Parts |
|
|
| def eval (values : Input → Nat) (p : Parts) : NatDifference := |
| ⟨NatExpressionCompiler.eval values p.pos, NatExpressionCompiler.eval values p.neg⟩ |
|
|
| def ofExpr (e : Expr Input) : Parts := ⟨e, .constant 0⟩ |
| def negate (p : Parts) : Parts := ⟨p.neg, p.pos⟩ |
| def add (p q : Parts) : Parts := ⟨.add p.pos q.pos, .add p.neg q.neg⟩ |
| def sub (p q : Parts) : Parts := ⟨.add p.pos q.neg, .add p.neg q.pos⟩ |
|
|
| @[simp] theorem eval_ofExpr (values : Input → Nat) (e : Expr Input) : |
| (ofExpr e).eval values = NatDifference.ofNat (NatExpressionCompiler.eval values e) := rfl |
|
|
| @[simp] theorem eval_negate (values : Input → Nat) (p : Parts) : |
| p.negate.eval values = (p.eval values).negate := rfl |
|
|
| @[simp] theorem eval_add (values : Input → Nat) (p q : Parts) : |
| (p.add q).eval values = (p.eval values).add (q.eval values) := rfl |
|
|
| @[simp] theorem eval_sub (values : Input → Nat) (p q : Parts) : |
| (p.sub q).eval values = (p.eval values).sub (q.eval values) := rfl |
|
|
| end Parts |
|
|
| inductive TreeDescriptor (plus minus : UniformTree) |
| | plusNode (node : plus.Node) |
| | minusNode (node : minus.Node) |
| | padding |
| deriving DecidableEq |
|
|
| instance (plus minus : UniformTree) : Fintype (TreeDescriptor plus minus) where |
| elems := Finset.univ.image TreeDescriptor.plusNode ∪ |
| Finset.univ.image TreeDescriptor.minusNode ∪ {.padding} |
| complete tree := by cases tree <;> simp |
| |
| inductive Descriptor (plus minus : UniformTree) (L : Nat) |
| | treeRow (tree : TreeDescriptor plus minus) |
| | jobRow (short : Bool) |
| | treeAnchor (tree : TreeDescriptor plus minus) |
| | jobAnchor |
| | jobKey |
| | globalUnit (one : Bool) |
| | globalEdge (permit : Bool) |
| | localDepth (depth : Fin (L + 1)) |
| | zero |
| deriving DecidableEq |
|
|
| instance (plus minus : UniformTree) (L : Nat) : Fintype (Descriptor plus minus L) where |
| elems := Finset.univ.image Descriptor.treeRow ∪ |
| Finset.univ.image Descriptor.jobRow ∪ |
| Finset.univ.image Descriptor.treeAnchor ∪ |
| {.jobAnchor, .jobKey, .zero} ∪ |
| Finset.univ.image Descriptor.globalUnit ∪ |
| Finset.univ.image Descriptor.globalEdge ∪ |
| Finset.univ.image Descriptor.localDepth |
| complete descriptor := by cases descriptor <;> simp |
| |
| def treeLeftExpr (bound L : Nat) (side : TreeGeometry.Side) (address : List Nat) : |
| Expr Input := |
| .add (.mul (.constant (rootOffsetNumerator side)) (.input .geometryDg)) |
| (.constant (pathNumerator bound L 0 address)) |
|
|
| def treeRightExpr (bound L : Nat) (side : TreeGeometry.Side) (address : List Nat) : |
| Expr Input := |
| .add (treeLeftExpr bound L side address) |
| (if address = [] then .input .geometryDg |
| else .constant (localNumerator bound L address.length)) |
|
|
| def treeBaselineExpr {plus minus : UniformTree} (bound L : Nat) : |
| TreeDescriptor plus minus → Parts |
| | .plusNode node => Parts.ofExpr (treeRightExpr bound L .plus node.val) |
| | .minusNode node => Parts.ofExpr (treeRightExpr bound L .minus node.val) |
| | .padding => Parts.ofExpr (.input .geometryDg) |
|
|
| def treeDeadlineExpr {plus minus : UniformTree} (bound L : Nat) : |
| TreeDescriptor plus minus → Parts |
| | .plusNode node => Parts.ofExpr |
| (if node.val ∈ plus.leaves then treeLeftExpr bound L .plus node.val |
| else treeRightExpr bound L .plus node.val) |
| | .minusNode node => Parts.ofExpr |
| (if node.val ∈ minus.leaves then treeLeftExpr bound L .minus node.val |
| else treeRightExpr bound L .minus node.val) |
| | .padding => Parts.ofExpr (.input .geometryDg) |
|
|
| def baselineExpr (bound L : Nat) : Parts := |
| ⟨.add |
| (.mul (.mul (.constant 80) (.input .totalPowerA)) |
| (.constant (widthRadix bound ^ L))) |
| (.mul |
| (.mul (.constant (10 * widthRadix bound ^ L)) (.input .repetitionOne)) |
| (.input .edgePower)), |
| .constant (10 * widthRadix bound ^ L)⟩ |
|
|
| def betaExpr (bound L : Nat) : Parts := |
| ⟨.mul (.constant (10 * widthRadix bound ^ L)) (.input .edgePower), |
| .constant (10 * widthRadix bound ^ L)⟩ |
|
|
| def expression {plus minus : UniformTree} {L : Nat} (bound : Nat) : |
| Descriptor plus minus L → Parts |
| | .treeRow tree => (treeBaselineExpr bound L tree).sub (Parts.ofExpr (.constant 0)) |
| | .jobRow short => (baselineExpr bound L).sub |
| (Parts.ofExpr (.constant (if short then 1 else 0))) |
| | .treeAnchor tree => (treeDeadlineExpr bound L tree).negate |
| | .jobAnchor => ((baselineExpr bound L).sub (Parts.ofExpr (.constant 1))).negate |
| | .jobKey => (baselineExpr bound L).negate.sub (betaExpr bound L) |
| | .globalUnit one => |
| (Parts.ofExpr (if one then .input .geometryDg else .constant 0)).negate |
| | .globalEdge permit => (betaExpr bound L).add |
| (Parts.ofExpr (.constant (if permit then 0 else 1))) |
| | .localDepth depth => |
| (Parts.ofExpr (.constant (localNumerator bound L depth.val))).negate |
| | .zero => Parts.ofExpr (.constant 0) |
|
|
| def registers (D : InventoryData) (edge repetitionOne : Nat) : Input → Nat |
| | .geometryDg => D.coordinateDenominator |
| | .totalPowerA => (D.R + 1) ^ D.graph.edges.length |
| | .edgePower => (D.R + 1) ^ edge |
| | .repetitionOne => repetitionOne |
|
|
| def treeDescriptor (D : InventoryData) : D.TreeRow → TreeDescriptor D.plus D.minus |
| | .inl (node, _) => .plusNode node |
| | .inr (.inl (node, _)) => .minusNode node |
| | .inr (.inr _) => .padding |
|
|
| def coordinateDescriptor (D : InventoryData) : D.Item → Descriptor D.plus D.minus D.L |
| | ⟨.x, ⟨_, .inl tree⟩⟩ => .treeRow (treeDescriptor D tree) |
| | ⟨.x, ⟨_, .inr (short, _)⟩⟩ => .jobRow short |
| | ⟨.anchor, ⟨_, .inl (.inl tree)⟩⟩ => .treeAnchor (treeDescriptor D tree) |
| | ⟨.anchor, ⟨_, .inl (.inr _)⟩⟩ => .jobAnchor |
| | ⟨.anchor, ⟨_, .inr _⟩⟩ => .jobKey |
| | ⟨.«global», ⟨.up one, _⟩⟩ => .globalUnit one |
| | ⟨.«global», ⟨.um one, _⟩⟩ => .globalUnit one |
| | ⟨.«global», ⟨.edge _ permit, _⟩⟩ => .globalEdge permit |
| | ⟨.«local», ⟨_, .inl (.inl ⟨depth, _⟩)⟩⟩ => |
| .localDepth ⟨depth.val, Nat.lt_succ_of_le (Finset.mem_Icc.mp depth.property).2⟩ |
| | ⟨.«local», _⟩ => .zero |
| | ⟨.flag, _⟩ => .zero |
|
|
| def edgeIndex (D : InventoryData) : D.Item → Nat |
| | ⟨.x, ⟨_, .inr (_, job)⟩⟩ => (D.jobPosition job).1.val |
| | ⟨.anchor, ⟨_, .inl (.inr job)⟩⟩ => (D.jobPosition job).1.val |
| | ⟨.anchor, ⟨_, .inr job⟩⟩ => (D.jobPosition job).1.val |
| | ⟨.«global», ⟨.edge edge _, _⟩⟩ => edge.val |
| | _ => 0 |
|
|
| def repetitionOne (D : InventoryData) : D.Item → Nat |
| | ⟨.x, ⟨_, .inr (_, job)⟩⟩ => (D.jobPosition job).2.val + 1 |
| | ⟨.anchor, ⟨_, .inl (.inr job)⟩⟩ => (D.jobPosition job).2.val + 1 |
| | ⟨.anchor, ⟨_, .inr job⟩⟩ => (D.jobPosition job).2.val + 1 |
| | _ => 0 |
|
|
| def coordinateValues (D : InventoryData) (i : D.Item) : Input → Nat := |
| registers D (edgeIndex D i) (repetitionOne D i) |
|
|
| @[simp] theorem eval_treeLeftExpr (D : InventoryData) (edge rep : Nat) |
| (side : TreeGeometry.Side) (address : List Nat) : |
| NatExpressionCompiler.eval (registers D edge rep) |
| (treeLeftExpr D.geometryBound D.L side address) = |
| treeLeftNumerator D.graph.edges.length D.R D.geometryBound D.L side address := rfl |
|
|
| @[simp] theorem eval_treeRightExpr (D : InventoryData) (edge rep : Nat) |
| (side : TreeGeometry.Side) (address : List Nat) : |
| NatExpressionCompiler.eval (registers D edge rep) |
| (treeRightExpr D.geometryBound D.L side address) = |
| treeRightNumerator D.graph.edges.length D.R D.geometryBound D.L side address := by |
| by_cases h : address = [] <;> |
| simp [treeRightExpr, treeRightNumerator, h, registers, InventoryData.coordinateDenominator] |
| |
| @[simp] theorem eval_treeBaselineExpr (D : InventoryData) (edge rep : Nat) (r : D.TreeRow) : |
| (treeBaselineExpr D.geometryBound D.L (treeDescriptor D r)).eval (registers D edge rep) = |
| treeBaselineParts D r := by |
| rcases r with ⟨node, copy⟩ | (⟨node, copy⟩ | copy) <;> |
| simp [treeDescriptor, treeBaselineExpr, treeBaselineParts, registers] |
| |
| @[simp] theorem eval_treeDeadlineExpr (D : InventoryData) (edge rep : Nat) (r : D.TreeRow) : |
| (treeDeadlineExpr D.geometryBound D.L (treeDescriptor D r)).eval (registers D edge rep) = |
| treeDeadlineParts D r := by |
| rcases r with ⟨node, copy⟩ | (⟨node, copy⟩ | copy) |
| · by_cases h : node.val ∈ D.plus.leaves <;> |
| simp [treeDescriptor, treeDeadlineExpr, treeDeadlineParts, h] |
| · by_cases h : node.val ∈ D.minus.leaves <;> |
| simp [treeDescriptor, treeDeadlineExpr, treeDeadlineParts, h] |
| · simp [treeDescriptor, treeDeadlineExpr, treeDeadlineParts, registers] |
| |
| @[simp] theorem eval_baselineExpr (D : InventoryData) (edge rep : Nat) : |
| (baselineExpr D.geometryBound D.L).eval (registers D edge rep) = |
| ⟨80 * (D.R + 1) ^ D.graph.edges.length * widthRadix D.geometryBound ^ D.L + |
| 10 * widthRadix D.geometryBound ^ D.L * rep * (D.R + 1) ^ edge, |
| 10 * widthRadix D.geometryBound ^ D.L⟩ := rfl |
|
|
| @[simp] theorem eval_betaExpr (D : InventoryData) (edge rep : Nat) : |
| (betaExpr D.geometryBound D.L).eval (registers D edge rep) = |
| ⟨10 * widthRadix D.geometryBound ^ D.L * (D.R + 1) ^ edge, |
| 10 * widthRadix D.geometryBound ^ D.L⟩ := rfl |
|
|
| theorem eval_coordinateDescriptor (D : InventoryData) (i : D.Item) : |
| (expression D.geometryBound (coordinateDescriptor D i)).eval (coordinateValues D i) = |
| coordinateParts D i := by |
| rcases i with ⟨role, i⟩ |
| cases role with |
| | x => |
| rcases i with ⟨v, tree | ⟨short, job⟩⟩ |
| · simp [coordinateDescriptor, expression, coordinateValues, edgeIndex, repetitionOne, |
| coordinateParts, rowParts, rowBaselineParts, InventoryData.rowShort] |
| · simp [coordinateDescriptor, expression, coordinateValues, edgeIndex, repetitionOne, |
| coordinateParts, rowParts, rowBaselineParts, InventoryData.rowShort, baselineParts] |
| rfl |
| | anchor => |
| rcases i with ⟨v, (tree | job) | job⟩ |
| · simp [coordinateDescriptor, expression, coordinateValues, edgeIndex, repetitionOne, |
| coordinateParts, anchorParts, deadlineParts] |
| · simp [coordinateDescriptor, expression, coordinateValues, edgeIndex, repetitionOne, |
| coordinateParts, anchorParts, deadlineParts, baselineParts] |
| · simp [coordinateDescriptor, expression, coordinateValues, edgeIndex, repetitionOne, |
| coordinateParts, anchorParts, baselineParts, betaParts] |
| | «global» => |
| rcases i with ⟨species, copy⟩ |
| cases species with |
| | up one => cases one <;> simp [coordinateDescriptor, expression, coordinateValues, edgeIndex, |
| repetitionOne, coordinateParts, globalParts, registers] |
| | um one => cases one <;> simp [coordinateDescriptor, expression, coordinateValues, edgeIndex, |
| repetitionOne, coordinateParts, globalParts, registers] |
| | edge edge permit => simp [coordinateDescriptor, expression, coordinateValues, edgeIndex, repetitionOne, |
| coordinateParts, globalParts, betaParts] |
| | «local» => |
| rcases i with ⟨v, (⟨depth, copy⟩ | (zero | job)) | job⟩ <;> |
| simp [coordinateDescriptor, expression, coordinateParts, localParts] |
| | flag => simp [coordinateDescriptor, expression, coordinateParts] |
| |
| theorem eval_coordinate_pos (D : InventoryData) (i : D.Item) : |
| NatExpressionCompiler.eval (coordinateValues D i) |
| (expression D.geometryBound (coordinateDescriptor D i)).pos = |
| (coordinateParts D i).pos := |
| congrArg NatDifference.pos (eval_coordinateDescriptor D i) |
|
|
| theorem eval_coordinate_neg (D : InventoryData) (i : D.Item) : |
| NatExpressionCompiler.eval (coordinateValues D i) |
| (expression D.geometryBound (coordinateDescriptor D i)).neg = |
| (coordinateParts D i).neg := |
| congrArg NatDifference.neg (eval_coordinateDescriptor D i) |
|
|
| theorem eval_coordinate_integer (D : InventoryData) (i : D.Item) : |
| ((expression D.geometryBound (coordinateDescriptor D i)).eval (coordinateValues D i)).eval = |
| D.itemIntegerCoordinate i := by |
| rw [eval_coordinateDescriptor, eval_coordinateParts] |
|
|
| end BinPackingGap.PackingCoordinateExpression |
|
|
| namespace BinPackingGap.PackingScalarExpression |
|
|
| open NatExpressionCompiler NaturalPackingNumerator IntegerPackingArithmetic |
|
|
| inductive Variable |
| | vertexPower | geometry | labelPower | coordinatePositive | coordinateNegative |
| deriving DecidableEq |
|
|
| instance : Fintype Variable where |
| elems := {.vertexPower, .geometry, .labelPower, .coordinatePositive, .coordinateNegative} |
| complete v := by cases v <;> simp |
| |
| def values {n : Nat} (geom : Nat) (label : Option (Fin n)) (W : NatDifference) : |
| Variable → Nat |
| | .vertexPower => 3 ^ n |
| | .geometry => geom |
| | .labelPower => NaturalPackingNumerator.labelPower label |
| | .coordinatePositive => W.pos |
| | .coordinateNegative => W.neg |
|
|
| def baseTerm : Expr Variable := |
| .mul (.mul (.constant (200000000 * primaryBound)) (.input .vertexPower)) |
| (.input .geometry) |
|
|
| def primaryFactor : Expr Variable := |
| .mul (.mul (.constant 1000000) (.input .vertexPower)) (.input .geometry) |
|
|
| def secondaryFactor : Expr Variable := .mul (.constant 1000) (.input .geometry) |
|
|
| def positiveLabel (subclass : Subclass) : Expr Variable := |
| match subclass.role with |
| | .x => .input .labelPower |
| | .«local» => .input .labelPower |
| | _ => .constant 0 |
|
|
| def negativeLabel (subclass : Subclass) : Expr Variable := |
| match subclass.role with |
| | .anchor => .mul (.constant 2) (.input .labelPower) |
| | _ => .constant 0 |
|
|
| def positiveTerm (subclass : Subclass) : Expr Variable := |
| .add (.add (.add baseTerm |
| (.mul primaryFactor (.constant (primaryParts subclass).pos))) |
| (.mul secondaryFactor (positiveLabel subclass))) (.input .coordinatePositive) |
|
|
| def negativeTerm (subclass : Subclass) : Expr Variable := |
| .add (.add (.mul primaryFactor (.constant (primaryParts subclass).neg)) |
| (.mul secondaryFactor (negativeLabel subclass))) (.input .coordinateNegative) |
|
|
| def numerator (subclass : Subclass) : Expr Variable := |
| .monus (positiveTerm subclass) (negativeTerm subclass) |
|
|
| def denominator : Expr Variable := |
| .mul (.mul (.constant (10 ^ 9 * primaryBound)) (.input .vertexPower)) |
| (.input .geometry) |
|
|
| theorem eval_positiveLabel {n : Nat} (geom : Nat) (label : Option (Fin n)) |
| (W : NatDifference) (subclass : Subclass) : |
| eval (values geom label W) (positiveLabel subclass) = (secondaryParts subclass label).pos := by |
| cases h : subclass.role <;> |
| simp [positiveLabel, secondaryParts, h, values, NatDifference.ofNat, |
| NatDifference.negate] |
| |
| theorem eval_negativeLabel {n : Nat} (geom : Nat) (label : Option (Fin n)) |
| (W : NatDifference) (subclass : Subclass) : |
| eval (values geom label W) (negativeLabel subclass) = (secondaryParts subclass label).neg := by |
| cases h : subclass.role <;> |
| simp [negativeLabel, secondaryParts, h, eval, values, NatDifference.ofNat, |
| NatDifference.negate] |
| |
| theorem eval_positiveTerm {n : Nat} (geom : Nat) (label : Option (Fin n)) |
| (W : NatDifference) (subclass : Subclass) : |
| eval (values geom label W) (positiveTerm subclass) = |
| (numeratorParts geom subclass label W).pos := by |
| simp only [positiveTerm, eval_add, eval_mul, eval_constant, eval_input, |
| eval_positiveLabel, numeratorParts, signedParts_pos] |
| rfl |
|
|
| theorem eval_negativeTerm {n : Nat} (geom : Nat) (label : Option (Fin n)) |
| (W : NatDifference) (subclass : Subclass) : |
| eval (values geom label W) (negativeTerm subclass) = |
| (numeratorParts geom subclass label W).neg := by |
| simp only [negativeTerm, eval_add, eval_mul, eval_constant, eval_input, |
| eval_negativeLabel, numeratorParts, signedParts_neg] |
| rfl |
|
|
| theorem eval_numerator {n : Nat} (geom : Nat) (label : Option (Fin n)) |
| (W : NatDifference) (subclass : Subclass) : |
| eval (values geom label W) (numerator subclass) = |
| (numeratorParts geom subclass label W).toNat := by |
| simp only [numerator, eval_monus, eval_positiveTerm, eval_negativeTerm, |
| NatDifference.toNat] |
|
|
| theorem eval_denominator {n : Nat} (geom : Nat) (label : Option (Fin n)) |
| (W : NatDifference) : |
| eval (values geom label W) denominator = sizeDenominator n geom := rfl |
|
|
| theorem eval_item_numerator (D : InventoryData) (i : D.Item) : |
| eval (values D.coordinateDenominator (D.itemLabel i) (coordinateParts D i)) |
| (numerator (D.itemSubclass i)) = (D.itemRawPair i).1 := by |
| rw [eval_numerator] |
| change inventoryNumerator D i = _ |
| exact congrArg Prod.fst (naturalRawItem_eq D i) |
|
|
| theorem eval_item_denominator (D : InventoryData) (i : D.Item) : |
| eval (values D.coordinateDenominator (D.itemLabel i) (coordinateParts D i)) |
| denominator = (D.itemRawPair i).2 := rfl |
|
|
| end BinPackingGap.PackingScalarExpression |
|
|
| end OAI |
|
|
