LookupCoin benchmark uses log(m) + log(k) (#7412)

* feat: implement additive log size metric for LookupCoin

Replace ValueLogOuterOrMaxInner with ValueLogOuterSizeAddLogMaxInnerSize
for LookupCoin costing. This change reflects experimental findings that
two-level map lookup time scales linearly with log(outerSize) + log(innerSize)
rather than max(log(outerSize), log(innerSize)).

Implementation:
- Add ValueLogOuterSizeAddLogMaxInnerSize type computing sum of log sizes
- Update LookupCoin builtin signature to use new size measurement
- Implement worst-case benchmark generation targeting max-size inner maps
- Optimize size test combinations for BST worst-case coverage (depths 10-18)
- Filter out empty values which cannot provide worst-case keys

Benchmark strategy:
- All lookups target the policy with maximum tokens (worst case)
- Test combinations maximize nodes at each depth: (32,32), (64,128),
  (256,256), (512,512), (1024,128), (2048,64)
- Ensures conservative costing that prevents underestimation attacks

* feat: update LookupCoin cost model with remote benchmark data

Updated benchmark data (206 entries) and cost model parameters for
LookupCoin using the new ValueLogOuterSizeAddLogMaxInnerSize metric.

Cost model changes:
- CPU: linear_in_z (intercept: 204546, slope: 7423)
- Memory: constant 10 (updated from 1)

Benchmark data sourced from GitHub Actions run 19272430553 using
worst-case targeting strategy (max-size inner map lookups).

* refactor: use exhaustive power-of-2 grid for LookupCoin benchmarks

Replace mixed random/specific test points with systematic exhaustive
coverage of all (2^a, 2^b) combinations where a, b ∈ {1..10}.

This provides:
- 100 deterministic test points (10×10 grid)
- Complete coverage of depths 2 to 20
- All distribution patterns (balanced, outer-heavy, inner-heavy)
- Reproducible results with no randomness

Removed random value generation and extractWorstCaseKeys function
which are no longer needed with systematic enumeration.

* feat: apply additive log metric to ValueContains and remove old wrapper

Update ValueContains to use ValueLogOuterSizeAddLogMaxInnerSize for
consistency with LookupCoin. The additive log metric better reflects
the algorithmic complexity where each containment check performs
multiple two-level lookups, each exhibiting additive depth behavior.

Changes:
- Update ValueContains builtin signature
- Update ValueContains benchmark wrapper
- Update golden signature test
- Update test generators
- Remove ValueLogOuterOrMaxInner (now completely unused)

This provides consistent and accurate costing across all Value lookup
operations based on the experimental evidence.

* feat: update benchmark data for LookupCoin and ValueContains

Merged new benchmark results from GitHub Actions using additive log metric:
- LookupCoin: 400 entries (power-of-2 grid, run 19294057613)
- ValueContains: 100 entries (run 19294814942)

Fixed lookupCoin memory cost from 10 to 1 (matches result type: Integer).
CPU costs remain from previous remote benchmarking.

Total: 500 new benchmark entries with systematic worst-case coverage.

* feat: refine LookupCoin and ValueContains cost models with remote benchmarks

Updated benchmark data and cost models for LookupCoin and ValueContains
based on remote GitHub Actions benchmark run (19295960854).

Benchmark changes:
- LookupCoin: 400 data points (3 parameters)
- ValueContains: 100 data points (2 parameters)

Cost model refinements:
- lookupCoin: adjusted intercept (204546→252573) and slope (7423→4734)
- valueContains: refined slope (96034→94269)

Both functions maintain their cost model types:
- lookupCoin: linear_in_z
- valueContains: linear_in_y

* test: update conformance budgets for refined cost models

Update expected CPU budgets in conformance test cases to reflect the refined cost models for LookupCoin and ValueContains builtins. These changes align with the additive log metric improvements and remote benchmark calibration applied in recent commits.

LookupCoin CPU increased from 338744 to 378875 (both scenarios). ValueContains CPU adjustments range from +108 to +216 depending on the specific test case complexity.

* feat(bench): strengthen ValueContains with systematic worst-case benchmarks

Replace random sampling approach with systematic power-of-2 grid targeting worst-case BST depth scenarios. Generate ~916 test cases (up from 100) using uniform container distributions and ensuring all lookups succeed by maintaining subset relationship (contained ⊆ container).

Key improvements:
- Use generateConstrainedValueWithMaxPolicy for worst-case BST structure
- Test all combinations of 10 power-of-2 sizes for containers
- Vary contained sizes to explore iteration count dimension
- Include deepest BST entry in each test to force maximum traversal depth
- No early exits as all entries are guaranteed to be found

This aligns ValueContains benchmarking with LookupCoin's approach while accounting for its multi-lookup nature (m × log(n) complexity vs single log(n)).

* feat(bench): improve ValueContains sample distribution with uniform spacing

Replace power-of-2 clustering with uniform linear spacing for contained
value sizes to achieve better benchmark coverage in the 0-1000 range.

## Changes

- Use uniform linear spacing (10 samples) instead of power-of-2 distribution
- Small containers (<10 entries) test all possible sizes
- Larger containers sample uniformly from 1 to min(1000, totalEntries)
- Maintains 10×10 container grid for BST depth variety
- Total benchmarks: ~1023 (close to 1000 target)

## Distribution Improvements

- Before: Power-of-2 clustering (2, 4, 8, 16, 32, 64, 128, 256, 512)
- After: Uniform spacing appropriate to container size
  - Log size 10: ~25 unit spacing
  - Log size 20: ~100 unit spacing
- Achieves smooth, uniform distribution across 0-1000 range

## Worst-Case Properties Maintained

- Container generated with worst-case BST structure
- Subset relationship: contained ⊆ container (all lookups succeed)
- Deepest BST entry included in each test (maximum lookup depth)
- No early exit conditions (comprehensive cost measurement)

* feat(cost): correct ValueContains model to multiplied_sizes

The previous linear_in_y model incorrectly ignored container size, only considering the contained value size. This was wrong because ValueContains iterates through every coin in the contained value and performs a lookupCoin on the container for each one, resulting in O(y * log(x)) complexity.

The multiplied_sizes model properly accounts for both parameters:
- x: log(outer_size) + log(max_inner_size) of container (BST depth)
- y: total_size of contained value

Cost formula changed from "1000 + 94269 × y" to "1000 + 6548 × (x × y)" picoseconds, reflecting the actual computational complexity.

Includes 1023 fresh systematic worst-case benchmark measurements (up from 100 entries) covering full parameter space using power-of-2 grid with uniform spacing, run on GitHub Actions self-hosted runners.

Author: Unisay

plutus-conformance/test-cases/uplc/evaluation/builtin/semantics/lookupCoin/absent/absent.uplc.budget.expected

@@ -1,2 +1,2 @@
-({cpu: 338744
+({cpu: 378875
 | mem: 801})

plutus-conformance/test-cases/uplc/evaluation/builtin/semantics/lookupCoin/present/present.uplc.budget.expected

@@ -1,2 +1,2 @@
-({cpu: 338744
+({cpu: 378875
 | mem: 801})

plutus-conformance/test-cases/uplc/evaluation/builtin/semantics/valueContains/ccy-missing/ccy-missing.uplc.budget.expected

@@ -1,2 +1,2 @@
-({cpu: 269422
+({cpu: 269638
 | mem: 601})

plutus-conformance/test-cases/uplc/evaluation/builtin/semantics/valueContains/multi-insufficient/multi-insufficient.uplc.budget.expected

@@ -1,2 +1,2 @@
-({cpu: 269422
+({cpu: 269638
 | mem: 601})

plutus-conformance/test-cases/uplc/evaluation/builtin/semantics/valueContains/multi-sufficient/multi-sufficient.uplc.budget.expected

@@ -1,2 +1,2 @@
-({cpu: 269422
+({cpu: 269638
 | mem: 601})

plutus-conformance/test-cases/uplc/evaluation/builtin/semantics/valueContains/reflexive/reflexive.uplc.budget.expected

@@ -1,2 +1,2 @@
-({cpu: 269422
+({cpu: 269638
 | mem: 601})

plutus-conformance/test-cases/uplc/evaluation/builtin/semantics/valueContains/token-missing/token-missing.uplc.budget.expected

@@ -1,2 +1,2 @@
-({cpu: 175261
+({cpu: 175369
 | mem: 601})

plutus-core/cost-model/budgeting-bench/Benchmarks/Values.hs

@@ -3,6 +3,7 @@
 {-# LANGUAGE LambdaCase          #-}
 {-# LANGUAGE NumericUnderscores  #-}
 {-# LANGUAGE TupleSections       #-}
+{-# LANGUAGE TypeApplications    #-}
 
 module Benchmarks.Values (makeBenchmarks) where
 
@@ -15,11 +16,12 @@ import Data.Bits (shiftR, (.&.))
 import Data.ByteString (ByteString)
 import Data.ByteString qualified as BS
 import Data.Int (Int64)
+import Data.List (find)
 import Data.Word (Word8)
 import GHC.Stack (HasCallStack)
 import PlutusCore (DefaultFun (LookupCoin, UnValueData, ValueContains, ValueData))
 import PlutusCore.Builtin (BuiltinResult (BuiltinFailure, BuiltinSuccess, BuiltinSuccessWithLogs))
-import PlutusCore.Evaluation.Machine.ExMemoryUsage (ValueLogOuterOrMaxInner (..),
+import PlutusCore.Evaluation.Machine.ExMemoryUsage (ValueLogOuterSizeAddLogMaxInnerSize (..),
                                                     ValueTotalSize (..))
 import PlutusCore.Value (K, Value)
 import PlutusCore.Value qualified as Value
@@ -42,67 +44,156 @@ makeBenchmarks gen =
 lookupCoinBenchmark :: StdGen -> Benchmark
 lookupCoinBenchmark gen =
   createThreeTermBuiltinBenchElementwiseWithWrappers
-    (id, id, ValueLogOuterOrMaxInner) -- Wrap Value argument to report outer/max inner size with log
+    (id, id, ValueLogOuterSizeAddLogMaxInnerSize) -- Wrap Value argument to report sum of log sizes
     LookupCoin -- the builtin fun
     [] -- no type arguments needed (monomorphic builtin)
     (lookupCoinArgs gen) -- the argument combos to generate benchmarks for
 
 lookupCoinArgs :: StdGen -> [(ByteString, ByteString, Value)]
 lookupCoinArgs gen = runStateGen_ gen \(g :: g) -> do
-  -- Add search keys to common test values
-  let testValues = generateTestValues gen
-  commonWithKeys <- mapM (withSearchKeys g . pure) testValues
-
-  -- Additional tests specific to lookupCoin
-  let valueSizes = [(100, 10), (500, 20), (1_000, 50), (2_000, 100)]
-  additionalTests <-
-    sequence $
-      -- Value size tests (number of policies × tokens per policy)
-      [ withSearchKeys g (generateConstrainedValue numPolicies tokensPerPolicy g)
-      | (numPolicies, tokensPerPolicy) <- valueSizes
+  {- Exhaustive power-of-2 combinations for BST worst-case benchmarking.
+
+     Tests all combinations of sizes from powers and half-powers of 2.
+     For each integer n ∈ {1..10}, includes both 2^n and 2^(n+0.5) ≈ 2^n * √2.
+
+     This provides:
+     - 400 total test points (20 × 20 grid)
+     - Complete systematic coverage of depth range 2 to 21
+     - Finer granularity between powers of 2
+     - All distribution patterns (balanced, outer-heavy, inner-heavy)
+
+     Size values: 2, 3, 4, 6, 8, 11, 16, 23, 32, 45, 64, 91, 128, 181,
+                  256, 362, 512, 724, 1024, 1448
+
+     Depth coverage:
+     - Minimum depth: log₂(2) + log₂(2) ≈ 2
+     - Maximum depth: log₂(1448) + log₂(1448) ≈ 21
+  -}
+  let
+    -- Generate powers of 2 and their geometric means (half-powers)
+    sizes =
+      [ 2 ^ n -- 2^n
+      | n <- [1 .. 10 :: Int]
       ]
-        -- Additional random tests for parameter spread
-        <> replicate 100 (withSearchKeys g (generateValue g))
-  pure $ commonWithKeys ++ additionalTests
-
--- | Add random search keys to a Value (keys may or may not exist in the Value)
-withSearchKeys :: (StatefulGen g m) => g -> m Value -> m (ByteString, ByteString, Value)
-withSearchKeys g genValue = do
-  value <- genValue
-  key1 <- generateKeyBS g
-  key2 <- generateKeyBS g
-  pure (key1, key2, value)
+        ++ [ round @Double (2 ^ n * sqrt 2) -- 2^(n+0.5)
+           | n <- [1 .. 10 :: Int]
+           ]
+
+  sequence
+    -- Generate worst-case lookups for each size combination
+    [ withWorstCaseSearchKeys (generateConstrainedValueWithMaxPolicy numPolicies tokensPerPolicy g)
+    | numPolicies <- sizes
+    , tokensPerPolicy <- sizes
+    ]
+
+-- | Add worst-case search keys targeting the max-size inner map
+withWorstCaseSearchKeys :: (Monad m) => m (Value, K, K) -> m (ByteString, ByteString, Value)
+withWorstCaseSearchKeys genValueWithKeys = do
+  (value, maxPolicyId, deepestToken) <- genValueWithKeys
+  pure (Value.unK maxPolicyId, Value.unK deepestToken, value)
 
 ----------------------------------------------------------------------------------------------------
 -- ValueContains -----------------------------------------------------------------------------------
 
 valueContainsBenchmark :: StdGen -> Benchmark
 valueContainsBenchmark gen =
   createTwoTermBuiltinBenchElementwiseWithWrappers
-    (ValueLogOuterOrMaxInner, ValueTotalSize)
-    -- Container: outer/maxInner with log, Contained: totalSize
+    (ValueLogOuterSizeAddLogMaxInnerSize, ValueTotalSize)
+    -- Container: sum of log sizes, Contained: totalSize
     ValueContains -- the builtin fun
     [] -- no type arguments needed (monomorphic builtin)
     (valueContainsArgs gen) -- the argument combos to generate benchmarks for
 
 valueContainsArgs :: StdGen -> [(Value, Value)]
-valueContainsArgs gen = runStateGen_ gen \g -> replicateM 100 do
-  -- Generate a random container value
-  container <- generateValue g
-  -- Select a random subset of entries from the container to ensure contained ⊆ container
-  containedSize <- uniformRM (0, Value.totalSize container) g
-  -- Take the first containedSize entries to ensure contained ⊆ container
-  let selectedEntries = take containedSize (Value.toFlatList container)
-
-  -- Group selected entries back by policy
-  let contained =
-        unsafeFromBuiltinResult $
-          Value.fromList
-            [ (policyId, [(tokenName, quantity)])
-            | (policyId, tokenName, quantity) <- selectedEntries
+valueContainsArgs gen = runStateGen_ gen \g -> do
+  {- ValueContains performs multiple LookupCoin operations (one per entry in contained).
+     Worst case: All lookups succeed at maximum depth with many entries to check.
+
+     Strategy:
+     1. Generate container with worst-case BST structure (uniform, power-of-2 sizes)
+     2. Select entries FROM container (maintain subset relationship for no early exit)
+     3. Include deepest entry to force maximum BST traversal
+     4. Test multiple contained sizes to explore iteration count dimension
+
+     Result: ~1000 systematic worst-case benchmarks vs 100 random cases previously
+  -}
+
+  -- Use power-of-2 grid (without half-powers) for systematic coverage
+  -- ValueContains does multiple lookups, so we don't need as fine-grained
+  -- size variation as LookupCoin
+  let containerSizes = [2 ^ n | n <- [1 .. 10 :: Int]] -- [2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
+
+  -- Generate test cases for all container size combinations
+  concat
+    <$> sequence
+      [ do
+          -- Generate container with worst-case BST structure:
+          -- - Uniform distribution (all policies have same token count)
+          -- - Worst-case keys (long common prefix, differ in last 4 bytes)
+          -- - Returns metadata about the deepest entry
+          (container, maxPolicyId, deepestToken) <-
+            generateConstrainedValueWithMaxPolicy numPolicies tokensPerPolicy g
+
+          -- Extract all entries from container as a flat list
+          -- This maintains the subset relationship: contained ⊆ container
+          let allEntries = Value.toFlatList container
+              totalEntries = length allEntries
+
+          -- Find the worst-case entry (deepest in both BSTs)
+          -- This entry forces maximum depth lookup:
+          -- - maxPolicyId: first in outer BST (but all equal size, so any works)
+          -- - deepestToken: last token in sorted order (maximum inner BST depth)
+          let worstCaseEntry =
+                find (\(p, t, _) -> p == maxPolicyId && t == deepestToken) allEntries
+
+          -- Generate test cases for different contained sizes (uniform linear distribution)
+          -- Each size tests the same container with different iteration counts
+          -- Use uniform spacing from 1 to min(1000, totalEntries) for better distribution
+          let maxContainedSize = min 1000 totalEntries
+              numSamples = 10
+              containedSizes =
+                if totalEntries < numSamples
+                  then [1 .. totalEntries] -- Test all sizes for small containers
+                  else
+                    let step = maxContainedSize `div` numSamples
+                     in [i * step | i <- [1 .. numSamples], i * step > 0]
+                          ++ [maxContainedSize | maxContainedSize `notElem` [i * step | i <- [1 .. numSamples]]]
+
+          -- Create one test case per contained size
+          pure
+            [ let
+                -- Select entries ensuring worst-case is included
+                -- Place worst-case entry at END so it's checked (not early-exit)
+                selectedEntries =
+                  case worstCaseEntry of
+                    Just worst ->
+                      -- Take (containedSize - 1) entries, then add worst-case
+                      -- This ensures: 1) subset relationship maintained
+                      --               2) worst-case depth is hit
+                      --               3) no early exit (all lookups succeed)
+                      let numOthers = min (containedSize - 1) (totalEntries - 1)
+                          others = take numOthers allEntries
+                       in others ++ [worst]
+                    Nothing ->
+                      -- Fallback if worst-case entry somehow not found
+                      -- (shouldn't happen, but defensive programming)
+                      take containedSize allEntries
+
+                -- Build contained Value from selected entries
+                -- This maintains the Value structure while ensuring subset
+                contained =
+                  unsafeFromBuiltinResult $
+                    Value.fromList
+                      [ (policyId, [(tokenName, quantity)])
+                      | (policyId, tokenName, quantity) <- selectedEntries
+                      ]
+               in
+                (container, contained)
+            | containedSize <- containedSizes
             ]
-
-  pure (container, contained)
+      | numPolicies <- containerSizes
+      , tokensPerPolicy <- containerSizes
+      ]
 
 ----------------------------------------------------------------------------------------------------
 -- ValueData ---------------------------------------------------------------------------------------
@@ -158,27 +249,46 @@ generateValueMaxEntries maxEntries g = do
 
   generateConstrainedValue numPolicies tokensPerPolicy g
 
--- | Generate constrained Value
-generateConstrainedValue
+-- | Generate constrained Value with information about max-size policy
+generateConstrainedValueWithMaxPolicy
   :: (StatefulGen g m)
   => Int -- Number of policies
   -> Int -- Number of tokens per policy
   -> g
-  -> m Value
-generateConstrainedValue numPolicies tokensPerPolicy g = do
+  -> m (Value, K, K) -- Returns (value, maxPolicyId, deepestTokenInMaxPolicy)
+generateConstrainedValueWithMaxPolicy numPolicies tokensPerPolicy g = do
   policyIds <- replicateM numPolicies (generateKey g)
   tokenNames <- replicateM tokensPerPolicy (generateKey g)
 
   let
     qty :: Value.Quantity
     qty = case Value.quantity (fromIntegral (maxBound :: Int64)) of
-      Just q  -> q
-      Nothing -> error "generateConstrainedValue: Int64 maxBound should be valid Quantity"
+      Just q -> q
+      Nothing -> error "generateConstrainedValueWithMaxPolicy: Int64 maxBound should be valid Quantity"
 
     nestedMap :: [(K, [(K, Value.Quantity)])]
     nestedMap = (,(,qty) <$> tokenNames) <$> policyIds
 
-  pure $ unsafeFromBuiltinResult $ Value.fromList nestedMap
+    value = unsafeFromBuiltinResult $ Value.fromList nestedMap
+
+    -- All policies have the same number of tokens in this uniform distribution,
+    -- so we pick the first policy as the max-size policy for worst-case targeting
+    maxPolicyId = head policyIds
+    -- Pick the last token (deepest in binary search tree) for worst-case inner lookup
+    deepestToken = last tokenNames
+
+  pure (value, maxPolicyId, deepestToken)
+
+-- | Generate constrained Value (legacy interface for other builtins)
+generateConstrainedValue
+  :: (StatefulGen g m)
+  => Int -- Number of policies
+  -> Int -- Number of tokens per policy
+  -> g
+  -> m Value
+generateConstrainedValue numPolicies tokensPerPolicy g = do
+  (value, _, _) <- generateConstrainedValueWithMaxPolicy numPolicies tokensPerPolicy g
+  pure value
 
 ----------------------------------------------------------------------------------------------------
 -- Other Generators --------------------------------------------------------------------------------
@@ -202,14 +312,6 @@ generateKey g = do
     Just key -> pure key
     Nothing  -> error "Internal error: maxKeyLen key should always be valid"
 
-{-| Generate worst-case key as ByteString (for lookup arguments).
-
-Like generateKey, but returns ByteString directly for use in lookup operations.
-Uses BS.copy to ensure physical distinctness for worst-case equality testing.
--}
-generateKeyBS :: (StatefulGen g m) => g -> m ByteString
-generateKeyBS g = BS.copy . mkWorstCaseKey <$> uniformRM (0, maxBound :: Int) g
-
 {-| Helper: Create a worst-case ByteString key from an integer
 The key has maxKeyLen-4 bytes of 0xFF prefix, followed by 4 bytes encoding the integer
 -}