diff --git a/.gitignore b/.gitignore
index f601b9b7..da75a41c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,6 +9,9 @@
 # OSX files
 .DS_Store
 
+# Compiled binary files
+*.so
+
 # Python created files
 .eggs/
 .tox/
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 2e74346b..ddc93258 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -110,6 +110,7 @@ target_sources(python
     src/count_wrapper.cpp
     src/tdigest_wrapper.cpp
     src/vector_of_kll.cpp
+    src/bloom_filter_wrapper.cpp
     src/py_serde.cpp
 )
 
diff --git a/src/bloom_filter_wrapper.cpp b/src/bloom_filter_wrapper.cpp
new file mode 100644
index 00000000..5fed0180
--- /dev/null
+++ b/src/bloom_filter_wrapper.cpp
@@ -0,0 +1,184 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include <nanobind/nanobind.h>
+#include <nanobind/stl/string.h>
+
+#include "bloom_filter.hpp"
+#include "common_defs.hpp"
+
+namespace nb = nanobind;
+
+template<typename A>
+void bind_bloom_filter(nb::module_ &m, const char* name) {
+  using namespace datasketches;
+  using bloom_filter_type = bloom_filter_alloc<A>;
+
+  // Bind the class with static factory methods only
+  nb::class_<bloom_filter_type>(m, name)
+    .def("is_empty", &bloom_filter_type::is_empty,
+         "Returns True if the filter has seen no items, otherwise False")
+    
+    // Update methods - efficient overloads for Python types
+    // Non-negative integers (uint64_t)
+    .def("update", static_cast<void (bloom_filter_type::*)(uint64_t)>(&bloom_filter_type::update), 
+         nb::arg("item"),
+         "Updates the filter with a non-negative integer")
+    // Negative/positive integers (int64_t)
+    .def("update", static_cast<void (bloom_filter_type::*)(int64_t)>(&bloom_filter_type::update), 
+         nb::arg("item"),
+         "Updates the filter with a negative/positive integer")
+    // Float (double)
+    .def("update", static_cast<void (bloom_filter_type::*)(double)>(&bloom_filter_type::update), 
+         nb::arg("item"),
+         "Updates the filter with a float")
+    // String (std::string)
+    .def("update", static_cast<void (bloom_filter_type::*)(const std::string&)>(&bloom_filter_type::update), 
+         nb::arg("item"),
+         "Updates the filter with a string")
+    // Bytes object
+    .def("update",
+         [](bloom_filter_type& self, nb::bytes b) {
+           self.update(b.c_str(), b.size());
+         },
+         nb::arg("item"),
+         "Updates the filter with a bytes object")
+    
+    // Query methods - efficient overloads for Python types
+    // Non-negative integers (uint64_t)
+    .def("query", static_cast<bool (bloom_filter_type::*)(uint64_t) const>(&bloom_filter_type::query), 
+         nb::arg("item"),
+         "Queries the filter for a non-negative integer")
+    // Negative/positive integers (int64_t)
+    .def("query", static_cast<bool (bloom_filter_type::*)(int64_t) const>(&bloom_filter_type::query), 
+         nb::arg("item"),
+         "Queries the filter for a negative/positive integer")
+    // Float (double)
+    .def("query", static_cast<bool (bloom_filter_type::*)(double) const>(&bloom_filter_type::query), 
+         nb::arg("item"),
+         "Queries the filter for a float")
+    // String (std::string)
+    .def("query", static_cast<bool (bloom_filter_type::*)(const std::string&) const>(&bloom_filter_type::query), 
+         nb::arg("item"),
+         "Queries the filter for a string")
+    // Bytes object
+    .def("query",
+         [](const bloom_filter_type& self, nb::bytes b) -> bool {
+           return self.query(b.c_str(), b.size());
+         },
+         nb::arg("item"),
+         "Queries the filter for a bytes object")
+    
+    .def("reset", &bloom_filter_type::reset,
+         "Resets the Bloom filter to its original empty state")
+    .def("union_with", &bloom_filter_type::union_with,
+         nb::arg("other"),
+         "Performs a union operation with another Bloom filter. Both filters must have the same capacity, number of hashes, and seed.")
+    .def("intersect", &bloom_filter_type::intersect,
+         nb::arg("other"),
+         "Performs an intersection operation with another Bloom filter. Both filters must have the same capacity, number of hashes, and seed.")
+    .def("invert", &bloom_filter_type::invert,
+         "Inverts all the bits of the BloomFilter. Approximately inverts the notion of set-membership.")
+    .def("to_string", &bloom_filter_type::to_string,
+         nb::arg("print_filter")=false,
+         "Returns a string representation of the Bloom filter\n\n"
+         ":param print_filter: If True, includes the actual bit array in the output\n:type print_filter: bool, optional\n"
+         ":return: String representation of the filter\n:rtype: str")
+    .def("__str__", [](const bloom_filter_type& self) { return self.to_string(false); },
+         "Returns a string summary of the Bloom filter (without printing the bit array)")
+    .def("__repr__", [](const bloom_filter_type& self) { return self.to_string(false); },
+         "Returns a detailed string representation of the Bloom filter for debugging and REPL use")
+    .def("__copy__", [](const bloom_filter_type& self) { return bloom_filter_type(self); },
+         "Returns a copy of the Bloom filter")
+    .def("is_compatible", &bloom_filter_type::is_compatible,
+         nb::arg("other"),
+         "Returns True if the other Bloom filter is compatible for union/intersection operations (same capacity, num_hashes, and seed)")
+    .def("get_serialized_size_bytes", 
+         [](const bloom_filter_type& sk) { return sk.get_serialized_size_bytes(); },
+         "Returns the size in bytes of the serialized image of the filter")
+    .def("serialize",
+        [](const bloom_filter_type& sk) {
+            auto v = sk.serialize(); // vector_bytes (std::vector<uint8_t, Allocator>)
+            return nb::bytes(reinterpret_cast<const char*>(v.data()), v.size());
+        },
+        "Serialize the filter to a cross-language compatible byte string")
+    .def_static(
+        "deserialize",
+        [](const nb::bytes& bytes) {
+            return bloom_filter_type::deserialize(bytes.c_str(), bytes.size());
+        },
+        nb::arg("bytes"),
+        "Reads a bytes object and returns the corresponding bloom_filter")
+    .def_static("suggest_num_hashes", 
+                static_cast<uint16_t (*)(uint64_t, uint64_t)>(&bloom_filter_type::builder::suggest_num_hashes),
+                nb::arg("max_distinct_items"), nb::arg("num_filter_bits"),
+                "Suggests the optimal number of hash functions for given target numbers of distinct items and filter size")
+    .def_static("suggest_num_hashes_by_probability", 
+                static_cast<uint16_t (*)(double)>(&bloom_filter_type::builder::suggest_num_hashes),
+                nb::arg("target_false_positive_prob"),
+                "Suggests the optimal number of hash functions to achieve a target false positive probability")
+    .def_static("suggest_num_filter_bits", 
+                &bloom_filter_type::builder::suggest_num_filter_bits,
+                nb::arg("max_distinct_items"), nb::arg("target_false_positive_prob"),
+                "Suggests the optimal number of bits for given target numbers of distinct items and false positive probability")
+    .def_static("create_by_accuracy",
+                [](uint64_t max_distinct_items, double target_false_positive_prob, uint64_t seed) {
+                  return bloom_filter_type::builder::create_by_accuracy(max_distinct_items, target_false_positive_prob, seed);
+                },
+                nb::arg("max_distinct_items"), nb::arg("target_false_positive_prob"), nb::arg("seed")=bloom_filter_type::builder::generate_random_seed(),
+                "Creates a Bloom filter with optimal parameters for the given accuracy requirements\n\n"
+                ":param max_distinct_items: Maximum expected number of distinct items to add to the filter\n:type max_distinct_items: int\n"
+                ":param target_false_positive_prob: Desired false positive probability per item\n:type target_false_positive_prob: float\n"
+                ":param seed: Hash seed to use (default: random)\n:type seed: int, optional"
+                )
+    .def_static("create_by_size",
+                [](uint64_t num_bits, uint16_t num_hashes, uint64_t seed) {
+                  return bloom_filter_type::builder::create_by_size(num_bits, num_hashes, seed);
+                },
+                nb::arg("num_bits"), nb::arg("num_hashes"), nb::arg("seed")=bloom_filter_type::builder::generate_random_seed(),
+                "Creates a Bloom filter with specified size parameters\n\n"
+                ":param num_bits: Size of the Bloom filter in bits\n:type num_bits: int\n"
+                ":param num_hashes: Number of hash functions to apply to items\n:type num_hashes: int\n"
+                ":param seed: Hash seed to use (default: random)\n:type seed: int, optional"
+                )
+    .def_prop_ro(
+        "num_bits_used",
+        &bloom_filter_type::get_bits_used,
+        "Number of bits set to 1 in the Bloom filter"
+        )
+    .def_prop_ro(
+        "capacity",
+        &bloom_filter_type::get_capacity,
+        "Number of bits in the Bloom filter's bit array"
+        )
+    .def_prop_ro(
+        "num_hashes",
+        &bloom_filter_type::get_num_hashes,
+        "Number of hash functions used by this Bloom filter"
+        )
+    .def_prop_ro(
+        "seed",
+        &bloom_filter_type::get_seed,
+        "Hash seed used by this Bloom filter"
+        );
+}
+
+void init_bloom_filter(nb::module_ &m) {
+  bind_bloom_filter<std::allocator<uint8_t>>(m, "bloom_filter");
+} 
\ No newline at end of file
diff --git a/src/datasketches.cpp b/src/datasketches.cpp
index 118683bc..4aec928e 100644
--- a/src/datasketches.cpp
+++ b/src/datasketches.cpp
@@ -41,6 +41,7 @@ void init_count_min(nb::module_& m);
 void init_density(nb::module_& m);
 void init_tdigest(nb::module_& m);
 void init_vector_of_kll(nb::module_& m);
+void init_bloom_filter(nb::module_& m);
 
 // supporting objects
 void init_kolmogorov_smirnov(nb::module_& m);
@@ -73,6 +74,7 @@ NB_MODULE(_datasketches, m) {
   init_density(m);
   init_tdigest(m);
   init_vector_of_kll(m);
+  init_bloom_filter(m);
 
   init_kolmogorov_smirnov(m);
   init_serde(m);
diff --git a/tests/bloom_filter_test.py b/tests/bloom_filter_test.py
new file mode 100644
index 00000000..76210314
--- /dev/null
+++ b/tests/bloom_filter_test.py
@@ -0,0 +1,705 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+import unittest
+from datasketches import bloom_filter
+
+class BloomFilterTest(unittest.TestCase):
+    def test_standard_constructors(self):
+        """Test standard constructors with exact validation."""
+        num_items = 4000
+        fpp = 0.01
+
+        num_bits = bloom_filter.suggest_num_filter_bits(num_items, fpp)
+        num_hashes = bloom_filter.suggest_num_hashes(num_items, num_bits)
+        seed = 89023
+
+        bf = bloom_filter.create_by_size(num_bits, num_hashes, seed)
+        # C++ rounds up to nearest multiple of 64
+        adjusted_num_bits = (num_bits + 63) & ~0x3F
+        self.assertEqual(bf.capacity, adjusted_num_bits)
+        self.assertEqual(bf.num_hashes, num_hashes)
+        self.assertEqual(bf.seed, seed)
+        self.assertTrue(bf.is_empty())
+
+        # Should match above
+        bf2 = bloom_filter.create_by_accuracy(num_items, fpp, seed)
+        self.assertEqual(bf2.capacity, adjusted_num_bits)
+        self.assertEqual(bf2.num_hashes, num_hashes)
+        self.assertEqual(bf2.seed, seed)
+        self.assertTrue(bf2.is_empty())
+
+    def test_basic_operations(self):
+        """Test basic operations with validation."""
+        num_items = 5000
+        fpp = 0.01
+        seed = 4897301548054
+
+        bf = bloom_filter.create_by_accuracy(num_items, fpp, seed)
+        self.assertTrue(bf.is_empty())
+        self.assertEqual(bf.num_bits_used, 0)
+
+        # Add items
+        for i in range(num_items):
+            bf.update(str(i))
+
+        self.assertFalse(bf.is_empty())
+        self.assertGreater(bf.num_bits_used, 0)
+        self.assertLessEqual(bf.num_bits_used, bf.capacity)
+
+        # Count false positives
+        false_positives = 0
+        for i in range(num_items, min(num_items + 1000, bf.capacity)):
+            if bf.query(str(i)):
+                false_positives += 1
+        
+        self.assertGreater(false_positives, 0)
+        self.assertLess(false_positives, 100)
+
+        # Test serialization
+        bf_bytes = bf.serialize()
+        self.assertEqual(bf.get_serialized_size_bytes(), len(bf_bytes))
+
+        new_bf = bloom_filter.deserialize(bf_bytes)
+        self.assertEqual(bf.capacity, new_bf.capacity)
+        self.assertEqual(bf.num_hashes, new_bf.num_hashes)
+        self.assertEqual(bf.seed, new_bf.seed)
+        self.assertEqual(bf.num_bits_used, new_bf.num_bits_used)
+
+        # Verify all original items are still found
+        for i in range(num_items):
+            self.assertTrue(new_bf.query(str(i)))
+
+    def test_update_types(self):
+        """Test update and query with different data types."""
+        bf = bloom_filter.create_by_accuracy(1000, 0.01)
+
+        # Test integers (positive and negative)
+        for v in [0, 1, 2**40, -1, -2**40]:
+            bf.update(v)
+            self.assertTrue(bf.query(v))
+
+        # Test floats
+        for v in [0.5, -3.25]:
+            bf.update(v)
+            self.assertTrue(bf.query(v))
+
+        # Test strings
+        bf.update("hello")
+        self.assertTrue(bf.query("hello"))
+
+        # Test bytes
+        b = b"abc\x00def"
+        bf.update(b)
+        self.assertTrue(bf.query(b))
+
+    def test_reset_method(self):
+        """Test the reset method functionality."""
+        bf = bloom_filter.create_by_accuracy(1000, 0.01)
+        
+        # Initially empty
+        self.assertTrue(bf.is_empty())
+        self.assertEqual(bf.num_bits_used, 0)
+        
+        # Add some items
+        test_items = ["item1", "item2", "item3", "item4", "item5"]
+        for item in test_items:
+            bf.update(item)
+        
+        # Verify items were added
+        self.assertFalse(bf.is_empty())
+        self.assertGreater(bf.num_bits_used, 0)
+        
+        for item in test_items:
+            self.assertTrue(bf.query(item))
+        
+        # Reset the filter
+        bf.reset()
+        
+        # Verify filter is back to empty state
+        self.assertTrue(bf.is_empty())
+        self.assertEqual(bf.num_bits_used, 0)
+        
+        # Verify none of the original items are found
+        for item in test_items:
+            self.assertFalse(bf.query(item))
+        
+        # Verify properties are preserved
+        self.assertGreater(bf.capacity, 0)
+        self.assertGreater(bf.num_hashes, 0)
+        self.assertIsInstance(bf.seed, int)
+        
+        # Can add new items after reset
+        bf.update("new_item")
+        self.assertFalse(bf.is_empty())
+        self.assertTrue(bf.query("new_item"))
+
+    def test_bloom_filter_accuracy_constructor(self):
+        """Test the accuracy-based constructor."""
+        max_distinct_items = 1000
+        target_false_positive_prob = 0.01
+        
+        bf = bloom_filter.create_by_accuracy(max_distinct_items, target_false_positive_prob)
+        self.assertTrue(bf.is_empty())
+        
+        test_items = ["item1", "item2", "item3", "item4", "item5"]
+        for item in test_items:
+            bf.update(item)
+        
+        self.assertFalse(bf.is_empty())
+        
+        for item in test_items:
+            self.assertTrue(bf.query(item))
+
+    def test_bloom_filter_size_constructor(self):
+        """Test the size-based constructor."""
+        num_bits = 8192
+        num_hashes = 5
+        
+        bf = bloom_filter.create_by_size(num_bits, num_hashes)
+        self.assertTrue(bf.is_empty())
+        self.assertEqual(bf.capacity, num_bits)
+        self.assertEqual(bf.num_hashes, num_hashes)
+        
+        test_items = ["item1", "item2", "item3"]
+        for item in test_items:
+            bf.update(item)
+        
+        self.assertFalse(bf.is_empty())
+        
+        for item in test_items:
+            self.assertTrue(bf.query(item))
+
+    def test_bloom_filter_static_methods(self):
+        """Test the static helper methods."""
+        max_distinct_items = 1000
+        target_false_positive_prob = 0.01
+        
+        num_hashes = bloom_filter.suggest_num_hashes_by_probability(target_false_positive_prob)
+        self.assertIsInstance(num_hashes, int)
+        self.assertGreater(num_hashes, 0)
+        
+        num_bits = bloom_filter.suggest_num_filter_bits(max_distinct_items, target_false_positive_prob)
+        self.assertIsInstance(num_bits, int)
+        self.assertGreater(num_bits, 0)
+        
+        num_hashes_alt = bloom_filter.suggest_num_hashes(max_distinct_items, num_bits)
+        self.assertIsInstance(num_hashes_alt, int)
+        self.assertGreater(num_hashes_alt, 0)
+
+    def test_bloom_filter_serialization(self):
+        """Test serialization and deserialization."""
+        bf = bloom_filter.create_by_accuracy(1000, 0.01)
+        
+        test_items = ["item1", "item2", "item3"]
+        for item in test_items:
+            bf.update(item)
+        
+        bf_bytes = bf.serialize()
+        self.assertEqual(bf.get_serialized_size_bytes(), len(bf_bytes))
+        
+        new_bf = bloom_filter.deserialize(bf_bytes)
+        
+        for item in test_items:
+            self.assertTrue(new_bf.query(item))
+        
+        self.assertFalse(new_bf.is_empty())
+        self.assertEqual(bf.capacity, new_bf.capacity)
+        self.assertEqual(bf.num_hashes, new_bf.num_hashes)
+        self.assertEqual(bf.seed, new_bf.seed)
+        self.assertEqual(bf.num_bits_used, new_bf.num_bits_used)
+
+    def test_empty_serialization(self):
+        """Test serialization of empty bloom filter."""
+        bf = bloom_filter.create_by_accuracy(1000, 0.01)
+        self.assertTrue(bf.is_empty())
+        
+        bf_bytes = bf.serialize()
+        self.assertEqual(bf.get_serialized_size_bytes(), len(bf_bytes))
+        
+        new_bf = bloom_filter.deserialize(bf_bytes)
+        self.assertTrue(new_bf.is_empty())
+        self.assertEqual(bf.capacity, new_bf.capacity)
+        self.assertEqual(bf.num_hashes, new_bf.num_hashes)
+        self.assertEqual(bf.seed, new_bf.seed)
+
+    def test_bits_used_properties(self):
+        """Test that bits_used behaves correctly."""
+        bf = bloom_filter.create_by_accuracy(1000, 0.01)
+
+        self.assertEqual(bf.num_bits_used, 0)
+
+        bf.update("alpha")
+        bits1 = bf.num_bits_used
+        self.assertIsInstance(bits1, int)
+        self.assertGreater(bits1, 0)
+
+        # Idempotent
+        bits1_again = bf.num_bits_used
+        self.assertEqual(bits1_again, bits1)
+
+        # Same item shouldn't change bits_used
+        bf.update("alpha")
+        bits_dup = bf.num_bits_used
+        self.assertEqual(bits_dup, bits1)
+
+        # Additional items should be non-decreasing
+        for s in ["beta", "gamma", "delta"]:
+            bf.update(s)
+            new_bits = bf.num_bits_used
+            self.assertGreaterEqual(new_bits, bits1)
+            bits1 = new_bits
+
+    def test_capacity_properties(self):
+        """Test that capacity is positive and constant."""
+        bf = bloom_filter.create_by_accuracy(1000, 0.01)
+        cap1 = bf.capacity
+        self.assertIsInstance(cap1, int)
+        self.assertGreater(cap1, 0)
+
+        cap2 = bf.capacity
+        self.assertEqual(cap1, cap2)
+
+        bf.update("alpha")
+        bf.update("beta")
+        self.assertEqual(cap1, bf.capacity)
+
+    def test_num_hashes_properties(self):
+        """Test that num_hashes is consistent."""
+        bf = bloom_filter.create_by_accuracy(1000, 0.01)
+        k1 = bf.num_hashes
+        self.assertIsInstance(k1, int)
+        self.assertGreaterEqual(k1, 1)
+        bf.update("alpha")
+        self.assertEqual(k1, bf.num_hashes)
+
+        bf2 = bloom_filter.create_by_size(10000, 3)
+        k2 = bf2.num_hashes
+        self.assertIsInstance(k2, int)
+        self.assertEqual(k2, 3)
+        bf2.update("beta")
+        self.assertEqual(k2, bf2.num_hashes)
+
+    def test_seed_properties(self):
+        """Test that seed is consistent."""
+        bf = bloom_filter.create_by_accuracy(1000, 0.01)
+        s1 = bf.seed
+        self.assertIsInstance(s1, int)
+
+        bf.update("alpha")
+        self.assertEqual(s1, bf.seed)
+
+        explicit_seed = 12345
+        bf2 = bloom_filter.create_by_accuracy(1000, 0.01, explicit_seed)
+        s2 = bf2.seed
+        self.assertIsInstance(s2, int)
+        self.assertEqual(s2, explicit_seed)
+
+    def test_deterministic_behavior(self):
+        """Test that bloom filters with the same seed behave deterministically."""
+        seed = 12345
+        max_distinct_items = 1000
+        target_fpp = 0.01
+        
+        bf1 = bloom_filter.create_by_accuracy(max_distinct_items, target_fpp, seed)
+        bf2 = bloom_filter.create_by_accuracy(max_distinct_items, target_fpp, seed)
+        
+        test_items = [f"item_{i}" for i in range(100)]
+        for item in test_items:
+            bf1.update(item)
+            bf2.update(item)
+        
+        self.assertEqual(bf1.capacity, bf2.capacity)
+        self.assertEqual(bf1.num_hashes, bf2.num_hashes)
+        self.assertEqual(bf1.seed, bf2.seed)
+        self.assertEqual(bf1.num_bits_used, bf2.num_bits_used)
+        
+        for item in test_items:
+            self.assertEqual(bf1.query(item), bf2.query(item))
+
+    def test_edge_cases(self):
+        """Test edge cases and boundary conditions."""
+        bf_small = bloom_filter.create_by_size(64, 1)
+        self.assertEqual(bf_small.capacity, 64)
+        self.assertEqual(bf_small.num_hashes, 1)
+        
+        bf_many_hashes = bloom_filter.create_by_size(1000, 20)
+        self.assertEqual(bf_many_hashes.num_hashes, 20)
+        
+        bf_low_fpp = bloom_filter.create_by_accuracy(100, 1e-6)
+        self.assertGreater(bf_low_fpp.num_hashes, 1)
+
+    def test_mathematical_properties(self):
+        """Test mathematical properties of bloom filters."""
+        bf = bloom_filter.create_by_size(100, 5)
+        self.assertEqual(bf.capacity % 64, 0)
+        
+        bf.update("test_item")
+        self.assertLessEqual(bf.num_bits_used, bf.capacity)
+        
+        self.assertGreater(bf.num_hashes, 0)
+        self.assertIsInstance(bf.seed, int)
+
+    def test_union_operation(self):
+        """Test union operation between compatible bloom filters."""
+        # Create two compatible bloom filters with larger size to reduce false positives
+        bf1 = bloom_filter.create_by_size(2048, 6, seed=12345)  # Increased size and hashes
+        bf2 = bloom_filter.create_by_size(2048, 6, seed=12345)
+        
+        # Verify they are compatible
+        self.assertTrue(bf1.is_compatible(bf2))
+        self.assertTrue(bf2.is_compatible(bf1))
+        
+        # Add items to first filter
+        items1 = ["item1", "item2", "item3", "item4", "item5"]
+        for item in items1:
+            bf1.update(item)
+        
+        # Add different items to second filter
+        items2 = ["item6", "item7", "item8", "item9", "item10"]
+        for item in items2:
+            bf2.update(item)
+        
+        # Add one common item to both
+        common_item = "common_item"
+        bf1.update(common_item)
+        bf2.update(common_item)
+        
+        # Record initial state
+        initial_bits1 = bf1.num_bits_used
+        initial_bits2 = bf2.num_bits_used
+        
+        # Perform union operation
+        bf1.union_with(bf2)
+        
+        # Verify all items from both filters are now in bf1
+        all_items = items1 + items2 + [common_item]
+        for item in all_items:
+            self.assertTrue(bf1.query(item))
+        
+        # Verify bits used increased (union should have more bits set)
+        self.assertGreaterEqual(bf1.num_bits_used, initial_bits1)
+        self.assertGreaterEqual(bf1.num_bits_used, initial_bits2)
+        
+        # Verify bf2 is unchanged - use probabilistic check instead of strict assertFalse
+        for item in items2 + [common_item]:
+            self.assertTrue(bf2.query(item))
+        
+        # Count false positives for items that should not be in bf2
+        # Bloom filters have inherent false positive probability, so we can't assert
+        # that items NOT added will always return False. Instead, we check that
+        # the false positive rate is reasonable (≤ 10%).
+        # 
+        # The 15% threshold is chosen because:
+        # 1. For a well-configured bloom filter (2048 bits, 6 hashes, 5-10 items),
+        #    the theoretical false positive rate should be < 1%
+        # 2. 15% provides a generous safety margin for test flakiness
+        # 3. If false positives exceed 10%, it indicates a real problem with
+        #    the filter configuration or implementation
+        false_positives = 0
+        for item in items1:
+            if bf2.query(item):
+                false_positives += 1
+        
+        # Allow at most 15% false positives (more lenient than strict assertFalse)
+        self.assertLessEqual(false_positives, len(items1) * 10 // 100)
+
+    def test_intersection_operation(self):
+        """Test intersection operation between compatible bloom filters."""
+        # Create two compatible bloom filters with larger size to reduce false positives
+        bf1 = bloom_filter.create_by_size(2048, 6, seed=12345)  # Increased size and hashes
+        bf2 = bloom_filter.create_by_size(2048, 6, seed=12345)
+        
+        # Verify they are compatible
+        self.assertTrue(bf1.is_compatible(bf2))
+        
+        # Add items to first filter
+        items1 = ["item1", "item2", "item3", "item4", "item5"]
+        for item in items1:
+            bf1.update(item)
+        
+        # Add different items to second filter
+        items2 = ["item6", "item7", "item8", "item9", "item10"]
+        for item in items2:
+            bf2.update(item)
+        
+        # Add common items to both
+        common_items = ["common1", "common2", "common3"]
+        for item in common_items:
+            bf1.update(item)
+            bf2.update(item)
+        
+        # Record initial state
+        initial_bits1 = bf1.num_bits_used
+        initial_bits2 = bf2.num_bits_used
+        
+        # Perform intersection operation
+        bf1.intersect(bf2)
+        
+        # Verify only common items remain in bf1
+        for item in common_items:
+            self.assertTrue(bf1.query(item))
+        
+        # Probabilistic check for items that should not be in intersection
+        # After intersection, items unique to each filter should NOT be present.
+        # However, bloom filters have inherent false positive probability, so we
+        # can't use strict assertFalse. Instead, we count false positives and
+        # ensure they don't exceed a reasonable threshold (≤ 15%).
+        #
+        # The 15% threshold is chosen because:
+        # 1. For a well-configured bloom filter (2048 bits, 6 hashes, 5-10 items),
+        #    the theoretical false positive rate should be < 1%
+        # 2. 15% provides a generous safety margin for test flakiness
+        # 3. If false positives exceed 15%, it indicates a real problem with
+        #    the filter configuration or implementation
+        false_positives = 0
+        total_tests = len(items1) + len(items2)
+        
+        for item in items1:
+            if bf1.query(item):
+                false_positives += 1
+        for item in items2:
+            if bf1.query(item):
+                false_positives += 1
+        
+        # Allow at most 15% false positives (more lenient than strict assertFalse)
+        self.assertLessEqual(false_positives, total_tests * 15 // 100)
+        
+        # Verify bits used decreased (intersection should have fewer bits set)
+        self.assertLessEqual(bf1.num_bits_used, initial_bits1)
+        
+        # Verify bf2 is unchanged
+        for item in items2 + common_items:
+            self.assertTrue(bf2.query(item))
+        for item in items1:
+            self.assertFalse(bf2.query(item))
+
+    def test_incompatible_filters(self):
+        """Test that union and intersection fail with incompatible filters."""
+        # Create filters with different capacities
+        bf1 = bloom_filter.create_by_size(1024, 5, seed=12345)
+        bf2 = bloom_filter.create_by_size(2048, 5, seed=12345)
+        
+        self.assertFalse(bf1.is_compatible(bf2))
+        self.assertFalse(bf2.is_compatible(bf1))
+        
+        # Should raise ValueError for union (std::invalid_argument maps to ValueError)
+        with self.assertRaises(ValueError):
+            bf1.union_with(bf2)
+        
+        # Should raise ValueError for intersection (std::invalid_argument maps to ValueError)
+        with self.assertRaises(ValueError):
+            bf1.intersect(bf2)
+        
+        # Create filters with different number of hashes
+        bf3 = bloom_filter.create_by_size(1024, 3, seed=12345)
+        self.assertFalse(bf1.is_compatible(bf3))
+        
+        # Create filters with different seeds
+        bf4 = bloom_filter.create_by_size(1024, 5, seed=54321)
+        self.assertFalse(bf1.is_compatible(bf4))
+
+    def test_union_intersection_edge_cases(self):
+        """Test edge cases for union and intersection operations."""
+        # Test with empty filters
+        bf1 = bloom_filter.create_by_size(1024, 5, seed=12345)
+        bf2 = bloom_filter.create_by_size(1024, 5, seed=12345)
+        
+        # Union of empty filters should remain empty
+        bf1.union_with(bf2)
+        self.assertTrue(bf1.is_empty())
+        self.assertEqual(bf1.num_bits_used, 0)
+        
+        # Intersection of empty filters should remain empty
+        bf1.reset()
+        bf1.intersect(bf2)
+        self.assertTrue(bf1.is_empty())
+        self.assertEqual(bf1.num_bits_used, 0)
+        
+        # Test union with self
+        bf1.update("test_item")
+        initial_bits = bf1.num_bits_used
+        bf1.union_with(bf1)
+        self.assertEqual(bf1.num_bits_used, initial_bits)
+        self.assertTrue(bf1.query("test_item"))
+        
+        # Test intersection with self
+        bf1.intersect(bf1)
+        self.assertEqual(bf1.num_bits_used, initial_bits)
+        self.assertTrue(bf1.query("test_item"))
+
+    def test_invert_operation(self):
+        """Test the invert operation on bloom filters."""
+        # Use larger filter to reduce false positive probability
+        num_bits = 16384  # Increased from 8192
+        num_hashes = 5    # Increased from 3
+        
+        bf = bloom_filter.create_by_size(num_bits, num_hashes)
+        
+        # Add items
+        n = 500
+        for i in range(n):
+            bf.update(i)
+        
+        num_bits_set = bf.num_bits_used
+        bf.invert()
+        
+        # After inversion, bits used should be capacity - original_bits_used
+        self.assertEqual(bf.num_bits_used, num_bits - num_bits_set)
+        
+        # Original items should be mostly not-present (probabilistic check)
+        # After inversion, items that were originally added should NOT be found.
+        # However, bloom filters have inherent false positive probability, so we
+        # can't use strict assertFalse. Instead, we count false positives and
+        # ensure they don't exceed a reasonable threshold (≤ 10%).
+        #
+        # The 10% threshold is chosen because:
+        # 1. For a well-configured bloom filter (16384 bits, 5 hashes, 500 items),
+        #    the theoretical false positive rate should be < 1%
+        # 2. 10% provides a generous safety margin for test flakiness
+        # 3. Since we're testing 500 items, even 10% false positives (50 items)
+        #    would indicate a significant problem with the implementation
+        num_found = 0
+        for i in range(n):
+            if bf.query(i):
+                num_found += 1
+        
+        # Allow at most 10% false positives instead of strict < n//10
+        self.assertLessEqual(num_found, n // 10)
+        
+        # Test that double inversion returns to original state
+        bf.invert()
+        self.assertEqual(bf.num_bits_used, num_bits_set)
+        
+        # Original items should be found again after double inversion
+        for i in range(n):
+            self.assertTrue(bf.query(i))
+
+    def test_invert_empty_filter(self):
+        """Test invert operation on an empty bloom filter."""
+        num_bits = 1024
+        bf = bloom_filter.create_by_size(num_bits, 5, seed=12345)
+        
+        # Initially empty
+        self.assertTrue(bf.is_empty())
+        self.assertEqual(bf.num_bits_used, 0)
+        
+        # Invert empty filter
+        bf.invert()
+        
+        # After inversion, all bits should be set
+        self.assertEqual(bf.num_bits_used, num_bits)
+        
+        # All items should be found (since all bits are now 1)
+        test_items = ["item1", "item2", "item3", "item4", "item5"]
+        for item in test_items:
+            self.assertTrue(bf.query(item))
+        
+        # Invert again - should be empty again
+        bf.invert()
+        self.assertTrue(bf.is_empty())
+        self.assertEqual(bf.num_bits_used, 0)
+        
+        # No items should be found
+        for item in test_items:
+            self.assertFalse(bf.query(item))
+
+    def test_invert_full_filter(self):
+        """Test invert operation on a nearly full bloom filter."""
+        # Use larger filter to reduce false positive probability
+        num_bits = 128  # Increased from 64
+        bf = bloom_filter.create_by_size(num_bits, 4, seed=12345)  # Increased hashes
+        
+        # Add many items to fill most bits
+        for i in range(50):
+            bf.update(f"item_{i}")
+        
+        # Record state
+        bits_before = bf.num_bits_used
+        
+        # Invert the filter
+        bf.invert()
+        
+        # Check that bits used follows the mathematical relationship
+        self.assertEqual(bf.num_bits_used, num_bits - bits_before)
+        
+        # Original items should not be found (probabilistic check)
+        # After inversion, items that were originally added should NOT be found.
+        # However, bloom filters have inherent false positive probability, so we
+        # can't use strict assertFalse. Instead, we count false positives and
+        # ensure they don't exceed a reasonable threshold (≤ 15%).
+        #
+        # The 15% threshold is chosen because:
+        # 1. For a well-configured bloom filter (128 bits, 4 hashes, 50 items),
+        #    the theoretical false positive rate should be < 5%
+        # 2. 15% provides a generous safety margin for test flakiness
+        # 3. If false positives exceed 15%, it indicates a real problem with
+        #    the filter configuration or implementation
+        false_positives = 0
+        for i in range(50):
+            if bf.query(f"item_{i}"):
+                false_positives += 1
+        
+        # Allow at most 15% false positives instead of strict assertFalse
+        self.assertLessEqual(false_positives, 50 * 15 // 100)
+        
+        # Invert again - should return to original state
+        bf.invert()
+        self.assertEqual(bf.num_bits_used, bits_before)
+        
+        # Original items should be found again
+        for i in range(50):
+            self.assertTrue(bf.query(f"item_{i}"))
+
+    def test_invert_mathematical_properties(self):
+        """Test mathematical properties of the invert operation."""
+        bf = bloom_filter.create_by_size(1024, 5, seed=12345)
+        
+        # Test that double inversion is identity
+        test_items = ["item1", "item2", "item3"]
+        for item in test_items:
+            bf.update(item)
+        
+        # Record initial state
+        initial_bits = bf.num_bits_used
+        
+        # First inversion
+        bf.invert()
+        bits_after_first = bf.num_bits_used
+        
+        # Second inversion
+        bf.invert()
+        bits_after_second = bf.num_bits_used
+        
+        # Should be back to original state
+        self.assertEqual(bits_after_second, initial_bits)
+        
+        # All original items should be found again
+        for item in test_items:
+            self.assertTrue(bf.query(item))
+        
+        # Test that double inversion preserves the original query behavior
+        # This is the key property: invert(invert(filter)) == filter
+        for item in test_items:
+            self.assertTrue(bf.query(item))
+        
+        # Test that the filter is not empty after double inversion
+        self.assertFalse(bf.is_empty())
+        self.assertEqual(bf.num_bits_used, initial_bits)
+
+if __name__ == '__main__':
+    unittest.main() 
\ No newline at end of file