refactor: use consistent size measure wrappers for Value builtins

Address Kenneth's review comment by ensuring builtins use the same
size measure wrappers as their budgeting benchmarks.

Changes:
- Add LogValueOuterOrMaxInner newtype combining logarithmic
  transformation with outer/max inner size measurement
- Update lookupCoin and valueContains to use size measure wrappers
- Add KnownTypeAst instances for ValueTotalSize and LogValueOuterOrMaxInner
- Update benchmarks to use new combined wrapper type

This ensures the cost model accurately reflects runtime behavior by
using identical size measures in both denotations and benchmarks.

Author: Unisay

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

@@ -11,7 +11,7 @@ import Control.Monad (replicateM)
 import Criterion.Main (Benchmark)
 import Data.ByteString (ByteString)
 import PlutusCore (DefaultFun (LookupCoin, UnValueData, ValueContains, ValueData))
-import PlutusCore.Evaluation.Machine.ExMemoryUsage (Logarithmic (..), ValueOuterOrMaxInner (..),
+import PlutusCore.Evaluation.Machine.ExMemoryUsage (LogValueOuterOrMaxInner (..),
                                                     ValueTotalSize (..))
 import PlutusCore.Value (K, Value)
 import PlutusCore.Value qualified as Value
@@ -34,7 +34,7 @@ makeBenchmarks gen =
 lookupCoinBenchmark :: StdGen -> Benchmark
 lookupCoinBenchmark gen =
   createThreeTermBuiltinBenchElementwiseWithWrappers
-    (id, id, Logarithmic . ValueOuterOrMaxInner) -- Wrap Value argument to report outer/max inner size
+    (id, id, LogValueOuterOrMaxInner) -- Wrap Value argument to report outer/max inner size with log
     LookupCoin -- the builtin fun
     [] -- no type arguments needed (monomorphic builtin)
     (lookupCoinArgs gen) -- the argument combos to generate benchmarks for
@@ -102,8 +102,8 @@ generateRandomLookupTest g = do
 valueContainsBenchmark :: StdGen -> Benchmark
 valueContainsBenchmark gen =
   createTwoTermBuiltinBenchElementwiseWithWrappers
-    (Logarithmic . ValueOuterOrMaxInner, ValueTotalSize)
-    -- Container: outer/maxInner, Contained: totalSize
+    (LogValueOuterOrMaxInner, ValueTotalSize)
+    -- Container: outer/maxInner with log, Contained: totalSize
     ValueContains -- the builtin fun
     [] -- no type arguments needed (monomorphic builtin)
     (valueContainsArgs gen) -- the argument combos to generate benchmarks for

plutus-core/plutus-core/src/PlutusCore/Default/Builtins.hs

@@ -24,8 +24,9 @@ import PlutusCore.Default.Universe
 import PlutusCore.Evaluation.Machine.BuiltinCostModel
 import PlutusCore.Evaluation.Machine.ExBudgetStream (ExBudgetStream)
 import PlutusCore.Evaluation.Machine.ExMemoryUsage (ExMemoryUsage, IntegerCostedLiterally (..),
-                                                    NumBytesCostedAsNumWords (..), memoryUsage,
-                                                    singletonRose)
+                                                    LogValueOuterOrMaxInner (..),
+                                                    NumBytesCostedAsNumWords (..),
+                                                    ValueTotalSize (..), memoryUsage, singletonRose)
 import PlutusCore.Pretty (PrettyConfigPlc)
 import PlutusCore.Value (Value)
 import PlutusCore.Value qualified as Value
@@ -2055,8 +2056,8 @@ instance uni ~ DefaultUni => ToBuiltinMeaning uni DefaultFun where
             (runCostingFunFourArguments . unimplementedCostingFun)
 
     toBuiltinMeaning _semvar LookupCoin =
-      let lookupCoinDenotation :: ByteString -> ByteString -> Value -> Integer
-          lookupCoinDenotation = Value.lookupCoin
+      let lookupCoinDenotation :: ByteString -> ByteString -> LogValueOuterOrMaxInner -> Integer
+          lookupCoinDenotation p t (LogValueOuterOrMaxInner v) = Value.lookupCoin p t v
           {-# INLINE lookupCoinDenotation #-}
        in makeBuiltinMeaning
             lookupCoinDenotation
@@ -2071,8 +2072,9 @@ instance uni ~ DefaultUni => ToBuiltinMeaning uni DefaultFun where
             (runCostingFunTwoArguments . unimplementedCostingFun)
 
     toBuiltinMeaning _semvar ValueContains =
-      let valueContainsDenotation :: Value -> Value -> BuiltinResult Bool
-          valueContainsDenotation = Value.valueContains
+      let valueContainsDenotation :: LogValueOuterOrMaxInner -> ValueTotalSize -> BuiltinResult Bool
+          valueContainsDenotation (LogValueOuterOrMaxInner v1) (ValueTotalSize v2) =
+            Value.valueContains v1 v2
           {-# INLINE valueContainsDenotation #-}
        in makeBuiltinMeaning
             valueContainsDenotation

plutus-core/plutus-core/src/PlutusCore/Default/Universe.hs

@@ -52,7 +52,9 @@ import PlutusCore.Crypto.BLS12_381.G2 qualified as BLS12_381.G2
 import PlutusCore.Crypto.BLS12_381.Pairing qualified as BLS12_381.Pairing
 import PlutusCore.Data (Data)
 import PlutusCore.Evaluation.Machine.ExMemoryUsage (IntegerCostedLiterally (..),
-                                                    NumBytesCostedAsNumWords (..))
+                                                    LogValueOuterOrMaxInner (..),
+                                                    NumBytesCostedAsNumWords (..),
+                                                    ValueTotalSize (..))
 import PlutusCore.Pretty.Extra (juxtRenderContext)
 import PlutusCore.Value (Value)
 
@@ -621,6 +623,28 @@ instance KnownBuiltinTypeIn DefaultUni term Integer =>
     readKnown = readKnownCoerce @Integer
     {-# INLINE readKnown #-}
 
+deriving newtype instance
+        KnownTypeAst tyname DefaultUni ValueTotalSize
+instance KnownBuiltinTypeIn DefaultUni term Value =>
+        MakeKnownIn DefaultUni term ValueTotalSize where
+    makeKnown = makeKnownCoerce @Value
+    {-# INLINE makeKnown #-}
+instance KnownBuiltinTypeIn DefaultUni term Value =>
+        ReadKnownIn DefaultUni term ValueTotalSize where
+    readKnown = readKnownCoerce @Value
+    {-# INLINE readKnown #-}
+
+deriving newtype instance
+        KnownTypeAst tyname DefaultUni LogValueOuterOrMaxInner
+instance KnownBuiltinTypeIn DefaultUni term Value =>
+        MakeKnownIn DefaultUni term LogValueOuterOrMaxInner where
+    makeKnown = makeKnownCoerce @Value
+    {-# INLINE makeKnown #-}
+instance KnownBuiltinTypeIn DefaultUni term Value =>
+        ReadKnownIn DefaultUni term LogValueOuterOrMaxInner where
+    readKnown = readKnownCoerce @Value
+    {-# INLINE readKnown #-}
+
 deriving via AsInteger Natural instance
         KnownTypeAst tyname DefaultUni Natural
 instance KnownBuiltinTypeIn DefaultUni term Integer =>

plutus-core/plutus-core/src/PlutusCore/Evaluation/Machine/ExMemoryUsage.hs

@@ -15,6 +15,7 @@ module PlutusCore.Evaluation.Machine.ExMemoryUsage
     , ValueTotalSize(..)
     , ValueOuterOrMaxInner(..)
     , Logarithmic(..)
+    , LogValueOuterOrMaxInner(..)
     ) where
 
 import PlutusCore.Crypto.BLS12_381.G1 as BLS12_381.G1
@@ -415,6 +416,25 @@ instance ExMemoryUsage n => ExMemoryUsage (Logarithmic n) where
           in singletonRose $ max 1 (fromIntegral (logSize + 1))
     {-# INLINE memoryUsage #-}
 
+{-| A combined wrapper for Value that measures size using outer/max inner map sizes
+with logarithmic transformation. This is equivalent to @Logarithmic ValueOuterOrMaxInner@
+but defined as a single newtype for simpler type instances and better error messages.
+
+Used for builtins like lookupCoin and valueContains where the cost depends on
+O(log max(m, k)) where m is the number of policies and k is the max tokens per policy.
+
+If this is used to wrap an argument in the denotation of a builtin then it *MUST* also
+be used to wrap the same argument in the relevant budgeting benchmark.
+-}
+newtype LogValueOuterOrMaxInner = LogValueOuterOrMaxInner { unLogValueOuterOrMaxInner :: Value }
+
+instance ExMemoryUsage LogValueOuterOrMaxInner where
+    memoryUsage (LogValueOuterOrMaxInner v) =
+      let size = Map.size (Value.unpack v) `max` Value.maxInnerSize v
+          logSize = integerLog2 (toInteger size)
+      in singletonRose $ max 1 (fromIntegral (logSize + 1))
+    {-# INLINE memoryUsage #-}
+
 {- Note [Costing constant-size types]
 The memory usage of each of the BLS12-381 types is constant, so we may be able
 to optimise things a little by ensuring that we don't re-compute the size of