diff --git a/Cargo.lock b/Cargo.lock
index 8d0683ef..cabaa4f0 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4,9 +4,9 @@ version = 4
 
 [[package]]
 name = "addr2line"
-version = "0.24.2"
+version = "0.25.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dfbe277e56a376000877090da837660b4427aad530e3028d44e0bffe4f89a1c1"
+checksum = "1b5d307320b3181d6d7954e663bd7c774a838b8220fe0593c86d9fb09f498b4b"
 dependencies = [
  "gimli",
 ]
@@ -52,9 +52,9 @@ checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299"
 
 [[package]]
 name = "anstyle"
-version = "1.0.11"
+version = "1.0.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "862ed96ca487e809f1c8e5a8447f6ee2cf102f846893800b20cebdf541fc6bbd"
+checksum = "5192cca8006f1fd4f7237516f40fa183bb07f8fbdfedaa0036de5ea9b0b45e78"
 
 [[package]]
 name = "ark-crypto-primitives"
@@ -212,9 +212,9 @@ checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
 
 [[package]]
 name = "backtrace"
-version = "0.3.75"
+version = "0.3.76"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6806a6321ec58106fea15becdad98371e28d92ccbc7c8f1b3b6dd724fe8f1002"
+checksum = "bb531853791a215d7c62a30daf0dde835f381ab5de4589cfe7c649d2cbe92bd6"
 dependencies = [
  "addr2line",
  "cfg-if",
@@ -222,14 +222,14 @@ dependencies = [
  "miniz_oxide",
  "object",
  "rustc-demangle",
- "windows-targets 0.52.6",
+ "windows-link",
 ]
 
 [[package]]
 name = "bitflags"
-version = "2.9.2"
+version = "2.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a65b545ab31d687cff52899d4890855fec459eb6afe0da6417b8a18da87aa29"
+checksum = "2261d10cca569e4643e526d8dc2e62e433cc8aba21ab764233731f8d369bf394"
 
 [[package]]
 name = "blake2"
@@ -263,9 +263,9 @@ checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
 [[package]]
 name = "cfg-if"
-version = "1.0.3"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2fd1289c04a9ea8cb22300a459a72a385d7c73d3259e2ed7dcb2af674838cfa9"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
 [[package]]
 name = "ciborium"
@@ -296,18 +296,18 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.45"
+version = "4.5.49"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fc0e74a703892159f5ae7d3aac52c8e6c392f5ae5f359c70b5881d60aaac318"
+checksum = "f4512b90fa68d3a9932cea5184017c5d200f5921df706d45e853537dea51508f"
 dependencies = [
  "clap_builder",
 ]
 
 [[package]]
 name = "clap_builder"
-version = "4.5.44"
+version = "4.5.49"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b3e7f4214277f3c7aa526a59dd3fbe306a370daee1f8b7b8c987069cd8e888a8"
+checksum = "0025e98baa12e766c67ba13ff4695a887a1eba19569aad00a472546795bd6730"
 dependencies = [
  "anstyle",
  "clap_lex",
@@ -315,9 +315,9 @@ dependencies = [
 
 [[package]]
 name = "clap_lex"
-version = "0.7.5"
+version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b94f61472cee1439c0b966b47e3aca9ae07e45d070759512cd390ea2bebc6675"
+checksum = "a1d728cc89cf3aee9ff92b05e62b19ee65a02b5702cff7d5a377e32c6ae29d8d"
 
 [[package]]
 name = "convert_case"
@@ -411,21 +411,6 @@ dependencies = [
  "typenum",
 ]
 
-[[package]]
-name = "cyclotomic-rings"
-version = "0.1.0"
-dependencies = [
- "ark-crypto-primitives",
- "ark-ff",
- "ark-std",
- "num-bigint",
- "rand",
- "stark-rings",
- "stark-rings-linalg",
- "stark-rings-poly",
- "thiserror",
-]
-
 [[package]]
 name = "delegate"
 version = "0.13.4"
@@ -519,9 +504,9 @@ checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
 
 [[package]]
 name = "generic-array"
-version = "0.14.7"
+version = "0.14.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+checksum = "4bb6743198531e02858aeaea5398fcc883e71851fcbcb5a2f773e2fb6cb1edf2"
 dependencies = [
  "typenum",
  "version_check",
@@ -540,18 +525,19 @@ dependencies = [
 
 [[package]]
 name = "gimli"
-version = "0.31.1"
+version = "0.32.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07e28edb80900c19c28f1072f2e8aeca7fa06b23cd4169cefe1af5aa3260783f"
+checksum = "e629b9b98ef3dd8afe6ca2bd0f89306cec16d43d907889945bc5d6687f2f13c7"
 
 [[package]]
 name = "half"
-version = "2.6.0"
+version = "2.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "459196ed295495a68f7d7fe1d84f6c4b7ff0e21fe3017b2f283c6fac3ad803c9"
+checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b"
 dependencies = [
  "cfg-if",
  "crunchy",
+ "zerocopy",
 ]
 
 [[package]]
@@ -574,6 +560,12 @@ dependencies = [
  "foldhash",
 ]
 
+[[package]]
+name = "hashbrown"
+version = "0.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5419bdc4f6a9207fbeba6d11b604d481addf78ecd10c11ad51e76c2f6482748d"
+
 [[package]]
 name = "hermit-abi"
 version = "0.5.2"
@@ -591,12 +583,12 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "2.10.0"
+version = "2.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe4cd85333e22411419a0bcae1297d25e58c9443848b11dc6a86fefe8c78a661"
+checksum = "6717a8d2a5a929a1a2eb43a12812498ed141a0bcfb7e8f7844fbdbe4303bba9f"
 dependencies = [
  "equivalent",
- "hashbrown 0.15.5",
+ "hashbrown 0.16.0",
 ]
 
 [[package]]
@@ -627,9 +619,9 @@ checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
 
 [[package]]
 name = "js-sys"
-version = "0.3.77"
+version = "0.3.81"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1cfaf33c695fc6e08064efbc1f72ec937429614f25eef83af942d0e227c3a28f"
+checksum = "ec48937a97411dcb524a265206ccd4c90bb711fca92b2792c407f268825b9305"
 dependencies = [
  "once_cell",
  "wasm-bindgen",
@@ -644,9 +636,9 @@ dependencies = [
  "ark-serialize",
  "ark-std",
  "criterion",
- "cyclotomic-rings",
  "dhat",
  "humansize",
+ "latticefold-rings",
  "lazy_static",
  "num-bigint",
  "num-traits",
@@ -671,9 +663,9 @@ dependencies = [
  "ark-serialize",
  "ark-std",
  "criterion",
- "cyclotomic-rings",
  "hashbrown 0.15.5",
  "latticefold",
+ "latticefold-rings",
  "num-bigint",
  "num-traits",
  "proc-macro2",
@@ -688,6 +680,21 @@ dependencies = [
  "toml",
 ]
 
+[[package]]
+name = "latticefold-rings"
+version = "0.1.0"
+dependencies = [
+ "ark-crypto-primitives",
+ "ark-ff",
+ "ark-std",
+ "num-bigint",
+ "rand",
+ "stark-rings",
+ "stark-rings-linalg",
+ "stark-rings-poly",
+ "thiserror",
+]
+
 [[package]]
 name = "lazy_static"
 version = "1.5.0"
@@ -696,9 +703,9 @@ checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 
 [[package]]
 name = "libc"
-version = "0.2.175"
+version = "0.2.177"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a82ae493e598baaea5209805c49bbf2ea7de956d50d7da0da1164f9c6d28543"
+checksum = "2874a2af47a2325c2001a6e6fad9b16a53b802102b528163885171cf92b15976"
 
 [[package]]
 name = "libm"
@@ -708,25 +715,24 @@ checksum = "f9fbbcab51052fe104eb5e5d351cf728d30a5be1fe14d9be8a3b097481fb97de"
 
 [[package]]
 name = "lock_api"
-version = "0.4.13"
+version = "0.4.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96936507f153605bddfcda068dd804796c84324ed2510809e5b2a624c81da765"
+checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"
 dependencies = [
- "autocfg",
  "scopeguard",
 ]
 
 [[package]]
 name = "log"
-version = "0.4.27"
+version = "0.4.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94"
+checksum = "34080505efa8e45a4b816c349525ebe327ceaa8559756f0356cba97ef3bf7432"
 
 [[package]]
 name = "memchr"
-version = "2.7.5"
+version = "2.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32a282da65faaf38286cf3be983213fcf1d2e2a58700e808f83f4ea9a4804bc0"
+checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273"
 
 [[package]]
 name = "miniz_oxide"
@@ -773,9 +779,9 @@ dependencies = [
 
 [[package]]
 name = "object"
-version = "0.36.7"
+version = "0.37.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62948e14d923ea95ea2c7c86c71013138b66525b86bdc08d2dcc262bdb497b87"
+checksum = "ff76201f031d8863c38aa7f905eca4f53abbfa15f609db4277d44cd8938f33fe"
 dependencies = [
  "memchr",
 ]
@@ -794,9 +800,9 @@ checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e"
 
 [[package]]
 name = "parking_lot"
-version = "0.12.4"
+version = "0.12.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70d58bf43669b5795d1576d0641cfb6fbb2057bf629506267a92807158584a13"
+checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a"
 dependencies = [
  "lock_api",
  "parking_lot_core",
@@ -804,15 +810,15 @@ dependencies = [
 
 [[package]]
 name = "parking_lot_core"
-version = "0.9.11"
+version = "0.9.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc838d2a56b5b1a6c25f55575dfc605fabb63bb2365f6c2353ef9159aa69e4a5"
+checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
 dependencies = [
  "cfg-if",
  "libc",
  "redox_syscall",
  "smallvec",
- "windows-targets 0.52.6",
+ "windows-link",
 ]
 
 [[package]]
@@ -875,9 +881,9 @@ dependencies = [
 
 [[package]]
 name = "quote"
-version = "1.0.40"
+version = "1.0.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d"
+checksum = "ce25767e7b499d1b604768e7cde645d14cc8584231ea6b295e9c9eb22c02e1d1"
 dependencies = [
  "proc-macro2",
 ]
@@ -934,18 +940,18 @@ dependencies = [
 
 [[package]]
 name = "redox_syscall"
-version = "0.5.17"
+version = "0.5.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5407465600fb0548f1442edf71dd20683c6ed326200ace4b1ef0763521bb3b77"
+checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
 dependencies = [
  "bitflags",
 ]
 
 [[package]]
 name = "regex"
-version = "1.11.1"
+version = "1.12.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
+checksum = "843bc0191f75f3e22651ae5f1e72939ab2f72a4bc30fa80a066bd66edefc24d4"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -955,9 +961,9 @@ dependencies = [
 
 [[package]]
 name = "regex-automata"
-version = "0.4.9"
+version = "0.4.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908"
+checksum = "5276caf25ac86c8d810222b3dbb938e512c55c6831a10f3e6ed1c93b84041f1c"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -966,9 +972,9 @@ dependencies = [
 
 [[package]]
 name = "regex-syntax"
-version = "0.8.5"
+version = "0.8.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
+checksum = "7a2d987857b319362043e95f5353c0535c1f58eec5336fdfcf626430af7def58"
 
 [[package]]
 name = "rustc-demangle"
@@ -1020,24 +1026,34 @@ checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 
 [[package]]
 name = "semver"
-version = "1.0.26"
+version = "1.0.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56e6fa9c48d24d85fb3de5ad847117517440f6beceb7798af16b4a87d616b8d0"
+checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2"
 
 [[package]]
 name = "serde"
-version = "1.0.219"
+version = "1.0.228"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f0e2c6ed6606019b4e29e69dbaba95b11854410e5347d525002456dbbb786b6"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.219"
+version = "1.0.228"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1046,14 +1062,15 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.143"
+version = "1.0.145"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d401abef1d108fbd9cbaebc3e46611f4b1021f714a0597a71f41ee463f5f4a5a"
+checksum = "402a6f66d8c709116cf22f558eab210f5a50187f702eb4d7e5ef38d9a7f1c79c"
 dependencies = [
  "itoa",
  "memchr",
  "ryu",
  "serde",
+ "serde_core",
 ]
 
 [[package]]
@@ -1067,12 +1084,11 @@ dependencies = [
 
 [[package]]
 name = "serde_with"
-version = "3.14.0"
+version = "3.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2c45cd61fefa9db6f254525d46e392b852e0e61d9a1fd36e5bd183450a556d5"
+checksum = "6093cd8c01b25262b84927e0f7151692158fab02d961e04c979d3903eba7ecc5"
 dependencies = [
- "serde",
- "serde_derive",
+ "serde_core",
 ]
 
 [[package]]
@@ -1095,7 +1111,7 @@ checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
 [[package]]
 name = "stark-rings"
 version = "0.0.1-alpha"
-source = "git+https://github.com/NethermindEth/stark-rings.git?branch=main#886a89f1febb45822b0ff453e39b640f755382b6"
+source = "git+https://github.com/NethermindEth/stark-rings.git?branch=main#a907aab35dd7afe105b30588eaf74008dea2f12b"
 dependencies = [
  "ark-crypto-primitives",
  "ark-ff",
@@ -1119,7 +1135,7 @@ dependencies = [
 [[package]]
 name = "stark-rings-linalg"
 version = "0.0.1-alpha"
-source = "git+https://github.com/NethermindEth/stark-rings.git?branch=main#886a89f1febb45822b0ff453e39b640f755382b6"
+source = "git+https://github.com/NethermindEth/stark-rings.git?branch=main#a907aab35dd7afe105b30588eaf74008dea2f12b"
 dependencies = [
  "ark-ff",
  "ark-serialize",
@@ -1136,7 +1152,7 @@ dependencies = [
 [[package]]
 name = "stark-rings-poly"
 version = "0.0.1-alpha"
-source = "git+https://github.com/NethermindEth/stark-rings.git?branch=main#886a89f1febb45822b0ff453e39b640f755382b6"
+source = "git+https://github.com/NethermindEth/stark-rings.git?branch=main#a907aab35dd7afe105b30588eaf74008dea2f12b"
 dependencies = [
  "ark-ff",
  "ark-serialize",
@@ -1180,18 +1196,18 @@ dependencies = [
 
 [[package]]
 name = "thiserror"
-version = "2.0.16"
+version = "2.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3467d614147380f2e4e374161426ff399c91084acd2363eaf549172b3d5e60c0"
+checksum = "f63587ca0f12b72a0600bcba1d40081f830876000bb46dd2337a3051618f4fc8"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "2.0.16"
+version = "2.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c5e1be1c48b9172ee610da68fd9cd2770e7a4056cb3fc98710ee6906f0c7960"
+checksum = "3ff15c8ecd7de3849db632e14d18d2571fa09dfc5ed93479bc4485c7a517c913"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1273,15 +1289,15 @@ checksum = "b9d12581f227e93f094d3af2ae690a574abb8a2b9b7a96e7cfe9647b2b617678"
 
 [[package]]
 name = "typenum"
-version = "1.18.0"
+version = "1.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1dccffe3ce07af9386bfd29e80c0ab1a8205a2fc34e4bcd40364df902cfa8f3f"
+checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb"
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.18"
+version = "1.0.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"
+checksum = "f63a545481291138910575129486daeaf8ac54aee4387fe7906919f7830c7d9d"
 
 [[package]]
 name = "version_check"
@@ -1307,21 +1323,22 @@ checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.100"
+version = "0.2.104"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1edc8929d7499fc4e8f0be2262a241556cfc54a0bea223790e71446f2aab1ef5"
+checksum = "c1da10c01ae9f1ae40cbfac0bac3b1e724b320abfcf52229f80b547c0d250e2d"
 dependencies = [
  "cfg-if",
  "once_cell",
  "rustversion",
  "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-backend"
-version = "0.2.100"
+version = "0.2.104"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f0a0651a5c2bc21487bde11ee802ccaf4c51935d0d3d42a6101f98161700bc6"
+checksum = "671c9a5a66f49d8a47345ab942e2cb93c7d1d0339065d4f8139c486121b43b19"
 dependencies = [
  "bumpalo",
  "log",
@@ -1333,9 +1350,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.100"
+version = "0.2.104"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fe63fc6d09ed3792bd0897b314f53de8e16568c2b3f7982f468c0bf9bd0b407"
+checksum = "7ca60477e4c59f5f2986c50191cd972e3a50d8a95603bc9434501cf156a9a119"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -1343,9 +1360,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.100"
+version = "0.2.104"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ae87ea40c9f689fc23f209965b6fb8a99ad69aeeb0231408be24920604395de"
+checksum = "9f07d2f20d4da7b26400c9f4a0511e6e0345b040694e8a75bd41d578fa4421d7"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1356,18 +1373,18 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.100"
+version = "0.2.104"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a05d73b933a847d6cccdda8f838a22ff101ad9bf93e33684f39c1f5f0eece3d"
+checksum = "bad67dc8b2a1a6e5448428adec4c3e84c43e561d8c9ee8a9e5aabeb193ec41d1"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "web-sys"
-version = "0.3.77"
+version = "0.3.81"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33b6dd2ef9186f1f2072e409e99cd22a975331a6b3591b12c764e0e55c60d5d2"
+checksum = "9367c417a924a74cae129e6a2ae3b47fabb1f8995595ab474029da749a8be120"
 dependencies = [
  "js-sys",
  "wasm-bindgen",
@@ -1375,18 +1392,18 @@ dependencies = [
 
 [[package]]
 name = "winapi-util"
-version = "0.1.10"
+version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0978bf7171b3d90bac376700cb56d606feb40f251a475a5d6634613564460b22"
+checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "windows-link"
-version = "0.1.3"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
 
 [[package]]
 name = "windows-sys"
@@ -1394,16 +1411,16 @@ version = "0.59.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
 dependencies = [
- "windows-targets 0.52.6",
+ "windows-targets",
 ]
 
 [[package]]
 name = "windows-sys"
-version = "0.60.2"
+version = "0.61.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
 dependencies = [
- "windows-targets 0.53.3",
+ "windows-link",
 ]
 
 [[package]]
@@ -1412,31 +1429,14 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
 dependencies = [
- "windows_aarch64_gnullvm 0.52.6",
- "windows_aarch64_msvc 0.52.6",
- "windows_i686_gnu 0.52.6",
- "windows_i686_gnullvm 0.52.6",
- "windows_i686_msvc 0.52.6",
- "windows_x86_64_gnu 0.52.6",
- "windows_x86_64_gnullvm 0.52.6",
- "windows_x86_64_msvc 0.52.6",
-]
-
-[[package]]
-name = "windows-targets"
-version = "0.53.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d5fe6031c4041849d7c496a8ded650796e7b6ecc19df1a431c1a363342e5dc91"
-dependencies = [
- "windows-link",
- "windows_aarch64_gnullvm 0.53.0",
- "windows_aarch64_msvc 0.53.0",
- "windows_i686_gnu 0.53.0",
- "windows_i686_gnullvm 0.53.0",
- "windows_i686_msvc 0.53.0",
- "windows_x86_64_gnu 0.53.0",
- "windows_x86_64_gnullvm 0.53.0",
- "windows_x86_64_msvc 0.53.0",
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
 ]
 
 [[package]]
@@ -1445,119 +1445,71 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
 
-[[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86b8d5f90ddd19cb4a147a5fa63ca848db3df085e25fee3cc10b39b6eebae764"
-
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
 
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7651a1f62a11b8cbd5e0d42526e55f2c99886c77e007179efff86c2b137e66c"
-
 [[package]]
 name = "windows_i686_gnu"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
 
-[[package]]
-name = "windows_i686_gnu"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1dc67659d35f387f5f6c479dc4e28f1d4bb90ddd1a5d3da2e5d97b42d6272c3"
-
 [[package]]
 name = "windows_i686_gnullvm"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
 
-[[package]]
-name = "windows_i686_gnullvm"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ce6ccbdedbf6d6354471319e781c0dfef054c81fbc7cf83f338a4296c0cae11"
-
 [[package]]
 name = "windows_i686_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
 
-[[package]]
-name = "windows_i686_msvc"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "581fee95406bb13382d2f65cd4a908ca7b1e4c2f1917f143ba16efe98a589b5d"
-
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
 
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e55b5ac9ea33f2fc1716d1742db15574fd6fc8dadc51caab1c16a3d3b4190ba"
-
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
 
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0a6e035dd0599267ce1ee132e51c27dd29437f63325753051e71dd9e42406c57"
-
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "271414315aff87387382ec3d271b52d7ae78726f5d44ac98b4f4030c91880486"
-
 [[package]]
 name = "winnow"
-version = "0.7.12"
+version = "0.7.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3edebf492c8125044983378ecb5766203ad3b4c2f7a922bd7dd207f6d443e95"
+checksum = "21a0236b59786fed61e2a80582dd500fe61f18b5dca67a4a067d0bc9039339cf"
 dependencies = [
  "memchr",
 ]
 
 [[package]]
 name = "zerocopy"
-version = "0.8.26"
+version = "0.8.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1039dd0d3c310cf05de012d8a39ff557cb0d23087fd44cad61df08fc31907a2f"
+checksum = "0894878a5fa3edfd6da3f88c4805f4c8558e2b996227a3d864f47fe11e38282c"
 dependencies = [
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.8.26"
+version = "0.8.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ecf5b4cc5364572d7f4c329661bcc82724222973f2cab6f050a4e5c22f75181"
+checksum = "88d2b8d9c68ad2b9e4340d7832716a4d21a22a1154777ad56ea55c51a9cf3831"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1566,9 +1518,9 @@ dependencies = [
 
 [[package]]
 name = "zeroize"
-version = "1.8.1"
+version = "1.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ced3678a2879b30306d323f4542626697a464a97c0a07c9aebf7ebca65cd4dde"
+checksum = "b97154e67e32c85465826e8bcc1c59429aaaf107c1e4a9e53c8d8ccd5eff88d0"
 dependencies = [
  "zeroize_derive",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index 25188ad2..6268abb4 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [workspace] 
 members = [
-    "crates/cyclotomic-rings",
+    "crates/rings",
     "crates/latticefold",
     "crates/latticefold-plus",
 ]
@@ -11,6 +11,16 @@ edition = "2021"
 license = "Apache-2.0 OR MIT"
 
 [workspace.dependencies]
+# Workspace
+latticefold-rings = { path = "crates/rings", default-features = false }
+latticefold       = { path = "crates/latticefold", default-features = false }
+
+# stark-rings
+stark-rings        = { git = "https://github.com/NethermindEth/stark-rings.git", branch = "main", default-features = false }
+stark-rings-linalg = { git = "https://github.com/NethermindEth/stark-rings.git", branch = "main", default-features = false }
+stark-rings-poly   = { git = "https://github.com/NethermindEth/stark-rings.git", branch = "main", default-features = false }
+
+# External
 ark-crypto-primitives = { version = "0.4.0", default-features = false, features = [
     "sponge",
 ] }
@@ -18,8 +28,6 @@ ark-ff = { version = "0.4.2", default-features = false }
 ark-serialize = { version = "0.4.2", features = ["derive"] }
 ark-std = { version = "0.4.0", default-features = false }
 criterion = "0.5.1"
-cyclotomic-rings = { path = "crates/cyclotomic-rings", default-features = false }
-latticefold = { path = "crates/latticefold", default-features = false }
 num-bigint = { version = "0.4.5", default-features = false }
 num-traits = { version = "0.2.19", default-features = false }
 proc-macro2 = "1.0.92"
@@ -27,9 +35,6 @@ quote = "1.0.37"
 rand = { version = "0.8.5", default-features = false }
 rayon = "1.10.0"
 serde = { version = "1.0.216", features = ["derive"] }
-stark-rings = { git = "https://github.com/NethermindEth/stark-rings.git", branch = "main", default-features = false }
-stark-rings-linalg = { git = "https://github.com/NethermindEth/stark-rings.git", branch = "main", default-features = false }
-stark-rings-poly = { git = "https://github.com/NethermindEth/stark-rings.git", branch = "main", default-features = false }
 thiserror = { version = "2.0.3", default-features = false }
 toml = "0.8.19"
 [workspace.metadata.docs.rs]
diff --git a/README.md b/README.md
index 8d074650..cfe6b848 100644
--- a/README.md
+++ b/README.md
@@ -37,7 +37,7 @@ latticefold = { git = "https://github.com/NethermindEth/latticefold.git", packag
 Available packages:
 - `latticefold`: main crate, contains the non-interactive folding scheme implementation, together with the Ajtai commitment scheme, R1CS/CCS structures, Fiat-Shamir transcript machinery, etc.
 - `latticefold-plus`: an improved version of LatticeFold. Currently a work-in-progress implementation. See [more](latticefold-plus/README.md). 
-- `cyclotomic-rings`: contains the trait definition of a ring suitable to be used in the LatticeFold protocol, a few ready-to-use rings and short challenge set machinery.
+- `cyclotomic-rings`: contains the trait definition of a ring suitable to be used in the LatticeFold protocol, a few ready-to-use rings and small challenge set machinery.
 
 ## Performance report
 The performance report for this library can be found [here](https://nethermind.notion.site/Latticefold-and-lattice-based-operations-performance-report-153360fc38d080ac930cdeeffed69559).
diff --git a/crates/latticefold-plus/Cargo.toml b/crates/latticefold-plus/Cargo.toml
index 872dc591..e10c6a60 100644
--- a/crates/latticefold-plus/Cargo.toml
+++ b/crates/latticefold-plus/Cargo.toml
@@ -6,7 +6,7 @@ license.workspace = true
 
 [features]
 default = ["std"]
-std = ["ark-std/std", "cyclotomic-rings/std", "rand/std"]
+std = ["ark-std/std", "latticefold-rings/std", "rand/std"]
 parallel = [
     "dep:rayon",
     "std",
@@ -21,12 +21,13 @@ getrandom = ["ark-std/getrandom"]
 dhat-heap = []
 
 [dependencies]
+latticefold-rings = { workspace = true }
+
 ark-crypto-primitives = { workspace = true }
 ark-ff = { workspace = true }
 ark-serialize = { workspace = true }
 ark-std = { workspace = true }
 criterion = { workspace = true }
-cyclotomic-rings = { workspace = true }
 hashbrown = "0.15"
 latticefold = { workspace = true }
 num-bigint = { workspace = true }
diff --git a/crates/latticefold-plus/benches/e2e.rs b/crates/latticefold-plus/benches/e2e.rs
index 73fd5963..1ee6ffd1 100644
--- a/crates/latticefold-plus/benches/e2e.rs
+++ b/crates/latticefold-plus/benches/e2e.rs
@@ -6,7 +6,6 @@
 use ark_ff::PrimeField;
 use ark_std::time::Duration;
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
-use cyclotomic_rings::rings::FrogPoseidonConfig as PC;
 use latticefold::arith::r1cs::R1CS;
 use latticefold_plus::{
     lin::LinParameters,
@@ -16,6 +15,7 @@ use latticefold_plus::{
     transcript::PoseidonTranscript,
     utils::estimate_bound,
 };
+use latticefold_rings::rings::FrogPoseidonConfig as PC;
 use rand::prelude::*;
 use stark_rings::{cyclotomic_ring::models::frog_ring::RqPoly as R, PolyRing, Ring};
 use stark_rings_linalg::{Matrix, SparseMatrix};
diff --git a/crates/latticefold-plus/src/cm.rs b/crates/latticefold-plus/src/cm.rs
index d1176b93..34a5660e 100644
--- a/crates/latticefold-plus/src/cm.rs
+++ b/crates/latticefold-plus/src/cm.rs
@@ -16,7 +16,7 @@ use stark_rings_poly::mle::DenseMultilinearExtension;
 
 use crate::{
     rgchk::{Dcom, Rg},
-    utils::{short_challenge, tensor, tensor_product},
+    utils::{small_challenge, tensor, tensor_product},
 };
 
 #[derive(Clone, Debug)]
@@ -67,13 +67,13 @@ where
         let dcom = self.rg.range_check(M, transcript);
 
         let s = (0..3)
-            .map(|_| short_challenge(128, transcript))
+            .map(|_| small_challenge(128, transcript))
             .collect::<Vec<R>>();
 
         let s_prime = (0..k)
             .map(|_| {
                 (0..d)
-                    .map(|_| short_challenge(128, transcript))
+                    .map(|_| small_challenge(128, transcript))
                     .collect::<Vec<R>>()
             })
             .collect::<Vec<_>>();
@@ -359,13 +359,13 @@ where
         self.dcom.verify(transcript).unwrap();
 
         let s = (0..3)
-            .map(|_| short_challenge(128, transcript))
+            .map(|_| small_challenge(128, transcript))
             .collect::<Vec<R>>();
 
         let s_prime = (0..k)
             .map(|_| {
                 (0..d)
-                    .map(|_| short_challenge(128, transcript))
+                    .map(|_| small_challenge(128, transcript))
                     .collect::<Vec<R>>()
             })
             .collect::<Vec<_>>();
@@ -609,7 +609,7 @@ where
 mod tests {
     use ark_ff::PrimeField;
     use ark_std::Zero;
-    use cyclotomic_rings::rings::FrogPoseidonConfig as PC;
+    use latticefold_rings::rings::FrogPoseidonConfig as PC;
     use stark_rings::cyclotomic_ring::models::frog_ring::RqPoly as R;
     use stark_rings_linalg::{Matrix, SparseMatrix};
 
diff --git a/crates/latticefold-plus/src/decomp.rs b/crates/latticefold-plus/src/decomp.rs
index 4a025c70..d53bd227 100644
--- a/crates/latticefold-plus/src/decomp.rs
+++ b/crates/latticefold-plus/src/decomp.rs
@@ -126,8 +126,8 @@ impl<R: PolyRing> DecompProof<R> {
 mod tests {
     use ark_ff::PrimeField;
     use ark_std::One;
-    use cyclotomic_rings::rings::FrogPoseidonConfig as PC;
     use latticefold::arith::r1cs::R1CS;
+    use latticefold_rings::rings::FrogPoseidonConfig as PC;
     use stark_rings::{
         balanced_decomposition::GadgetDecompose, cyclotomic_ring::models::frog_ring::RqPoly as R,
     };
diff --git a/crates/latticefold-plus/src/lin.rs b/crates/latticefold-plus/src/lin.rs
index fa346d7b..7597d27f 100644
--- a/crates/latticefold-plus/src/lin.rs
+++ b/crates/latticefold-plus/src/lin.rs
@@ -67,8 +67,8 @@ where
 mod tests {
     use ark_ff::PrimeField;
     use ark_std::One;
-    use cyclotomic_rings::rings::FrogPoseidonConfig as PC;
     use latticefold::arith::r1cs::R1CS;
+    use latticefold_rings::rings::FrogPoseidonConfig as PC;
     use stark_rings::{
         balanced_decomposition::GadgetDecompose, cyclotomic_ring::models::frog_ring::RqPoly as R,
         PolyRing,
diff --git a/crates/latticefold-plus/src/mlin.rs b/crates/latticefold-plus/src/mlin.rs
index 4d75eea8..240d1fdf 100644
--- a/crates/latticefold-plus/src/mlin.rs
+++ b/crates/latticefold-plus/src/mlin.rs
@@ -109,8 +109,8 @@ where
 mod tests {
     use ark_ff::PrimeField;
     use ark_std::One;
-    use cyclotomic_rings::rings::FrogPoseidonConfig as PC;
     use latticefold::arith::r1cs::R1CS;
+    use latticefold_rings::rings::FrogPoseidonConfig as PC;
     use stark_rings::{cyclotomic_ring::models::frog_ring::RqPoly as R, PolyRing};
     use stark_rings_linalg::SparseMatrix;
 
diff --git a/crates/latticefold-plus/src/plus.rs b/crates/latticefold-plus/src/plus.rs
index fb981a68..d32b8a43 100644
--- a/crates/latticefold-plus/src/plus.rs
+++ b/crates/latticefold-plus/src/plus.rs
@@ -145,8 +145,8 @@ where
 #[cfg(test)]
 mod tests {
     use ark_ff::PrimeField;
-    use cyclotomic_rings::rings::FrogPoseidonConfig as PC;
     use latticefold::arith::r1cs::R1CS;
+    use latticefold_rings::rings::FrogPoseidonConfig as PC;
     use rand::prelude::*;
     use stark_rings::{cyclotomic_ring::models::frog_ring::RqPoly as R, PolyRing, Ring};
     use stark_rings_linalg::SparseMatrix;
diff --git a/crates/latticefold-plus/src/r1cs.rs b/crates/latticefold-plus/src/r1cs.rs
index db9def41..b6893021 100644
--- a/crates/latticefold-plus/src/r1cs.rs
+++ b/crates/latticefold-plus/src/r1cs.rs
@@ -187,7 +187,7 @@ pub fn r1cs_decomposed_square<R: Decompose + Ring>(
 #[cfg(test)]
 mod tests {
     use ark_std::One;
-    use cyclotomic_rings::rings::GoldilocksPoseidonConfig as PC;
+    use latticefold_rings::rings::GoldilocksPoseidonConfig as PC;
     use stark_rings::{
         balanced_decomposition::GadgetDecompose, cyclotomic_ring::models::goldilocks::RqPoly as R,
     };
diff --git a/crates/latticefold-plus/src/rgchk.rs b/crates/latticefold-plus/src/rgchk.rs
index abf50ebe..cc401602 100644
--- a/crates/latticefold-plus/src/rgchk.rs
+++ b/crates/latticefold-plus/src/rgchk.rs
@@ -343,7 +343,7 @@ fn absorb_evaluations<R: OverField>(evals: &[DcomEvals<R>], transcript: &mut imp
 mod tests {
     use ark_ff::PrimeField;
     use ark_std::{log2, Zero};
-    use cyclotomic_rings::rings::FrogPoseidonConfig as PC;
+    use latticefold_rings::rings::FrogPoseidonConfig as PC;
     use stark_rings::cyclotomic_ring::models::frog_ring::RqPoly as R;
 
     use super::*;
diff --git a/crates/latticefold-plus/src/setchk.rs b/crates/latticefold-plus/src/setchk.rs
index 26b3f30b..087192c0 100644
--- a/crates/latticefold-plus/src/setchk.rs
+++ b/crates/latticefold-plus/src/setchk.rs
@@ -357,7 +357,7 @@ fn absorb_evaluations<R: OverField>(
 #[cfg(test)]
 mod tests {
     use ark_std::One;
-    use cyclotomic_rings::rings::FrogPoseidonConfig as PC;
+    use latticefold_rings::rings::FrogPoseidonConfig as PC;
     use stark_rings::{cyclotomic_ring::models::frog_ring::RqPoly as R, unit_monomial};
     use stark_rings_linalg::SparseMatrix;
 
diff --git a/crates/latticefold-plus/src/transcript.rs b/crates/latticefold-plus/src/transcript.rs
index de207beb..71b1662e 100644
--- a/crates/latticefold-plus/src/transcript.rs
+++ b/crates/latticefold-plus/src/transcript.rs
@@ -3,8 +3,8 @@ use ark_crypto_primitives::sponge::{
     CryptographicSponge,
 };
 use ark_ff::{Field, PrimeField};
-use cyclotomic_rings::rings::GetPoseidonParams;
 use latticefold::transcript::Transcript;
+use latticefold_rings::rings::GetPoseidonParams;
 use stark_rings::OverField;
 
 /// Transcript using Poseidon sponge
diff --git a/crates/latticefold-plus/src/utils.rs b/crates/latticefold-plus/src/utils.rs
index e3c9bae9..6de082bf 100644
--- a/crates/latticefold-plus/src/utils.rs
+++ b/crates/latticefold-plus/src/utils.rs
@@ -84,7 +84,7 @@ where
     result
 }
 
-pub fn short_challenge<R: OverField>(lambda: usize, transcript: &mut impl Transcript<R>) -> R {
+pub fn small_challenge<R: OverField>(lambda: usize, transcript: &mut impl Transcript<R>) -> R {
     let u = 2usize.pow(lambda as u32 / R::dimension() as u32);
     let bytes = transcript.squeeze_bytes(R::dimension());
 
diff --git a/crates/latticefold/Cargo.toml b/crates/latticefold/Cargo.toml
index 1af2e291..e661af21 100644
--- a/crates/latticefold/Cargo.toml
+++ b/crates/latticefold/Cargo.toml
@@ -6,7 +6,7 @@ license.workspace = true
 
 [features]
 default = ["std"]
-std = ["ark-std/std", "cyclotomic-rings/std", "rand/std"]
+std = ["ark-std/std", "latticefold-rings/std", "rand/std"]
 parallel = [
     "dep:rayon",
     "std",
@@ -25,7 +25,7 @@ ark-crypto-primitives = { workspace = true }
 ark-ff = { workspace = true }
 ark-serialize = { workspace = true }
 ark-std = { workspace = true }
-cyclotomic-rings = { workspace = true }
+latticefold-rings = { workspace = true }
 num-bigint = { workspace = true }
 num-traits = { workspace = true }
 rand = { workspace = true }
diff --git a/crates/latticefold/benches/ajtai.rs b/crates/latticefold/benches/ajtai.rs
index bccbdc96..bd46c4ea 100644
--- a/crates/latticefold/benches/ajtai.rs
+++ b/crates/latticefold/benches/ajtai.rs
@@ -3,9 +3,9 @@ use criterion::{
     criterion_group, criterion_main, AxisScale, BatchSize::SmallInput, BenchmarkId, Criterion,
     PlotConfiguration,
 };
-use cyclotomic_rings::rings::{BabyBearRingNTT, FrogRingNTT, GoldilocksRingNTT, StarkRingNTT};
 use env::ENV;
 use latticefold::commitment::AjtaiCommitmentScheme;
+use latticefold_rings::rings::{BabyBearRingNTT, FrogRingNTT, GoldilocksRingNTT, StarkRingNTT};
 use stark_rings::cyclotomic_ring::{CRT, ICRT};
 
 mod env;
diff --git a/crates/latticefold/benches/utils.rs b/crates/latticefold/benches/utils.rs
index cd1466ca..f07d575b 100644
--- a/crates/latticefold/benches/utils.rs
+++ b/crates/latticefold/benches/utils.rs
@@ -2,7 +2,6 @@ use std::{fmt::Debug, marker::PhantomData};
 
 use ark_std::UniformRand;
 use criterion::{measurement::WallTime, BenchmarkGroup, BenchmarkId};
-use cyclotomic_rings::{challenge_set::LatticefoldChallengeSet, rings::SuitableRing};
 use latticefold::{
     arith::{
         ccs::get_test_dummy_degree_three_ccs_non_scalar,
@@ -28,6 +27,7 @@ use latticefold::{
     },
     transcript::poseidon::PoseidonTranscript,
 };
+use latticefold_rings::rings::SuitableRing;
 
 #[derive(Clone, Copy)]
 pub enum R1CS {
@@ -170,18 +170,12 @@ pub fn wit_and_ccs_gen_degree_three_non_scalar<
     (cm_i, wit, ccs, scheme)
 }
 
-pub struct Bencher<
-    P: DecompositionParams,
-    R: SuitableRing + Clone,
-    CS: LatticefoldChallengeSet<R> + Clone,
-> {
-    phantom_data: PhantomData<(P, R, CS)>,
+pub struct Bencher<P: DecompositionParams, R: SuitableRing + Clone> {
+    phantom_data: PhantomData<(P, R)>,
 }
 
 #[allow(dead_code)]
-impl<P: DecompositionParams, R: SuitableRing + Clone, CS: LatticefoldChallengeSet<R> + Clone>
-    Bencher<P, R, CS>
-{
+impl<P: DecompositionParams, R: SuitableRing + Clone> Bencher<P, R> {
     pub fn setup_r1cs(
         x_len: usize,
         n: usize,
@@ -204,14 +198,12 @@ impl<P: DecompositionParams, R: SuitableRing + Clone, CS: LatticefoldChallengeSe
 
     pub fn verify_linearization_proof(
         proof: &LinearizationProof<R>,
-        transcript: &mut PoseidonTranscript<R, CS>,
+        transcript: &mut PoseidonTranscript<R>,
         cm_i: &CCCS<R>,
         ccs: &CCS<R>,
     ) -> LCCCS<R> {
-        LFLinearizationVerifier::<_, PoseidonTranscript<R, CS>>::verify(
-            cm_i, proof, transcript, ccs,
-        )
-        .expect("Failed to verify linearization proof")
+        LFLinearizationVerifier::<_, PoseidonTranscript<R>>::verify(cm_i, proof, transcript, ccs)
+            .expect("Failed to verify linearization proof")
     }
 
     pub fn bench_linearization_prover(
@@ -236,12 +228,12 @@ impl<P: DecompositionParams, R: SuitableRing + Clone, CS: LatticefoldChallengeSe
                 ),
             ),
             |b| {
-                let transcript = PoseidonTranscript::<R, CS>::default();
+                let transcript = PoseidonTranscript::<R>::default();
                 let (cm_i, wit, ccs, _) = Self::setup_r1cs(x_len, n, wit_len, kappa, t);
                 b.iter_batched(
                     || transcript.clone(),
                     |mut bench_transcript| {
-                        let _ = LFLinearizationProver::<_, PoseidonTranscript<R, CS>>::prove(
+                        let _ = LFLinearizationProver::<_, PoseidonTranscript<R>>::prove(
                             &cm_i,
                             &wit,
                             &mut bench_transcript,
@@ -277,9 +269,9 @@ impl<P: DecompositionParams, R: SuitableRing + Clone, CS: LatticefoldChallengeSe
                 ),
             ),
             |b| {
-                let mut transcript = PoseidonTranscript::<R, CS>::default();
+                let mut transcript = PoseidonTranscript::<R>::default();
                 let (cm_i, wit, ccs, _) = Self::setup_r1cs(x_len, n, wit_len, kappa, t);
-                let (_, proof) = LFLinearizationProver::<_, PoseidonTranscript<R, CS>>::prove(
+                let (_, proof) = LFLinearizationProver::<_, PoseidonTranscript<R>>::prove(
                     &cm_i,
                     &wit,
                     &mut transcript,
@@ -288,8 +280,8 @@ impl<P: DecompositionParams, R: SuitableRing + Clone, CS: LatticefoldChallengeSe
                 .expect("Failed to generate linearization proof");
 
                 b.iter(|| {
-                    let mut transcript = PoseidonTranscript::<R, CS>::default();
-                    let _ = LFLinearizationVerifier::<_, PoseidonTranscript<R, CS>>::verify(
+                    let mut transcript = PoseidonTranscript::<R>::default();
+                    let _ = LFLinearizationVerifier::<_, PoseidonTranscript<R>>::verify(
                         &cm_i,
                         &proof,
                         &mut transcript,
@@ -323,10 +315,10 @@ impl<P: DecompositionParams, R: SuitableRing + Clone, CS: LatticefoldChallengeSe
                 ),
             ),
             |b| {
-                let mut prover_transcript = PoseidonTranscript::<R, CS>::default();
-                let mut verifier_transcript = PoseidonTranscript::<R, CS>::default();
+                let mut prover_transcript = PoseidonTranscript::<R>::default();
+                let mut verifier_transcript = PoseidonTranscript::<R>::default();
                 let (cm_i, wit, ccs, scheme) = Self::setup_r1cs(x_len, n, wit_len, kappa, t);
-                let (_, proof) = LFLinearizationProver::<_, PoseidonTranscript<R, CS>>::prove(
+                let (_, proof) = LFLinearizationProver::<_, PoseidonTranscript<R>>::prove(
                     &cm_i,
                     &wit,
                     &mut prover_transcript,
@@ -337,7 +329,7 @@ impl<P: DecompositionParams, R: SuitableRing + Clone, CS: LatticefoldChallengeSe
                     Self::verify_linearization_proof(&proof, &mut verifier_transcript, &cm_i, &ccs);
 
                 b.iter(|| {
-                    let _ = LFDecompositionProver::<_, PoseidonTranscript<R, CS>>::prove::<P>(
+                    let _ = LFDecompositionProver::<_, PoseidonTranscript<R>>::prove::<P>(
                         &lcccs,
                         &wit,
                         &mut prover_transcript,
@@ -372,18 +364,18 @@ impl<P: DecompositionParams, R: SuitableRing + Clone, CS: LatticefoldChallengeSe
                 ),
             ),
             |b| {
-                let mut prover_transcript = PoseidonTranscript::<R, CS>::default();
-                let mut verifier_transcript = PoseidonTranscript::<R, CS>::default();
+                let mut prover_transcript = PoseidonTranscript::<R>::default();
+                let mut verifier_transcript = PoseidonTranscript::<R>::default();
                 let (cm_i, wit, ccs, scheme) = Self::setup_r1cs(x_len, n, wit_len, kappa, t);
                 let (_, linearization_proof) =
-                    LFLinearizationProver::<_, PoseidonTranscript<R, CS>>::prove(
+                    LFLinearizationProver::<_, PoseidonTranscript<R>>::prove(
                         &cm_i,
                         &wit,
                         &mut prover_transcript,
                         &ccs,
                     )
                     .expect("Failed to generate linearization proof");
-                let lcccs = LFLinearizationVerifier::<_, PoseidonTranscript<R, CS>>::verify(
+                let lcccs = LFLinearizationVerifier::<_, PoseidonTranscript<R>>::verify(
                     &cm_i,
                     &linearization_proof,
                     &mut verifier_transcript,
@@ -392,7 +384,7 @@ impl<P: DecompositionParams, R: SuitableRing + Clone, CS: LatticefoldChallengeSe
                 .expect("Failed to verify linearization proof");
 
                 let (_, _, _, proof) =
-                    LFDecompositionProver::<_, PoseidonTranscript<R, CS>>::prove::<P>(
+                    LFDecompositionProver::<_, PoseidonTranscript<R>>::prove::<P>(
                         &lcccs,
                         &wit,
                         &mut prover_transcript,
@@ -404,14 +396,13 @@ impl<P: DecompositionParams, R: SuitableRing + Clone, CS: LatticefoldChallengeSe
                 b.iter_batched(
                     || verifier_transcript.clone(),
                     |mut bench_verifier_transcript| {
-                        let _ =
-                            LFDecompositionVerifier::<_, PoseidonTranscript<R, CS>>::verify::<P>(
-                                &lcccs,
-                                &proof,
-                                &mut bench_verifier_transcript,
-                                &ccs,
-                            )
-                            .expect("Failed to verify decomposition proof");
+                        let _ = LFDecompositionVerifier::<_, PoseidonTranscript<R>>::verify::<P>(
+                            &lcccs,
+                            &proof,
+                            &mut bench_verifier_transcript,
+                            &ccs,
+                        )
+                        .expect("Failed to verify decomposition proof");
                     },
                     criterion::BatchSize::SmallInput,
                 );
@@ -442,11 +433,11 @@ impl<P: DecompositionParams, R: SuitableRing + Clone, CS: LatticefoldChallengeSe
             ),
             |b| {
                 let (cm_i, wit, ccs, scheme) = Self::setup_r1cs(x_len, n, wit_len, kappa, t);
-                let mut prover_transcript = PoseidonTranscript::<R, CS>::default();
-                let mut verifier_transcript = PoseidonTranscript::<R, CS>::default();
+                let mut prover_transcript = PoseidonTranscript::<R>::default();
+                let mut verifier_transcript = PoseidonTranscript::<R>::default();
 
                 let (_, linearization_proof) =
-                    LFLinearizationProver::<_, PoseidonTranscript<R, CS>>::prove(
+                    LFLinearizationProver::<_, PoseidonTranscript<R>>::prove(
                         &cm_i,
                         &wit,
                         &mut prover_transcript,
@@ -454,7 +445,7 @@ impl<P: DecompositionParams, R: SuitableRing + Clone, CS: LatticefoldChallengeSe
                     )
                     .unwrap();
 
-                let lcccs = LFLinearizationVerifier::<_, PoseidonTranscript<R, CS>>::verify(
+                let lcccs = LFLinearizationVerifier::<_, PoseidonTranscript<R>>::verify(
                     &cm_i,
                     &linearization_proof,
                     &mut verifier_transcript,
@@ -463,7 +454,7 @@ impl<P: DecompositionParams, R: SuitableRing + Clone, CS: LatticefoldChallengeSe
                 .unwrap();
 
                 let (mz_mles, _, wit_vec, decomposition_proof) =
-                    LFDecompositionProver::<_, PoseidonTranscript<R, CS>>::prove::<P>(
+                    LFDecompositionProver::<_, PoseidonTranscript<R>>::prove::<P>(
                         &lcccs,
                         &wit,
                         &mut prover_transcript,
@@ -472,14 +463,13 @@ impl<P: DecompositionParams, R: SuitableRing + Clone, CS: LatticefoldChallengeSe
                     )
                     .unwrap();
 
-                let lcccs_vec =
-                    LFDecompositionVerifier::<_, PoseidonTranscript<R, CS>>::verify::<P>(
-                        &lcccs,
-                        &decomposition_proof,
-                        &mut verifier_transcript,
-                        &ccs,
-                    )
-                    .unwrap();
+                let lcccs_vec = LFDecompositionVerifier::<_, PoseidonTranscript<R>>::verify::<P>(
+                    &lcccs,
+                    &decomposition_proof,
+                    &mut verifier_transcript,
+                    &ccs,
+                )
+                .unwrap();
                 let (lcccs, wit_s, mz_mles) = {
                     let mut lcccs = lcccs_vec.clone();
                     let mut lcccs_r = lcccs_vec.clone();
@@ -498,7 +488,7 @@ impl<P: DecompositionParams, R: SuitableRing + Clone, CS: LatticefoldChallengeSe
                 b.iter_batched(
                     || (lcccs.clone(), wit_s.clone()),
                     |(lcccs_vec, wit_vec)| {
-                        let _ = LFFoldingProver::<R, PoseidonTranscript<R, CS>>::prove::<P>(
+                        let _ = LFFoldingProver::<R, PoseidonTranscript<R>>::prove::<P>(
                             &lcccs_vec,
                             wit_vec,
                             &mut prover_transcript,
@@ -535,11 +525,11 @@ impl<P: DecompositionParams, R: SuitableRing + Clone, CS: LatticefoldChallengeSe
                 ),
             ),
             |b| {
-                let mut prover_transcript = PoseidonTranscript::<R, CS>::default();
-                let mut verifier_transcript = PoseidonTranscript::<R, CS>::default();
+                let mut prover_transcript = PoseidonTranscript::<R>::default();
+                let mut verifier_transcript = PoseidonTranscript::<R>::default();
                 let (cm_i, wit, ccs, scheme) = Self::setup_r1cs(x_len, n, wit_len, kappa, t);
                 let (_, linearization_proof) =
-                    LFLinearizationProver::<_, PoseidonTranscript<R, CS>>::prove(
+                    LFLinearizationProver::<_, PoseidonTranscript<R>>::prove(
                         &cm_i,
                         &wit,
                         &mut prover_transcript,
@@ -547,7 +537,7 @@ impl<P: DecompositionParams, R: SuitableRing + Clone, CS: LatticefoldChallengeSe
                     )
                     .expect("Failed to generate linearization proof");
 
-                let lcccs = LFLinearizationVerifier::<_, PoseidonTranscript<R, CS>>::verify(
+                let lcccs = LFLinearizationVerifier::<_, PoseidonTranscript<R>>::verify(
                     &cm_i,
                     &linearization_proof,
                     &mut verifier_transcript,
@@ -556,7 +546,7 @@ impl<P: DecompositionParams, R: SuitableRing + Clone, CS: LatticefoldChallengeSe
                 .expect("Failed to verify linearization proof");
 
                 let (mz_mles, _, wit_vec, decomposition_proof) =
-                    LFDecompositionProver::<_, PoseidonTranscript<R, CS>>::prove::<P>(
+                    LFDecompositionProver::<_, PoseidonTranscript<R>>::prove::<P>(
                         &lcccs,
                         &wit,
                         &mut prover_transcript,
@@ -565,14 +555,13 @@ impl<P: DecompositionParams, R: SuitableRing + Clone, CS: LatticefoldChallengeSe
                     )
                     .expect("Failed to generate decomposition proof");
 
-                let lcccs_vec =
-                    LFDecompositionVerifier::<_, PoseidonTranscript<R, CS>>::verify::<P>(
-                        &lcccs,
-                        &decomposition_proof,
-                        &mut verifier_transcript,
-                        &ccs,
-                    )
-                    .expect("Failed to verify decomposition proof");
+                let lcccs_vec = LFDecompositionVerifier::<_, PoseidonTranscript<R>>::verify::<P>(
+                    &lcccs,
+                    &decomposition_proof,
+                    &mut verifier_transcript,
+                    &ccs,
+                )
+                .expect("Failed to verify decomposition proof");
 
                 let (lcccs, wit_s, mz_mles) = {
                     let mut lcccs = lcccs_vec.clone();
@@ -590,7 +579,7 @@ impl<P: DecompositionParams, R: SuitableRing + Clone, CS: LatticefoldChallengeSe
                 };
 
                 let (_, _, folding_proof) =
-                    LFFoldingProver::<R, PoseidonTranscript<R, CS>>::prove::<P>(
+                    LFFoldingProver::<R, PoseidonTranscript<R>>::prove::<P>(
                         &lcccs,
                         wit_s,
                         &mut prover_transcript,
@@ -602,7 +591,7 @@ impl<P: DecompositionParams, R: SuitableRing + Clone, CS: LatticefoldChallengeSe
                 b.iter_batched(
                     || verifier_transcript.clone(),
                     |mut bench_verifier_transcript| {
-                        let _ = LFFoldingVerifier::<_, PoseidonTranscript<R, CS>>::verify::<P>(
+                        let _ = LFFoldingVerifier::<_, PoseidonTranscript<R>>::verify::<P>(
                             &lcccs,
                             &folding_proof,
                             &mut bench_verifier_transcript,
@@ -638,12 +627,12 @@ impl<P: DecompositionParams, R: SuitableRing + Clone, CS: LatticefoldChallengeSe
                 ),
             ),
             |b| {
-                let mut prover_transcript = PoseidonTranscript::<R, CS>::default();
-                let mut verifier_transcript = PoseidonTranscript::<R, CS>::default();
+                let mut prover_transcript = PoseidonTranscript::<R>::default();
+                let mut verifier_transcript = PoseidonTranscript::<R>::default();
                 let (cm_i, wit, ccs, scheme) = Self::setup_r1cs(x_len, n, wit_len, kappa, t);
 
                 let (_, linearization_proof) =
-                    LFLinearizationProver::<_, PoseidonTranscript<R, CS>>::prove(
+                    LFLinearizationProver::<_, PoseidonTranscript<R>>::prove(
                         &cm_i,
                         &wit,
                         &mut prover_transcript,
@@ -651,7 +640,7 @@ impl<P: DecompositionParams, R: SuitableRing + Clone, CS: LatticefoldChallengeSe
                     )
                     .expect("Failed to generate linearization proof");
 
-                let lcccs = LFLinearizationVerifier::<_, PoseidonTranscript<R, CS>>::verify(
+                let lcccs = LFLinearizationVerifier::<_, PoseidonTranscript<R>>::verify(
                     &cm_i,
                     &linearization_proof,
                     &mut verifier_transcript,
@@ -662,7 +651,7 @@ impl<P: DecompositionParams, R: SuitableRing + Clone, CS: LatticefoldChallengeSe
                 b.iter_batched(
                     || prover_transcript.clone(),
                     |mut bench_prover_transcript| {
-                        let _ = NIFSProver::<R, P, PoseidonTranscript<R, CS>>::prove(
+                        let _ = NIFSProver::<R, P, PoseidonTranscript<R>>::prove(
                             &lcccs,
                             &wit,
                             &cm_i,
@@ -701,19 +690,19 @@ impl<P: DecompositionParams, R: SuitableRing + Clone, CS: LatticefoldChallengeSe
                 ),
             ),
             |b| {
-                let mut prover_transcript = PoseidonTranscript::<R, CS>::default();
-                let mut verifier_transcript = PoseidonTranscript::<R, CS>::default();
+                let mut prover_transcript = PoseidonTranscript::<R>::default();
+                let mut verifier_transcript = PoseidonTranscript::<R>::default();
                 let (cm_i, wit, ccs, scheme) = Self::setup_r1cs(x_len, n, wit_len, kappa, t);
 
                 let (acc_lcccs, linearization_proof) = LFLinearizationProver::<
                     _,
-                    PoseidonTranscript<R, CS>,
+                    PoseidonTranscript<R>,
                 >::prove(
                     &cm_i, &wit, &mut prover_transcript, &ccs
                 )
                 .expect("Failed to generate linearization proof");
 
-                let lcccs = LFLinearizationVerifier::<_, PoseidonTranscript<R, CS>>::verify(
+                let lcccs = LFLinearizationVerifier::<_, PoseidonTranscript<R>>::verify(
                     &cm_i,
                     &linearization_proof,
                     &mut verifier_transcript,
@@ -721,7 +710,7 @@ impl<P: DecompositionParams, R: SuitableRing + Clone, CS: LatticefoldChallengeSe
                 )
                 .expect("Failed to verify linearization");
 
-                let (_, _, proof) = NIFSProver::<R, P, PoseidonTranscript<R, CS>>::prove(
+                let (_, _, proof) = NIFSProver::<R, P, PoseidonTranscript<R>>::prove(
                     &lcccs,
                     &wit,
                     &cm_i,
@@ -735,7 +724,7 @@ impl<P: DecompositionParams, R: SuitableRing + Clone, CS: LatticefoldChallengeSe
                 b.iter_batched(
                     || verifier_transcript.clone(),
                     |mut bench_verifier_transcript| {
-                        let result = NIFSVerifier::<R, P, PoseidonTranscript<R, CS>>::verify(
+                        let result = NIFSVerifier::<R, P, PoseidonTranscript<R>>::verify(
                             &acc_lcccs,
                             &cm_i,
                             &proof,
diff --git a/crates/latticefold/build.rs b/crates/latticefold/build.rs
index b5cb608b..44332f3c 100644
--- a/crates/latticefold/build.rs
+++ b/crates/latticefold/build.rs
@@ -111,32 +111,32 @@ fn generate_code_for_examples() {
             r#"
             const N: usize = N_GOLDILOCKS;
             type DP = GoldilocksExampleDP;
-            type RqNTT = cyclotomic_rings::rings::GoldilocksRingNTT;
-            type CS = cyclotomic_rings::rings::GoldilocksChallengeSet;
+            type RqNTT = latticefold_rings::rings::GoldilocksRingNTT;
+            type CS = latticefold_rings::rings::GoldilocksChallengeSet;
             "#,
         ),
         "BabyBear" => generated_code.push_str(
             r#"
             const N: usize = N_BABYBEAR;
             type DP = BabyBearExampleDP;
-            type RqNTT = cyclotomic_rings::rings::BabyBearRingNTT;
-            type CS = cyclotomic_rings::rings::BabyBearChallengeSet;
+            type RqNTT = latticefold_rings::rings::BabyBearRingNTT;
+            type CS = latticefold_rings::rings::BabyBearChallengeSet;
             "#,
         ),
         "Frog" => generated_code.push_str(
             r#"
             const N: usize = N_FROG;
             type DP = FrogExampleDP;
-            type RqNTT = cyclotomic_rings::rings::FrogRingNTT;
-            type CS = cyclotomic_rings::rings::FrogChallengeSet;
+            type RqNTT = latticefold_rings::rings::FrogRingNTT;
+            type CS = latticefold_rings::rings::FrogChallengeSet;
             "#,
         ),
         "StarkPrime" => generated_code.push_str(
             r#"
             const N: usize = N_STARK;
             type DP = StarkPrimeExampleDP;
-            type RqNTT = cyclotomic_rings::rings::StarkRingNTT;
-            type CS = cyclotomic_rings::rings::StarkChallengeSet;
+            type RqNTT = latticefold_rings::rings::StarkRingNTT;
+            type CS = latticefold_rings::rings::StarkChallengeSet;
             "#,
         ),
         _ => panic!("Unknown ring configuration"),
@@ -243,28 +243,28 @@ fn parse_benches() {
         File::create(&linearization_file_path).expect("Failed to create benchmark generated file");
 
     writeln!(&mut linearization_file, "use utils::{{Bencher, R1CS}};").unwrap();
-    writeln!(&mut linearization_file, "use cyclotomic_rings::rings::{{BabyBearChallengeSet, BabyBearRingNTT, FrogChallengeSet, FrogRingNTT, GoldilocksChallengeSet, GoldilocksRingNTT, StarkChallengeSet, StarkRingNTT}};").unwrap();
+    writeln!(&mut linearization_file, "use latticefold_rings::rings::{{BabyBearRingNTT, FrogRingNTT, GoldilocksRingNTT, StarkRingNTT}};").unwrap();
 
     let decomposition_file_path = Path::new(&out_dir).join("generated_decomposition_benchmarks.rs");
     let mut decomposition_file =
         File::create(&decomposition_file_path).expect("Failed to create benchmark generated file");
 
     writeln!(&mut decomposition_file, "use utils::{{Bencher, R1CS}};").unwrap();
-    writeln!(&mut decomposition_file, "use cyclotomic_rings::rings::{{BabyBearChallengeSet, BabyBearRingNTT, FrogChallengeSet, FrogRingNTT, GoldilocksChallengeSet, GoldilocksRingNTT, StarkChallengeSet, StarkRingNTT}};").unwrap();
+    writeln!(&mut decomposition_file, "use latticefold_rings::rings::{{BabyBearRingNTT, FrogRingNTT, GoldilocksRingNTT, StarkRingNTT}};").unwrap();
 
     let folding_file_path = Path::new(&out_dir).join("generated_folding_benchmarks.rs");
     let mut folding_file =
         File::create(&folding_file_path).expect("Failed to create benchmark generated file");
 
     writeln!(&mut folding_file, "use utils::{{Bencher, R1CS}};").unwrap();
-    writeln!(&mut folding_file, "use cyclotomic_rings::rings::{{BabyBearChallengeSet, BabyBearRingNTT, FrogChallengeSet, FrogRingNTT, GoldilocksChallengeSet, GoldilocksRingNTT, StarkChallengeSet, StarkRingNTT}};").unwrap();
+    writeln!(&mut folding_file, "use latticefold_rings::rings::{{BabyBearRingNTT, FrogRingNTT, GoldilocksRingNTT, StarkRingNTT}};").unwrap();
 
     let e2e_file_path = Path::new(&out_dir).join("generated_e2e_benchmarks.rs");
     let mut e2e_file =
         File::create(&e2e_file_path).expect("Failed to create benchmark generated file");
 
     writeln!(&mut e2e_file, "use utils::{{Bencher, R1CS}};").unwrap();
-    writeln!(&mut e2e_file, "use cyclotomic_rings::rings::{{BabyBearChallengeSet, BabyBearRingNTT, FrogChallengeSet, FrogRingNTT, GoldilocksChallengeSet, GoldilocksRingNTT, StarkChallengeSet, StarkRingNTT}};").unwrap();
+    writeln!(&mut e2e_file, "use latticefold_rings::rings::{{BabyBearRingNTT, FrogRingNTT, GoldilocksRingNTT, StarkRingNTT}};").unwrap();
 
     let mut files = (
         linearization_file,
@@ -576,7 +576,7 @@ fn write_function(
     scalar: R1CS,
     group_name: &str,
 ) -> TokenStream {
-    let cs = Ident::new(cs, Span::call_site());
+    let _cs = Ident::new(cs, Span::call_site());
     let ring = Ident::new(ring, Span::call_site());
     let prover_function = Ident::new(&format!("bench_{subprotocol}_prover"), Span::call_site());
     let verifier_function = Ident::new(&format!("bench_{subprotocol}_verifier"), Span::call_site());
@@ -603,10 +603,9 @@ fn write_function(
                         const K: usize = #k;
                     }
 
-                    type CS = #cs;
                     type R = #ring;
 
-                    type BlockBencher = Bencher<DP, R, CS>;
+                    type BlockBencher = Bencher<DP, R>;
 
                     if X_LEN == ENV.x_len.unwrap_or(X_LEN) &&
                         KAPPA == ENV.kappa.unwrap_or(KAPPA) &&
diff --git a/crates/latticefold/examples/e2e.rs b/crates/latticefold/examples/e2e.rs
index 1582215a..449185b2 100644
--- a/crates/latticefold/examples/e2e.rs
+++ b/crates/latticefold/examples/e2e.rs
@@ -4,7 +4,6 @@ use std::{fmt::Debug, time::Instant};
 
 use ark_serialize::{CanonicalSerialize, Compress};
 use ark_std::{vec::Vec, UniformRand};
-use cyclotomic_rings::{challenge_set::LatticefoldChallengeSet, rings::SuitableRing};
 use latticefold::{
     arith::{
         ccs::get_test_dummy_degree_three_ccs_non_scalar, r1cs::get_test_dummy_z_split_ntt, Arith,
@@ -17,6 +16,7 @@ use latticefold::{
     },
     transcript::poseidon::PoseidonTranscript,
 };
+use latticefold_rings::rings::SuitableRing;
 
 include!(concat!(env!("OUT_DIR"), "/examples_generated.rs"));
 
@@ -59,11 +59,7 @@ pub fn wit_and_ccs_gen_degree_three_non_scalar<
 }
 
 #[allow(clippy::type_complexity)]
-fn setup_example_environment<
-    RqNTT: SuitableRing,
-    DP: DecompositionParams,
-    CS: LatticefoldChallengeSet<RqNTT>,
->() -> (
+fn setup_example_environment<RqNTT: SuitableRing, DP: DecompositionParams>() -> (
     LCCCS<RqNTT>,
     Witness<RqNTT>,
     CCCS<RqNTT>,
@@ -79,9 +75,9 @@ fn setup_example_environment<
     let rand_w_ccs: Vec<RqNTT> = (0..WIT_LEN).map(|i| RqNTT::from(i as u64)).collect();
     let wit_acc = Witness::from_w_ccs::<DP>(rand_w_ccs);
 
-    let mut transcript = PoseidonTranscript::<RqNTT, CS>::default();
+    let mut transcript = PoseidonTranscript::<RqNTT>::default();
 
-    let (acc, _) = LFLinearizationProver::<_, PoseidonTranscript<RqNTT, CS>>::prove(
+    let (acc, _) = LFLinearizationProver::<_, PoseidonTranscript<RqNTT>>::prove(
         &cm_i,
         &wit_acc,
         &mut transcript,
@@ -92,7 +88,7 @@ fn setup_example_environment<
     (acc, wit_acc, cm_i, wit, ccs, scheme)
 }
 
-type T = PoseidonTranscript<RqNTT, CS>;
+type T = PoseidonTranscript<RqNTT>;
 
 fn main() {
     println!("Setting up example environment...");
@@ -103,10 +99,10 @@ fn main() {
     println!("\tB_SMALL: {}", DP::B_SMALL);
     println!("\tK: {}", DP::K);
 
-    let (acc, wit_acc, cm_i, wit_i, ccs, scheme) = setup_example_environment::<RqNTT, DP, CS>();
+    let (acc, wit_acc, cm_i, wit_i, ccs, scheme) = setup_example_environment::<RqNTT, DP>();
 
-    let mut prover_transcript = PoseidonTranscript::<RqNTT, CS>::default();
-    let mut verifier_transcript = PoseidonTranscript::<RqNTT, CS>::default();
+    let mut prover_transcript = PoseidonTranscript::<RqNTT>::default();
+    let mut verifier_transcript = PoseidonTranscript::<RqNTT>::default();
     println!("Generating proof...");
     let start = Instant::now();
 
diff --git a/crates/latticefold/src/arith.rs b/crates/latticefold/src/arith.rs
index d7004536..5db47c4d 100644
--- a/crates/latticefold/src/arith.rs
+++ b/crates/latticefold/src/arith.rs
@@ -6,7 +6,7 @@ use core::mem;
 
 use ark_ff::Field;
 use ark_std::log2;
-use cyclotomic_rings::rings::SuitableRing;
+use latticefold_rings::rings::SuitableRing;
 use r1cs::R1CS;
 use stark_rings::{
     balanced_decomposition::{GadgetDecompose, GadgetRecompose},
@@ -423,7 +423,7 @@ impl<R: Ring> Instance<R> for LCCCS<R> {
 #[cfg(test)]
 pub mod tests {
     use ark_ff::{One, Zero};
-    use cyclotomic_rings::rings::{
+    use latticefold_rings::rings::{
         BabyBearRingNTT, GoldilocksRingNTT, GoldilocksRingPoly, StarkRingNTT,
     };
     use stark_rings::cyclotomic_ring::models::goldilocks::{Fq, Fq3};
diff --git a/crates/latticefold/src/arith/ccs.rs b/crates/latticefold/src/arith/ccs.rs
index 989e49e2..76516968 100644
--- a/crates/latticefold/src/arith/ccs.rs
+++ b/crates/latticefold/src/arith/ccs.rs
@@ -1,7 +1,7 @@
 //! Provide test and benchmark utility for CCS
 
 use ark_std::{log2, vec::Vec};
-use cyclotomic_rings::rings::SuitableRing;
+use latticefold_rings::rings::SuitableRing;
 use stark_rings::Ring;
 use stark_rings_linalg::SparseMatrix;
 
@@ -165,7 +165,7 @@ pub(crate) fn create_dummy_cubing_sparse_matrix<R: Ring>(
 #[allow(clippy::upper_case_acronyms)]
 #[cfg(test)]
 mod tests {
-    use cyclotomic_rings::rings::GoldilocksRingNTT;
+    use latticefold_rings::rings::GoldilocksRingNTT;
 
     use super::{get_test_degree_three_ccs, get_test_dummy_degree_three_ccs_non_scalar};
     use crate::arith::{
diff --git a/crates/latticefold/src/arith/r1cs.rs b/crates/latticefold/src/arith/r1cs.rs
index 95a9fbef..828f05bb 100644
--- a/crates/latticefold/src/arith/r1cs.rs
+++ b/crates/latticefold/src/arith/r1cs.rs
@@ -1,7 +1,7 @@
 //! Defines behaviour of R1CS, a degree two constraint system
 
 use ark_std::collections::{btree_map, BTreeMap};
-use cyclotomic_rings::rings::SuitableRing;
+use latticefold_rings::rings::SuitableRing;
 use stark_rings::Ring;
 use stark_rings_linalg::{Matrix, SparseMatrix};
 
@@ -603,7 +603,7 @@ impl VariableMap {
 
 #[cfg(test)]
 mod tests {
-    use cyclotomic_rings::rings::GoldilocksRingNTT;
+    use latticefold_rings::rings::GoldilocksRingNTT;
 
     use super::*;
 
diff --git a/crates/latticefold/src/commitment/commitment_scheme.rs b/crates/latticefold/src/commitment/commitment_scheme.rs
index 5f3683a7..6806ff60 100644
--- a/crates/latticefold/src/commitment/commitment_scheme.rs
+++ b/crates/latticefold/src/commitment/commitment_scheme.rs
@@ -1,4 +1,4 @@
-use cyclotomic_rings::rings::SuitableRing;
+use latticefold_rings::rings::SuitableRing;
 use stark_rings::{
     balanced_decomposition::DecomposeToVec,
     cyclotomic_ring::{CRT, ICRT},
@@ -115,7 +115,7 @@ impl<NTT: SuitableRing> AjtaiCommitmentScheme<NTT> {
 
 #[cfg(test)]
 mod tests {
-    use cyclotomic_rings::rings::GoldilocksRingNTT;
+    use latticefold_rings::rings::GoldilocksRingNTT;
     use stark_rings::OverField;
 
     use super::{AjtaiCommitmentScheme, CommitmentError};
diff --git a/crates/latticefold/src/nifs.rs b/crates/latticefold/src/nifs.rs
index d528b561..be0e7400 100644
--- a/crates/latticefold/src/nifs.rs
+++ b/crates/latticefold/src/nifs.rs
@@ -5,7 +5,7 @@
 use ark_ff::{Field, PrimeField};
 use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
 use ark_std::{marker::PhantomData, vec::Vec};
-use cyclotomic_rings::rings::SuitableRing;
+use latticefold_rings::rings::SuitableRing;
 use stark_rings::OverField;
 
 use self::{decomposition::*, error::LatticefoldError, folding::*, linearization::*};
@@ -13,7 +13,7 @@ use crate::{
     arith::{error::CSError, Witness, CCCS, CCS, LCCCS},
     commitment::AjtaiCommitmentScheme,
     decomposition_parameters::DecompositionParams,
-    transcript::{Transcript, TranscriptWithShortChallenges},
+    transcript::{Transcript, TranscriptWithSmallChallenges},
 };
 
 pub mod decomposition;
@@ -42,7 +42,7 @@ pub struct NIFSProver<NTT, P, T> {
     _t: PhantomData<T>,
 }
 
-impl<NTT: SuitableRing, P: DecompositionParams, T: TranscriptWithShortChallenges<NTT>>
+impl<NTT: SuitableRing, P: DecompositionParams, T: TranscriptWithSmallChallenges<NTT>>
     NIFSProver<NTT, P, T>
 {
     pub fn prove(
@@ -50,7 +50,7 @@ impl<NTT: SuitableRing, P: DecompositionParams, T: TranscriptWithShortChallenges
         w_acc: &Witness<NTT>,
         cm_i: &CCCS<NTT>,
         w_i: &Witness<NTT>,
-        transcript: &mut impl TranscriptWithShortChallenges<NTT>,
+        transcript: &mut impl TranscriptWithSmallChallenges<NTT>,
         ccs: &CCS<NTT>,
         scheme: &AjtaiCommitmentScheme<NTT>,
     ) -> Result<(LCCCS<NTT>, Witness<NTT>, LFProof<NTT>), LatticefoldError<NTT>> {
@@ -111,14 +111,14 @@ pub struct NIFSVerifier<NTT, P, T> {
     _t: PhantomData<T>,
 }
 
-impl<NTT: SuitableRing, P: DecompositionParams, T: TranscriptWithShortChallenges<NTT>>
+impl<NTT: SuitableRing, P: DecompositionParams, T: TranscriptWithSmallChallenges<NTT>>
     NIFSVerifier<NTT, P, T>
 {
     pub fn verify(
         acc: &LCCCS<NTT>,
         cm_i: &CCCS<NTT>,
         proof: &LFProof<NTT>,
-        transcript: &mut impl TranscriptWithShortChallenges<NTT>,
+        transcript: &mut impl TranscriptWithSmallChallenges<NTT>,
         ccs: &CCS<NTT>,
     ) -> Result<LCCCS<NTT>, LatticefoldError<NTT>> {
         sanity_check::<NTT, P>(ccs)?;
diff --git a/crates/latticefold/src/nifs/decomposition.rs b/crates/latticefold/src/nifs/decomposition.rs
index f09c8c88..f8866a83 100644
--- a/crates/latticefold/src/nifs/decomposition.rs
+++ b/crates/latticefold/src/nifs/decomposition.rs
@@ -1,7 +1,7 @@
 #![allow(non_snake_case, clippy::upper_case_acronyms)]
 
 use ark_std::{cfg_into_iter, cfg_iter};
-use cyclotomic_rings::rings::SuitableRing;
+use latticefold_rings::rings::SuitableRing;
 #[cfg(feature = "parallel")]
 use rayon::prelude::*;
 use stark_rings::OverField;
diff --git a/crates/latticefold/src/nifs/decomposition/structs.rs b/crates/latticefold/src/nifs/decomposition/structs.rs
index e37c4834..81126eaf 100644
--- a/crates/latticefold/src/nifs/decomposition/structs.rs
+++ b/crates/latticefold/src/nifs/decomposition/structs.rs
@@ -1,7 +1,7 @@
 #![allow(non_snake_case, clippy::upper_case_acronyms)]
 use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
 use ark_std::marker::PhantomData;
-use cyclotomic_rings::rings::SuitableRing;
+use latticefold_rings::rings::SuitableRing;
 use stark_rings::{OverField, Ring};
 use stark_rings_poly::mle::DenseMultilinearExtension;
 
diff --git a/crates/latticefold/src/nifs/decomposition/tests/mod.rs b/crates/latticefold/src/nifs/decomposition/tests/mod.rs
index 8338bcb1..b132b814 100644
--- a/crates/latticefold/src/nifs/decomposition/tests/mod.rs
+++ b/crates/latticefold/src/nifs/decomposition/tests/mod.rs
@@ -1,11 +1,5 @@
 use ark_std::vec::Vec;
-use cyclotomic_rings::{
-    challenge_set::LatticefoldChallengeSet,
-    rings::{
-        BabyBearChallengeSet, BabyBearRingNTT, GoldilocksChallengeSet, GoldilocksRingNTT,
-        StarkChallengeSet, StarkRingNTT, SuitableRing,
-    },
-};
+use latticefold_rings::rings::{BabyBearRingNTT, GoldilocksRingNTT, StarkRingNTT, SuitableRing};
 use num_traits::One;
 use rand::Rng;
 #[cfg(feature = "parallel")]
@@ -34,21 +28,20 @@ use crate::{
     utils::mle_helpers::{evaluate_mles, to_mles_err},
 };
 
-fn generate_decomposition_args<RqNTT, CS, DP>(
+fn generate_decomposition_args<RqNTT, DP>(
     kappa: usize,
     n: usize,
     wit_len: usize,
 ) -> (
     LCCCS<RqNTT>,
-    PoseidonTranscript<RqNTT, CS>,
-    PoseidonTranscript<RqNTT, CS>,
+    PoseidonTranscript<RqNTT>,
+    PoseidonTranscript<RqNTT>,
     CCS<RqNTT>,
     Witness<RqNTT>,
     AjtaiCommitmentScheme<RqNTT>,
 )
 where
     RqNTT: SuitableRing,
-    CS: LatticefoldChallengeSet<RqNTT>,
     DP: DecompositionParams,
 {
     let mut rng = ark_std::test_rng();
@@ -95,25 +88,24 @@ where
 
     (
         lcccs,
-        PoseidonTranscript::<RqNTT, CS>::default(),
-        PoseidonTranscript::<RqNTT, CS>::default(),
+        PoseidonTranscript::<RqNTT>::default(),
+        PoseidonTranscript::<RqNTT>::default(),
         ccs,
         wit,
         scheme,
     )
 }
 
-fn test_decomposition<RqNTT, CS, DP>(kappa: usize, n: usize, wit_len: usize)
+fn test_decomposition<RqNTT, DP>(kappa: usize, n: usize, wit_len: usize)
 where
     RqNTT: SuitableRing,
-    CS: LatticefoldChallengeSet<RqNTT>,
     DP: DecompositionParams,
 {
     let (lcccs, mut verifier_transcript, mut prover_transcript, ccs, wit, scheme) =
-        generate_decomposition_args::<RqNTT, CS, DP>(kappa, n, wit_len);
+        generate_decomposition_args::<RqNTT, DP>(kappa, n, wit_len);
 
     let (_, _, _, decomposition_proof) =
-        LFDecompositionProver::<_, PoseidonTranscript<RqNTT, CS>>::prove::<DP>(
+        LFDecompositionProver::<_, PoseidonTranscript<RqNTT>>::prove::<DP>(
             &lcccs,
             &wit,
             &mut prover_transcript,
@@ -122,7 +114,7 @@ where
         )
         .unwrap();
 
-    let res = LFDecompositionVerifier::<_, PoseidonTranscript<RqNTT, CS>>::verify::<DP>(
+    let res = LFDecompositionVerifier::<_, PoseidonTranscript<RqNTT>>::verify::<DP>(
         &lcccs,
         &decomposition_proof,
         &mut verifier_transcript,
@@ -134,16 +126,15 @@ where
 #[test]
 fn test_decompose_witness() {
     type RqNTT = StarkRingNTT;
-    type CS = StarkChallengeSet;
     type DP = StarkDP;
     const KAPPA: usize = 4;
     const WIT_LEN: usize = 4;
     const N: usize = WIT_LEN * DP::L;
 
-    let (_, _, _, _, wit, _) = generate_decomposition_args::<RqNTT, CS, DP>(KAPPA, N, WIT_LEN);
+    let (_, _, _, _, wit, _) = generate_decomposition_args::<RqNTT, DP>(KAPPA, N, WIT_LEN);
 
     let wit_vec =
-        LFDecompositionProver::<_, PoseidonTranscript<RqNTT, CS>>::decompose_witness::<DP>(&wit);
+        LFDecompositionProver::<_, PoseidonTranscript<RqNTT>>::decompose_witness::<DP>(&wit);
 
     // Compute expected result
     let f_s = decompose_B_vec_into_k_vec::<RqNTT, DP>(&wit.f_coeff);
@@ -170,14 +161,13 @@ fn test_decompose_witness() {
 #[test]
 fn test_compute_x_s() {
     type RqNTT = BabyBearRingNTT;
-    type CS = BabyBearChallengeSet;
     type DP = BabyBearDP;
     const KAPPA: usize = 4;
     const WIT_LEN: usize = 4;
     const N: usize = WIT_LEN * DP::L;
 
-    let (lcccs, _, _, _, _, _) = generate_decomposition_args::<RqNTT, CS, DP>(KAPPA, N, WIT_LEN);
-    let x_s = LFDecompositionProver::<_, PoseidonTranscript<RqNTT, CS>>::compute_x_s::<DP>(
+    let (lcccs, _, _, _, _, _) = generate_decomposition_args::<RqNTT, DP>(KAPPA, N, WIT_LEN);
+    let x_s = LFDecompositionProver::<_, PoseidonTranscript<RqNTT>>::compute_x_s::<DP>(
         lcccs.x_w.clone(),
         lcccs.h,
     );
@@ -203,19 +193,17 @@ fn test_compute_x_s() {
 #[test]
 fn test_commit_witnesses() {
     type RqNTT = GoldilocksRingNTT;
-    type CS = GoldilocksChallengeSet;
     type DP = GoldilocksDP;
     const KAPPA: usize = 4;
     const WIT_LEN: usize = 4;
     const N: usize = WIT_LEN * DP::L;
 
-    let (cm_i, _, _, _, wit, scheme) =
-        generate_decomposition_args::<RqNTT, CS, DP>(KAPPA, N, WIT_LEN);
+    let (cm_i, _, _, _, wit, scheme) = generate_decomposition_args::<RqNTT, DP>(KAPPA, N, WIT_LEN);
 
     let wit_vec =
-        LFDecompositionProver::<_, PoseidonTranscript<RqNTT, CS>>::decompose_witness::<DP>(&wit);
+        LFDecompositionProver::<_, PoseidonTranscript<RqNTT>>::decompose_witness::<DP>(&wit);
     let y_s: Vec<Commitment<RqNTT>> =
-        LFDecompositionProver::<_, PoseidonTranscript<RqNTT, CS>>::commit_witnesses::<DP>(
+        LFDecompositionProver::<_, PoseidonTranscript<RqNTT>>::commit_witnesses::<DP>(
             &wit_vec, &scheme, &cm_i,
         )
         .unwrap();
@@ -238,17 +226,16 @@ fn test_commit_witnesses() {
 #[test]
 fn test_compute_v_s() {
     type RqNTT = BabyBearRingNTT;
-    type CS = BabyBearChallengeSet;
     type DP = BabyBearDP;
     const KAPPA: usize = 4;
     const WIT_LEN: usize = 4;
     const N: usize = WIT_LEN * DP::L;
 
-    let (lcccs, _, _, _, wit, _) = generate_decomposition_args::<RqNTT, CS, DP>(KAPPA, N, WIT_LEN);
+    let (lcccs, _, _, _, wit, _) = generate_decomposition_args::<RqNTT, DP>(KAPPA, N, WIT_LEN);
     let wit_vec =
-        LFDecompositionProver::<_, PoseidonTranscript<RqNTT, CS>>::decompose_witness::<DP>(&wit);
+        LFDecompositionProver::<_, PoseidonTranscript<RqNTT>>::decompose_witness::<DP>(&wit);
     let v_s =
-        LFDecompositionProver::<_, PoseidonTranscript<RqNTT, CS>>::compute_v_s(&wit_vec, &lcccs.r)
+        LFDecompositionProver::<_, PoseidonTranscript<RqNTT>>::compute_v_s(&wit_vec, &lcccs.r)
             .unwrap();
 
     // Compute expected result
@@ -268,27 +255,25 @@ fn test_compute_v_s() {
 #[test]
 fn test_compute_u_s() {
     type RqNTT = GoldilocksRingNTT;
-    type CS = GoldilocksChallengeSet;
     type DP = GoldilocksDP;
     const KAPPA: usize = 4;
     const WIT_LEN: usize = 4;
     const N: usize = WIT_LEN * DP::L;
 
-    let (lcccs, _, _, ccs, wit, _) =
-        generate_decomposition_args::<RqNTT, CS, DP>(KAPPA, N, WIT_LEN);
+    let (lcccs, _, _, ccs, wit, _) = generate_decomposition_args::<RqNTT, DP>(KAPPA, N, WIT_LEN);
     let wit_vec =
-        LFDecompositionProver::<_, PoseidonTranscript<RqNTT, CS>>::decompose_witness::<DP>(&wit);
-    let x_s = LFDecompositionProver::<_, PoseidonTranscript<RqNTT, CS>>::compute_x_s::<DP>(
+        LFDecompositionProver::<_, PoseidonTranscript<RqNTT>>::decompose_witness::<DP>(&wit);
+    let x_s = LFDecompositionProver::<_, PoseidonTranscript<RqNTT>>::compute_x_s::<DP>(
         lcccs.x_w.clone(),
         lcccs.h,
     );
-    let mz_mles = LFDecompositionProver::<_, PoseidonTranscript<RqNTT, CS>>::compute_mz_mles(
+    let mz_mles = LFDecompositionProver::<_, PoseidonTranscript<RqNTT>>::compute_mz_mles(
         &wit_vec, &ccs.M, &x_s, ccs.s,
     )
     .unwrap();
 
     let u_s =
-        LFDecompositionProver::<_, PoseidonTranscript<RqNTT, CS>>::compute_u_s(&mz_mles, &lcccs.r)
+        LFDecompositionProver::<_, PoseidonTranscript<RqNTT>>::compute_u_s(&mz_mles, &lcccs.r)
             .unwrap();
 
     // Compute expected result
@@ -328,28 +313,26 @@ fn test_compute_u_s() {
 #[test]
 fn test_test_decomposition() {
     type RqNTT = StarkRingNTT;
-    type CS = StarkChallengeSet;
     type DP = StarkDP;
     const WIT_LEN: usize = 4;
     const KAPPA: usize = 4;
     const N: usize = WIT_LEN * DP::L;
 
-    test_decomposition::<RqNTT, CS, DP>(KAPPA, N, WIT_LEN);
+    test_decomposition::<RqNTT, DP>(KAPPA, N, WIT_LEN);
 }
 
 #[test]
 fn test_recompose_commitment() {
-    type CS = GoldilocksChallengeSet;
     type RqNTT = GoldilocksRingNTT;
     type DP = GoldilocksDP;
-    type T = PoseidonTranscript<RqNTT, CS>;
+    type T = PoseidonTranscript<RqNTT>;
     type Verifier = LFDecompositionVerifier<RqNTT, T>;
     const WIT_LEN: usize = 4;
     const N: usize = WIT_LEN * DP::L;
     const KAPPA: usize = 4;
 
     let (lcccs, _, mut prover_transcript, ccs, wit, scheme) =
-        generate_decomposition_args::<RqNTT, CS, DP>(KAPPA, N, WIT_LEN);
+        generate_decomposition_args::<RqNTT, DP>(KAPPA, N, WIT_LEN);
 
     let (_, _, _, proof) = LFDecompositionProver::<_, T>::prove::<DP>(
         &lcccs,
@@ -370,17 +353,16 @@ fn test_recompose_commitment() {
 
 #[test]
 fn test_recompose_u() {
-    type CS = StarkChallengeSet;
     type RqNTT = StarkRingNTT;
     type DP = StarkDP;
-    type T = PoseidonTranscript<RqNTT, CS>;
+    type T = PoseidonTranscript<RqNTT>;
     type Verifier = LFDecompositionVerifier<RqNTT, T>;
     const WIT_LEN: usize = 4;
     const N: usize = WIT_LEN * DP::L;
     const KAPPA: usize = 4;
 
     let (lcccs, _, mut prover_transcript, ccs, wit, scheme) =
-        generate_decomposition_args::<RqNTT, CS, DP>(KAPPA, N, WIT_LEN);
+        generate_decomposition_args::<RqNTT, DP>(KAPPA, N, WIT_LEN);
     let (_, _, _, proof) = LFDecompositionProver::<_, T>::prove::<DP>(
         &lcccs,
         &wit,
@@ -399,17 +381,16 @@ fn test_recompose_u() {
 
 #[test]
 fn test_recompose_v() {
-    type CS = BabyBearChallengeSet;
     type RqNTT = BabyBearRingNTT;
     type DP = BabyBearDP;
-    type T = PoseidonTranscript<RqNTT, CS>;
+    type T = PoseidonTranscript<RqNTT>;
     type Verifier = LFDecompositionVerifier<RqNTT, T>;
     const WIT_LEN: usize = 4;
     const N: usize = WIT_LEN * DP::L;
     const KAPPA: usize = 4;
 
     let (lcccs, _, mut prover_transcript, ccs, wit, scheme) =
-        generate_decomposition_args::<RqNTT, CS, DP>(KAPPA, N, WIT_LEN);
+        generate_decomposition_args::<RqNTT, DP>(KAPPA, N, WIT_LEN);
 
     let (_, _, _, proof) = LFDecompositionProver::<_, T>::prove::<DP>(
         &lcccs,
@@ -429,17 +410,16 @@ fn test_recompose_v() {
 
 #[test]
 fn test_recompose_xw_and_h() {
-    type CS = GoldilocksChallengeSet;
     type RqNTT = GoldilocksRingNTT;
     type DP = GoldilocksDP;
-    type T = PoseidonTranscript<RqNTT, CS>;
+    type T = PoseidonTranscript<RqNTT>;
     type Verifier = LFDecompositionVerifier<RqNTT, T>;
     const WIT_LEN: usize = 4;
     const N: usize = WIT_LEN * DP::L;
     const KAPPA: usize = 4;
 
     let (lcccs, _, mut prover_transcript, ccs, wit, scheme) =
-        generate_decomposition_args::<RqNTT, CS, DP>(KAPPA, N, WIT_LEN);
+        generate_decomposition_args::<RqNTT, DP>(KAPPA, N, WIT_LEN);
 
     let (_, _, _, proof) = LFDecompositionProver::<_, T>::prove::<DP>(
         &lcccs,
@@ -461,17 +441,16 @@ fn test_recompose_xw_and_h() {
 
 #[test]
 fn test_verify_full() {
-    type CS = StarkChallengeSet;
     type RqNTT = StarkRingNTT;
     type DP = StarkDP;
-    type T = PoseidonTranscript<RqNTT, CS>;
+    type T = PoseidonTranscript<RqNTT>;
     type Verifier = LFDecompositionVerifier<RqNTT, T>;
     const WIT_LEN: usize = 4;
     const N: usize = WIT_LEN * DP::L;
     const KAPPA: usize = 4;
 
     let (lcccs, mut verifier_transcript, mut prover_transcript, ccs, wit, scheme) =
-        generate_decomposition_args::<RqNTT, CS, DP>(KAPPA, N, WIT_LEN);
+        generate_decomposition_args::<RqNTT, DP>(KAPPA, N, WIT_LEN);
 
     let (_, _, _, proof) = LFDecompositionProver::<_, T>::prove::<DP>(
         &lcccs,
@@ -488,17 +467,16 @@ fn test_verify_full() {
 
 #[test]
 fn test_verify_invalid_proof() {
-    type CS = GoldilocksChallengeSet;
     type RqNTT = GoldilocksRingNTT;
     type DP = GoldilocksDP;
-    type T = PoseidonTranscript<RqNTT, CS>;
+    type T = PoseidonTranscript<RqNTT>;
     type Verifier = LFDecompositionVerifier<RqNTT, T>;
     const WIT_LEN: usize = 4;
     const N: usize = WIT_LEN * DP::L;
     const KAPPA: usize = 4;
 
     let (lcccs, mut verifier_transcript, mut prover_transcript, ccs, wit, scheme) =
-        generate_decomposition_args::<RqNTT, CS, DP>(KAPPA, N, WIT_LEN);
+        generate_decomposition_args::<RqNTT, DP>(KAPPA, N, WIT_LEN);
 
     let (_, _, _, mut proof) = LFDecompositionProver::<_, T>::prove::<DP>(
         &lcccs,
diff --git a/crates/latticefold/src/nifs/decomposition/utils.rs b/crates/latticefold/src/nifs/decomposition/utils.rs
index 8a204136..49da4674 100644
--- a/crates/latticefold/src/nifs/decomposition/utils.rs
+++ b/crates/latticefold/src/nifs/decomposition/utils.rs
@@ -1,4 +1,4 @@
-use cyclotomic_rings::rings::SuitableRing;
+use latticefold_rings::rings::SuitableRing;
 use stark_rings::{
     balanced_decomposition::{recompose, DecomposeToVec, GadgetDecompose},
     cyclotomic_ring::{CRT, ICRT},
@@ -50,7 +50,7 @@ pub(super) fn decompose_B_vec_into_k_vec<NTT: SuitableRing, DP: DecompositionPar
 
 #[cfg(test)]
 mod tests {
-    use cyclotomic_rings::rings::SuitableRing;
+    use latticefold_rings::rings::SuitableRing;
     use rand::Rng;
     use stark_rings::{
         balanced_decomposition::{recompose, Decompose},
diff --git a/crates/latticefold/src/nifs/folding.rs b/crates/latticefold/src/nifs/folding.rs
index 8cdc27fd..e110c095 100644
--- a/crates/latticefold/src/nifs/folding.rs
+++ b/crates/latticefold/src/nifs/folding.rs
@@ -7,7 +7,7 @@
 
 use ark_ff::Zero;
 use ark_std::{cfg_iter, iter::successors, iterable::Iterable};
-use cyclotomic_rings::rings::SuitableRing;
+use latticefold_rings::rings::SuitableRing;
 #[cfg(feature = "parallel")]
 use rayon::prelude::*;
 use stark_rings_poly::mle::DenseMultilinearExtension;
@@ -19,7 +19,7 @@ use crate::{
     ark_base::*,
     commitment::Commitment,
     decomposition_parameters::DecompositionParams,
-    transcript::TranscriptWithShortChallenges,
+    transcript::TranscriptWithSmallChallenges,
     utils::{
         mle_helpers::evaluate_mles,
         sumcheck::{
@@ -36,13 +36,13 @@ pub use structs::*;
 
 mod structs;
 
-impl<NTT: SuitableRing, T: TranscriptWithShortChallenges<NTT>> FoldingProver<NTT, T>
+impl<NTT: SuitableRing, T: TranscriptWithSmallChallenges<NTT>> FoldingProver<NTT, T>
     for LFFoldingProver<NTT, T>
 {
     fn prove<P: DecompositionParams>(
         cm_i_s: &[LCCCS<NTT>],
         mut w_s: Vec<Witness<NTT>>,
-        transcript: &mut impl TranscriptWithShortChallenges<NTT>,
+        transcript: &mut impl TranscriptWithSmallChallenges<NTT>,
         ccs: &CCS<NTT>,
         mz_mles: &[Vec<DenseMultilinearExtension<NTT>>],
     ) -> Result<(LCCCS<NTT>, Witness<NTT>, FoldingProof<NTT>), FoldingError<NTT>> {
@@ -130,13 +130,13 @@ impl<NTT: SuitableRing, T: TranscriptWithShortChallenges<NTT>> FoldingProver<NTT
     }
 }
 
-impl<NTT: SuitableRing, T: TranscriptWithShortChallenges<NTT>> FoldingVerifier<NTT, T>
+impl<NTT: SuitableRing, T: TranscriptWithSmallChallenges<NTT>> FoldingVerifier<NTT, T>
     for LFFoldingVerifier<NTT, T>
 {
     fn verify<P: DecompositionParams>(
         cm_i_s: &[LCCCS<NTT>],
         proof: &FoldingProof<NTT>,
-        transcript: &mut impl TranscriptWithShortChallenges<NTT>,
+        transcript: &mut impl TranscriptWithSmallChallenges<NTT>,
         ccs: &CCS<NTT>,
     ) -> Result<LCCCS<NTT>, FoldingError<NTT>> {
         sanity_check::<NTT, P>(ccs)?;
@@ -194,7 +194,7 @@ impl<NTT: SuitableRing, T: TranscriptWithShortChallenges<NTT>> FoldingVerifier<N
     }
 }
 
-impl<NTT: SuitableRing, T: TranscriptWithShortChallenges<NTT>> LFFoldingProver<NTT, T> {
+impl<NTT: SuitableRing, T: TranscriptWithSmallChallenges<NTT>> LFFoldingProver<NTT, T> {
     fn setup_f_hat_mles(w_s: &mut [Witness<NTT>]) -> Vec<Vec<DenseMultilinearExtension<NTT>>> {
         cfg_iter_mut!(w_s)
             .map(|w| w.take_f_hat())
@@ -268,7 +268,7 @@ impl<NTT: SuitableRing, T: TranscriptWithShortChallenges<NTT>> LFFoldingProver<N
     }
 }
 
-impl<NTT: SuitableRing, T: TranscriptWithShortChallenges<NTT>> LFFoldingVerifier<NTT, T> {
+impl<NTT: SuitableRing, T: TranscriptWithSmallChallenges<NTT>> LFFoldingVerifier<NTT, T> {
     #[allow(clippy::too_many_arguments)]
     fn verify_evaluation<P: DecompositionParams>(
         alpha_s: &[NTT],
@@ -343,7 +343,7 @@ impl<NTT: SuitableRing, T: TranscriptWithShortChallenges<NTT>> LFFoldingVerifier
     }
 
     fn verify_sumcheck_proof(
-        transcript: &mut impl TranscriptWithShortChallenges<NTT>,
+        transcript: &mut impl TranscriptWithSmallChallenges<NTT>,
         nvars: usize,
         degree: usize,
         total_claim: NTT,
diff --git a/crates/latticefold/src/nifs/folding/structs.rs b/crates/latticefold/src/nifs/folding/structs.rs
index f1b018aa..de60c655 100644
--- a/crates/latticefold/src/nifs/folding/structs.rs
+++ b/crates/latticefold/src/nifs/folding/structs.rs
@@ -1,6 +1,6 @@
 use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
 use ark_std::marker::PhantomData;
-use cyclotomic_rings::rings::SuitableRing;
+use latticefold_rings::rings::SuitableRing;
 use stark_rings::OverField;
 use stark_rings_poly::mle::DenseMultilinearExtension;
 
@@ -9,7 +9,7 @@ use crate::{
     ark_base::Vec,
     decomposition_parameters::DecompositionParams,
     nifs::error::FoldingError,
-    transcript::TranscriptWithShortChallenges,
+    transcript::TranscriptWithSmallChallenges,
     utils::sumcheck,
 };
 
@@ -40,7 +40,7 @@ pub struct FoldingProof<NTT: OverField> {
 }
 
 /// Prover for the folding subprotocol
-pub trait FoldingProver<NTT: SuitableRing, T: TranscriptWithShortChallenges<NTT>> {
+pub trait FoldingProver<NTT: SuitableRing, T: TranscriptWithSmallChallenges<NTT>> {
     /// Generates a folded witness and its linearized commitment, along with proof to the correctness of the folding.
     ///
     /// # Arguments
@@ -63,14 +63,14 @@ pub trait FoldingProver<NTT: SuitableRing, T: TranscriptWithShortChallenges<NTT>
     fn prove<P: DecompositionParams>(
         cm_i_s: &[LCCCS<NTT>],
         w_s: Vec<Witness<NTT>>,
-        transcript: &mut impl TranscriptWithShortChallenges<NTT>,
+        transcript: &mut impl TranscriptWithSmallChallenges<NTT>,
         ccs: &CCS<NTT>,
         mz_mles: &[Vec<DenseMultilinearExtension<NTT>>],
     ) -> Result<(LCCCS<NTT>, Witness<NTT>, FoldingProof<NTT>), FoldingError<NTT>>;
 }
 
 /// Verifier for folding subprotocol
-pub trait FoldingVerifier<NTT: SuitableRing, T: TranscriptWithShortChallenges<NTT>> {
+pub trait FoldingVerifier<NTT: SuitableRing, T: TranscriptWithSmallChallenges<NTT>> {
     /// Verifies a proof for the folding subprotocol.
     ///
     /// # Arguments
@@ -88,7 +88,7 @@ pub trait FoldingVerifier<NTT: SuitableRing, T: TranscriptWithShortChallenges<NT
     fn verify<P: DecompositionParams>(
         cm_i_s: &[LCCCS<NTT>],
         proof: &FoldingProof<NTT>,
-        transcript: &mut impl TranscriptWithShortChallenges<NTT>,
+        transcript: &mut impl TranscriptWithSmallChallenges<NTT>,
         ccs: &CCS<NTT>,
     ) -> Result<LCCCS<NTT>, FoldingError<NTT>>;
 }
diff --git a/crates/latticefold/src/nifs/folding/tests/mod.rs b/crates/latticefold/src/nifs/folding/tests/mod.rs
index 515d07ba..52460a70 100644
--- a/crates/latticefold/src/nifs/folding/tests/mod.rs
+++ b/crates/latticefold/src/nifs/folding/tests/mod.rs
@@ -1,13 +1,7 @@
 use ark_ff::{Field, PrimeField};
 use ark_serialize::{CanonicalDeserialize, CanonicalSerialize, Compress, Validate};
 use ark_std::{io::Cursor, test_rng};
-use cyclotomic_rings::{
-    challenge_set::LatticefoldChallengeSet,
-    rings::{
-        BabyBearChallengeSet, BabyBearRingNTT, FrogChallengeSet, GoldilocksChallengeSet,
-        StarkChallengeSet, SuitableRing,
-    },
-};
+use latticefold_rings::rings::{BabyBearRingNTT, SuitableRing};
 use num_traits::{One, Zero};
 use stark_rings::{
     cyclotomic_ring::{
@@ -51,27 +45,26 @@ use crate::{
         },
         FoldingProof,
     },
-    transcript::{poseidon::PoseidonTranscript, Transcript, TranscriptWithShortChallenges},
+    transcript::{poseidon::PoseidonTranscript, Transcript, TranscriptWithSmallChallenges},
     utils::sumcheck::MLSumcheck,
 };
 
 const KAPPA: usize = 4;
 const WIT_LEN: usize = 3;
 
-fn setup_test_environment<RqNTT, CS, DP>(
+fn setup_test_environment<RqNTT, DP>(
     n: usize,
     generate_proof: bool,
 ) -> (
     Vec<LCCCS<RqNTT>>,
     Vec<Witness<RqNTT>>,
-    PoseidonTranscript<RqNTT, CS>,
+    PoseidonTranscript<RqNTT>,
     CCS<RqNTT>,
     Option<FoldingProof<RqNTT>>,
     Vec<Vec<DenseMultilinearExtension<RqNTT>>>,
 )
 where
     RqNTT: SuitableRing,
-    CS: LatticefoldChallengeSet<RqNTT>,
     DP: DecompositionParams,
 {
     let ccs = get_test_degree_three_ccs_padded::<RqNTT>(n, DP::L);
@@ -86,19 +79,18 @@ where
         cm: wit.commit::<DP>(&scheme).unwrap(),
         x_ccs,
     };
-    let mut prover_transcript = PoseidonTranscript::<RqNTT, CS>::default();
-    let mut verifier_transcript = PoseidonTranscript::<RqNTT, CS>::default();
+    let mut prover_transcript = PoseidonTranscript::<RqNTT>::default();
+    let mut verifier_transcript = PoseidonTranscript::<RqNTT>::default();
 
-    let (_, linearization_proof) =
-        LFLinearizationProver::<_, PoseidonTranscript<RqNTT, CS>>::prove(
-            &cm_i,
-            &wit,
-            &mut prover_transcript,
-            &ccs,
-        )
-        .unwrap();
+    let (_, linearization_proof) = LFLinearizationProver::<_, PoseidonTranscript<RqNTT>>::prove(
+        &cm_i,
+        &wit,
+        &mut prover_transcript,
+        &ccs,
+    )
+    .unwrap();
 
-    let lcccs = LFLinearizationVerifier::<_, PoseidonTranscript<RqNTT, CS>>::verify(
+    let lcccs = LFLinearizationVerifier::<_, PoseidonTranscript<RqNTT>>::verify(
         &cm_i,
         &linearization_proof,
         &mut verifier_transcript,
@@ -107,7 +99,7 @@ where
     .unwrap();
 
     let (mz_mles, _, wit_vec, decomposition_proof) =
-        LFDecompositionProver::<_, PoseidonTranscript<RqNTT, CS>>::prove::<DP>(
+        LFDecompositionProver::<_, PoseidonTranscript<RqNTT>>::prove::<DP>(
             &lcccs,
             &wit,
             &mut prover_transcript,
@@ -116,7 +108,7 @@ where
         )
         .unwrap();
 
-    let lcccs_vec = LFDecompositionVerifier::<_, PoseidonTranscript<RqNTT, CS>>::verify::<DP>(
+    let lcccs_vec = LFDecompositionVerifier::<_, PoseidonTranscript<RqNTT>>::verify::<DP>(
         &lcccs,
         &decomposition_proof,
         &mut verifier_transcript,
@@ -140,7 +132,7 @@ where
     };
 
     let folding_proof = if generate_proof {
-        Some(generate_folding_proof::<_, _, DP>(
+        Some(generate_folding_proof::<_, DP>(
             &ccs,
             &mut prover_transcript,
             &lcccs,
@@ -161,41 +153,37 @@ where
     )
 }
 
-fn generate_folding_proof<RqNTT, CS, DP>(
+fn generate_folding_proof<RqNTT, DP>(
     ccs: &CCS<RqNTT>,
-    prover_transcript: &mut PoseidonTranscript<RqNTT, CS>,
+    prover_transcript: &mut PoseidonTranscript<RqNTT>,
     lcccs: &[LCCCS<RqNTT>],
     wit_s: Vec<Witness<RqNTT>>,
     mz_mles: Vec<Vec<DenseMultilinearExtension<RqNTT>>>,
 ) -> FoldingProof<RqNTT>
 where
     RqNTT: SuitableRing,
-    CS: LatticefoldChallengeSet<RqNTT>,
     DP: DecompositionParams,
 {
-    let (_, _, folding_proof) =
-        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::prove::<DP>(
-            lcccs,
-            wit_s,
-            prover_transcript,
-            ccs,
-            &mz_mles,
-        )
-        .unwrap();
+    let (_, _, folding_proof) = LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT>>::prove::<DP>(
+        lcccs,
+        wit_s,
+        prover_transcript,
+        ccs,
+        &mz_mles,
+    )
+    .unwrap();
     folding_proof
 }
 
 #[test]
 fn test_setup_f_hat_mles() {
     type RqNTT = StarkRqNTT;
-    type CS = StarkChallengeSet;
     type DP = StarkFoldingDP;
     let n = WIT_LEN * DP::L;
 
-    let (_, wit_s, _, _, _, _) = setup_test_environment::<RqNTT, CS, DP>(n, false);
-    let f_hat_mles = LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::setup_f_hat_mles(
-        &mut wit_s.clone(),
-    );
+    let (_, wit_s, _, _, _, _) = setup_test_environment::<RqNTT, DP>(n, false);
+    let f_hat_mles =
+        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT>>::setup_f_hat_mles(&mut wit_s.clone());
 
     let expected_f_hat = wit_s
         .iter()
@@ -221,13 +209,12 @@ fn test_setup_f_hat_mles() {
 #[test]
 fn test_get_ris() {
     type RqNTT = BabyBearRingNTT;
-    type CS = BabyBearChallengeSet;
     type DP = BabyBearDP;
     let n = WIT_LEN * DP::L;
 
-    let (lccs, wit_s, _, _, _, _) = setup_test_environment::<RqNTT, CS, DP>(n, false);
+    let (lccs, wit_s, _, _, _, _) = setup_test_environment::<RqNTT, DP>(n, false);
 
-    let ris = LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::get_ris(&lccs);
+    let ris = LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT>>::get_ris(&lccs);
 
     // Compute expected output
     let expected_ris = lccs.iter().map(|cm_i| cm_i.r.clone()).collect::<Vec<_>>();
@@ -244,27 +231,26 @@ fn test_get_ris() {
 #[test]
 fn test_get_sumcheck_randomness() {
     type RqNTT = BabyBearRingNTT;
-    type CS = BabyBearChallengeSet;
     type DP = BabyBearDP;
 
     let n = WIT_LEN * DP::L;
 
     let (lccs, mut wit_s, mut transcript, ccs, _, mz_mles) =
-        setup_test_environment::<RqNTT, CS, DP>(n, false);
+        setup_test_environment::<RqNTT, DP>(n, false);
     let (alpha_s, beta_s, zeta_s, mu_s) = transcript.squeeze_alpha_beta_zeta_mu::<DP>(ccs.s);
     let f_hat_mles =
-        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::setup_f_hat_mles(&mut wit_s);
+        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT>>::setup_f_hat_mles(&mut wit_s);
 
-    let ris = LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::get_ris(&lccs);
+    let ris = LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT>>::get_ris(&lccs);
 
     let prechallenged_Ms_1 =
-        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::calculate_challenged_mz_mle(
+        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT>>::calculate_challenged_mz_mle(
             &mz_mles[0..DP::K],
             &zeta_s[0..DP::K],
         )
         .unwrap();
     let prechallenged_Ms_2 =
-        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::calculate_challenged_mz_mle(
+        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT>>::calculate_challenged_mz_mle(
             &mz_mles[DP::K..2 * DP::K],
             &zeta_s[DP::K..2 * DP::K],
         )
@@ -288,9 +274,8 @@ fn test_get_sumcheck_randomness() {
     let (_, prover_state) =
         MLSumcheck::prove_as_subprotocol(&mut transcript, g_mles, ccs.s, g_degree, comb_fn);
     // Derive randomness
-    let r_0 = LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::get_sumcheck_randomness(
-        prover_state,
-    );
+    let r_0 =
+        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT>>::get_sumcheck_randomness(prover_state);
 
     // Validate - Check dimensions
     assert_eq!(r_0.len(), ccs.s, "Randomness r_0 has the wrong length");
@@ -299,27 +284,26 @@ fn test_get_sumcheck_randomness() {
 #[test]
 fn test_get_thetas() {
     type RqNTT = StarkRqNTT;
-    type CS = StarkChallengeSet;
     type DP = StarkFoldingDP;
 
     let n = WIT_LEN * DP::L;
 
     let (lccs, mut wit_s, mut transcript, ccs, _, mz_mles) =
-        setup_test_environment::<RqNTT, CS, DP>(n, false);
+        setup_test_environment::<RqNTT, DP>(n, false);
     let (alpha_s, beta_s, zeta_s, mu_s) = transcript.squeeze_alpha_beta_zeta_mu::<DP>(ccs.s);
     let f_hat_mles =
-        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::setup_f_hat_mles(&mut wit_s);
+        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT>>::setup_f_hat_mles(&mut wit_s);
 
-    let ris = LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::get_ris(&lccs);
+    let ris = LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT>>::get_ris(&lccs);
 
     let prechallenged_Ms_1 =
-        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::calculate_challenged_mz_mle(
+        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT>>::calculate_challenged_mz_mle(
             &mz_mles[0..DP::K],
             &zeta_s[0..DP::K],
         )
         .unwrap();
     let prechallenged_Ms_2 =
-        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::calculate_challenged_mz_mle(
+        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT>>::calculate_challenged_mz_mle(
             &mz_mles[DP::K..2 * DP::K],
             &zeta_s[DP::K..2 * DP::K],
         )
@@ -341,13 +325,11 @@ fn test_get_thetas() {
 
     let (_, prover_state) =
         MLSumcheck::prove_as_subprotocol(&mut transcript, g_mles, ccs.s, g_degree, comb_fn);
-    let r_0 = LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::get_sumcheck_randomness(
-        prover_state,
-    );
+    let r_0 =
+        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT>>::get_sumcheck_randomness(prover_state);
 
     let theta_s =
-        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::get_thetas(&f_hat_mles, &r_0)
-            .unwrap();
+        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT>>::get_thetas(&f_hat_mles, &r_0).unwrap();
 
     let expected_thetas: Vec<Vec<RqNTT>> = f_hat_mles
         .iter()
@@ -371,27 +353,26 @@ fn test_get_thetas() {
 #[test]
 fn test_get_etas() {
     type RqNTT = StarkRqNTT;
-    type CS = StarkChallengeSet;
     type DP = StarkFoldingDP;
 
     let n = WIT_LEN * DP::L;
 
     let (lccs, mut wit_s, mut transcript, ccs, _, mz_mles) =
-        setup_test_environment::<RqNTT, CS, DP>(n, false);
+        setup_test_environment::<RqNTT, DP>(n, false);
     let (alpha_s, beta_s, zeta_s, mu_s) = transcript.squeeze_alpha_beta_zeta_mu::<DP>(ccs.s);
     let f_hat_mles =
-        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::setup_f_hat_mles(&mut wit_s);
+        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT>>::setup_f_hat_mles(&mut wit_s);
 
-    let ris = LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::get_ris(&lccs);
+    let ris = LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT>>::get_ris(&lccs);
 
     let prechallenged_Ms_1 =
-        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::calculate_challenged_mz_mle(
+        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT>>::calculate_challenged_mz_mle(
             &mz_mles[0..DP::K],
             &zeta_s[0..DP::K],
         )
         .unwrap();
     let prechallenged_Ms_2 =
-        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::calculate_challenged_mz_mle(
+        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT>>::calculate_challenged_mz_mle(
             &mz_mles[DP::K..2 * DP::K],
             &zeta_s[DP::K..2 * DP::K],
         )
@@ -413,12 +394,11 @@ fn test_get_etas() {
 
     let (_, prover_state) =
         MLSumcheck::prove_as_subprotocol(&mut transcript, g_mles, ccs.s, g_degree, comb_fn);
-    let r_0 = LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::get_sumcheck_randomness(
-        prover_state,
-    );
+    let r_0 =
+        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT>>::get_sumcheck_randomness(prover_state);
 
     let eta_s =
-        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::get_etas(&mz_mles, &r_0).unwrap();
+        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT>>::get_etas(&mz_mles, &r_0).unwrap();
 
     let expected_eta_s: Vec<Vec<RqNTT>> = mz_mles
         .iter()
@@ -442,12 +422,11 @@ fn test_get_etas() {
 #[test]
 fn test_get_rhos() {
     type RqNTT = BabyBearRingNTT;
-    type CS = BabyBearChallengeSet;
     type DP = BabyBearDP;
 
     let n = WIT_LEN * DP::L;
 
-    let (_, _, mut transcript, _, _, _) = setup_test_environment::<RqNTT, CS, DP>(n, false);
+    let (_, _, mut transcript, _, _, _) = setup_test_environment::<RqNTT, DP>(n, false);
     let mut transcript_clone = transcript.clone();
 
     let (rho_s_coeff, rho_s) = get_rhos::<_, _, DP>(&mut transcript);
@@ -471,27 +450,26 @@ fn test_get_rhos() {
 #[test]
 fn test_prepare_public_output() {
     type RqNTT = StarkRqNTT;
-    type CS = StarkChallengeSet;
     type DP = StarkFoldingDP;
 
     let n = WIT_LEN * DP::L;
 
     let (lccs, mut wit_s, mut transcript, ccs, _, mz_mles) =
-        setup_test_environment::<RqNTT, CS, DP>(n, false);
+        setup_test_environment::<RqNTT, DP>(n, false);
     let (alpha_s, beta_s, zeta_s, mu_s) = transcript.squeeze_alpha_beta_zeta_mu::<DP>(ccs.s);
     let f_hat_mles =
-        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::setup_f_hat_mles(&mut wit_s);
+        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT>>::setup_f_hat_mles(&mut wit_s);
 
-    let ris = LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::get_ris(&lccs);
+    let ris = LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT>>::get_ris(&lccs);
 
     let prechallenged_Ms_1 =
-        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::calculate_challenged_mz_mle(
+        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT>>::calculate_challenged_mz_mle(
             &mz_mles[0..DP::K],
             &zeta_s[0..DP::K],
         )
         .unwrap();
     let prechallenged_Ms_2 =
-        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::calculate_challenged_mz_mle(
+        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT>>::calculate_challenged_mz_mle(
             &mz_mles[DP::K..2 * DP::K],
             &zeta_s[DP::K..2 * DP::K],
         )
@@ -513,15 +491,13 @@ fn test_prepare_public_output() {
 
     let (_, prover_state) =
         MLSumcheck::prove_as_subprotocol(&mut transcript, g_mles, ccs.s, g_degree, comb_fn);
-    let r_0 = LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::get_sumcheck_randomness(
-        prover_state,
-    );
+    let r_0 =
+        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT>>::get_sumcheck_randomness(prover_state);
     let theta_s =
-        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::get_thetas(&f_hat_mles, &r_0)
-            .unwrap();
+        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT>>::get_thetas(&f_hat_mles, &r_0).unwrap();
 
     let eta_s =
-        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::get_etas(&mz_mles, &r_0).unwrap();
+        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT>>::get_etas(&mz_mles, &r_0).unwrap();
 
     theta_s
         .iter()
@@ -554,26 +530,25 @@ fn test_prepare_public_output() {
 #[test]
 fn test_compute_f_0() {
     type RqNTT = StarkRqNTT;
-    type CS = StarkChallengeSet;
     type DP = StarkFoldingDP;
 
     let n = WIT_LEN * DP::L;
 
     let (lccs, mut wit_s, mut transcript, ccs, _, Mz_mles) =
-        setup_test_environment::<RqNTT, CS, DP>(n, false);
+        setup_test_environment::<RqNTT, DP>(n, false);
     let (alpha_s, beta_s, zeta_s, mu_s) = transcript.squeeze_alpha_beta_zeta_mu::<DP>(ccs.s);
     let f_hat_mles =
-        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::setup_f_hat_mles(&mut wit_s);
+        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT>>::setup_f_hat_mles(&mut wit_s);
 
-    let ris = LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::get_ris(&lccs);
+    let ris = LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT>>::get_ris(&lccs);
     let prechallenged_Ms_1 =
-        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::calculate_challenged_mz_mle(
+        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT>>::calculate_challenged_mz_mle(
             &Mz_mles[0..DP::K],
             &zeta_s[0..DP::K],
         )
         .unwrap();
     let prechallenged_Ms_2 =
-        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::calculate_challenged_mz_mle(
+        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT>>::calculate_challenged_mz_mle(
             &Mz_mles[DP::K..2 * DP::K],
             &zeta_s[DP::K..2 * DP::K],
         )
@@ -595,15 +570,13 @@ fn test_compute_f_0() {
 
     let (_, prover_state) =
         MLSumcheck::prove_as_subprotocol(&mut transcript, g_mles, ccs.s, g_degree, comb_fn);
-    let r_0 = LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::get_sumcheck_randomness(
-        prover_state,
-    );
+    let r_0 =
+        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT>>::get_sumcheck_randomness(prover_state);
     let theta_s =
-        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::get_thetas(&f_hat_mles, &r_0)
-            .unwrap();
+        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT>>::get_thetas(&f_hat_mles, &r_0).unwrap();
 
     let eta_s =
-        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::get_etas(&Mz_mles, &r_0).unwrap();
+        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT>>::get_etas(&Mz_mles, &r_0).unwrap();
     theta_s
         .iter()
         .for_each(|thetas| transcript.absorb_slice(thetas));
@@ -612,7 +585,7 @@ fn test_compute_f_0() {
     let (_, rho_s) = get_rhos::<_, _, DP>(&mut transcript);
 
     let f_0: Vec<RqNTT> =
-        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::compute_f_0(&rho_s, &wit_s);
+        LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT>>::compute_f_0(&rho_s, &wit_s);
 
     let expected_f_0 =
         rho_s
@@ -637,13 +610,12 @@ fn test_compute_f_0() {
 #[test]
 fn test_full_prove() {
     type RqNTT = StarkRqNTT;
-    type CS = StarkChallengeSet;
     type DP = StarkFoldingDP;
     let n = WIT_LEN * DP::L;
 
     let (lccs, wit_s, mut transcript, ccs, _, mz_mles) =
-        setup_test_environment::<RqNTT, CS, DP>(n, false);
-    let _ = LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::prove::<DP>(
+        setup_test_environment::<RqNTT, DP>(n, false);
+    let _ = LFFoldingProver::<RqNTT, PoseidonTranscript<RqNTT>>::prove::<DP>(
         &lccs,
         wit_s,
         &mut transcript,
@@ -656,11 +628,10 @@ fn test_full_prove() {
 #[test]
 fn test_proof_serialization() {
     type RqNTT = GoldilocksRqNTT;
-    type CS = GoldilocksChallengeSet;
     type DP = GoldilocksDP;
     let n = WIT_LEN * DP::L;
 
-    let (_, _, _, _, proof, _) = setup_test_environment::<RqNTT, CS, DP>(n, true);
+    let (_, _, _, _, proof, _) = setup_test_environment::<RqNTT, DP>(n, true);
 
     let proof = proof.unwrap();
 
@@ -682,12 +653,10 @@ fn test_proof_serialization() {
 #[test]
 fn test_verify_evaluation() {
     type RqNTT = GoldilocksRqNTT;
-    type CS = GoldilocksChallengeSet;
     type DP = GoldilocksDP;
     let n = WIT_LEN * DP::L;
 
-    let (lccs_vec, _, mut transcript, ccs, proof, _) =
-        setup_test_environment::<RqNTT, CS, DP>(n, true);
+    let (lccs_vec, _, mut transcript, ccs, proof, _) = setup_test_environment::<RqNTT, DP>(n, true);
     let proof = proof.unwrap();
 
     let (alpha_s, beta_s, zeta_s, mu_s) = transcript.squeeze_alpha_beta_zeta_mu::<DP>(ccs.s);
@@ -696,12 +665,12 @@ fn test_verify_evaluation() {
     let degree = 2 * DP::B_SMALL;
 
     let (claim_g1, claim_g3) =
-        LFFoldingVerifier::<RqNTT, PoseidonTranscript<RqNTT, CS>>::calculate_claims(
+        LFFoldingVerifier::<RqNTT, PoseidonTranscript<RqNTT>>::calculate_claims(
             &alpha_s, &zeta_s, &lccs_vec,
         );
 
     let (r_0, expected_evaluation) =
-        LFFoldingVerifier::<RqNTT, PoseidonTranscript<RqNTT, CS>>::verify_sumcheck_proof(
+        LFFoldingVerifier::<RqNTT, PoseidonTranscript<RqNTT>>::verify_sumcheck_proof(
             &mut transcript,
             nvars,
             degree,
@@ -710,7 +679,7 @@ fn test_verify_evaluation() {
         )
         .unwrap();
 
-    let result = LFFoldingVerifier::<RqNTT, PoseidonTranscript<RqNTT, CS>>::verify_evaluation::<DP>(
+    let result = LFFoldingVerifier::<RqNTT, PoseidonTranscript<RqNTT>>::verify_evaluation::<DP>(
         &alpha_s,
         &beta_s,
         &mu_s,
@@ -727,17 +696,16 @@ fn test_verify_evaluation() {
 #[test]
 fn test_calculate_claims() {
     type RqNTT = GoldilocksRqNTT;
-    type CS = GoldilocksChallengeSet;
     type DP = GoldilocksDP;
     let n = WIT_LEN * DP::L;
 
-    let (lcccs_vec, _, _, _, _, _) = setup_test_environment::<RqNTT, CS, DP>(n, false);
+    let (lcccs_vec, _, _, _, _, _) = setup_test_environment::<RqNTT, DP>(n, false);
 
     let alpha_s = vec![RqNTT::one(); 2 * DP::K];
     let zeta_s = vec![RqNTT::one(); 2 * DP::K];
 
     let (claim_g1, claim_g3) =
-        LFFoldingVerifier::<RqNTT, PoseidonTranscript<RqNTT, CS>>::calculate_claims(
+        LFFoldingVerifier::<RqNTT, PoseidonTranscript<RqNTT>>::calculate_claims(
             &alpha_s, &zeta_s, &lcccs_vec,
         );
 
@@ -748,7 +716,7 @@ fn test_calculate_claims() {
     let zero_zetas = vec![RqNTT::zero(); 2 * DP::K];
 
     let (zero_claim_g1, zero_claim_g3) =
-        LFFoldingVerifier::<RqNTT, PoseidonTranscript<RqNTT, CS>>::calculate_claims(
+        LFFoldingVerifier::<RqNTT, PoseidonTranscript<RqNTT>>::calculate_claims(
             &zero_alphas,
             &zero_zetas,
             &lcccs_vec,
@@ -761,13 +729,12 @@ fn test_calculate_claims() {
 #[test]
 fn test_verify_sumcheck_proof() {
     type RqNTT = FrogRqNTT;
-    type CS = FrogChallengeSet;
     type DP = FrogDP;
 
     let n = WIT_LEN * DP::L;
 
     let (lcccs_vec, _, mut transcript, ccs, proof, _) =
-        setup_test_environment::<RqNTT, CS, DP>(n, true);
+        setup_test_environment::<RqNTT, DP>(n, true);
     let proof = proof.unwrap();
 
     let (alpha_s, _, zeta_s, _) = transcript.squeeze_alpha_beta_zeta_mu::<DP>(ccs.s);
@@ -776,11 +743,11 @@ fn test_verify_sumcheck_proof() {
     let degree = 2 * DP::B_SMALL;
 
     let (claim_g1, claim_g3) =
-        LFFoldingVerifier::<RqNTT, PoseidonTranscript<RqNTT, CS>>::calculate_claims(
+        LFFoldingVerifier::<RqNTT, PoseidonTranscript<RqNTT>>::calculate_claims(
             &alpha_s, &zeta_s, &lcccs_vec,
         );
 
-    let result = LFFoldingVerifier::<RqNTT, PoseidonTranscript<RqNTT, CS>>::verify_sumcheck_proof(
+    let result = LFFoldingVerifier::<RqNTT, PoseidonTranscript<RqNTT>>::verify_sumcheck_proof(
         &mut transcript,
         nvars,
         degree,
@@ -800,15 +767,13 @@ fn test_verify_sumcheck_proof() {
 #[test]
 fn test_full_verify() {
     type RqNTT = GoldilocksRqNTT;
-    type CS = GoldilocksChallengeSet;
     type DP = GoldilocksDP;
     let n = WIT_LEN * DP::L;
 
-    let (lccs_vec, _, mut transcript, ccs, proof, _) =
-        setup_test_environment::<RqNTT, CS, DP>(n, true);
+    let (lccs_vec, _, mut transcript, ccs, proof, _) = setup_test_environment::<RqNTT, DP>(n, true);
     let proof = proof.unwrap();
 
-    let result = LFFoldingVerifier::<RqNTT, PoseidonTranscript<RqNTT, CS>>::verify::<DP>(
+    let result = LFFoldingVerifier::<RqNTT, PoseidonTranscript<RqNTT>>::verify::<DP>(
         &lccs_vec,
         &proof,
         &mut transcript,
diff --git a/crates/latticefold/src/nifs/folding/utils.rs b/crates/latticefold/src/nifs/folding/utils.rs
index a23a379f..980dff15 100644
--- a/crates/latticefold/src/nifs/folding/utils.rs
+++ b/crates/latticefold/src/nifs/folding/utils.rs
@@ -5,7 +5,7 @@ use ark_std::{
     iter::{self, successors},
     iterable::Iterable,
 };
-use cyclotomic_rings::{rings::SuitableRing, rotation::rot_lin_combination};
+use latticefold_rings::{rings::SuitableRing, rotation::rot_lin_combination};
 use stark_rings::{cyclotomic_ring::CRT, OverField, PolyRing, Ring};
 use stark_rings_poly::mle::DenseMultilinearExtension;
 
@@ -15,7 +15,7 @@ use crate::{
     commitment::Commitment,
     decomposition_parameters::DecompositionParams,
     nifs::error::FoldingError,
-    transcript::{Transcript, TranscriptWithShortChallenges},
+    transcript::{Transcript, TranscriptWithSmallChallenges},
     utils::sumcheck::utils::build_eq_x_r,
 };
 
@@ -98,7 +98,7 @@ impl<NTT: SuitableRing, T: Transcript<NTT>> SqueezeAlphaBetaZetaMu<NTT> for T {
 /// Generates `rho` values based on the provided transcript and decomposition parameters.
 ///
 /// This function is used within the module to extract or compute values required for further
-/// operations, based on the interaction with a transcript that supports short challenges.
+/// operations, based on the interaction with a transcript that supports small challenges.
 ///
 /// # Type Parameters
 /// - `R`: A ring suitable to be used in the LatticeFold protocol.
@@ -115,7 +115,7 @@ impl<NTT: SuitableRing, T: Transcript<NTT>> SqueezeAlphaBetaZetaMu<NTT> for T {
 ///
 pub(super) fn get_rhos<
     R: SuitableRing,
-    T: TranscriptWithShortChallenges<R>,
+    T: TranscriptWithSmallChallenges<R>,
     P: DecompositionParams,
 >(
     transcript: &mut T,
diff --git a/crates/latticefold/src/nifs/linearization.rs b/crates/latticefold/src/nifs/linearization.rs
index ed889d75..99467495 100644
--- a/crates/latticefold/src/nifs/linearization.rs
+++ b/crates/latticefold/src/nifs/linearization.rs
@@ -1,4 +1,4 @@
-use cyclotomic_rings::rings::SuitableRing;
+use latticefold_rings::rings::SuitableRing;
 use stark_rings::OverField;
 use stark_rings_poly::mle::DenseMultilinearExtension;
 
diff --git a/crates/latticefold/src/nifs/linearization/tests/mod.rs b/crates/latticefold/src/nifs/linearization/tests/mod.rs
index 3c84079a..fe7927da 100644
--- a/crates/latticefold/src/nifs/linearization/tests/mod.rs
+++ b/crates/latticefold/src/nifs/linearization/tests/mod.rs
@@ -1,8 +1,5 @@
 use ark_std::test_rng;
-use cyclotomic_rings::{
-    challenge_set::LatticefoldChallengeSet,
-    rings::{BabyBearChallengeSet, FrogChallengeSet, GoldilocksChallengeSet, StarkChallengeSet},
-};
+use latticefold_rings::rings::SuitableRing;
 use num_traits::One;
 use rand::Rng;
 use stark_rings::cyclotomic_ring::models::{
@@ -68,16 +65,15 @@ fn test_compute_z_ccs() {
 #[test]
 fn test_construct_polynomial() {
     type RqNTT = GoldilocksRqNTT;
-    type CS = GoldilocksChallengeSet;
     type DP = GoldilocksDP;
     let n = WIT_LEN * DP::L;
     let (wit, cm_i, ccs, _) = setup_test_environment::<RqNTT, DP>(None, n);
 
     let z_ccs = cm_i.get_z_vector(&wit.w_ccs);
 
-    let mut transcript = PoseidonTranscript::<RqNTT, CS>::default();
+    let mut transcript = PoseidonTranscript::<RqNTT>::default();
     let (_, g_degree, mz_mles) =
-        LFLinearizationProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::construct_polynomial_g(
+        LFLinearizationProver::<RqNTT, PoseidonTranscript<RqNTT>>::construct_polynomial_g(
             &z_ccs,
             &mut transcript,
             &ccs,
@@ -94,16 +90,15 @@ fn test_construct_polynomial() {
 #[test]
 fn test_generate_sumcheck() {
     type RqNTT = FrogRqNTT;
-    type CS = FrogChallengeSet;
     type DP = FrogDP;
     let n = WIT_LEN * DP::L;
     let (wit, cm_i, ccs, _) = setup_test_environment::<RqNTT, DP>(None, n);
 
     let z_ccs = cm_i.get_z_vector(&wit.w_ccs);
 
-    let mut transcript = PoseidonTranscript::<RqNTT, CS>::default();
+    let mut transcript = PoseidonTranscript::<RqNTT>::default();
     let (g_mles, g_degree, _) =
-        LFLinearizationProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::construct_polynomial_g(
+        LFLinearizationProver::<RqNTT, PoseidonTranscript<RqNTT>>::construct_polynomial_g(
             &z_ccs,
             &mut transcript,
             &ccs,
@@ -113,7 +108,7 @@ fn test_generate_sumcheck() {
     let comb_fn = |vals: &[RqNTT]| -> RqNTT { sumcheck_polynomial_comb_fn::<RqNTT>(vals, &ccs) };
 
     let (_, point_r) =
-        LFLinearizationProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::generate_sumcheck_proof(
+        LFLinearizationProver::<RqNTT, PoseidonTranscript<RqNTT>>::generate_sumcheck_proof(
             &mut transcript,
             g_mles,
             ccs.s,
@@ -126,16 +121,16 @@ fn test_generate_sumcheck() {
     assert_eq!(point_r.len(), ccs.s);
 }
 
-fn prepare_test_vectors<RqNTT: SuitableRing, CS: LatticefoldChallengeSet<RqNTT>>(
+fn prepare_test_vectors<RqNTT: SuitableRing>(
     wit: &Witness<RqNTT>,
     cm_i: &CCCS<RqNTT>,
     ccs: &CCS<RqNTT>,
 ) -> (Vec<RqNTT>, Vec<DenseMultilinearExtension<RqNTT>>) {
     let z_ccs = cm_i.get_z_vector(&wit.w_ccs);
 
-    let mut transcript = PoseidonTranscript::<RqNTT, CS>::default();
+    let mut transcript = PoseidonTranscript::<RqNTT>::default();
     let (g_mles, g_degree, Mz_mles) =
-        LFLinearizationProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::construct_polynomial_g(
+        LFLinearizationProver::<RqNTT, PoseidonTranscript<RqNTT>>::construct_polynomial_g(
             &z_ccs,
             &mut transcript,
             ccs,
@@ -145,7 +140,7 @@ fn prepare_test_vectors<RqNTT: SuitableRing, CS: LatticefoldChallengeSet<RqNTT>>
     let comb_fn = |vals: &[RqNTT]| -> RqNTT { sumcheck_polynomial_comb_fn::<RqNTT>(vals, ccs) };
 
     let (_, point_r) =
-        LFLinearizationProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::generate_sumcheck_proof(
+        LFLinearizationProver::<RqNTT, PoseidonTranscript<RqNTT>>::generate_sumcheck_proof(
             &mut transcript,
             g_mles,
             ccs.s,
@@ -160,17 +155,16 @@ fn prepare_test_vectors<RqNTT: SuitableRing, CS: LatticefoldChallengeSet<RqNTT>>
 #[test]
 fn test_compute_v() {
     type RqNTT = BabyBearRqNTT;
-    type CS = BabyBearChallengeSet;
     type DP = BabyBearDP;
     let n = WIT_LEN * DP::L;
 
     // Setup shared test state
     let (wit, cm_i, ccs, _) = setup_test_environment::<RqNTT, DP>(None, n);
-    let (point_r, Mz_mles) = prepare_test_vectors::<RqNTT, CS>(&wit, &cm_i, &ccs);
+    let (point_r, Mz_mles) = prepare_test_vectors::<RqNTT>(&wit, &cm_i, &ccs);
 
     // Compute actual v vector
     let (point_r, v, _) =
-        LFLinearizationProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::compute_evaluation_vectors(
+        LFLinearizationProver::<RqNTT, PoseidonTranscript<RqNTT>>::compute_evaluation_vectors(
             &wit, &point_r, &Mz_mles,
         )
         .unwrap();
@@ -191,16 +185,15 @@ fn test_compute_v() {
 #[test]
 fn test_compute_u() {
     type RqNTT = FrogRqNTT;
-    type CS = FrogChallengeSet;
     type DP = FrogDP;
     let n = WIT_LEN * DP::L;
     // Setup shared test state
     let (wit, cm_i, ccs, _) = setup_test_environment::<RqNTT, DP>(None, n);
-    let (point_r, Mz_mles) = prepare_test_vectors::<RqNTT, CS>(&wit, &cm_i, &ccs);
+    let (point_r, Mz_mles) = prepare_test_vectors::<RqNTT>(&wit, &cm_i, &ccs);
 
     // Compute actual u vector
     let (point_r, _, u) =
-        LFLinearizationProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::compute_evaluation_vectors(
+        LFLinearizationProver::<RqNTT, PoseidonTranscript<RqNTT>>::compute_evaluation_vectors(
             &wit, &point_r, &Mz_mles,
         )
         .unwrap();
@@ -225,13 +218,12 @@ fn test_compute_u() {
 #[test]
 fn test_full_prove() {
     type RqNTT = GoldilocksRqNTT;
-    type CS = GoldilocksChallengeSet;
     type DP = GoldilocksDP;
     let n = WIT_LEN * DP::L;
     let (wit, cm_i, ccs, _) = setup_test_environment::<RqNTT, DP>(None, n);
-    let mut transcript = PoseidonTranscript::<RqNTT, CS>::default();
+    let mut transcript = PoseidonTranscript::<RqNTT>::default();
 
-    let (lcccs, proof) = LFLinearizationProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::prove(
+    let (lcccs, proof) = LFLinearizationProver::<RqNTT, PoseidonTranscript<RqNTT>>::prove(
         &cm_i,
         &wit,
         &mut transcript,
@@ -247,14 +239,13 @@ fn test_full_prove() {
 #[test]
 fn test_verify_sumcheck_proof() {
     type RqNTT = StarkRqNTT;
-    type CS = StarkChallengeSet;
     type DP = StarkDP;
     let n = WIT_LEN * DP::L;
     let (wit, cm_i, ccs, _) = setup_test_environment::<RqNTT, DP>(None, n);
-    let mut prove_transcript = PoseidonTranscript::<RqNTT, CS>::default();
+    let mut prove_transcript = PoseidonTranscript::<RqNTT>::default();
 
     // Generate proof
-    let (lcccs, proof) = LFLinearizationProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::prove(
+    let (lcccs, proof) = LFLinearizationProver::<RqNTT, PoseidonTranscript<RqNTT>>::prove(
         &cm_i,
         &wit,
         &mut prove_transcript,
@@ -263,17 +254,16 @@ fn test_verify_sumcheck_proof() {
     .unwrap();
 
     // We need to recreate the exact same transcript state
-    let mut verify_transcript = PoseidonTranscript::<RqNTT, CS>::default();
+    let mut verify_transcript = PoseidonTranscript::<RqNTT>::default();
 
     // Generate beta challenges to match prover's transcript state
     let _ = verify_transcript.squeeze_beta_challenges(ccs.s);
 
-    let result =
-        LFLinearizationVerifier::<RqNTT, PoseidonTranscript<RqNTT, CS>>::verify_sumcheck_proof(
-            &proof,
-            &mut verify_transcript,
-            &ccs,
-        );
+    let result = LFLinearizationVerifier::<RqNTT, PoseidonTranscript<RqNTT>>::verify_sumcheck_proof(
+        &proof,
+        &mut verify_transcript,
+        &ccs,
+    );
 
     // Instead of unwrapping, handle the result
     match result {
@@ -289,14 +279,13 @@ fn test_verify_sumcheck_proof() {
 #[test]
 fn test_verify_evaluation_claim() {
     type RqNTT = BabyBearRqNTT;
-    type CS = BabyBearChallengeSet;
     type DP = BabyBearDP;
     let n = WIT_LEN * DP::L;
     let (wit, cm_i, ccs, _) = setup_test_environment::<RqNTT, DP>(None, n);
-    let mut transcript = PoseidonTranscript::<RqNTT, CS>::default();
+    let mut transcript = PoseidonTranscript::<RqNTT>::default();
 
     // Generate proof
-    let (_, proof) = LFLinearizationProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::prove(
+    let (_, proof) = LFLinearizationProver::<RqNTT, PoseidonTranscript<RqNTT>>::prove(
         &cm_i,
         &wit,
         &mut transcript,
@@ -305,11 +294,11 @@ fn test_verify_evaluation_claim() {
     .unwrap();
 
     // Reset transcript and generate verification data
-    let mut transcript = PoseidonTranscript::<RqNTT, CS>::default();
+    let mut transcript = PoseidonTranscript::<RqNTT>::default();
     let beta_s = transcript.squeeze_beta_challenges(ccs.s);
 
     let (point_r, s) =
-        LFLinearizationVerifier::<RqNTT, PoseidonTranscript<RqNTT, CS>>::verify_sumcheck_proof(
+        LFLinearizationVerifier::<RqNTT, PoseidonTranscript<RqNTT>>::verify_sumcheck_proof(
             &proof,
             &mut transcript,
             &ccs,
@@ -318,7 +307,7 @@ fn test_verify_evaluation_claim() {
 
     // Test the evaluation claim verification
     let result =
-        LFLinearizationVerifier::<RqNTT, PoseidonTranscript<RqNTT, CS>>::verify_evaluation_claim(
+        LFLinearizationVerifier::<RqNTT, PoseidonTranscript<RqNTT>>::verify_evaluation_claim(
             &beta_s, &point_r, s, &proof, &ccs,
         );
 
@@ -328,13 +317,12 @@ fn test_verify_evaluation_claim() {
 #[test]
 fn test_prepare_verifier_output() {
     type RqNTT = FrogRqNTT;
-    type CS = FrogChallengeSet;
     type DP = FrogDP;
     let n = WIT_LEN * DP::L;
     let (wit, cm_i, ccs, _) = setup_test_environment::<RqNTT, DP>(None, n);
-    let mut transcript = PoseidonTranscript::<RqNTT, CS>::default();
+    let mut transcript = PoseidonTranscript::<RqNTT>::default();
 
-    let (_, proof) = LFLinearizationProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::prove(
+    let (_, proof) = LFLinearizationProver::<RqNTT, PoseidonTranscript<RqNTT>>::prove(
         &cm_i,
         &wit,
         &mut transcript,
@@ -345,7 +333,7 @@ fn test_prepare_verifier_output() {
     let point_r = vec![RqNTT::one(); ccs.s]; // Example point_r
 
     let lcccs =
-        LFLinearizationVerifier::<RqNTT, PoseidonTranscript<RqNTT, CS>>::prepare_verifier_output(
+        LFLinearizationVerifier::<RqNTT, PoseidonTranscript<RqNTT>>::prepare_verifier_output(
             &cm_i,
             point_r.clone(),
             &proof,
@@ -363,13 +351,12 @@ fn test_prepare_verifier_output() {
 #[test]
 fn test_verify_invalid_proof() {
     type RqNTT = GoldilocksRqNTT;
-    type CS = GoldilocksChallengeSet;
     type DP = GoldilocksDP;
     let n = WIT_LEN * DP::L;
     let (wit, cm_i, ccs, _) = setup_test_environment::<RqNTT, DP>(None, n);
-    let mut transcript = PoseidonTranscript::<RqNTT, CS>::default();
+    let mut transcript = PoseidonTranscript::<RqNTT>::default();
 
-    let (_, mut proof) = LFLinearizationProver::<RqNTT, PoseidonTranscript<RqNTT, CS>>::prove(
+    let (_, mut proof) = LFLinearizationProver::<RqNTT, PoseidonTranscript<RqNTT>>::prove(
         &cm_i,
         &wit,
         &mut transcript,
@@ -383,9 +370,9 @@ fn test_verify_invalid_proof() {
     }
 
     // Reset transcript for verification
-    let mut transcript = PoseidonTranscript::<RqNTT, CS>::default();
+    let mut transcript = PoseidonTranscript::<RqNTT>::default();
 
-    let result = LFLinearizationVerifier::<RqNTT, PoseidonTranscript<RqNTT, CS>>::verify(
+    let result = LFLinearizationVerifier::<RqNTT, PoseidonTranscript<RqNTT>>::verify(
         &cm_i,
         &proof,
         &mut transcript,
diff --git a/crates/latticefold/src/nifs/linearization/utils.rs b/crates/latticefold/src/nifs/linearization/utils.rs
index 6f7bae5c..a7be9bbc 100644
--- a/crates/latticefold/src/nifs/linearization/utils.rs
+++ b/crates/latticefold/src/nifs/linearization/utils.rs
@@ -1,5 +1,5 @@
 use ark_ff::{Field, PrimeField};
-use cyclotomic_rings::rings::SuitableRing;
+use latticefold_rings::rings::SuitableRing;
 use stark_rings::OverField;
 use stark_rings_poly::mle::DenseMultilinearExtension;
 
diff --git a/crates/latticefold/src/nifs/tests.rs b/crates/latticefold/src/nifs/tests.rs
index da29cbd4..4e78d23d 100644
--- a/crates/latticefold/src/nifs/tests.rs
+++ b/crates/latticefold/src/nifs/tests.rs
@@ -1,5 +1,5 @@
 use ark_std::{test_rng, vec::Vec};
-use cyclotomic_rings::{challenge_set::LatticefoldChallengeSet, rings::SuitableRing};
+use latticefold_rings::rings::SuitableRing;
 use rand::Rng;
 
 use crate::{
@@ -10,14 +10,10 @@ use crate::{
         linearization::{LFLinearizationProver, LinearizationProver},
         NIFSProver, NIFSVerifier,
     },
-    transcript::{poseidon::PoseidonTranscript, TranscriptWithShortChallenges},
+    transcript::{poseidon::PoseidonTranscript, TranscriptWithSmallChallenges},
 };
 
-fn setup_test_environment<
-    RqNTT: SuitableRing,
-    DP: DecompositionParams,
-    CS: LatticefoldChallengeSet<RqNTT>,
->(
+fn setup_test_environment<RqNTT: SuitableRing, DP: DecompositionParams>(
     kappa: usize,
     n: usize,
     wit_len: usize,
@@ -43,9 +39,9 @@ fn setup_test_environment<
     let rand_w_ccs: Vec<RqNTT> = (0..wit_len).map(|i| RqNTT::from(i as u64)).collect();
     let wit_acc = Witness::from_w_ccs::<DP>(rand_w_ccs);
 
-    let mut transcript = PoseidonTranscript::<RqNTT, CS>::default();
+    let mut transcript = PoseidonTranscript::<RqNTT>::default();
 
-    let (acc, _) = LFLinearizationProver::<_, PoseidonTranscript<RqNTT, CS>>::prove(
+    let (acc, _) = LFLinearizationProver::<_, PoseidonTranscript<RqNTT>>::prove(
         &cm_i,
         &wit_acc,
         &mut transcript,
@@ -57,18 +53,17 @@ fn setup_test_environment<
 
 fn test_nifs_prove<
     RqNTT: SuitableRing,
-    CS: LatticefoldChallengeSet<RqNTT>,
     DP: DecompositionParams,
-    T: TranscriptWithShortChallenges<RqNTT>,
+    T: TranscriptWithSmallChallenges<RqNTT>,
 >(
     kappa: usize,
     n: usize,
     wit_len: usize,
 ) {
     let (acc, w_acc, cm_i, w_i, ccs, scheme) =
-        setup_test_environment::<RqNTT, DP, CS>(kappa, n, wit_len);
+        setup_test_environment::<RqNTT, DP>(kappa, n, wit_len);
 
-    let mut transcript = PoseidonTranscript::<RqNTT, CS>::default();
+    let mut transcript = PoseidonTranscript::<RqNTT>::default();
 
     let result = NIFSProver::<RqNTT, DP, T>::prove(
         &acc,
@@ -85,19 +80,18 @@ fn test_nifs_prove<
 
 fn test_nifs_verify<
     RqNTT: SuitableRing,
-    CS: LatticefoldChallengeSet<RqNTT>,
     DP: DecompositionParams,
-    T: TranscriptWithShortChallenges<RqNTT>,
+    T: TranscriptWithSmallChallenges<RqNTT>,
 >(
     kappa: usize,
     n: usize,
     wit_len: usize,
 ) {
     let (acc, w_acc, cm_i, w_i, ccs, scheme) =
-        setup_test_environment::<RqNTT, DP, CS>(kappa, n, wit_len);
+        setup_test_environment::<RqNTT, DP>(kappa, n, wit_len);
 
-    let mut prover_transcript = PoseidonTranscript::<RqNTT, CS>::default();
-    let mut verifier_transcript = PoseidonTranscript::<RqNTT, CS>::default();
+    let mut prover_transcript = PoseidonTranscript::<RqNTT>::default();
+    let mut verifier_transcript = PoseidonTranscript::<RqNTT>::default();
 
     let (_, _, proof) = NIFSProver::<RqNTT, DP, T>::prove(
         &acc,
@@ -119,7 +113,7 @@ fn test_nifs_verify<
 mod e2e_tests {
     use super::*;
     mod stark {
-        use cyclotomic_rings::rings::{StarkChallengeSet, StarkRingNTT};
+        use latticefold_rings::rings::StarkRingNTT;
 
         use crate::{
             decomposition_parameters::{test_params::StarkDP, DecompositionParams},
@@ -128,9 +122,8 @@ mod e2e_tests {
         };
 
         type RqNTT = StarkRingNTT;
-        type CS = StarkChallengeSet;
         type DP = StarkDP;
-        type T = PoseidonTranscript<RqNTT, CS>;
+        type T = PoseidonTranscript<RqNTT>;
 
         const KAPPA: usize = 4;
         const WIT_LEN: usize = 4;
@@ -139,26 +132,25 @@ mod e2e_tests {
         #[ignore]
         #[test]
         fn test_prove() {
-            test_nifs_prove::<RqNTT, CS, DP, T>(KAPPA, N, WIT_LEN);
+            test_nifs_prove::<RqNTT, DP, T>(KAPPA, N, WIT_LEN);
         }
 
         #[ignore]
         #[test]
         fn test_verify() {
-            test_nifs_verify::<RqNTT, CS, DP, T>(KAPPA, N, WIT_LEN);
+            test_nifs_verify::<RqNTT, DP, T>(KAPPA, N, WIT_LEN);
         }
     }
 
     mod goldilocks {
-        use cyclotomic_rings::rings::{GoldilocksChallengeSet, GoldilocksRingNTT};
+        use latticefold_rings::rings::GoldilocksRingNTT;
 
         use super::*;
         use crate::decomposition_parameters::test_params::GoldilocksDP;
 
         type RqNTT = GoldilocksRingNTT;
-        type CS = GoldilocksChallengeSet;
         type DP = GoldilocksDP;
-        type T = PoseidonTranscript<RqNTT, CS>;
+        type T = PoseidonTranscript<RqNTT>;
 
         const KAPPA: usize = 4;
         const WIT_LEN: usize = 4;
@@ -166,25 +158,24 @@ mod e2e_tests {
 
         #[test]
         fn test_prove() {
-            test_nifs_prove::<RqNTT, CS, DP, T>(KAPPA, N, WIT_LEN);
+            test_nifs_prove::<RqNTT, DP, T>(KAPPA, N, WIT_LEN);
         }
 
         #[test]
         fn test_verify() {
-            test_nifs_verify::<RqNTT, CS, DP, T>(KAPPA, N, WIT_LEN);
+            test_nifs_verify::<RqNTT, DP, T>(KAPPA, N, WIT_LEN);
         }
     }
 
     mod babybear {
-        use cyclotomic_rings::rings::{BabyBearChallengeSet, BabyBearRingNTT};
+        use latticefold_rings::rings::BabyBearRingNTT;
 
         use super::*;
         use crate::decomposition_parameters::test_params::BabyBearDP;
 
         type RqNTT = BabyBearRingNTT;
-        type CS = BabyBearChallengeSet;
         type DP = BabyBearDP;
-        type T = PoseidonTranscript<RqNTT, CS>;
+        type T = PoseidonTranscript<RqNTT>;
 
         const KAPPA: usize = 4;
         const WIT_LEN: usize = 4;
@@ -192,12 +183,12 @@ mod e2e_tests {
 
         #[test]
         fn test_prove() {
-            test_nifs_prove::<RqNTT, CS, DP, T>(KAPPA, N, WIT_LEN);
+            test_nifs_prove::<RqNTT, DP, T>(KAPPA, N, WIT_LEN);
         }
 
         #[test]
         fn test_verify() {
-            test_nifs_verify::<RqNTT, CS, DP, T>(KAPPA, N, WIT_LEN);
+            test_nifs_verify::<RqNTT, DP, T>(KAPPA, N, WIT_LEN);
         }
     }
 }
diff --git a/crates/latticefold/src/transcript.rs b/crates/latticefold/src/transcript.rs
index cd665981..d6c6e28b 100644
--- a/crates/latticefold/src/transcript.rs
+++ b/crates/latticefold/src/transcript.rs
@@ -3,7 +3,7 @@
 //! Transcripts allow provers and verifiers to independently draw the same challenges.
 
 use ark_std::fmt::Debug;
-use cyclotomic_rings::{challenge_set::LatticefoldChallengeSet, rings::SuitableRing};
+use latticefold_rings::{challenge_set::ChallengeSet, rings::SuitableRing};
 use stark_rings::OverField;
 
 use crate::ark_base::*;
@@ -38,14 +38,14 @@ pub trait Transcript<R: OverField> {
     fn squeeze_bytes(&mut self, n: usize) -> Vec<u8>;
 }
 
-pub trait TranscriptWithShortChallenges<R: SuitableRing>: Transcript<R> {
-    type ChallengeSet: LatticefoldChallengeSet<R>;
+pub trait TranscriptWithSmallChallenges<R: SuitableRing>: Transcript<R> {
+    type ChallengeSet: ChallengeSet<R>;
 
-    fn get_short_challenge(&mut self) -> R::CoefficientRepresentation;
+    fn get_small_challenge(&mut self) -> R::CoefficientRepresentation;
 
     fn get_small_challenges(&mut self, n: usize) -> Vec<R::CoefficientRepresentation> {
         let mut challenges = Vec::with_capacity(n);
-        challenges.extend((0..n).map(|_| self.get_short_challenge()));
+        challenges.extend((0..n).map(|_| self.get_small_challenge()));
         challenges
     }
 }
diff --git a/crates/latticefold/src/transcript/poseidon.rs b/crates/latticefold/src/transcript/poseidon.rs
index cfd6d580..50ecc59e 100644
--- a/crates/latticefold/src/transcript/poseidon.rs
+++ b/crates/latticefold/src/transcript/poseidon.rs
@@ -3,38 +3,33 @@ use ark_crypto_primitives::sponge::{
     CryptographicSponge,
 };
 use ark_ff::Field;
-use ark_std::marker::PhantomData;
-use cyclotomic_rings::{
-    challenge_set::LatticefoldChallengeSet,
+use latticefold_rings::{
+    challenge_set::ChallengeSet,
     rings::{GetPoseidonParams, SuitableRing},
 };
 use stark_rings::OverField;
 
-use super::{Transcript, TranscriptWithShortChallenges};
+use super::{Transcript, TranscriptWithSmallChallenges};
 use crate::ark_base::*;
 
 /// PoseidonTranscript implements the Transcript trait using the Poseidon hash
 #[derive(Clone)]
-pub struct PoseidonTranscript<R: OverField, CS> {
-    _marker: PhantomData<CS>,
+pub struct PoseidonTranscript<R: OverField> {
     sponge: PoseidonSponge<<R::BaseRing as Field>::BasePrimeField>,
 }
 
-impl<R: SuitableRing, CS: LatticefoldChallengeSet<R>> Default for PoseidonTranscript<R, CS> {
+impl<R: SuitableRing> Default for PoseidonTranscript<R> {
     fn default() -> Self {
         Self::new(&R::PoseidonParams::get_poseidon_config())
     }
 }
 
-impl<R: OverField, CS> Transcript<R> for PoseidonTranscript<R, CS> {
+impl<R: OverField> Transcript<R> for PoseidonTranscript<R> {
     type TranscriptConfig = PoseidonConfig<<R::BaseRing as Field>::BasePrimeField>;
 
     fn new(config: &Self::TranscriptConfig) -> Self {
         let sponge = PoseidonSponge::<<R::BaseRing as Field>::BasePrimeField>::new(config);
-        Self {
-            sponge,
-            _marker: PhantomData,
-        }
+        Self { sponge }
     }
 
     fn absorb(&mut self, v: &R) {
@@ -61,15 +56,13 @@ impl<R: OverField, CS> Transcript<R> for PoseidonTranscript<R, CS> {
     }
 }
 
-impl<R: SuitableRing, CS: LatticefoldChallengeSet<R>> TranscriptWithShortChallenges<R>
-    for PoseidonTranscript<R, CS>
-{
-    type ChallengeSet = CS;
+impl<R: SuitableRing> TranscriptWithSmallChallenges<R> for PoseidonTranscript<R> {
+    type ChallengeSet = R::ChallengeSet;
 
-    fn get_short_challenge(&mut self) -> R::CoefficientRepresentation {
+    fn get_small_challenge(&mut self) -> R::CoefficientRepresentation {
         let random_bytes = self.sponge.squeeze_bytes(Self::ChallengeSet::BYTES_NEEDED);
 
-        Self::ChallengeSet::short_challenge_from_random_bytes(&random_bytes)
+        Self::ChallengeSet::small_challenge_from_random_bytes(&random_bytes)
             .expect("not enough bytes to get a small challenge")
     }
 }
@@ -77,15 +70,14 @@ impl<R: SuitableRing, CS: LatticefoldChallengeSet<R>> TranscriptWithShortChallen
 #[cfg(test)]
 mod tests {
     use ark_ff::BigInt;
-    use cyclotomic_rings::rings::{GoldilocksChallengeSet, GoldilocksRingNTT, GoldilocksRingPoly};
+    use latticefold_rings::rings::{GoldilocksRingNTT, GoldilocksRingPoly};
     use stark_rings::cyclotomic_ring::models::goldilocks::{Fq, Fq3};
 
     use super::*;
 
     #[test]
     fn test_get_big_challenge() {
-        let mut transcript =
-            PoseidonTranscript::<GoldilocksRingNTT, GoldilocksChallengeSet>::default();
+        let mut transcript = PoseidonTranscript::<GoldilocksRingNTT>::default();
 
         transcript
             .sponge
@@ -102,8 +94,7 @@ mod tests {
 
     #[test]
     fn test_get_small_challenge() {
-        let mut transcript =
-            PoseidonTranscript::<GoldilocksRingNTT, GoldilocksChallengeSet>::default();
+        let mut transcript = PoseidonTranscript::<GoldilocksRingNTT>::default();
 
         transcript
             .sponge
@@ -138,6 +129,6 @@ mod tests {
 
         let expected = GoldilocksRingPoly::from(expected_coeffs);
 
-        assert_eq!(expected, transcript.get_short_challenge())
+        assert_eq!(expected, transcript.get_small_challenge())
     }
 }
diff --git a/crates/latticefold/src/utils/mle_helpers.rs b/crates/latticefold/src/utils/mle_helpers.rs
index dbc672c2..2e210548 100644
--- a/crates/latticefold/src/utils/mle_helpers.rs
+++ b/crates/latticefold/src/utils/mle_helpers.rs
@@ -3,7 +3,7 @@
 //!  
 
 use ark_std::{cfg_into_iter, cfg_iter, vec::Vec};
-use cyclotomic_rings::rings::SuitableRing;
+use latticefold_rings::rings::SuitableRing;
 #[cfg(feature = "parallel")]
 use rayon::iter::{IntoParallelIterator, IntoParallelRefIterator, ParallelIterator};
 use stark_rings::Ring;
diff --git a/crates/latticefold/src/utils/sumcheck.rs b/crates/latticefold/src/utils/sumcheck.rs
index 0ad42d60..d555d189 100644
--- a/crates/latticefold/src/utils/sumcheck.rs
+++ b/crates/latticefold/src/utils/sumcheck.rs
@@ -108,7 +108,7 @@ impl<R: OverField, T: Transcript<R>> MLSumcheck<R, T> {
 mod tests {
     use ark_serialize::{CanonicalDeserialize, CanonicalSerialize, Compress, Validate};
     use ark_std::io::Cursor;
-    use cyclotomic_rings::{challenge_set::LatticefoldChallengeSet, rings::SuitableRing};
+    use latticefold_rings::rings::SuitableRing;
     use rand::Rng;
 
     use crate::{
@@ -120,15 +120,14 @@ mod tests {
         },
     };
 
-    fn generate_sumcheck_proof<R, CS>(
+    fn generate_sumcheck_proof<R>(
         nvars: usize,
         mut rng: &mut (impl Rng + Sized),
     ) -> (usize, R, Proof<R>)
     where
         R: SuitableRing,
-        CS: LatticefoldChallengeSet<R>,
     {
-        let mut transcript = PoseidonTranscript::<R, CS>::default();
+        let mut transcript = PoseidonTranscript::<R>::default();
 
         let ((poly_mles, poly_degree), products, sum) =
             rand_poly(nvars, (2, 5), 3, &mut rng).unwrap();
@@ -145,33 +144,31 @@ mod tests {
         (poly_degree, sum, proof)
     }
 
-    fn test_sumcheck<R, CS>()
+    fn test_sumcheck<R>()
     where
         R: SuitableRing,
-        CS: LatticefoldChallengeSet<R>,
     {
         let mut rng = ark_std::test_rng();
         let nvars = 5;
 
         for _ in 0..20 {
-            let (poly_degree, sum, proof) = generate_sumcheck_proof::<R, CS>(nvars, &mut rng);
+            let (poly_degree, sum, proof) = generate_sumcheck_proof::<R>(nvars, &mut rng);
 
-            let mut transcript: PoseidonTranscript<R, CS> = PoseidonTranscript::default();
+            let mut transcript: PoseidonTranscript<R> = PoseidonTranscript::default();
             let res =
                 MLSumcheck::verify_as_subprotocol(&mut transcript, nvars, poly_degree, sum, &proof);
             assert!(res.is_ok())
         }
     }
 
-    fn test_sumcheck_proof_serialization<R, CS>()
+    fn test_sumcheck_proof_serialization<R>()
     where
         R: SuitableRing,
-        CS: LatticefoldChallengeSet<R>,
     {
         let mut rng = ark_std::test_rng();
         let nvars = 5;
 
-        let proof = generate_sumcheck_proof::<R, CS>(nvars, &mut rng).2;
+        let proof = generate_sumcheck_proof::<R>(nvars, &mut rng).2;
 
         let mut serialized = Vec::new();
         proof
@@ -186,15 +183,14 @@ mod tests {
         );
     }
 
-    fn test_failing_sumcheck<R, CS>()
+    fn test_failing_sumcheck<R>()
     where
         R: SuitableRing,
-        CS: LatticefoldChallengeSet<R>,
     {
         let mut rng = ark_std::test_rng();
 
         for _ in 0..20 {
-            let mut transcript: PoseidonTranscript<R, CS> = PoseidonTranscript::default();
+            let mut transcript: PoseidonTranscript<R> = PoseidonTranscript::default();
 
             let nvars = 5;
             let ((poly_mles, poly_degree), products, _) =
@@ -224,90 +220,78 @@ mod tests {
     }
 
     mod stark {
-        use cyclotomic_rings::rings::StarkChallengeSet;
         use stark_rings::cyclotomic_ring::models::stark_prime::RqNTT;
 
-        type CS = StarkChallengeSet;
-
         #[test]
         fn test_sumcheck() {
-            super::test_sumcheck::<RqNTT, CS>();
+            super::test_sumcheck::<RqNTT>();
         }
 
         #[test]
         fn test_sumcheck_proof_serialization() {
-            super::test_sumcheck_proof_serialization::<RqNTT, CS>();
+            super::test_sumcheck_proof_serialization::<RqNTT>();
         }
 
         #[test]
         fn test_failing_sumcheck() {
-            super::test_failing_sumcheck::<RqNTT, CS>();
+            super::test_failing_sumcheck::<RqNTT>();
         }
     }
 
     mod frog {
-        use cyclotomic_rings::rings::FrogChallengeSet;
         use stark_rings::cyclotomic_ring::models::frog_ring::RqNTT;
 
-        type CS = FrogChallengeSet;
-
         #[test]
         fn test_sumcheck() {
-            super::test_sumcheck::<RqNTT, CS>();
+            super::test_sumcheck::<RqNTT>();
         }
 
         #[test]
         fn test_sumcheck_proof_serialization() {
-            super::test_sumcheck_proof_serialization::<RqNTT, CS>();
+            super::test_sumcheck_proof_serialization::<RqNTT>();
         }
 
         #[test]
         fn test_failing_sumcheck() {
-            super::test_failing_sumcheck::<RqNTT, CS>();
+            super::test_failing_sumcheck::<RqNTT>();
         }
     }
 
     mod goldilocks {
-        use cyclotomic_rings::rings::GoldilocksChallengeSet;
         use stark_rings::cyclotomic_ring::models::goldilocks::RqNTT;
 
-        type CS = GoldilocksChallengeSet;
-
         #[test]
         fn test_sumcheck() {
-            super::test_sumcheck::<RqNTT, CS>();
+            super::test_sumcheck::<RqNTT>();
         }
 
         #[test]
         fn test_sumcheck_proof_serialization() {
-            super::test_sumcheck_proof_serialization::<RqNTT, CS>();
+            super::test_sumcheck_proof_serialization::<RqNTT>();
         }
 
         #[test]
         fn test_failing_sumcheck() {
-            super::test_failing_sumcheck::<RqNTT, CS>();
+            super::test_failing_sumcheck::<RqNTT>();
         }
     }
 
     mod babybear {
-        use cyclotomic_rings::rings::BabyBearChallengeSet;
         use stark_rings::cyclotomic_ring::models::babybear::RqNTT;
 
-        type CS = BabyBearChallengeSet;
-
         #[test]
         fn test_sumcheck() {
-            super::test_sumcheck::<RqNTT, CS>();
+            super::test_sumcheck::<RqNTT>();
         }
 
         #[test]
         fn test_sumcheck_proof_serialization() {
-            super::test_sumcheck_proof_serialization::<RqNTT, CS>();
+            super::test_sumcheck_proof_serialization::<RqNTT>();
         }
 
         #[test]
         fn test_failing_sumcheck() {
-            super::test_failing_sumcheck::<RqNTT, CS>();
+            super::test_failing_sumcheck::<RqNTT>();
         }
     }
 }
diff --git a/crates/cyclotomic-rings/Cargo.toml b/crates/rings/Cargo.toml
similarity index 94%
rename from crates/cyclotomic-rings/Cargo.toml
rename to crates/rings/Cargo.toml
index a963a5da..2b656cd4 100644
--- a/crates/cyclotomic-rings/Cargo.toml
+++ b/crates/rings/Cargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "cyclotomic-rings"
+name = "latticefold-rings"
 version = "0.1.0"
 edition.workspace = true
 license.workspace = true
diff --git a/crates/cyclotomic-rings/src/challenge_set.rs b/crates/rings/src/challenge_set.rs
similarity index 50%
rename from crates/cyclotomic-rings/src/challenge_set.rs
rename to crates/rings/src/challenge_set.rs
index edc2fb99..b048e933 100644
--- a/crates/cyclotomic-rings/src/challenge_set.rs
+++ b/crates/rings/src/challenge_set.rs
@@ -1,5 +1,5 @@
 //!
-//!  Short challenge set API.
+//!  Small challenge set API.
 //!
 
 use error::ChallengeSetError;
@@ -8,15 +8,15 @@ use crate::{ark_base::*, rings::SuitableRing};
 
 pub mod error;
 
-/// A trait to specify short challenge set for use in the LatticeFold protocol.
-pub trait LatticefoldChallengeSet<R: SuitableRing> {
-    /// Amount of bytes needed to obtain a single short challenge.
+/// A trait to specify small challenge set for use in the LatticeFold protocol.
+pub trait ChallengeSet<R: SuitableRing> {
+    /// Amount of bytes needed to obtain a single small challenge.
     const BYTES_NEEDED: usize;
 
-    /// Given a slice of bytes `bs` returns the short challenge encode with these bytes
+    /// Given a slice of bytes `bs` returns the small challenge encode with these bytes
     /// in the coefficient form. Returns `TooFewBytes` error if there is not enough bytes
-    /// to obtain a short challenge.
-    fn short_challenge_from_random_bytes(
+    /// to obtain a small challenge.
+    fn small_challenge_from_random_bytes(
         bs: &[u8],
     ) -> Result<R::CoefficientRepresentation, ChallengeSetError>;
 }
diff --git a/crates/cyclotomic-rings/src/challenge_set/error.rs b/crates/rings/src/challenge_set/error.rs
similarity index 79%
rename from crates/cyclotomic-rings/src/challenge_set/error.rs
rename to crates/rings/src/challenge_set/error.rs
index 807befa3..c77dcdbf 100644
--- a/crates/cyclotomic-rings/src/challenge_set/error.rs
+++ b/crates/rings/src/challenge_set/error.rs
@@ -2,11 +2,11 @@ use thiserror::Error;
 
 use crate::ark_base::*;
 
-/// Short challenge generation error.
+/// Small challenge generation error.
 #[derive(Debug, Error)]
 pub enum ChallengeSetError {
     /// An error meaning there is not enough bytes to generate
-    /// a short challenge.
+    /// a small challenge.
     #[error("too few bytes: got {0}, expected {1}")]
     TooFewBytes(usize, usize),
 }
diff --git a/crates/cyclotomic-rings/src/lib.rs b/crates/rings/src/lib.rs
similarity index 88%
rename from crates/cyclotomic-rings/src/lib.rs
rename to crates/rings/src/lib.rs
index 9d5169f8..340174d5 100644
--- a/crates/cyclotomic-rings/src/lib.rs
+++ b/crates/rings/src/lib.rs
@@ -1,6 +1,6 @@
 //!
 //! A crate containing the trait definition of a ring suitable to be used in the LatticeFold protocol,
-//! a few ready-to-use rings and short challenge set machinery.
+//! a few ready-to-use rings and small challenge set machinery.
 //!
 
 #![cfg_attr(not(feature = "std"), no_std)]
diff --git a/crates/cyclotomic-rings/src/rings.rs b/crates/rings/src/rings.rs
similarity index 97%
rename from crates/cyclotomic-rings/src/rings.rs
rename to crates/rings/src/rings.rs
index 73fefd86..738852f2 100644
--- a/crates/cyclotomic-rings/src/rings.rs
+++ b/crates/rings/src/rings.rs
@@ -12,6 +12,8 @@ use stark_rings::{
     Cyclotomic, OverField, PolyRing,
 };
 
+use crate::challenge_set::ChallengeSet;
+
 mod babybear;
 mod frog;
 mod goldilocks;
@@ -69,6 +71,9 @@ where
 
     /// Poseidon sponge parameters for the base prime field.
     type PoseidonParams: GetPoseidonParams<<<Self as PolyRing>::BaseRing as Field>::BasePrimeField>;
+
+    /// LatticeFold challenge set.
+    type ChallengeSet: ChallengeSet<Self>;
 }
 
 /// A trait for types with an associated Poseidon sponge configuration.
diff --git a/crates/cyclotomic-rings/src/rings/babybear.rs b/crates/rings/src/rings/babybear.rs
similarity index 93%
rename from crates/cyclotomic-rings/src/rings/babybear.rs
rename to crates/rings/src/rings/babybear.rs
index 094660e8..048e5358 100644
--- a/crates/cyclotomic-rings/src/rings/babybear.rs
+++ b/crates/rings/src/rings/babybear.rs
@@ -3,7 +3,7 @@ use stark_rings::cyclotomic_ring::models::babybear::{Fq, RqNTT, RqPoly};
 use super::SuitableRing;
 use crate::{
     ark_base::*,
-    challenge_set::{error, LatticefoldChallengeSet},
+    challenge_set::{error, ChallengeSet},
 };
 
 /// BabyBear ring in the NTT form.
@@ -22,6 +22,7 @@ pub type BabyBearRingPoly = RqPoly;
 impl SuitableRing for BabyBearRingNTT {
     type CoefficientRepresentation = RqPoly;
     type PoseidonParams = BabyBearPoseidonConfig;
+    type ChallengeSet = BabyBearChallengeSet;
 }
 
 pub struct BabyBearPoseidonConfig;
@@ -33,12 +34,12 @@ const MAX_COEFF: i16 = 32;
 
 /// For Babybear prime the challenge set is the set of all
 /// ring elements whose coefficients are in the range [-32, 32[.
-impl LatticefoldChallengeSet<BabyBearRingNTT> for BabyBearChallengeSet {
+impl ChallengeSet<BabyBearRingNTT> for BabyBearChallengeSet {
     /// To generate an element in [-32, 32[ it is enough to use 6 bits.
     /// Thus to generate 24 coefficients in that range 18 bytes is enough.
     const BYTES_NEEDED: usize = 18;
 
-    fn short_challenge_from_random_bytes(
+    fn small_challenge_from_random_bytes(
         bs: &[u8],
     ) -> Result<BabyBearRingPoly, error::ChallengeSetError> {
         if bs.len() != Self::BYTES_NEEDED {
@@ -76,7 +77,7 @@ mod tests {
 
     #[test]
     fn test_small_challenge_from_random_bytes() {
-        let challenge = BabyBearChallengeSet::short_challenge_from_random_bytes(&[
+        let challenge = BabyBearChallengeSet::small_challenge_from_random_bytes(&[
             0x7b, 0x4b, 0xe5, 0x8e, 0xe5, 0x11, 0xd2, 0xd0, 0x9c, 0x22, 0xba, 0x2e, 0xeb, 0xa8,
             0xba, 0x35, 0xf2, 0x18,
         ])
diff --git a/crates/cyclotomic-rings/src/rings/frog.rs b/crates/rings/src/rings/frog.rs
similarity index 91%
rename from crates/cyclotomic-rings/src/rings/frog.rs
rename to crates/rings/src/rings/frog.rs
index 61c9c375..a1a7d327 100644
--- a/crates/cyclotomic-rings/src/rings/frog.rs
+++ b/crates/rings/src/rings/frog.rs
@@ -3,7 +3,7 @@ use stark_rings::cyclotomic_ring::models::frog_ring::{Fq, RqNTT, RqPoly};
 use super::SuitableRing;
 use crate::{
     ark_base::*,
-    challenge_set::{error, LatticefoldChallengeSet},
+    challenge_set::{error, ChallengeSet},
 };
 
 /// Frog ring in the NTT form.
@@ -22,6 +22,7 @@ pub type FrogRingPoly = RqPoly;
 impl SuitableRing for FrogRingNTT {
     type CoefficientRepresentation = RqPoly;
     type PoseidonParams = FrogPoseidonConfig;
+    type ChallengeSet = FrogChallengeSet;
 }
 
 pub struct FrogPoseidonConfig;
@@ -31,10 +32,10 @@ pub struct FrogChallengeSet;
 
 /// For Frog prime the challenge set is the set of all
 /// ring elements whose coefficients are in the range [-128, 128[.
-impl LatticefoldChallengeSet<FrogRingNTT> for FrogChallengeSet {
+impl ChallengeSet<FrogRingNTT> for FrogChallengeSet {
     const BYTES_NEEDED: usize = 16;
 
-    fn short_challenge_from_random_bytes(
+    fn small_challenge_from_random_bytes(
         bs: &[u8],
     ) -> Result<
         <FrogRingNTT as SuitableRing>::CoefficientRepresentation,
@@ -64,7 +65,7 @@ mod tests {
 
     #[test]
     fn test_small_challenge_from_random_bytes() {
-        let challenge = FrogChallengeSet::short_challenge_from_random_bytes(&[
+        let challenge = FrogChallengeSet::small_challenge_from_random_bytes(&[
             0x7b, 0x4b, 0xe5, 0x8e, 0xe5, 0x11, 0xd2, 0xd0, 0x9c, 0x22, 0xba, 0x2e, 0xeb, 0xa8,
             0xba, 0x35,
         ])
diff --git a/crates/cyclotomic-rings/src/rings/goldilocks.rs b/crates/rings/src/rings/goldilocks.rs
similarity index 93%
rename from crates/cyclotomic-rings/src/rings/goldilocks.rs
rename to crates/rings/src/rings/goldilocks.rs
index 14c36986..39e3540c 100644
--- a/crates/cyclotomic-rings/src/rings/goldilocks.rs
+++ b/crates/rings/src/rings/goldilocks.rs
@@ -3,7 +3,7 @@ use stark_rings::cyclotomic_ring::models::goldilocks::{Fq, RqNTT, RqPoly};
 use super::SuitableRing;
 use crate::{
     ark_base::*,
-    challenge_set::{error, LatticefoldChallengeSet},
+    challenge_set::{error, ChallengeSet},
 };
 
 /// Goldilocks ring in the NTT form.
@@ -22,6 +22,7 @@ pub type GoldilocksRingPoly = RqPoly;
 impl SuitableRing for GoldilocksRingNTT {
     type CoefficientRepresentation = RqPoly;
     type PoseidonParams = GoldilocksPoseidonConfig;
+    type ChallengeSet = GoldilocksChallengeSet;
 }
 
 pub struct GoldilocksPoseidonConfig;
@@ -33,12 +34,12 @@ const MAX_COEFF: i16 = 32;
 
 /// For Goldilocks prime the challenge set is the set of all
 /// ring elements whose coefficients are in the range [-32, 32[.
-impl LatticefoldChallengeSet<GoldilocksRingNTT> for GoldilocksChallengeSet {
+impl ChallengeSet<GoldilocksRingNTT> for GoldilocksChallengeSet {
     /// To generate an element in [-32, 32[ it is enough to use 6 bits.
     /// Thus to generate 24 coefficients in that range 18 bytes is enough.
     const BYTES_NEEDED: usize = 18;
 
-    fn short_challenge_from_random_bytes(
+    fn small_challenge_from_random_bytes(
         bs: &[u8],
     ) -> Result<GoldilocksRingPoly, error::ChallengeSetError> {
         if bs.len() != Self::BYTES_NEEDED {
@@ -76,7 +77,7 @@ mod tests {
 
     #[test]
     fn test_small_challenge_from_random_bytes() {
-        let challenge = GoldilocksChallengeSet::short_challenge_from_random_bytes(&[
+        let challenge = GoldilocksChallengeSet::small_challenge_from_random_bytes(&[
             0x7b, 0x4b, 0xe5, 0x8e, 0xe5, 0x11, 0xd2, 0xd0, 0x9c, 0x22, 0xba, 0x2e, 0xeb, 0xa8,
             0xba, 0x35, 0xf2, 0x18,
         ])
diff --git a/crates/cyclotomic-rings/src/rings/poseidon.rs b/crates/rings/src/rings/poseidon.rs
similarity index 100%
rename from crates/cyclotomic-rings/src/rings/poseidon.rs
rename to crates/rings/src/rings/poseidon.rs
diff --git a/crates/cyclotomic-rings/src/rings/poseidon/babybear.rs b/crates/rings/src/rings/poseidon/babybear.rs
similarity index 100%
rename from crates/cyclotomic-rings/src/rings/poseidon/babybear.rs
rename to crates/rings/src/rings/poseidon/babybear.rs
diff --git a/crates/cyclotomic-rings/src/rings/poseidon/frog.rs b/crates/rings/src/rings/poseidon/frog.rs
similarity index 100%
rename from crates/cyclotomic-rings/src/rings/poseidon/frog.rs
rename to crates/rings/src/rings/poseidon/frog.rs
diff --git a/crates/cyclotomic-rings/src/rings/poseidon/goldilocks.rs b/crates/rings/src/rings/poseidon/goldilocks.rs
similarity index 100%
rename from crates/cyclotomic-rings/src/rings/poseidon/goldilocks.rs
rename to crates/rings/src/rings/poseidon/goldilocks.rs
diff --git a/crates/cyclotomic-rings/src/rings/poseidon/stark.rs b/crates/rings/src/rings/poseidon/stark.rs
similarity index 100%
rename from crates/cyclotomic-rings/src/rings/poseidon/stark.rs
rename to crates/rings/src/rings/poseidon/stark.rs
diff --git a/crates/cyclotomic-rings/src/rings/stark.rs b/crates/rings/src/rings/stark.rs
similarity index 90%
rename from crates/cyclotomic-rings/src/rings/stark.rs
rename to crates/rings/src/rings/stark.rs
index c1d13b34..6c801f1d 100644
--- a/crates/cyclotomic-rings/src/rings/stark.rs
+++ b/crates/rings/src/rings/stark.rs
@@ -4,7 +4,7 @@ use stark_rings::cyclotomic_ring::models::stark_prime::{Fq, RqNTT, RqPoly};
 use super::SuitableRing;
 use crate::{
     ark_base::*,
-    challenge_set::{error, LatticefoldChallengeSet},
+    challenge_set::{error, ChallengeSet},
 };
 
 /// Starknet prime ring in the NTT form.
@@ -21,8 +21,8 @@ pub type StarkRingPoly = RqPoly;
 
 impl SuitableRing for StarkRingNTT {
     type CoefficientRepresentation = StarkRingPoly;
-
     type PoseidonParams = StarkPoseidonConfig;
+    type ChallengeSet = StarkChallengeSet;
 }
 
 pub struct StarkPoseidonConfig;
@@ -31,10 +31,10 @@ pub struct StarkPoseidonConfig;
 pub struct StarkChallengeSet;
 
 /// Small challenges are the ring elements with coefficients in range [0; 2^8[.
-impl LatticefoldChallengeSet<StarkRingNTT> for StarkChallengeSet {
+impl ChallengeSet<StarkRingNTT> for StarkChallengeSet {
     const BYTES_NEEDED: usize = 16;
 
-    fn short_challenge_from_random_bytes(
+    fn small_challenge_from_random_bytes(
         bs: &[u8],
     ) -> Result<<StarkRingNTT as SuitableRing>::CoefficientRepresentation, error::ChallengeSetError>
     {
@@ -59,7 +59,7 @@ mod tests {
 
     #[test]
     fn test_small_challenge_from_random_bytes() {
-        let challenge = StarkChallengeSet::short_challenge_from_random_bytes(&[
+        let challenge = StarkChallengeSet::small_challenge_from_random_bytes(&[
             0x7b, 0x4b, 0xe5, 0x8e, 0xe5, 0x11, 0xd2, 0xd0, 0x9c, 0x22, 0xba, 0x2e, 0xeb, 0xa8,
             0xba, 0x35,
         ])
diff --git a/crates/cyclotomic-rings/src/rotation.rs b/crates/rings/src/rotation.rs
similarity index 100%
rename from crates/cyclotomic-rings/src/rotation.rs
rename to crates/rings/src/rotation.rs