From 33f4befe7219ac3042a57aaf76b9cecf76df4a62 Mon Sep 17 00:00:00 2001
From: guipublic <47281315+guipublic@users.noreply.github.com>
Date: Mon, 5 Feb 2024 14:52:31 +0100
Subject: [PATCH] feat!: Add expression width into acir (#4014)

Resolves Noir issue https://github.com/noir-lang/noir/issues/4012, by
adding ExpressionWidth into acir.
The PR simply account for this new field and update the serialisation.
It also set the width during csat transformation phase.

---------

Co-authored-by: kevaundray <kevtheappdev@gmail.com>
---
 .../dsl/acir_format/serde/acir.hpp            | 167 ++++++++++++++++++
 noir/acvm-repo/acir/codegen/acir.cpp          | 142 +++++++++++++++
 noir/acvm-repo/acir/src/circuit/mod.rs        |  22 ++-
 noir/acvm-repo/acir/src/lib.rs                |   3 +-
 noir/acvm-repo/acvm/src/compiler/mod.rs       |   4 +-
 .../compiler/optimizers/redundant_range.rs    |   3 +-
 .../acvm/src/compiler/transformers/mod.rs     |   9 +-
 noir/acvm-repo/acvm/src/lib.rs                |  25 ---
 noir/compiler/noirc_driver/src/lib.rs         |   8 +-
 noir/compiler/noirc_evaluator/src/ssa.rs      |   3 +-
 noir/compiler/wasm/src/compile.rs             |   2 +-
 noir/compiler/wasm/src/compile_new.rs         |   4 +-
 .../tooling/backend_interface/src/cli/info.rs |   3 +-
 .../backend_interface/src/proof_system.rs     |   6 +-
 .../backend_interface/src/smart_contract.rs   |   3 +-
 noir/tooling/lsp/src/requests/profile_run.rs  |   2 +-
 noir/tooling/nargo/src/ops/transform.rs       |   2 +-
 noir/tooling/nargo_cli/src/cli/dap_cmd.rs     |   7 +-
 noir/tooling/nargo_cli/src/cli/info_cmd.rs    |   2 +-
 19 files changed, 365 insertions(+), 52 deletions(-)

diff --git a/barretenberg/cpp/src/barretenberg/dsl/acir_format/serde/acir.hpp b/barretenberg/cpp/src/barretenberg/dsl/acir_format/serde/acir.hpp
index fe9c4e9f340..fc6ad6b3fa7 100644
--- a/barretenberg/cpp/src/barretenberg/dsl/acir_format/serde/acir.hpp
+++ b/barretenberg/cpp/src/barretenberg/dsl/acir_format/serde/acir.hpp
@@ -1078,6 +1078,29 @@ struct Opcode {
     static Opcode bincodeDeserialize(std::vector<uint8_t>);
 };
 
+struct ExpressionWidth {
+
+    struct Unbounded {
+        friend bool operator==(const Unbounded&, const Unbounded&);
+        std::vector<uint8_t> bincodeSerialize() const;
+        static Unbounded bincodeDeserialize(std::vector<uint8_t>);
+    };
+
+    struct Bounded {
+        uint64_t width;
+
+        friend bool operator==(const Bounded&, const Bounded&);
+        std::vector<uint8_t> bincodeSerialize() const;
+        static Bounded bincodeDeserialize(std::vector<uint8_t>);
+    };
+
+    std::variant<Unbounded, Bounded> value;
+
+    friend bool operator==(const ExpressionWidth&, const ExpressionWidth&);
+    std::vector<uint8_t> bincodeSerialize() const;
+    static ExpressionWidth bincodeDeserialize(std::vector<uint8_t>);
+};
+
 struct OpcodeLocation {
 
     struct Acir {
@@ -1115,6 +1138,7 @@ struct PublicInputs {
 struct Circuit {
     uint32_t current_witness_index;
     std::vector<Opcode> opcodes;
+    ExpressionWidth expression_width;
     std::vector<Witness> private_parameters;
     PublicInputs public_parameters;
     PublicInputs return_values;
@@ -5933,6 +5957,9 @@ inline bool operator==(const Circuit& lhs, const Circuit& rhs)
     if (!(lhs.opcodes == rhs.opcodes)) {
         return false;
     }
+    if (!(lhs.expression_width == rhs.expression_width)) {
+        return false;
+    }
     if (!(lhs.private_parameters == rhs.private_parameters)) {
         return false;
     }
@@ -5977,6 +6004,7 @@ void serde::Serializable<Circuit::Circuit>::serialize(const Circuit::Circuit& ob
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.current_witness_index)>::serialize(obj.current_witness_index, serializer);
     serde::Serializable<decltype(obj.opcodes)>::serialize(obj.opcodes, serializer);
+    serde::Serializable<decltype(obj.expression_width)>::serialize(obj.expression_width, serializer);
     serde::Serializable<decltype(obj.private_parameters)>::serialize(obj.private_parameters, serializer);
     serde::Serializable<decltype(obj.public_parameters)>::serialize(obj.public_parameters, serializer);
     serde::Serializable<decltype(obj.return_values)>::serialize(obj.return_values, serializer);
@@ -5993,6 +6021,7 @@ Circuit::Circuit serde::Deserializable<Circuit::Circuit>::deserialize(Deserializ
     Circuit::Circuit obj;
     obj.current_witness_index = serde::Deserializable<decltype(obj.current_witness_index)>::deserialize(deserializer);
     obj.opcodes = serde::Deserializable<decltype(obj.opcodes)>::deserialize(deserializer);
+    obj.expression_width = serde::Deserializable<decltype(obj.expression_width)>::deserialize(deserializer);
     obj.private_parameters = serde::Deserializable<decltype(obj.private_parameters)>::deserialize(deserializer);
     obj.public_parameters = serde::Deserializable<decltype(obj.public_parameters)>::deserialize(deserializer);
     obj.return_values = serde::Deserializable<decltype(obj.return_values)>::deserialize(deserializer);
@@ -6231,6 +6260,144 @@ Circuit::Expression serde::Deserializable<Circuit::Expression>::deserialize(Dese
 
 namespace Circuit {
 
+inline bool operator==(const ExpressionWidth& lhs, const ExpressionWidth& rhs)
+{
+    if (!(lhs.value == rhs.value)) {
+        return false;
+    }
+    return true;
+}
+
+inline std::vector<uint8_t> ExpressionWidth::bincodeSerialize() const
+{
+    auto serializer = serde::BincodeSerializer();
+    serde::Serializable<ExpressionWidth>::serialize(*this, serializer);
+    return std::move(serializer).bytes();
+}
+
+inline ExpressionWidth ExpressionWidth::bincodeDeserialize(std::vector<uint8_t> input)
+{
+    auto deserializer = serde::BincodeDeserializer(input);
+    auto value = serde::Deserializable<ExpressionWidth>::deserialize(deserializer);
+    if (deserializer.get_buffer_offset() < input.size()) {
+        throw_or_abort("Some input bytes were not read");
+    }
+    return value;
+}
+
+} // end of namespace Circuit
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Circuit::ExpressionWidth>::serialize(const Circuit::ExpressionWidth& obj,
+                                                              Serializer& serializer)
+{
+    serializer.increase_container_depth();
+    serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
+    serializer.decrease_container_depth();
+}
+
+template <>
+template <typename Deserializer>
+Circuit::ExpressionWidth serde::Deserializable<Circuit::ExpressionWidth>::deserialize(Deserializer& deserializer)
+{
+    deserializer.increase_container_depth();
+    Circuit::ExpressionWidth obj;
+    obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
+    deserializer.decrease_container_depth();
+    return obj;
+}
+
+namespace Circuit {
+
+inline bool operator==(const ExpressionWidth::Unbounded& lhs, const ExpressionWidth::Unbounded& rhs)
+{
+    return true;
+}
+
+inline std::vector<uint8_t> ExpressionWidth::Unbounded::bincodeSerialize() const
+{
+    auto serializer = serde::BincodeSerializer();
+    serde::Serializable<ExpressionWidth::Unbounded>::serialize(*this, serializer);
+    return std::move(serializer).bytes();
+}
+
+inline ExpressionWidth::Unbounded ExpressionWidth::Unbounded::bincodeDeserialize(std::vector<uint8_t> input)
+{
+    auto deserializer = serde::BincodeDeserializer(input);
+    auto value = serde::Deserializable<ExpressionWidth::Unbounded>::deserialize(deserializer);
+    if (deserializer.get_buffer_offset() < input.size()) {
+        throw_or_abort("Some input bytes were not read");
+    }
+    return value;
+}
+
+} // end of namespace Circuit
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Circuit::ExpressionWidth::Unbounded>::serialize(const Circuit::ExpressionWidth::Unbounded& obj,
+                                                                         Serializer& serializer)
+{}
+
+template <>
+template <typename Deserializer>
+Circuit::ExpressionWidth::Unbounded serde::Deserializable<Circuit::ExpressionWidth::Unbounded>::deserialize(
+    Deserializer& deserializer)
+{
+    Circuit::ExpressionWidth::Unbounded obj;
+    return obj;
+}
+
+namespace Circuit {
+
+inline bool operator==(const ExpressionWidth::Bounded& lhs, const ExpressionWidth::Bounded& rhs)
+{
+    if (!(lhs.width == rhs.width)) {
+        return false;
+    }
+    return true;
+}
+
+inline std::vector<uint8_t> ExpressionWidth::Bounded::bincodeSerialize() const
+{
+    auto serializer = serde::BincodeSerializer();
+    serde::Serializable<ExpressionWidth::Bounded>::serialize(*this, serializer);
+    return std::move(serializer).bytes();
+}
+
+inline ExpressionWidth::Bounded ExpressionWidth::Bounded::bincodeDeserialize(std::vector<uint8_t> input)
+{
+    auto deserializer = serde::BincodeDeserializer(input);
+    auto value = serde::Deserializable<ExpressionWidth::Bounded>::deserialize(deserializer);
+    if (deserializer.get_buffer_offset() < input.size()) {
+        throw_or_abort("Some input bytes were not read");
+    }
+    return value;
+}
+
+} // end of namespace Circuit
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Circuit::ExpressionWidth::Bounded>::serialize(const Circuit::ExpressionWidth::Bounded& obj,
+                                                                       Serializer& serializer)
+{
+    serde::Serializable<decltype(obj.width)>::serialize(obj.width, serializer);
+}
+
+template <>
+template <typename Deserializer>
+Circuit::ExpressionWidth::Bounded serde::Deserializable<Circuit::ExpressionWidth::Bounded>::deserialize(
+    Deserializer& deserializer)
+{
+    Circuit::ExpressionWidth::Bounded obj;
+    obj.width = serde::Deserializable<decltype(obj.width)>::deserialize(deserializer);
+    return obj;
+}
+
+namespace Circuit {
+
 inline bool operator==(const FunctionInput& lhs, const FunctionInput& rhs)
 {
     if (!(lhs.witness == rhs.witness)) {
diff --git a/noir/acvm-repo/acir/codegen/acir.cpp b/noir/acvm-repo/acir/codegen/acir.cpp
index b65dfd45030..c26d6528c4f 100644
--- a/noir/acvm-repo/acir/codegen/acir.cpp
+++ b/noir/acvm-repo/acir/codegen/acir.cpp
@@ -1017,6 +1017,29 @@ namespace Circuit {
         static Opcode bincodeDeserialize(std::vector<uint8_t>);
     };
 
+    struct ExpressionWidth {
+
+        struct Unbounded {
+            friend bool operator==(const Unbounded&, const Unbounded&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static Unbounded bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        struct Bounded {
+            uint64_t width;
+
+            friend bool operator==(const Bounded&, const Bounded&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static Bounded bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        std::variant<Unbounded, Bounded> value;
+
+        friend bool operator==(const ExpressionWidth&, const ExpressionWidth&);
+        std::vector<uint8_t> bincodeSerialize() const;
+        static ExpressionWidth bincodeDeserialize(std::vector<uint8_t>);
+    };
+
     struct OpcodeLocation {
 
         struct Acir {
@@ -1054,6 +1077,7 @@ namespace Circuit {
     struct Circuit {
         uint32_t current_witness_index;
         std::vector<Circuit::Opcode> opcodes;
+        Circuit::ExpressionWidth expression_width;
         std::vector<Circuit::Witness> private_parameters;
         Circuit::PublicInputs public_parameters;
         Circuit::PublicInputs return_values;
@@ -4890,6 +4914,7 @@ namespace Circuit {
     inline bool operator==(const Circuit &lhs, const Circuit &rhs) {
         if (!(lhs.current_witness_index == rhs.current_witness_index)) { return false; }
         if (!(lhs.opcodes == rhs.opcodes)) { return false; }
+        if (!(lhs.expression_width == rhs.expression_width)) { return false; }
         if (!(lhs.private_parameters == rhs.private_parameters)) { return false; }
         if (!(lhs.public_parameters == rhs.public_parameters)) { return false; }
         if (!(lhs.return_values == rhs.return_values)) { return false; }
@@ -4921,6 +4946,7 @@ void serde::Serializable<Circuit::Circuit>::serialize(const Circuit::Circuit &ob
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.current_witness_index)>::serialize(obj.current_witness_index, serializer);
     serde::Serializable<decltype(obj.opcodes)>::serialize(obj.opcodes, serializer);
+    serde::Serializable<decltype(obj.expression_width)>::serialize(obj.expression_width, serializer);
     serde::Serializable<decltype(obj.private_parameters)>::serialize(obj.private_parameters, serializer);
     serde::Serializable<decltype(obj.public_parameters)>::serialize(obj.public_parameters, serializer);
     serde::Serializable<decltype(obj.return_values)>::serialize(obj.return_values, serializer);
@@ -4936,6 +4962,7 @@ Circuit::Circuit serde::Deserializable<Circuit::Circuit>::deserialize(Deserializ
     Circuit::Circuit obj;
     obj.current_witness_index = serde::Deserializable<decltype(obj.current_witness_index)>::deserialize(deserializer);
     obj.opcodes = serde::Deserializable<decltype(obj.opcodes)>::deserialize(deserializer);
+    obj.expression_width = serde::Deserializable<decltype(obj.expression_width)>::deserialize(deserializer);
     obj.private_parameters = serde::Deserializable<decltype(obj.private_parameters)>::deserialize(deserializer);
     obj.public_parameters = serde::Deserializable<decltype(obj.public_parameters)>::deserialize(deserializer);
     obj.return_values = serde::Deserializable<decltype(obj.return_values)>::deserialize(deserializer);
@@ -5126,6 +5153,121 @@ Circuit::Expression serde::Deserializable<Circuit::Expression>::deserialize(Dese
     return obj;
 }
 
+namespace Circuit {
+
+    inline bool operator==(const ExpressionWidth &lhs, const ExpressionWidth &rhs) {
+        if (!(lhs.value == rhs.value)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> ExpressionWidth::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<ExpressionWidth>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline ExpressionWidth ExpressionWidth::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<ExpressionWidth>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Circuit
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Circuit::ExpressionWidth>::serialize(const Circuit::ExpressionWidth &obj, Serializer &serializer) {
+    serializer.increase_container_depth();
+    serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
+    serializer.decrease_container_depth();
+}
+
+template <>
+template <typename Deserializer>
+Circuit::ExpressionWidth serde::Deserializable<Circuit::ExpressionWidth>::deserialize(Deserializer &deserializer) {
+    deserializer.increase_container_depth();
+    Circuit::ExpressionWidth obj;
+    obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
+    deserializer.decrease_container_depth();
+    return obj;
+}
+
+namespace Circuit {
+
+    inline bool operator==(const ExpressionWidth::Unbounded &lhs, const ExpressionWidth::Unbounded &rhs) {
+        return true;
+    }
+
+    inline std::vector<uint8_t> ExpressionWidth::Unbounded::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<ExpressionWidth::Unbounded>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline ExpressionWidth::Unbounded ExpressionWidth::Unbounded::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<ExpressionWidth::Unbounded>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Circuit
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Circuit::ExpressionWidth::Unbounded>::serialize(const Circuit::ExpressionWidth::Unbounded &obj, Serializer &serializer) {
+}
+
+template <>
+template <typename Deserializer>
+Circuit::ExpressionWidth::Unbounded serde::Deserializable<Circuit::ExpressionWidth::Unbounded>::deserialize(Deserializer &deserializer) {
+    Circuit::ExpressionWidth::Unbounded obj;
+    return obj;
+}
+
+namespace Circuit {
+
+    inline bool operator==(const ExpressionWidth::Bounded &lhs, const ExpressionWidth::Bounded &rhs) {
+        if (!(lhs.width == rhs.width)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> ExpressionWidth::Bounded::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<ExpressionWidth::Bounded>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline ExpressionWidth::Bounded ExpressionWidth::Bounded::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<ExpressionWidth::Bounded>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Circuit
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Circuit::ExpressionWidth::Bounded>::serialize(const Circuit::ExpressionWidth::Bounded &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.width)>::serialize(obj.width, serializer);
+}
+
+template <>
+template <typename Deserializer>
+Circuit::ExpressionWidth::Bounded serde::Deserializable<Circuit::ExpressionWidth::Bounded>::deserialize(Deserializer &deserializer) {
+    Circuit::ExpressionWidth::Bounded obj;
+    obj.width = serde::Deserializable<decltype(obj.width)>::deserialize(deserializer);
+    return obj;
+}
+
 namespace Circuit {
 
     inline bool operator==(const FunctionInput &lhs, const FunctionInput &rhs) {
diff --git a/noir/acvm-repo/acir/src/circuit/mod.rs b/noir/acvm-repo/acir/src/circuit/mod.rs
index ccfb19bbf05..9cbacdc2ab0 100644
--- a/noir/acvm-repo/acir/src/circuit/mod.rs
+++ b/noir/acvm-repo/acir/src/circuit/mod.rs
@@ -15,12 +15,30 @@ use serde::{de::Error as DeserializationError, Deserialize, Deserializer, Serial
 
 use std::collections::BTreeSet;
 
+/// Specifies the maximum width of the expressions which will be constrained.
+///
+/// Unbounded Expressions are useful if you are eventually going to pass the ACIR
+/// into a proving system which supports R1CS.
+///
+/// Bounded Expressions are useful if you are eventually going to pass the ACIR
+/// into a proving system which supports PLONK, where arithmetic expressions have a
+/// finite fan-in.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
+pub enum ExpressionWidth {
+    #[default]
+    Unbounded,
+    Bounded {
+        width: usize,
+    },
+}
+
 #[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
 pub struct Circuit {
     // current_witness_index is the highest witness index in the circuit. The next witness to be added to this circuit
     // will take on this value. (The value is cached here as an optimization.)
     pub current_witness_index: u32,
     pub opcodes: Vec<Opcode>,
+    pub expression_width: ExpressionWidth,
 
     /// The set of private inputs to the circuit.
     pub private_parameters: BTreeSet<Witness>,
@@ -240,7 +258,7 @@ mod tests {
         opcodes::{BlackBoxFuncCall, FunctionInput},
         Circuit, Compression, Opcode, PublicInputs,
     };
-    use crate::native_types::Witness;
+    use crate::{circuit::ExpressionWidth, native_types::Witness};
     use acir_field::FieldElement;
 
     fn and_opcode() -> Opcode {
@@ -318,6 +336,7 @@ mod tests {
     fn serialization_roundtrip() {
         let circuit = Circuit {
             current_witness_index: 5,
+            expression_width: ExpressionWidth::Unbounded,
             opcodes: vec![and_opcode(), range_opcode()],
             private_parameters: BTreeSet::new(),
             public_parameters: PublicInputs(BTreeSet::from_iter(vec![Witness(2), Witness(12)])),
@@ -340,6 +359,7 @@ mod tests {
     fn test_serialize() {
         let circuit = Circuit {
             current_witness_index: 0,
+            expression_width: ExpressionWidth::Unbounded,
             opcodes: vec![
                 Opcode::AssertZero(crate::native_types::Expression {
                     mul_terms: vec![],
diff --git a/noir/acvm-repo/acir/src/lib.rs b/noir/acvm-repo/acir/src/lib.rs
index 0a72cec6070..aac01400290 100644
--- a/noir/acvm-repo/acir/src/lib.rs
+++ b/noir/acvm-repo/acir/src/lib.rs
@@ -39,7 +39,7 @@ mod reflection {
             brillig::{BrilligInputs, BrilligOutputs},
             directives::Directive,
             opcodes::BlackBoxFuncCall,
-            Circuit, Opcode, OpcodeLocation,
+            Circuit, ExpressionWidth, Opcode, OpcodeLocation,
         },
         native_types::{Witness, WitnessMap},
     };
@@ -57,6 +57,7 @@ mod reflection {
 
         let mut tracer = Tracer::new(TracerConfig::default());
         tracer.trace_simple_type::<Circuit>().unwrap();
+        tracer.trace_simple_type::<ExpressionWidth>().unwrap();
         tracer.trace_simple_type::<Opcode>().unwrap();
         tracer.trace_simple_type::<OpcodeLocation>().unwrap();
         tracer.trace_simple_type::<BinaryFieldOp>().unwrap();
diff --git a/noir/acvm-repo/acvm/src/compiler/mod.rs b/noir/acvm-repo/acvm/src/compiler/mod.rs
index ccb043914d6..6543c70958b 100644
--- a/noir/acvm-repo/acvm/src/compiler/mod.rs
+++ b/noir/acvm-repo/acvm/src/compiler/mod.rs
@@ -1,8 +1,6 @@
 use std::collections::HashMap;
 
-use acir::circuit::{Circuit, OpcodeLocation};
-
-use crate::ExpressionWidth;
+use acir::circuit::{Circuit, ExpressionWidth, OpcodeLocation};
 
 // The various passes that we can use over ACIR
 mod optimizers;
diff --git a/noir/acvm-repo/acvm/src/compiler/optimizers/redundant_range.rs b/noir/acvm-repo/acvm/src/compiler/optimizers/redundant_range.rs
index c7561298d4a..64fe5291cc6 100644
--- a/noir/acvm-repo/acvm/src/compiler/optimizers/redundant_range.rs
+++ b/noir/acvm-repo/acvm/src/compiler/optimizers/redundant_range.rs
@@ -148,7 +148,7 @@ mod tests {
     use acir::{
         circuit::{
             opcodes::{BlackBoxFuncCall, FunctionInput},
-            Circuit, Opcode, PublicInputs,
+            Circuit, ExpressionWidth, Opcode, PublicInputs,
         },
         native_types::{Expression, Witness},
     };
@@ -167,6 +167,7 @@ mod tests {
 
         Circuit {
             current_witness_index: 1,
+            expression_width: ExpressionWidth::Bounded { width: 3 },
             opcodes,
             private_parameters: BTreeSet::new(),
             public_parameters: PublicInputs::default(),
diff --git a/noir/acvm-repo/acvm/src/compiler/transformers/mod.rs b/noir/acvm-repo/acvm/src/compiler/transformers/mod.rs
index e184401c5d4..4be2eb7029e 100644
--- a/noir/acvm-repo/acvm/src/compiler/transformers/mod.rs
+++ b/noir/acvm-repo/acvm/src/compiler/transformers/mod.rs
@@ -1,12 +1,10 @@
 use acir::{
-    circuit::{brillig::BrilligOutputs, directives::Directive, Circuit, Opcode},
+    circuit::{brillig::BrilligOutputs, directives::Directive, Circuit, ExpressionWidth, Opcode},
     native_types::{Expression, Witness},
     FieldElement,
 };
 use indexmap::IndexMap;
 
-use crate::ExpressionWidth;
-
 mod csat;
 mod r1cs;
 
@@ -44,11 +42,11 @@ pub(super) fn transform_internal(
     acir_opcode_positions: Vec<usize>,
 ) -> (Circuit, Vec<usize>) {
     let mut transformer = match &expression_width {
-        crate::ExpressionWidth::Unbounded => {
+        ExpressionWidth::Unbounded => {
             let transformer = R1CSTransformer::new(acir);
             return (transformer.transform(), acir_opcode_positions);
         }
-        crate::ExpressionWidth::Bounded { width } => {
+        ExpressionWidth::Bounded { width } => {
             let mut csat = CSatTransformer::new(*width);
             for value in acir.circuit_arguments() {
                 csat.mark_solvable(value);
@@ -159,6 +157,7 @@ pub(super) fn transform_internal(
 
     let acir = Circuit {
         current_witness_index,
+        expression_width,
         opcodes: transformed_opcodes,
         // The transformer does not add new public inputs
         ..acir
diff --git a/noir/acvm-repo/acvm/src/lib.rs b/noir/acvm-repo/acvm/src/lib.rs
index 264479d8a12..00a253fde07 100644
--- a/noir/acvm-repo/acvm/src/lib.rs
+++ b/noir/acvm-repo/acvm/src/lib.rs
@@ -7,7 +7,6 @@ pub mod compiler;
 pub mod pwg;
 
 pub use acvm_blackbox_solver::{BlackBoxFunctionSolver, BlackBoxResolutionError};
-use core::fmt::Debug;
 use pwg::OpcodeResolutionError;
 
 // re-export acir
@@ -17,27 +16,3 @@ pub use acir::FieldElement;
 pub use brillig_vm;
 // re-export blackbox solver
 pub use acvm_blackbox_solver as blackbox_solver;
-
-/// Specifies the maximum width of the expressions which will be constrained.
-///
-/// Unbounded Expressions are useful if you are eventually going to pass the ACIR
-/// into a proving system which supports R1CS.
-///
-/// Bounded Expressions are useful if you are eventually going to pass the ACIR
-/// into a proving system which supports PLONK, where arithmetic expressions have a
-/// finite fan-in.
-#[derive(Debug, Clone, Copy)]
-pub enum ExpressionWidth {
-    Unbounded,
-    Bounded { width: usize },
-}
-
-impl From<usize> for ExpressionWidth {
-    fn from(width: usize) -> ExpressionWidth {
-        if width == 0 {
-            ExpressionWidth::Unbounded
-        } else {
-            ExpressionWidth::Bounded { width }
-        }
-    }
-}
diff --git a/noir/compiler/noirc_driver/src/lib.rs b/noir/compiler/noirc_driver/src/lib.rs
index 6fd69f8b576..cded514f28c 100644
--- a/noir/compiler/noirc_driver/src/lib.rs
+++ b/noir/compiler/noirc_driver/src/lib.rs
@@ -3,7 +3,7 @@
 #![warn(unreachable_pub)]
 #![warn(clippy::semicolon_if_nothing_returned)]
 
-use acvm::ExpressionWidth;
+use acvm::acir::circuit::ExpressionWidth;
 use clap::Args;
 use fm::{FileId, FileManager};
 use iter_extended::vecmap;
@@ -87,12 +87,14 @@ pub struct CompileOptions {
 
 fn parse_expression_width(input: &str) -> Result<ExpressionWidth, std::io::Error> {
     use std::io::{Error, ErrorKind};
-
     let width = input
         .parse::<usize>()
         .map_err(|err| Error::new(ErrorKind::InvalidInput, err.to_string()))?;
 
-    Ok(ExpressionWidth::from(width))
+    match width {
+        0 => Ok(ExpressionWidth::Unbounded),
+        _ => Ok(ExpressionWidth::Bounded { width }),
+    }
 }
 
 /// Helper type used to signify where only warnings are expected in file diagnostics
diff --git a/noir/compiler/noirc_evaluator/src/ssa.rs b/noir/compiler/noirc_evaluator/src/ssa.rs
index 108737f1f75..e1a2e0d3564 100644
--- a/noir/compiler/noirc_evaluator/src/ssa.rs
+++ b/noir/compiler/noirc_evaluator/src/ssa.rs
@@ -14,7 +14,7 @@ use crate::{
     errors::{RuntimeError, SsaReport},
 };
 use acvm::acir::{
-    circuit::{Circuit, PublicInputs},
+    circuit::{Circuit, ExpressionWidth, PublicInputs},
     native_types::Witness,
 };
 
@@ -107,6 +107,7 @@ pub fn create_circuit(
 
     let circuit = Circuit {
         current_witness_index,
+        expression_width: ExpressionWidth::Unbounded,
         opcodes,
         private_parameters,
         public_parameters,
diff --git a/noir/compiler/wasm/src/compile.rs b/noir/compiler/wasm/src/compile.rs
index b39a27a7931..c8b1680bc00 100644
--- a/noir/compiler/wasm/src/compile.rs
+++ b/noir/compiler/wasm/src/compile.rs
@@ -177,7 +177,7 @@ pub fn compile(
     let compile_options = CompileOptions::default();
 
     // For now we default to a bounded width of 3, though we can add it as a parameter
-    let expression_width = acvm::ExpressionWidth::Bounded { width: 3 };
+    let expression_width = acvm::acir::circuit::ExpressionWidth::Bounded { width: 3 };
 
     if contracts.unwrap_or_default() {
         let compiled_contract = compile_contract(&mut context, crate_id, &compile_options)
diff --git a/noir/compiler/wasm/src/compile_new.rs b/noir/compiler/wasm/src/compile_new.rs
index 4616004ae2b..f8fbed4f470 100644
--- a/noir/compiler/wasm/src/compile_new.rs
+++ b/noir/compiler/wasm/src/compile_new.rs
@@ -94,7 +94,7 @@ impl CompilerContext {
         program_width: usize,
     ) -> Result<JsCompileResult, JsCompileError> {
         let compile_options = CompileOptions::default();
-        let np_language = acvm::ExpressionWidth::Bounded { width: program_width };
+        let np_language = acvm::acir::circuit::ExpressionWidth::Bounded { width: program_width };
 
         let root_crate_id = *self.context.root_crate_id();
 
@@ -120,7 +120,7 @@ impl CompilerContext {
         program_width: usize,
     ) -> Result<JsCompileResult, JsCompileError> {
         let compile_options = CompileOptions::default();
-        let np_language = acvm::ExpressionWidth::Bounded { width: program_width };
+        let np_language = acvm::acir::circuit::ExpressionWidth::Bounded { width: program_width };
         let root_crate_id = *self.context.root_crate_id();
 
         let compiled_contract =
diff --git a/noir/tooling/backend_interface/src/cli/info.rs b/noir/tooling/backend_interface/src/cli/info.rs
index 934351dd517..8ca3d4dd0a3 100644
--- a/noir/tooling/backend_interface/src/cli/info.rs
+++ b/noir/tooling/backend_interface/src/cli/info.rs
@@ -1,4 +1,5 @@
-use acvm::ExpressionWidth;
+use acvm::acir::circuit::ExpressionWidth;
+
 use serde::Deserialize;
 use std::path::{Path, PathBuf};
 
diff --git a/noir/tooling/backend_interface/src/proof_system.rs b/noir/tooling/backend_interface/src/proof_system.rs
index 9369c91fa94..485381006df 100644
--- a/noir/tooling/backend_interface/src/proof_system.rs
+++ b/noir/tooling/backend_interface/src/proof_system.rs
@@ -2,8 +2,10 @@ use std::fs::File;
 use std::io::Write;
 use std::path::Path;
 
-use acvm::acir::{circuit::Circuit, native_types::WitnessMap};
-use acvm::ExpressionWidth;
+use acvm::acir::{
+    circuit::{Circuit, ExpressionWidth},
+    native_types::WitnessMap,
+};
 use acvm::FieldElement;
 use tempfile::tempdir;
 use tracing::warn;
diff --git a/noir/tooling/backend_interface/src/smart_contract.rs b/noir/tooling/backend_interface/src/smart_contract.rs
index 524832c6308..5af75e48389 100644
--- a/noir/tooling/backend_interface/src/smart_contract.rs
+++ b/noir/tooling/backend_interface/src/smart_contract.rs
@@ -38,7 +38,7 @@ mod tests {
     use std::collections::BTreeSet;
 
     use acvm::acir::{
-        circuit::{Circuit, Opcode, PublicInputs},
+        circuit::{Circuit, ExpressionWidth, Opcode, PublicInputs},
         native_types::{Expression, Witness},
     };
 
@@ -51,6 +51,7 @@ mod tests {
 
         let circuit = Circuit {
             current_witness_index: 4,
+            expression_width: ExpressionWidth::Bounded { width: 3 },
             opcodes: vec![constraint],
             private_parameters: BTreeSet::from([Witness(1), Witness(2)]),
             public_parameters: PublicInputs::default(),
diff --git a/noir/tooling/lsp/src/requests/profile_run.rs b/noir/tooling/lsp/src/requests/profile_run.rs
index d866be8988b..917c247410d 100644
--- a/noir/tooling/lsp/src/requests/profile_run.rs
+++ b/noir/tooling/lsp/src/requests/profile_run.rs
@@ -3,7 +3,7 @@ use std::{
     future::{self, Future},
 };
 
-use acvm::ExpressionWidth;
+use acvm::acir::circuit::ExpressionWidth;
 use async_lsp::{ErrorCode, ResponseError};
 use nargo::{artifacts::debug::DebugArtifact, insert_all_files_for_workspace_into_file_manager};
 use nargo_toml::{find_package_manifest, resolve_workspace_from_toml, PackageSelection};
diff --git a/noir/tooling/nargo/src/ops/transform.rs b/noir/tooling/nargo/src/ops/transform.rs
index f3efd82333e..9267ed7e045 100644
--- a/noir/tooling/nargo/src/ops/transform.rs
+++ b/noir/tooling/nargo/src/ops/transform.rs
@@ -1,4 +1,4 @@
-use acvm::ExpressionWidth;
+use acvm::acir::circuit::ExpressionWidth;
 use iter_extended::vecmap;
 use noirc_driver::{CompiledContract, CompiledProgram};
 
diff --git a/noir/tooling/nargo_cli/src/cli/dap_cmd.rs b/noir/tooling/nargo_cli/src/cli/dap_cmd.rs
index 67322b1873e..f25d0ac212b 100644
--- a/noir/tooling/nargo_cli/src/cli/dap_cmd.rs
+++ b/noir/tooling/nargo_cli/src/cli/dap_cmd.rs
@@ -1,5 +1,5 @@
+use acvm::acir::circuit::ExpressionWidth;
 use acvm::acir::native_types::WitnessMap;
-use acvm::ExpressionWidth;
 use backend_interface::Backend;
 use clap::Args;
 use nargo::constants::PROVER_INPUT_FILE;
@@ -43,7 +43,10 @@ fn parse_expression_width(input: &str) -> Result<ExpressionWidth, std::io::Error
         .parse::<usize>()
         .map_err(|err| Error::new(ErrorKind::InvalidInput, err.to_string()))?;
 
-    Ok(ExpressionWidth::from(width))
+    match width {
+        0 => Ok(ExpressionWidth::Unbounded),
+        _ => Ok(ExpressionWidth::Bounded { width }),
+    }
 }
 
 struct LoadError(&'static str);
diff --git a/noir/tooling/nargo_cli/src/cli/info_cmd.rs b/noir/tooling/nargo_cli/src/cli/info_cmd.rs
index 131fd6ad214..ef0df0bf25b 100644
--- a/noir/tooling/nargo_cli/src/cli/info_cmd.rs
+++ b/noir/tooling/nargo_cli/src/cli/info_cmd.rs
@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 
-use acvm::ExpressionWidth;
+use acvm::acir::circuit::ExpressionWidth;
 use backend_interface::BackendError;
 use clap::Args;
 use iter_extended::vecmap;