diff --git a/QPIXL/audio_processor.py b/QPIXL/audio_processor.py
new file mode 100644
index 0000000..9bf1c9d
--- /dev/null
+++ b/QPIXL/audio_processor.py
@@ -0,0 +1,163 @@
+"""
+Enhanced Audio Processing with QPIXL Circuit Integration
+
+This module provides functions for processing audio data using quantum circuits
+with sliced algorithm integration.
+"""
+
+import os
+import numpy as np
+import soundfile
+from itertools import chain
+from typing import Optional, Callable, Dict, Union, List
+
+import qiskit
+from qiskit import QuantumCircuit
+from qiskit_aer import Aer
+
+import QPIXL.helper as hlp
+from QPIXL.qiskit.qpixl import cFRQI
+from QPIXL.qiskit.qpixl_angs import cFRQIangs, decodeAngQPIXL
+from QPIXL.qpixl_integrator import CircuitIntegrator, IntegrationMode, QPIXLAlgorithmEncoder
+
+
+def process_audio_with_slices(
+    input_file: str,
+    output_dir: str,
+    algorithm_circuit: QuantumCircuit,
+    slice_size: int = 3,
+    insertion_rule: str = 'interval',
+    interval: int = 8,
+    connection_rule: str = 'cx',
+    connection_map: Optional[Dict[int, int]] = None,
+    compression: int = 0,
+    tag: str = "",
+) -> None:
+    """
+    Process audio with sliced quantum algorithm integration.
+    
+    Args:
+        input_file: Path to the input audio file
+        output_dir: Directory to save processed audio
+        algorithm_circuit: Algorithm circuit to slice and interleave
+        slice_size: Number of gates per slice
+        insertion_rule: Rule for where to insert slices ('interval', 'angles', 'custom')
+        interval: Insert a slice every N loop iterations (if insertion_rule='interval')
+        connection_rule: How to connect circuits ('cx', 'cz', 'swap')
+        connection_map: Dictionary mapping data qubits to algorithm qubits
+        compression: Compression level (0-100)
+        tag: Tag to append to output files
+    """
+    os.makedirs(output_dir, exist_ok=True)
+    file_name, _ = os.path.splitext(os.path.basename(input_file))
+    metadata_file_path = os.path.join(
+        output_dir, f"{file_name}_metadata_{tag}_c{compression}.txt"
+    )
+    
+    if not os.path.exists(metadata_file_path):
+        data, samplerate = soundfile.read(input_file)
+        chunk_size = 512
+        sections = [
+            hlp.pad_0(data[i : i + chunk_size]) for i in range(0, len(data), chunk_size)
+        ][:-1]  
+        
+        decoded = []
+        encoder = QPIXLAlgorithmEncoder()
+        
+        for index, section in enumerate(sections):
+            print(
+                f"Processing {file_name} chunk: {index + 1}/{len(sections)}", end="\r"
+            )
+            
+            normalized_section = section - np.min(section)
+            
+            qc = encoder.create_sliced_circuit(
+                normalized_section,
+                algorithm_circuit,
+                compression=compression,
+                slice_size=slice_size,
+                insertion_rule=insertion_rule,
+                interval=interval,
+                connection_rule=connection_rule,
+                connection_map=connection_map,
+                algorithm_qubits=algorithm_circuit.num_qubits
+            )
+            
+            backend = Aer.get_backend('statevector_simulator')
+            job = backend.run(qc)
+            state_vector = np.real(job.result().get_statevector())
+            
+            decoded.append(
+                decodeAngQPIXL(
+                    state=state_vector,
+                    qc=qc,
+                    trace=algorithm_circuit.num_qubits,  # Trace out algorithm qubits
+                    max_pixel_val=section.max(),
+                    min_pixel_val=section.min(),
+                )
+            )
+        
+        decoded_full = np.array(list(chain.from_iterable(decoded)))
+        soundfile.write(
+            os.path.join(output_dir, f"{file_name}_output_{tag}_c{compression}.wav"),
+            decoded_full,
+            samplerate,
+        )
+        
+        with open(metadata_file_path, 'w') as f:
+            f.write(f"Original file: {input_file}\n")
+            f.write(f"Compression: {compression}%\n")
+            f.write(f"Slice size: {slice_size}\n")
+            f.write(f"Insertion rule: {insertion_rule}\n")
+            f.write(f"Connection rule: {connection_rule}\n")
+
+
+def create_algorithm_circuit(circuit_type: str, num_qubits: int = 3, **params) -> QuantumCircuit:
+    """
+    Create a simple algorithm circuit for demonstration.
+    
+    Args:
+        circuit_type: Type of circuit ('hadamard', 'qaoa', 'qft', 'custom')
+        num_qubits: Number of qubits
+        **params: Additional parameters
+        
+    Returns:
+        A quantum circuit
+    """
+    circuit = QuantumCircuit(num_qubits)
+    
+    if circuit_type == 'hadamard':
+        for i in range(num_qubits):
+            circuit.h(i)
+    
+    elif circuit_type == 'qaoa':
+        angle = params.get('angle', np.pi/4)
+        for i in range(num_qubits):
+            circuit.h(i)
+        for i in range(num_qubits-1):
+            circuit.cx(i, i+1)
+            circuit.rz(angle, i+1)
+            circuit.cx(i, i+1)
+        for i in range(num_qubits):
+            circuit.rx(angle, i)
+    
+    elif circuit_type == 'qft':
+        for i in range(num_qubits):
+            circuit.h(i)
+            for j in range(i+1, num_qubits):
+                circuit.cp(np.pi/float(2**(j-i)), i, j)
+    
+    elif circuit_type == 'custom':
+        gates = params.get('gates', [])
+        for gate in gates:
+            name = gate.get('name', '')
+            qubits = gate.get('qubits', [0])
+            params = gate.get('params', {})
+            
+            if hasattr(circuit, name):
+                if params:
+                    getattr(circuit, name)(params.get('angle', 0), *qubits)
+                else:
+                    getattr(circuit, name)(*qubits)
+    
+    return circuit
\ No newline at end of file
diff --git a/QPIXL/qpixl_integrator.py b/QPIXL/qpixl_integrator.py
new file mode 100644
index 0000000..5d2e08c
--- /dev/null
+++ b/QPIXL/qpixl_integrator.py
@@ -0,0 +1,668 @@
+"""
+QPIXL Circuit Integrator
+
+A flexible module for integrating quantum circuits with QPIXL-encoded data circuits.
+"""
+
+import numpy as np
+from enum import Enum
+from typing import Callable, Dict, List, Optional, Union, Tuple, Any
+from qiskit import QuantumCircuit, QuantumRegister, transpile
+import QPIXL.helper as hlp
+
+
+class IntegrationMode(Enum):
+    """Enum defining different modes of circuit integration."""
+    MERGE = "merge"               # Combine circuits side by side
+    SEQUENTIAL = "sequential"     # Apply circuits one after another
+    ENTANGLE = "entangle"         # Connect circuits with entangling operations
+    CUSTOM = "custom"             # User-defined custom integration rule
+    SLICED = "sliced"             # Slice and interleave circuits
+
+
+class CircuitIntegrator:
+    """
+    A class for integrating quantum circuits with QPIXL-encoded data circuits.
+    
+    This provides a flexible mechanism to combine arbitrary quantum circuits
+    with QPIXL-encoded data circuits using various integration strategies.
+    """
+    
+    def integrate(self, 
+                 data_circuit: QuantumCircuit,
+                 algorithm_circuit: QuantumCircuit,
+                 mode: Union[str, IntegrationMode] = IntegrationMode.MERGE,
+                 connection_map: Optional[Dict[int, int]] = None,
+                 custom_rule: Optional[Callable] = None,
+                 **kwargs) -> QuantumCircuit:
+        """
+        Integrate a QPIXL data circuit with an algorithm circuit.
+        
+        Args:
+            data_circuit: The QPIXL-encoded data circuit
+            algorithm_circuit: An arbitrary quantum circuit
+            mode: Integration mode (merge, sequential, entangle, custom, sliced)
+            connection_map: Dictionary mapping data qubits to algorithm qubits
+            custom_rule: Custom function to apply for integration
+            **kwargs: Additional arguments for specific integration modes
+            
+        Returns:
+            A quantum circuit combining the data and algorithm circuits
+        """
+        if isinstance(mode, str):
+            try:
+                mode = IntegrationMode(mode.lower())
+            except ValueError:
+                raise ValueError(f"Unknown integration mode: {mode}")
+        
+        if connection_map is None:
+            connection_map = {}
+            
+        if mode == IntegrationMode.MERGE:
+            return self._merge_circuits(data_circuit, algorithm_circuit, connection_map, **kwargs)
+        elif mode == IntegrationMode.SEQUENTIAL:
+            return self._sequential_circuits(data_circuit, algorithm_circuit, **kwargs)
+        elif mode == IntegrationMode.ENTANGLE:
+            return self._entangle_circuits(data_circuit, algorithm_circuit, connection_map, **kwargs)
+        elif mode == IntegrationMode.SLICED:
+            return self._sliced_circuits(data_circuit, algorithm_circuit, connection_map, **kwargs)
+        elif mode == IntegrationMode.CUSTOM:
+            if custom_rule is None:
+                raise ValueError("For CUSTOM mode, a custom_rule function must be provided")
+            return custom_rule(data_circuit, algorithm_circuit, **kwargs)
+        else:
+            raise ValueError(f"Unsupported integration mode: {mode}")
+    
+    def _merge_circuits(self, 
+                       data_circuit: QuantumCircuit, 
+                       algorithm_circuit: QuantumCircuit,
+                       connection_map: Dict[int, int],
+                       **kwargs) -> QuantumCircuit:
+        """
+        Merge circuits side by side and optionally add connections between them.
+        
+        Args:
+            data_circuit: QPIXL data circuit
+            algorithm_circuit: Algorithm circuit
+            connection_map: Dictionary mapping data qubits to algorithm qubits
+            
+        Returns:
+            A merged quantum circuit
+        """
+        combined = QuantumCircuit(data_circuit.num_qubits + algorithm_circuit.num_qubits)
+        
+        combined = combined.compose(data_circuit, qubits=range(data_circuit.num_qubits))
+        
+        algo_qubits = range(data_circuit.num_qubits, 
+                          data_circuit.num_qubits + algorithm_circuit.num_qubits)
+        combined = combined.compose(algorithm_circuit, qubits=algo_qubits)
+        
+        for data_qubit, algo_qubit in connection_map.items():
+            adjusted_algo_qubit = data_circuit.num_qubits + algo_qubit
+            combined.cx(data_qubit, adjusted_algo_qubit)
+        
+        return combined
+    
+    def _sequential_circuits(self, 
+                           data_circuit: QuantumCircuit, 
+                           algorithm_circuit: QuantumCircuit,
+                           **kwargs) -> QuantumCircuit:
+        """
+        Apply circuits sequentially (data circuit followed by algorithm circuit).
+        
+        Args:
+            data_circuit: QPIXL data circuit
+            algorithm_circuit: Algorithm circuit
+            
+        Returns:
+            A sequential quantum circuit
+        """
+        if data_circuit.num_qubits != algorithm_circuit.num_qubits:
+            raise ValueError(
+                f"Circuits must have same number of qubits for sequential integration: "
+                f"{data_circuit.num_qubits} vs {algorithm_circuit.num_qubits}"
+            )
+            
+        combined = data_circuit.copy()
+        
+        combined.compose(algorithm_circuit, inplace=True)
+        
+        return combined
+    
+    def _entangle_circuits(self, 
+                          data_circuit: QuantumCircuit,
+                          algorithm_circuit: QuantumCircuit,
+                          connection_map: Dict[int, int],
+                          **kwargs) -> QuantumCircuit:
+        """
+        Combine circuits and add entanglement operations between them.
+        
+        Args:
+            data_circuit: QPIXL data circuit
+            algorithm_circuit: Algorithm circuit
+            connection_map: Dictionary mapping data qubits to algorithm qubits
+            
+        Returns:
+            An entangled quantum circuit
+        """
+        combined = self._merge_circuits(data_circuit, algorithm_circuit, {}, **kwargs)
+        
+        if not connection_map:
+            if data_circuit.num_qubits > 0 and algorithm_circuit.num_qubits > 0:
+                connection_map = {0: 0}  
+        
+        for data_qubit, algo_qubit in connection_map.items():
+            adjusted_algo_qubit = data_circuit.num_qubits + algo_qubit
+            
+            entangle_type = kwargs.get('entangle_type', 'cx')
+            
+            if entangle_type == 'cx':
+                combined.cx(data_qubit, adjusted_algo_qubit)
+            elif entangle_type == 'cz':
+                combined.cz(data_qubit, adjusted_algo_qubit)
+            elif entangle_type == 'swap':
+                combined.swap(data_qubit, adjusted_algo_qubit)
+            else:
+                raise ValueError(f"Unsupported entanglement type: {entangle_type}")
+        
+        return combined
+
+    def _slice_circuit(self, 
+                    circuit: QuantumCircuit, 
+                    slice_size: int) -> List[QuantumCircuit]:
+        """
+        Slice a quantum circuit into segments of a specified size.
+        
+        Args:
+            circuit: The circuit to slice
+            slice_size: Number of gates per slice
+            
+        Returns:
+            List of circuit slices
+        """
+        circuit_ops = circuit.data
+        
+        slices = []
+        for i in range(0, len(circuit_ops), slice_size):
+            end_idx = min(i + slice_size, len(circuit_ops))
+            slice_circuit = QuantumCircuit(circuit.num_qubits)
+            
+            for op in circuit_ops[i:end_idx]:
+                instruction = op[0]
+                qargs = op[1]
+                cargs = op[2] if len(op) > 2 else []
+                
+                qbit_indices = [circuit.qubits.index(q) for q in qargs]
+                
+                slice_circuit.append(instruction, qbit_indices, cargs)
+                
+            slices.append(slice_circuit)
+            
+        return slices
+    
+    def _sliced_circuits(self,
+                    data_circuit: QuantumCircuit,
+                    algorithm_circuit: QuantumCircuit,
+                    connection_map: Dict[int, int],
+                    **kwargs) -> QuantumCircuit:
+        """
+        Slice algorithm circuit and interleave slices with data circuit.
+        
+        Args:
+            data_circuit: QPIXL data circuit
+            algorithm_circuit: Algorithm circuit to be sliced
+            connection_map: Dictionary mapping data qubits to algorithm qubits
+            slice_size: Number of gates per slice (default: 3)
+            insertion_rule: Rule for where to insert slices ('interval', 'angles', etc.)
+            interval: Insert a slice every N operations (if insertion_rule='interval')
+            connection_rule: Rule to apply at each insertion point (default: 'cx')
+            
+        Returns:
+            An integrated circuit with interleaved slices
+        """
+        slice_size = kwargs.get('slice_size', 3)
+        connection_rule = kwargs.get('connection_rule', 'cx')
+        insertion_rule = kwargs.get('insertion_rule', 'interval')
+        interval = kwargs.get('interval', 8)
+        
+        slices = self._slice_circuit(algorithm_circuit, slice_size)
+        
+        total_qubits = data_circuit.num_qubits + algorithm_circuit.num_qubits
+        combined = QuantumCircuit(total_qubits)
+        
+        if insertion_rule == 'interval':
+            num_ops = len(data_circuit.data)
+            insertion_points = list(range(0, num_ops, interval))
+            if not insertion_points:
+                insertion_points = [0]
+        else:
+            num_ops = len(data_circuit.data)
+            if len(slices) > 1:
+                step = max(1, num_ops // len(slices))
+                insertion_points = list(range(0, num_ops, step))
+                if len(insertion_points) > len(slices):
+                    insertion_points = insertion_points[:len(slices)]
+            else:
+                insertion_points = [num_ops // 2]  
+        
+        segments = []
+        last_point = 0
+        for point in insertion_points + [len(data_circuit.data)]:
+            if point > last_point:
+                segment = QuantumCircuit(data_circuit.num_qubits)
+                for i in range(last_point, point):
+                    if i < len(data_circuit.data):
+                        inst, qargs, cargs = data_circuit.data[i]
+                        segment.append(inst, qargs, cargs)
+                segments.append(segment)
+                last_point = point
+        
+        data_qubits = list(range(data_circuit.num_qubits))
+        algo_qubits = list(range(data_circuit.num_qubits, total_qubits))
+        
+        current_slice = 0
+        for i, segment in enumerate(segments[:-1]):  
+            combined.compose(segment, data_qubits, inplace=True)
+            
+            if current_slice < len(slices):
+                slice_circ = slices[current_slice]
+                combined.compose(slice_circ, algo_qubits[:slice_circ.num_qubits], inplace=True)
+                
+                for data_qubit, algo_qubit in connection_map.items():
+                    adjusted_algo_qubit = data_circuit.num_qubits + algo_qubit
+                    
+                    if connection_rule == 'cx':
+                        combined.cx(data_qubit, adjusted_algo_qubit)
+                    elif connection_rule == 'cz':
+                        combined.cz(data_qubit, adjusted_algo_qubit)
+                    elif connection_rule == 'swap':
+                        combined.swap(data_qubit, adjusted_algo_qubit)
+                
+                current_slice += 1
+        
+        if segments:
+            combined.compose(segments[-1], data_qubits, inplace=True)
+        
+        while current_slice < len(slices):
+            slice_circ = slices[current_slice]
+            combined.compose(slice_circ, algo_qubits[:slice_circ.num_qubits], inplace=True)
+            
+            for data_qubit, algo_qubit in connection_map.items():
+                adjusted_algo_qubit = data_circuit.num_qubits + algo_qubit
+                
+                if connection_rule == 'cx':
+                    combined.cx(data_qubit, adjusted_algo_qubit)
+                elif connection_rule == 'cz':
+                    combined.cz(data_qubit, adjusted_algo_qubit)
+                elif connection_rule == 'swap':
+                    combined.swap(data_qubit, adjusted_algo_qubit)
+            
+            current_slice += 1
+        
+        return combined
+
+
+class QPIXLAlgorithmEncoder:
+    """
+    A class to create QPIXL circuits with integrated algorithm operations.
+    
+    This allows algorithm operations to be injected during the QPIXL encoding process,
+    similar to the cFRQI_with_alg_demo function in the QPIXL_demo notebook.
+    """
+    
+    def create_circuit(self, 
+                     data: np.ndarray, 
+                     compression: float = 0,
+                     algorithm_ops: Optional[List[Dict[str, Any]]] = None,
+                     post_processing: Optional[Callable] = None,
+                     algorithm_qubits: int = 1) -> QuantumCircuit:
+        """
+        Create a QPIXL circuit with integrated algorithm operations.
+        
+        Args:
+            data: Input data array to encode
+            compression: Compression ratio (0-100)
+            algorithm_ops: List of algorithm operations to apply
+                Each operation is a dict with:
+                - 'gate': Gate type ('unitary', 'cry', etc.)
+                - 'params': Parameters for the gate
+                - 'qubits': Qubits to apply the gate to (algorithm and encoding)
+            post_processing: Function to apply to the circuit after encoding
+            algorithm_qubits: Number of qubits to allocate for algorithm
+            
+        Returns:
+            A QPIXL circuit with integrated algorithm operations
+        """
+        a = hlp.convertToAngles(data)
+        a = hlp.preprocess_image(a)
+        n = len(a)
+        k = hlp.ilog2(n)
+        a = 2 * a
+        a = hlp.sfwht(a)
+        a = hlp.grayPermutation(a)
+        
+        if compression > 0:
+            a_sort_ind = np.argsort(np.abs(a))
+            cutoff = int((compression / 100.0) * n)
+            for it in a_sort_ind[:cutoff]:
+                a[it] = 0
+        
+        storage_qubits = QuantumRegister(k, "storage")
+        encoding_qubit = QuantumRegister(1, "encoding")
+        algo_qubits = QuantumRegister(algorithm_qubits, "algorithm")
+        
+        circuit = QuantumCircuit(storage_qubits, encoding_qubit, algo_qubits)
+        
+        circuit.h(storage_qubits)
+        
+        ctrl, pc, i = 0, 0, 0
+        while i < (2**k):
+            pc = int(0)  
+            
+            if a[i] != 0:
+                if algorithm_ops:
+                    for op in algorithm_ops:
+                        gate_type = op.get('gate')
+                        params = op.get('params', {})
+                        
+                        if gate_type == 'unitary':
+                            angle = a[i]
+                            unitary_matrix = np.array([
+                                [np.cos(angle), -1j * np.sin(angle)],
+                                [-1j * np.sin(angle), np.cos(angle)]
+                            ])
+                            circuit.unitary(unitary_matrix, algo_qubits[0], label=f"alg_{i}")
+                            
+                        elif gate_type == 'cry':
+                            circuit.cry(a[i], algo_qubits[0], encoding_qubit[0])
+                            
+                        elif gate_type == 'crx':
+                            circuit.crx(a[i], algo_qubits[0], encoding_qubit[0])
+                            
+                        elif gate_type == 'custom':
+                            custom_func = params.get('func')
+                            if custom_func:
+                                custom_func(circuit, a[i], i)
+                                
+                if not any(op.get('gate') == 'cry' for op in algorithm_ops or []):
+                    circuit.ry(a[i], encoding_qubit)
+            
+            if i == ((2**k) - 1):
+                ctrl = 0
+            else:
+                ctrl = hlp.grayCode(i) ^ hlp.grayCode(i + 1)
+                ctrl = k - hlp.countr_zero(ctrl, n_bits=k + 1) - 1
+            
+            pc ^= 2**ctrl  
+            i += 1
+            
+            while i < (2**k) and a[i] == 0:
+                if i == ((2**k) - 1):
+                    ctrl = 0
+                else:
+                    ctrl = hlp.grayCode(i) ^ hlp.grayCode(i + 1)
+                    ctrl = k - hlp.countr_zero(ctrl, n_bits=k + 1) - 1
+                pc ^= 2**ctrl  
+                i += 1
+            
+            for j in range(k):
+                if (pc >> j) & 1:
+                    circuit.cx(storage_qubits[j], encoding_qubit[0])
+        
+        circuit.reverse_bits()
+        
+        if post_processing:
+            post_processing(circuit)
+        
+        return circuit
+
+    def create_sliced_circuit(self,
+                            data: np.ndarray,
+                            algorithm_circuit: QuantumCircuit,
+                            compression: float = 0,
+                            slice_size: int = 3,
+                            insertion_rule: str = 'interval',
+                            interval: int = 8,
+                            connection_rule: str = 'cx',
+                            connection_map: Optional[Dict[int, int]] = None,
+                            algorithm_qubits: int = 1) -> QuantumCircuit:
+        """
+        Create a QPIXL circuit with slices of an algorithm circuit integrated at specific points.
+        
+        Args:
+            data: Input data array to encode
+            algorithm_circuit: Circuit to slice and integrate
+            compression: Compression ratio (0-100)
+            slice_size: Number of gates per slice
+            insertion_rule: Rule for where to insert slices ('interval', 'angles', 'custom')
+            interval: Insert a slice every N loop iterations (if insertion_rule='interval')
+            connection_rule: How to connect circuits ('cx', 'cz', 'swap')
+            connection_map: Dictionary mapping data qubits to algorithm qubits
+            algorithm_qubits: Number of qubits for algorithm
+            
+        Returns:
+            A QPIXL circuit with integrated algorithm slices
+        """
+        a = hlp.convertToAngles(data)
+        a = hlp.preprocess_image(a)
+        n = len(a)
+        k = hlp.ilog2(n)
+        a = 2 * a
+        a = hlp.sfwht(a)
+        a = hlp.grayPermutation(a)
+        
+        if compression > 0:
+            a_sort_ind = np.argsort(np.abs(a))
+            cutoff = int((compression / 100.0) * n)
+            for it in a_sort_ind[:cutoff]:
+                a[it] = 0
+        
+        integrator = CircuitIntegrator()
+        slices = integrator._slice_circuit(algorithm_circuit, slice_size)
+        current_slice = 0
+        
+        if connection_map is None:
+            connection_map = {0: 0}  
+        
+        storage_qubits = QuantumRegister(k, "storage")
+        encoding_qubit = QuantumRegister(1, "encoding")
+        algo_qubits = QuantumRegister(algorithm_qubits, "algorithm")
+        
+        circuit = QuantumCircuit(storage_qubits, encoding_qubit, algo_qubits)
+        
+        circuit.h(storage_qubits)
+        
+        insert_counter = 0
+        insertion_points = []
+        
+        if insertion_rule == 'custom':
+            insertion_points = insertion_points or []
+        elif insertion_rule == 'angles':
+            insertion_points = [i for i, angle in enumerate(a) if angle != 0]
+        
+        ctrl, pc, i = 0, 0, 0
+        while i < (2**k):
+            pc = int(0)
+            
+            insert_slice = False
+            if insertion_rule == 'interval' and insert_counter % interval == 0:
+                insert_slice = True
+            elif insertion_rule == 'angles' and i in insertion_points:
+                insert_slice = True
+            elif insertion_rule == 'custom' and i in insertion_points:
+                insert_slice = True
+            
+            if insert_slice and current_slice < len(slices):
+                slice_circ = slices[current_slice]
+                for j in range(min(slice_circ.num_qubits, len(algo_qubits))):
+                    for inst, qargs, cargs in slice_circ.data:
+                        qbit_indices = [slice_circ.qubits.index(q) for q in qargs]
+                        mapped_qargs = [algo_qubits[idx] if idx < len(algo_qubits) else qarg 
+                                    for idx, qarg in zip(qbit_indices, qargs)]
+                        circuit.append(inst, mapped_qargs, cargs)
+                
+                for data_qubit, algo_qubit in connection_map.items():
+                    if connection_rule == 'cx':
+                        circuit.cx(storage_qubits[data_qubit], algo_qubits[algo_qubit])
+                    elif connection_rule == 'cz':
+                        circuit.cz(storage_qubits[data_qubit], algo_qubits[algo_qubit])
+                    elif connection_rule == 'swap':
+                        circuit.swap(storage_qubits[data_qubit], algo_qubits[algo_qubit])
+                
+                current_slice += 1
+            
+            if a[i] != 0:
+                circuit.ry(a[i], encoding_qubit)
+            
+            if i == ((2**k) - 1):
+                ctrl = 0
+            else:
+                ctrl = hlp.grayCode(i) ^ hlp.grayCode(i + 1)
+                ctrl = k - hlp.countr_zero(ctrl, n_bits=k + 1) - 1
+            
+            pc ^= 2**ctrl
+            i += 1
+            
+            while i < (2**k) and a[i] == 0:
+                if i == ((2**k) - 1):
+                    ctrl = 0
+                else:
+                    ctrl = hlp.grayCode(i) ^ hlp.grayCode(i + 1)
+                    ctrl = k - hlp.countr_zero(ctrl, n_bits=k + 1) - 1
+                pc ^= 2**ctrl
+                i += 1
+            
+            for j in range(k):
+                if (pc >> j) & 1:
+                    circuit.cx(storage_qubits[j], encoding_qubit[0])
+            
+            insert_counter += 1
+        
+        while current_slice < len(slices):
+            slice_circ = slices[current_slice]
+            for j in range(min(slice_circ.num_qubits, len(algo_qubits))):
+                for inst, qargs, cargs in slice_circ.data:
+                    # Same fix as above
+                    qbit_indices = [slice_circ.qubits.index(q) for q in qargs]
+                    mapped_qargs = [algo_qubits[idx] if idx < len(algo_qubits) else qarg 
+                                for idx, qarg in zip(qbit_indices, qargs)]
+                    circuit.append(inst, mapped_qargs, cargs)
+                
+            for data_qubit, algo_qubit in connection_map.items():
+                if connection_rule == 'cx':
+                    circuit.cx(storage_qubits[data_qubit], algo_qubits[algo_qubit])
+                elif connection_rule == 'cz':
+                    circuit.cz(storage_qubits[data_qubit], algo_qubits[algo_qubit])
+                elif connection_rule == 'swap':
+                    circuit.swap(storage_qubits[data_qubit], algo_qubits[algo_qubit])
+            
+            current_slice += 1
+        
+        circuit.reverse_bits()
+        return circuit
+
+
+def create_pattern_function(gate_name: str, **params) -> Tuple[Callable, any]:
+    """
+    Create a pattern function for use with cFRQIangs.
+    
+    Args:
+        gate_name: Name of the gate to apply ('rx', 'ry', 'crx', 'cry', etc.)
+        **params: Parameters for the gate (angle, control, target, etc.)
+        
+    Returns:
+        A tuple of (pattern_function, angle)
+    """
+    gate_ops = {
+        'rx': lambda c: c.rx(params.get('angle', 0), params.get('target', 0)),
+        'ry': lambda c: c.ry(params.get('angle', 0), params.get('target', 0)),
+        'rz': lambda c: c.rz(params.get('angle', 0), params.get('target', 0)),
+        'crx': lambda c: c.crx(params.get('angle', 0), params.get('control', 1), params.get('target', 0)),
+        'cry': lambda c: c.cry(params.get('angle', 0), params.get('control', 1), params.get('target', 0)),
+        'crz': lambda c: c.crz(params.get('angle', 0), params.get('control', 1), params.get('target', 0)),
+        'cx': lambda c: c.cx(params.get('control', 1), params.get('target', 0)),
+        'cnot': lambda c: c.cx(params.get('control', 1), params.get('target', 0)),
+        'h': lambda c: c.h(params.get('target', 0))
+    }
+    
+    def pattern_func(circ):
+        """Pattern function to apply the specified gate to the circuit."""
+        gate_name_lower = gate_name.lower()
+        if gate_name_lower in gate_ops:
+            gate_ops[gate_name_lower](circ)
+        else:
+            raise ValueError(f"Unsupported gate: {gate_name}")
+    
+    return pattern_func, params.get('angle', 0)
+
+
+def create_post_processing(operations: List[Dict]) -> Callable:
+    """
+    Create a post-processing function to apply operations to a circuit.
+    
+    Args:
+        operations: List of operations to apply
+            Each operation is a dict with:
+            - 'gate': Gate type ('h', 'x', 'rx', etc.)
+            - 'qubits': List of qubits to apply the gate to
+            - 'params': Parameters for the gate (if needed)
+    
+    Returns:
+        A post-processing function
+    """
+    gate_ops = {
+        'h': lambda c, q, p: c.h(q),
+        'x': lambda c, q, p: c.x(q),
+        'y': lambda c, q, p: c.y(q),
+        'z': lambda c, q, p: c.z(q),
+        'rx': lambda c, q, p: c.rx(p.get('angle', 0), q),
+        'ry': lambda c, q, p: c.ry(p.get('angle', 0), q),
+        'rz': lambda c, q, p: c.rz(p.get('angle', 0), q),
+    }
+    
+    def post_process(circuit):
+        """Apply the specified operations to the circuit."""
+        for op in operations:
+            gate = op.get('gate', '').lower()
+            qubits = op.get('qubits', [0])
+            params = op.get('params', {})
+            
+            for q in qubits:
+                if gate in gate_ops:
+                    gate_ops[gate](circuit, q, params)
+    
+    return post_process
+
+# ------------------------------------------------------------
+# USAGE EXAMPLES
+# ------------------------------------------------------------
+# To create circuit integrations:
+#
+# integrator = CircuitIntegrator()
+# combined = integrator.integrate(
+#     data_circuit,
+#     algorithm_circuit,
+#     mode=IntegrationMode.MERGE,
+#     connection_map={0: 0, 1: 1}
+# )
+#
+# To create QPIXL circuits with algorithm operations:
+#
+# encoder = QPIXLAlgorithmEncoder()
+# circuit = encoder.create_circuit(
+#     data,
+#     compression=0,
+#     algorithm_ops=[{'gate': 'unitary', 'params': {}}]
+# )
+#
+# To create QPIXL circuits with sliced algorithm integration:
+#
+# encoder = QPIXLAlgorithmEncoder()
+# circuit = encoder.create_sliced_circuit(
+#     data,
+#     algorithm_circuit,
+#     compression=0,
+#     slice_size=3,
+#     insertion_rule='interval',
+#     interval=8
+# )
\ No newline at end of file
diff --git a/QPIXL_Flexible_Circuit_Integration_Demo.ipynb b/QPIXL_Flexible_Circuit_Integration_Demo.ipynb
new file mode 100644
index 0000000..baaab5f
--- /dev/null
+++ b/QPIXL_Flexible_Circuit_Integration_Demo.ipynb
@@ -0,0 +1,1096 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "fd9b90a7",
+   "metadata": {},
+   "source": [
+    "# Flexible Quantum Circuit Integration with QPIXL\n",
+    "\n",
+    "This notebook demonstrates a flexible framework for integrating arbitrary quantum circuits with QPIXL-encoded data circuits. The goal is to provide a modular and extensible way to combine data encoding with quantum algorithms using various strategies like merging, entangling, or slicing circuits.\n",
+    "\n",
+    "We will showcase the `CircuitIntegrator` and `QPIXLAlgorithmEncoder` classes, along with helper functions and their application in image and audio processing.\n",
+    "\n",
+    "### Step 1: Notebook Title and Initial Setup (Imports)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cfe859f7",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Libraries imported successfully.\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "import os\n",
+    "from enum import Enum\n",
+    "from typing import Callable, Dict, List, Optional, Union, Tuple, Any\n",
+    "from itertools import chain\n",
+    "\n",
+    "import qiskit\n",
+    "from qiskit import QuantumCircuit, QuantumRegister\n",
+    "from qiskit_aer import StatevectorSimulator\n",
+    "import matplotlib.pyplot as plt\n",
+    "from matplotlib import animation\n",
+    "from PIL import Image\n",
+    "from ipywidgets import interact \n",
+    "\n",
+    "import QPIXL.helper as hlp\n",
+    "from QPIXL.qiskit.qpixl import cFRQI\n",
+    "from QPIXL.qiskit.qpixl_angs import cFRQIangs, decodeAngQPIXL\n",
+    "\n",
+    "from QPIXL.qpixl_integrator import (\n",
+    "    CircuitIntegrator, \n",
+    "    IntegrationMode, \n",
+    "    QPIXLAlgorithmEncoder, \n",
+    "    create_pattern_function, \n",
+    "    create_post_processing\n",
+    ")\n",
+    "from QPIXL.audio_processor import (\n",
+    "    process_audio_with_slices, \n",
+    "    create_algorithm_circuit\n",
+    ")\n",
+    "\n",
+    "import warnings\n",
+    "import soundfile \n",
+    "\n",
+    "warnings.filterwarnings(\"ignore\") \n",
+    "backend = StatevectorSimulator(method=\"statevector\") \n",
+    "\n",
+    "print(\"Libraries imported successfully.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "21c0f919",
+   "metadata": {},
+   "source": [
+    "### Step 2: Introduction to QPIXL and Baseline Encoding\n",
+    "\n",
+    "This step will briefly introduce QPIXL encoding and show a standard image encoding example. This serves as a baseline before we introduce algorithm integration. We'll also define a helper function to run and visualize circuits."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "fb9ffc3f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 300x300 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "QPIXL-encoded data circuit (30% compression):\n",
+      "- Qubits: 8\n",
+      "- Depth: 204\n",
+      "\n",
+      "Visualizing the baseline QPIXL-encoded image:\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 400x400 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "image_data_raw = hlp.examples().space \n",
+    "image_shape = image_data_raw.shape \n",
+    "\n",
+    "plt.figure(figsize=(3,3))\n",
+    "plt.imshow(image_data_raw)\n",
+    "plt.title(\"Original Sample Image\")\n",
+    "plt.axis('off')\n",
+    "plt.show()\n",
+    "\n",
+    "\n",
+    "compression_level = 30\n",
+    "data_circuit_qpixl = cFRQI(image_data_raw, compression_level)\n",
+    "\n",
+    "print(f\"QPIXL-encoded data circuit ({compression_level}% compression):\")\n",
+    "print(f\"- Qubits: {data_circuit_qpixl.num_qubits}\")\n",
+    "print(f\"- Depth: {data_circuit_qpixl.depth()}\")\n",
+    "data_circuit_qpixl.draw(output='mpl', fold=120, scale=0.7) \n",
+    "\n",
+    "\n",
+    "def run_and_show_image(circuit: QuantumCircuit, \n",
+    "                       original_shape: Tuple[int, int], \n",
+    "                       title: str = \"Decoded Image\",\n",
+    "                       ax=None):\n",
+    "    \"\"\"Runs a quantum circuit, decodes the QPIXL image, and displays it.\"\"\"\n",
+    "    job = backend.run(circuit)\n",
+    "    statevector = np.real(job.result().get_statevector())\n",
+    "    decoded_image_angles = hlp.decodeQPIXL(statevector) # Using the basic decoder\n",
+    "    reconstructed_image = hlp.reconstruct_img(decoded_image_angles, original_shape).T\n",
+    "    \n",
+    "    if ax is None:\n",
+    "        fig, current_ax = plt.subplots(figsize=(4,4))\n",
+    "    else:\n",
+    "        current_ax = ax\n",
+    "        \n",
+    "    current_ax.imshow(reconstructed_image)\n",
+    "    current_ax.set_title(f\"{title}\\nDepth: {circuit.depth()}, Qubits: {circuit.num_qubits}\")\n",
+    "    current_ax.axis('off')\n",
+    "    \n",
+    "    if ax is None:\n",
+    "        plt.show()\n",
+    "    return reconstructed_image\n",
+    "\n",
+    "print(\"\\nVisualizing the baseline QPIXL-encoded image:\")\n",
+    "baseline_image = run_and_show_image(data_circuit_qpixl, image_shape, \"Baseline QPIXL Encoding\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bb49e9a9",
+   "metadata": {},
+   "source": [
+    "### Step 3: Define a Sample Algorithm Circuit\n",
+    "\n",
+    "We need a simple quantum circuit to represent an \"algorithm\" that we want to integrate with our QPIXL-encoded data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "3199cec2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Sample Algorithm Circuit:\n",
+      "- Qubits: 3\n",
+      "- Depth: 4\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 430.664x227.422 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "algorithm_qubits = 3\n",
+    "algorithm_circuit = QuantumCircuit(algorithm_qubits, name=\"Algo\")\n",
+    "algorithm_circuit.h(0)\n",
+    "algorithm_circuit.cx(0, 1)\n",
+    "algorithm_circuit.rx(np.pi/3, 2)\n",
+    "algorithm_circuit.barrier()\n",
+    "algorithm_circuit.cx(1, 2)\n",
+    "algorithm_circuit.rz(np.pi/4, 0)\n",
+    "algorithm_circuit.h(range(algorithm_qubits))\n",
+    "\n",
+    "print(\"Sample Algorithm Circuit:\")\n",
+    "print(f\"- Qubits: {algorithm_circuit.num_qubits}\")\n",
+    "print(f\"- Depth: {algorithm_circuit.depth()}\")\n",
+    "display(algorithm_circuit.draw(output='mpl', scale=0.8))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2b7d0c49",
+   "metadata": {},
+   "source": [
+    "### Step 4: Introduce `CircuitIntegrator` - Basic Integration Modes (`MERGE`, `ENTANGLE`)\n",
+    "\n",
+    "This step will introduce the `CircuitIntegrator` class and demonstrate its basic integration modes: `MERGE` and `ENTANGLE`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "306763a3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "--- MERGE Mode ---\n",
+      "Merged circuit qubits: 11, depth: 205\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 400x400 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "--- ENTANGLE Mode ---\n",
+      "Entangled circuit qubits: 11, depth: 205\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 400x400 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Entangled (SWAP) circuit qubits: 11, depth: 205\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 400x400 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "integrator = CircuitIntegrator()\n",
+    "\n",
+    "print(\"--- MERGE Mode ---\")\n",
+    "merged_circuit = integrator.integrate(\n",
+    "    data_circuit=data_circuit_qpixl.copy(), \n",
+    "    algorithm_circuit=algorithm_circuit.copy(),\n",
+    "    mode=IntegrationMode.MERGE,\n",
+    "    connection_map={0: 0, 1: 1}, \n",
+    "    connection_type='cx' \n",
+    ")\n",
+    "\n",
+    "print(f\"Merged circuit qubits: {merged_circuit.num_qubits}, depth: {merged_circuit.depth()}\")\n",
+    "merged_circuit.draw(output='mpl', fold=150, scale=0.7) \n",
+    "merged_image = run_and_show_image(merged_circuit, image_shape, \"MERGE Integration\")\n",
+    "\n",
+    "print(\"\\n--- ENTANGLE Mode ---\")\n",
+    "entangled_circuit = integrator.integrate(\n",
+    "    data_circuit=data_circuit_qpixl.copy(),\n",
+    "    algorithm_circuit=algorithm_circuit.copy(),\n",
+    "    mode=IntegrationMode.ENTANGLE,\n",
+    "    connection_map={0: 0, 2: 1}, \n",
+    "    entangle_type='cz' \n",
+    ")\n",
+    "\n",
+    "print(f\"Entangled circuit qubits: {entangled_circuit.num_qubits}, depth: {entangled_circuit.depth()}\")\n",
+    "entangled_circuit.draw(output='mpl', fold=150, scale=0.7) \n",
+    "entangled_image = run_and_show_image(entangled_circuit, image_shape, \"ENTANGLE Integration (CZ)\")\n",
+    "\n",
+    "entangled_swap_circuit = integrator.integrate(\n",
+    "    data_circuit=data_circuit_qpixl.copy(),\n",
+    "    algorithm_circuit=algorithm_circuit.copy(),\n",
+    "    mode=IntegrationMode.ENTANGLE,\n",
+    "    connection_map={i: i for i in range(min(data_circuit_qpixl.num_qubits, algorithm_circuit.num_qubits))}, # Connect corresponding qubits\n",
+    "    entangle_type='swap'\n",
+    ")\n",
+    "print(f\"\\nEntangled (SWAP) circuit qubits: {entangled_swap_circuit.num_qubits}, depth: {entangled_swap_circuit.depth()}\")\n",
+    "entangled_swap_image = run_and_show_image(entangled_swap_circuit, image_shape, \"ENTANGLE Integration (SWAP)\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7f0d2a3b",
+   "metadata": {},
+   "source": [
+    "### Step 5: `CircuitIntegrator` - `SLICED` Mode\n",
+    "\n",
+    "The `SLICED` mode is more advanced. It breaks the algorithm circuit into smaller pieces (slices) and interleaves them within the data circuit."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "402cfed7",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "--- SLICED Mode ---\n",
+      "Sliced (interval) circuit qubits: 11, depth: 204\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 400x400 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Sliced (end) circuit qubits: 11, depth: 205\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 400x400 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "print(\"--- SLICED Mode ---\")\n",
+    "\n",
+    "sliced_circuit_interval = integrator.integrate(\n",
+    "    data_circuit=data_circuit_qpixl.copy(),\n",
+    "    algorithm_circuit=algorithm_circuit.copy(),\n",
+    "    mode=IntegrationMode.SLICED,\n",
+    "    slice_size=1,  \n",
+    "    connection_map={0:0, 1:1}, \n",
+    "    insertion_rule='interval', \n",
+    "    interval=15, \n",
+    "    connection_type_within_slice='cx' \n",
+    ")\n",
+    "\n",
+    "print(f\"Sliced (interval) circuit qubits: {sliced_circuit_interval.num_qubits}, depth: {sliced_circuit_interval.depth()}\")\n",
+    "sliced_circuit_interval.draw(output='mpl', fold=180, scale=0.6) \n",
+    "sliced_interval_image = run_and_show_image(sliced_circuit_interval, image_shape, \"SLICED Integration (Interval)\")\n",
+    "\n",
+    "sliced_circuit_end = integrator.integrate(\n",
+    "    data_circuit=data_circuit_qpixl.copy(),\n",
+    "    algorithm_circuit=algorithm_circuit.copy(),\n",
+    "    mode=IntegrationMode.SLICED,\n",
+    "    slice_size=2,\n",
+    "    connection_map={0:0},\n",
+    "    insertion_rule='end',\n",
+    "    connection_type_within_slice='cz'\n",
+    ")\n",
+    "print(f\"\\nSliced (end) circuit qubits: {sliced_circuit_end.num_qubits}, depth: {sliced_circuit_end.depth()}\")\n",
+    "sliced_end_image = run_and_show_image(sliced_circuit_end, image_shape, \"SLICED Integration (End)\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0f9843bf",
+   "metadata": {},
+   "source": [
+    "### Step 6: `CircuitIntegrator` - `CUSTOM` Mode\n",
+    "\n",
+    "The `CUSTOM` mode offers maximum flexibility by allowing you to define your own Python function to perform the integration"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "7cae2089",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "--- CUSTOM Mode ---\n",
+      "Custom integrated circuit qubits: 11, depth: 206\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 400x400 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "print(\"--- CUSTOM Mode ---\")\n",
+    "\n",
+    "def my_custom_integration_rule(data_circ: QuantumCircuit, \n",
+    "                               algo_circ: QuantumCircuit, \n",
+    "                               **kwargs) -> QuantumCircuit:\n",
+    "    \"\"\"\n",
+    "    A custom rule that composes data and algorithm circuits,\n",
+    "    then applies a layer of Hadamard gates to all algorithm qubits,\n",
+    "    and finally adds a CNOT between a specified data qubit and algorithm qubit.\n",
+    "    \"\"\"\n",
+    "    num_data_qubits = data_circ.num_qubits\n",
+    "    num_algo_qubits = algo_circ.num_qubits\n",
+    "    \n",
+    "    combined_circuit = QuantumCircuit(num_data_qubits + num_algo_qubits, name=\"CustomIntegrated\")\n",
+    "    \n",
+    "    combined_circuit.compose(data_circ, qubits=range(num_data_qubits), inplace=True)\n",
+    "    \n",
+    "    algo_qubit_indices = list(range(num_data_qubits, num_data_qubits + num_algo_qubits))\n",
+    "    combined_circuit.compose(algo_circ, qubits=algo_qubit_indices, inplace=True)\n",
+    "    \n",
+    "    combined_circuit.barrier()\n",
+    "    for q_idx in algo_qubit_indices:\n",
+    "        combined_circuit.h(q_idx)\n",
+    "    combined_circuit.barrier()\n",
+    "        \n",
+    "    data_control_qubit = kwargs.get('data_control', 0)\n",
+    "    algo_target_qubit_offset = kwargs.get('algo_target', 0)\n",
+    "    \n",
+    "    if data_control_qubit < num_data_qubits and algo_target_qubit_offset < num_algo_qubits:\n",
+    "        actual_algo_target = num_data_qubits + algo_target_qubit_offset\n",
+    "        combined_circuit.cx(data_control_qubit, actual_algo_target)\n",
+    "        \n",
+    "    return combined_circuit\n",
+    "\n",
+    "custom_integrated_circuit = integrator.integrate(\n",
+    "    data_circuit=data_circuit_qpixl.copy(),\n",
+    "    algorithm_circuit=algorithm_circuit.copy(),\n",
+    "    mode=IntegrationMode.CUSTOM,\n",
+    "    custom_rule=my_custom_integration_rule,\n",
+    "    data_control=1, \n",
+    "    algo_target=0 \n",
+    ")\n",
+    "\n",
+    "print(f\"Custom integrated circuit qubits: {custom_integrated_circuit.num_qubits}, depth: {custom_integrated_circuit.depth()}\")\n",
+    "custom_integrated_circuit.draw(output='mpl', fold=150, scale=0.7) \n",
+    "custom_image = run_and_show_image(custom_integrated_circuit, image_shape, \"CUSTOM Integration\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b3b2d041",
+   "metadata": {},
+   "source": [
+    "### Step 7: Introduce `QPIXLAlgorithmEncoder` - Direct Algorithm Integration\n",
+    "\n",
+    "The `QPIXLAlgorithmEncoder` class allows for integrating algorithm operations directly during the QPIXL encoding process. This is different from the `CircuitIntegrator` which combines already existing circuits."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "964a6172",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "--- QPIXLAlgorithmEncoder: create_circuit ---\n",
+      "Directly integrated circuit qubits: 4, depth: 9\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 780.588x294.311 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Directly integrated image circuit qubits: 9, depth: 205\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 400x400 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "encoder = QPIXLAlgorithmEncoder()\n",
+    "\n",
+    "algorithm_ops_config = [\n",
+    "    {'gate': 'unitary', 'params': {'label_prefix': 'custom_U'}}, \n",
+    "    {'gate': 'cry', 'params': {}}  \n",
+    "]\n",
+    "\n",
+    "simple_data_array = np.array([0.1, 0.5, 1.0, 1.5]) \n",
+    "num_algorithm_qubits_for_encoder = 1 \n",
+    "\n",
+    "print(\"--- QPIXLAlgorithmEncoder: create_circuit ---\")\n",
+    "direct_integration_circuit = encoder.create_circuit(\n",
+    "    data=simple_data_array,\n",
+    "    compression=0, \n",
+    "    algorithm_ops=algorithm_ops_config,\n",
+    "    algorithm_qubits=num_algorithm_qubits_for_encoder\n",
+    ")\n",
+    "\n",
+    "print(f\"Directly integrated circuit qubits: {direct_integration_circuit.num_qubits}, depth: {direct_integration_circuit.depth()}\")\n",
+    "display(direct_integration_circuit.draw(output='mpl', fold=100, scale=0.8))\n",
+    "\n",
+    "\n",
+    "small_image_data = hlp.examples().space[:16, :16] \n",
+    "small_image_shape = small_image_data.shape\n",
+    "\n",
+    "direct_integration_image_circuit = encoder.create_circuit(\n",
+    "    data=small_image_data, \n",
+    "    compression=compression_level,\n",
+    "    algorithm_ops=algorithm_ops_config,\n",
+    "    algorithm_qubits=num_algorithm_qubits_for_encoder\n",
+    ")\n",
+    "\n",
+    "print(f\"\\nDirectly integrated image circuit qubits: {direct_integration_image_circuit.num_qubits}, depth: {direct_integration_image_circuit.depth()}\")\n",
+    "direct_integration_image = run_and_show_image(direct_integration_image_circuit, small_image_shape, \"Direct Encoder Integration\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3c530b74",
+   "metadata": {},
+   "source": [
+    "### Step 8: `QPIXLAlgorithmEncoder` - `create_sliced_circuit` Method\n",
+    "\n",
+    "This method of the `QPIXLAlgorithmEncoder` is specifically designed to integrate an existing algorithm circuit by slicing it and interleaving it during the QPIXL encoding of data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "8028ae3e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "--- QPIXLAlgorithmEncoder: create_sliced_circuit ---\n",
+      "Encoder-sliced circuit qubits: 11, depth: 211\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 400x400 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "print(\"--- QPIXLAlgorithmEncoder: create_sliced_circuit ---\")\n",
+    "\n",
+    "if algorithm_circuit.num_qubits != 3: \n",
+    "    algorithm_circuit_for_slicing = QuantumCircuit(3, name=\"AlgoSlice\")\n",
+    "    algorithm_circuit_for_slicing.h(0)\n",
+    "    algorithm_circuit_for_slicing.cx(0,1)\n",
+    "    algorithm_circuit_for_slicing.rz(np.pi/2, 2)\n",
+    "else:\n",
+    "    algorithm_circuit_for_slicing = algorithm_circuit.copy()\n",
+    "\n",
+    "\n",
+    "encoder_sliced_circuit = encoder.create_sliced_circuit(\n",
+    "    data=image_data_raw, \n",
+    "    algorithm_circuit=algorithm_circuit_for_slicing,\n",
+    "    compression=compression_level,\n",
+    "    slice_size=1,  \n",
+    "    insertion_rule='interval',\n",
+    "    interval=20,   \n",
+    "    connection_rule='cx', \n",
+    "    connection_map = {0:0}, \n",
+    "    algorithm_qubits=algorithm_circuit_for_slicing.num_qubits \n",
+    ")\n",
+    "\n",
+    "print(f\"Encoder-sliced circuit qubits: {encoder_sliced_circuit.num_qubits}, depth: {encoder_sliced_circuit.depth()}\")\n",
+    "encoder_sliced_circuit.draw(output='mpl', fold=200, scale=0.5) \n",
+    "encoder_sliced_image = run_and_show_image(encoder_sliced_circuit, image_shape, \"Encoder Sliced Integration\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1f2098bd",
+   "metadata": {},
+   "source": [
+    "### Step 9: Helper Functions - `create_pattern_function` and `create_post_processing`\n",
+    "\n",
+    "These utility functions help define reusable patterns or sequences of gates that can be incorporated into the encoding process."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "e7812055",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "--- Helper: create_pattern_function ---\n",
+      "Dummy circuit with CRX pattern:\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 203.683x200.667 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "--- Helper: create_post_processing ---\n",
+      "Encoder circuit with post-processing qubits: 10, depth: 205\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 400x400 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "print(\"--- Helper: create_pattern_function ---\")\n",
+    "\n",
+    "crx_pattern_func, crx_angle = create_pattern_function(\n",
+    "    gate_name='crx', \n",
+    "    angle=np.pi/4, \n",
+    "    control=0, \n",
+    "    target=1   \n",
+    ")\n",
+    "dummy_qc_pattern = QuantumCircuit(2)\n",
+    "crx_pattern_func(dummy_qc_pattern) \n",
+    "print(\"Dummy circuit with CRX pattern:\")\n",
+    "display(dummy_qc_pattern.draw(output='mpl'))\n",
+    "\n",
+    "\n",
+    "print(\"\\n--- Helper: create_post_processing ---\")\n",
+    "post_processing_ops_config = [\n",
+    "    {'gate': 'h', 'qubits': [0]}, \n",
+    "    {'gate': 'rx', 'qubits': [1], 'params': {'angle': np.pi/6}} \n",
+    "]\n",
+    "\n",
+    "\n",
+    "post_processing_callable = create_post_processing(post_processing_ops_config)\n",
+    "\n",
+    "def get_max_qubit_index_from_op_list(op_list: List[Dict]) -> int:\n",
+    "    \"\"\"\n",
+    "    Calculates the maximum qubit index referenced in a list of operations.\n",
+    "    Each operation is a dict and should have a 'qubits' key (a list of ints).\n",
+    "    \"\"\"\n",
+    "    max_idx = -1\n",
+    "    if not op_list:\n",
+    "        return 0 \n",
+    "    for op in op_list:\n",
+    "        if 'qubits' in op and op['qubits']:\n",
+    "            current_max = max(op['qubits'])\n",
+    "            if current_max > max_idx:\n",
+    "                max_idx = current_max\n",
+    "    return max_idx\n",
+    "\n",
+    "if post_processing_ops_config:\n",
+    "    max_qubit_idx_post_proc = get_max_qubit_index_from_op_list(post_processing_ops_config)\n",
+    "    num_algo_qubits_for_post_proc = max_qubit_idx_post_proc + 1\n",
+    "else:\n",
+    "    num_algo_qubits_for_post_proc = 1 \n",
+    "\n",
+    "\n",
+    "encoder_with_post_proc_circuit = encoder.create_circuit(\n",
+    "    data=small_image_data, \n",
+    "    compression=compression_level,\n",
+    "    algorithm_ops=[], \n",
+    "    algorithm_qubits=num_algo_qubits_for_post_proc,\n",
+    "    post_processing=post_processing_callable \n",
+    ")\n",
+    "\n",
+    "print(f\"Encoder circuit with post-processing qubits: {encoder_with_post_proc_circuit.num_qubits}, depth: {encoder_with_post_proc_circuit.depth()}\")\n",
+    "encoder_with_post_proc_circuit.draw(output='mpl', fold=150, scale=0.7) \n",
+    "post_proc_image = run_and_show_image(encoder_with_post_proc_circuit, small_image_shape, \"Encoder with Post-Processing\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4eb5a1b0",
+   "metadata": {},
+   "source": [
+    "### Step 10: Application - Visual Effects on Images\n",
+    "\n",
+    "This step will demonstrate how to use the `CircuitIntegrator` (particularly `CUSTOM` or `ENTANGLE` modes) to create visual effects by combining QPIXL circuits of two different images."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c3716bc1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "--- Visual Effects Demo ---\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "4d6369539b75462d80b24d2f53ac7785",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "interactive(children=(FloatSlider(value=0.7853981633974483, description='angle_param', max=6.283185307179586),…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "img1_raw = hlp.examples().invader\n",
+    "shape1 = img1_raw.shape\n",
+    "img2_raw = hlp.examples().space \n",
+    "shape2 = img2_raw.shape \n",
+    "\n",
+    "print(\"--- Visual Effects Demo ---\")\n",
+    "\n",
+    "def interactive_image_integration(angle_param:float=np.pi/4, \n",
+    "                                  gate_type:str=\"CRX\", \n",
+    "                                  compression1:int=30, \n",
+    "                                  compression2:int=30,\n",
+    "                                  num_connecting_qubits:int=4):\n",
+    "    \n",
+    "    qpixl_circuit1 = cFRQI(img1_raw.copy(), compression1)\n",
+    "    qpixl_circuit2 = cFRQI(img2_raw.copy(), compression2)\n",
+    "\n",
+    "\n",
+    "    num_address_qubits1 = qpixl_circuit1.num_qubits - 1 \n",
+    "    num_address_qubits2 = qpixl_circuit2.num_qubits - 1\n",
+    "    \n",
+    "    connect_limit = min(num_address_qubits1, num_address_qubits2, num_connecting_qubits)\n",
+    "\n",
+    "    if connect_limit <= 0:\n",
+    "        print(\"Cannot connect qubits, check compression or num_connecting_qubits.\")\n",
+    "        run_and_show_image(qpixl_circuit1, shape1, f\"Original Image 1 (No Connection)\")\n",
+    "        return\n",
+    "\n",
+    "    integrator_imgs = CircuitIntegrator()\n",
+    "    integrated_img_qc = None\n",
+    "\n",
+    "    if gate_type == \"CRX\" or gate_type == \"CRY\":\n",
+    "        def custom_rot_rule(data_circ1, data_circ2, **kwargs):\n",
+    "            g_type = kwargs.get('gate', 'crx')\n",
+    "            ang = kwargs.get('angle', 0)\n",
+    "            limit = kwargs.get('limit', 1)\n",
+    "            \n",
+    "            combined_qc = QuantumCircuit(data_circ1.num_qubits + data_circ2.num_qubits)\n",
+    "            combined_qc.compose(data_circ1, qubits=range(data_circ1.num_qubits), inplace=True)\n",
+    "            combined_qc.compose(data_circ2, qubits=range(data_circ1.num_qubits, combined_qc.num_qubits), inplace=True)\n",
+    "            \n",
+    "            combined_qc.barrier()\n",
+    "            for i in range(limit): \n",
+    "                q_control = i \n",
+    "                q_target = data_circ1.num_qubits + i \n",
+    "                if g_type == 'crx':\n",
+    "                    combined_qc.crx(ang, q_control, q_target)\n",
+    "                elif g_type == 'cry':\n",
+    "                    combined_qc.cry(ang, q_control, q_target)\n",
+    "            combined_qc.barrier()\n",
+    "            return combined_qc\n",
+    "        \n",
+    "        integrated_img_qc = integrator_imgs.integrate(\n",
+    "            qpixl_circuit1, qpixl_circuit2,\n",
+    "            mode=IntegrationMode.CUSTOM,\n",
+    "            custom_rule=custom_rot_rule,\n",
+    "            gate=gate_type.lower(),\n",
+    "            angle=angle_param,\n",
+    "            limit=connect_limit\n",
+    "        )\n",
+    "    elif gate_type == \"SWAP\":\n",
+    "        connection_map_swap = {i: i for i in range(connect_limit)}\n",
+    "        integrated_img_qc = integrator_imgs.integrate(\n",
+    "            qpixl_circuit1, qpixl_circuit2,\n",
+    "            mode=IntegrationMode.ENTANGLE,\n",
+    "            connection_map=connection_map_swap,\n",
+    "            entangle_type='swap'\n",
+    "        )\n",
+    "    elif gate_type == \"CX\":\n",
+    "        connection_map_cx = {i: i for i in range(connect_limit)}\n",
+    "        integrated_img_qc = integrator_imgs.integrate(\n",
+    "            qpixl_circuit1, qpixl_circuit2,\n",
+    "            mode=IntegrationMode.ENTANGLE,\n",
+    "            connection_map=connection_map_cx,\n",
+    "            entangle_type='cx' \n",
+    "        )\n",
+    "    else:\n",
+    "        print(f\"Gate type {gate_type} not recognized for this demo. Showing original image 1.\")\n",
+    "        run_and_show_image(qpixl_circuit1, shape1, f\"Original Image 1 (Unrecognized Gate)\")\n",
+    "        return\n",
+    "\n",
+    "    print(f\"Integrated with {gate_type}, angle: {angle_param if 'CR' in gate_type else 'N/A'}, connections: {connect_limit}\")\n",
+    "    run_and_show_image(integrated_img_qc, shape1, f\"Visual Effect: {gate_type}\")\n",
+    "\n",
+    "interact(\n",
+    "    interactive_image_integration,\n",
+    "    angle_param=(0, 2 * np.pi, 0.1),\n",
+    "    gate_type=[\"CRX\", \"CRY\", \"SWAP\", \"CX\"],\n",
+    "    compression1=(0, 95, 5),\n",
+    "    compression2=(0, 95, 5),\n",
+    "    num_connecting_qubits=(1, min(hlp.ilog2(img1_raw.size), hlp.ilog2(img2_raw.size)) -1 , 1) # Max based on smaller image dimension\n",
+    ");"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "4c202448",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "--- Creating Algorithm Circuits for Audio ---\n",
+      "Sample QFT Algorithm Circuit (for audio):\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 454.517x200.667 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Sample Custom Algorithm Circuit (for audio):\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 370.906x200.667 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "--- Demonstrating `process_audio_with_slices` ---\n",
+      "The following shows how to call `process_audio_with_slices`.\n",
+      "\n",
+      "Attempting to process: Sample_Material/underground.mp3\n",
+      "Output will be in: Sample_Material/underground\n",
+      "Audio processing finished for QFT. Check Sample_Material/underground\n",
+      "Audio processing finished for Custom Algo. Check Sample_Material/underground\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"--- Creating Algorithm Circuits for Audio ---\")\n",
+    "qft_algorithm_audio = create_algorithm_circuit(\n",
+    "    circuit_type='qft', \n",
+    "    num_qubits=2 \n",
+    ")\n",
+    "print(\"Sample QFT Algorithm Circuit (for audio):\")\n",
+    "display(qft_algorithm_audio.draw(output='mpl'))\n",
+    "\n",
+    "custom_algo_audio = QuantumCircuit(2, name=\"CustomAudioAlgo\")\n",
+    "custom_algo_audio.h(0)\n",
+    "custom_algo_audio.cz(0,1)\n",
+    "custom_algo_audio.rx(np.pi/5, 0)\n",
+    "custom_algo_audio.ry(np.pi/3, 1)\n",
+    "print(\"\\nSample Custom Algorithm Circuit (for audio):\")\n",
+    "display(custom_algo_audio.draw(output='mpl'))\n",
+    "\n",
+    "\n",
+    "print(\"\\n--- Demonstrating `process_audio_with_slices` ---\")\n",
+    "print(\"The following shows how to call `process_audio_with_slices`.\")\n",
+    "\n",
+    "example_input_audio_file = \"Sample_Material/underground.mp3\"\n",
+    "example_output_directory = \"Sample_Material/underground\"\n",
+    "\n",
+    "os.makedirs(example_output_directory, exist_ok=True)\n",
+    "\n",
+    "\n",
+    "audio_connection_map = {0: 0, 1: 1} \n",
+    "\n",
+    "print(f\"\\nAttempting to process: {example_input_audio_file}\")\n",
+    "print(f\"Output will be in: {example_output_directory}\")\n",
+    "\n",
+    "if os.path.exists(example_input_audio_file):\n",
+    "    try:\n",
+    "        process_audio_with_slices(\n",
+    "            input_file=example_input_audio_file,\n",
+    "            output_dir=example_output_directory,\n",
+    "            algorithm_circuit=qft_algorithm_audio, \n",
+    "            slice_size=1,                           \n",
+    "            insertion_rule='interval',              \n",
+    "            interval=10,                           \n",
+    "            connection_rule='cx',                   \n",
+    "            connection_map=audio_connection_map,\n",
+    "            compression=10,                         \n",
+    "            tag=\"qft_integrated_demo\"               \n",
+    "        )\n",
+    "        print(f\"Audio processing finished for QFT. Check {example_output_directory}\")\n",
+    "\n",
+    "        process_audio_with_slices(\n",
+    "            input_file=example_input_audio_file,\n",
+    "            output_dir=example_output_directory,\n",
+    "            algorithm_circuit=custom_algo_audio, \n",
+    "            slice_size=1,\n",
+    "            insertion_rule='interval',\n",
+    "            interval=8,\n",
+    "            connection_rule='cz',\n",
+    "            connection_map=audio_connection_map,\n",
+    "            compression=10,\n",
+    "            tag=\"custom_algo_integrated_demo\"\n",
+    "        )\n",
+    "        print(f\"Audio processing finished for Custom Algo. Check {example_output_directory}\")\n",
+    "\n",
+    "    except Exception as e:\n",
+    "        print(f\"An error occurred during audio processing: {e}\")\n",
+    "        print(\"Please ensure 'ffmpeg' is installed and accessible in your system PATH if not using wav.\")\n",
+    "        print(\"Also, verify the input audio file format and integrity.\")\n",
+    "else:\n",
+    "    print(f\"\\nSkipping audio processing example as '{example_input_audio_file}' not found.\")\n",
+    "    print(\"Please set 'example_input_audio_file' to a valid audio file path to run this.\")\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c6423ddf",
+   "metadata": {},
+   "source": [
+    "\n",
+    "## Summary of Demonstrated Capabilities\n",
+    "\n",
+    "This notebook has demonstrated a flexible framework for integrating quantum algorithms\n",
+    "with QPIXL-encoded data (images and audio). Key components and functionalities showcased include:\n",
+    "\n",
+    "1.  **`CircuitIntegrator` Class:**\n",
+    "    *   **`MERGE` Mode:** Combining data and algorithm circuits side-by-side with optional connections.\n",
+    "    *   **`ENTANGLE` Mode:** Connecting circuits using specified entangling operations (e.g., CX, CZ, SWAP).\n",
+    "    *   **`SLICED` Mode:** Breaking an algorithm circuit into smaller slices and interleaving them within a data circuit based on rules like 'interval' or 'end'.\n",
+    "    *   **`CUSTOM` Mode:** Allowing users to define their own Python functions for bespoke integration logic, offering maximum flexibility.\n",
+    "\n",
+    "2.  **`QPIXLAlgorithmEncoder` Class:**\n",
+    "    *   **`create_circuit` Method:** Directly embedding algorithm operations (defined via `algorithm_ops`) into the QPIXL encoding process on a per-data-point basis. It also supports `post_processing` steps.\n",
+    "    *   **`create_sliced_circuit` Method:** Integrating an existing algorithm circuit by slicing it and interleaving these slices during the QPIXL encoding of data, with specified connection rules.\n",
+    "\n",
+    "3.  **Helper Functions:**\n",
+    "    *   `create_pattern_function`: For defining reusable circuit patterns (often used with older functions like `cFRQIangs` or as components in custom rules).\n",
+    "    *   `create_post_processing`: For defining a sequence of operations to be applied after the main encoding and integration.\n",
+    "    *   `create_algorithm_circuit`: For easily generating standard algorithm circuits (e.g., QFT, QAOA) for use in integration.\n",
+    "\n",
+    "4.  **Applications:**\n",
+    "    *   **Image Processing:** Demonstrated interactive visual effects by combining QPIXL encodings of two images using various integration strategies.\n",
+    "    *   **Audio Processing:** Showcased how `process_audio_with_slices` can be used to integrate sliced algorithm circuits into the QPIXL encoding of audio chunks, enabling quantum-enhanced audio manipulation.\n",
+    "\n",
+    "## Benefits of this Framework\n",
+    "\n",
+    "*   **Modularity:** Separates data encoding logic from algorithm logic and integration strategy.\n",
+    "*   **Extensibility:** Easily add new integration rules or algorithm components.\n",
+    "*   **Flexibility:** Supports various ways to combine circuits, from simple appending to complex interleaving.\n",
+    "*   **Experimentation:** Facilitates rapid prototyping and testing of different quantum data processing pipelines.\n",
+    "*   **Clarity:** Provides a structured approach to building complex quantum circuits for data-driven tasks.\n",
+    "\n",
+    "## Future Directions\n",
+    "\n",
+    "This framework can be extended further by:\n",
+    "*   Adding more predefined integration modes or algorithm components.\n",
+    "*   Integrating with quantum machine learning libraries.\n",
+    "*   Optimizing circuit compositions for specific hardware backends.\n",
+    "*   Developing more sophisticated rules for slicing and insertion based on circuit properties."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/QPIXL_demo.ipynb b/QPIXL_demo.ipynb
index 2b79f10..6638cf7 100644
--- a/QPIXL_demo.ipynb
+++ b/QPIXL_demo.ipynb
@@ -1145,7 +1145,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": ".venv",
+   "display_name": "Python 3",
    "language": "python",
    "name": "python3"
   },
@@ -1159,7 +1159,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.8"
+   "version": "3.11.9"
   }
  },
  "nbformat": 4,
diff --git a/Sample_Material/underground/underground_metadata_custom_algo_integrated_demo_c10.txt b/Sample_Material/underground/underground_metadata_custom_algo_integrated_demo_c10.txt
new file mode 100644
index 0000000..597b625
--- /dev/null
+++ b/Sample_Material/underground/underground_metadata_custom_algo_integrated_demo_c10.txt
@@ -0,0 +1,5 @@
+Original file: Sample_Material/underground.mp3
+Compression: 10%
+Slice size: 1
+Insertion rule: interval
+Connection rule: cz
diff --git a/Sample_Material/underground/underground_metadata_qft_integrated_demo_c10.txt b/Sample_Material/underground/underground_metadata_qft_integrated_demo_c10.txt
new file mode 100644
index 0000000..6a99e81
--- /dev/null
+++ b/Sample_Material/underground/underground_metadata_qft_integrated_demo_c10.txt
@@ -0,0 +1,5 @@
+Original file: Sample_Material/underground.mp3
+Compression: 10%
+Slice size: 1
+Insertion rule: interval
+Connection rule: cx
diff --git a/Sample_Material/underground/underground_output_custom_algo_integrated_demo_c10.wav b/Sample_Material/underground/underground_output_custom_algo_integrated_demo_c10.wav
new file mode 100644
index 0000000..b962a6e
Binary files /dev/null and b/Sample_Material/underground/underground_output_custom_algo_integrated_demo_c10.wav differ
diff --git a/Sample_Material/underground/underground_output_demo_c90.wav b/Sample_Material/underground/underground_output_demo_c90.wav
deleted file mode 100644
index 4ede974..0000000
Binary files a/Sample_Material/underground/underground_output_demo_c90.wav and /dev/null differ
diff --git a/Sample_Material/underground/underground_output_qft_integrated_demo_c10.wav b/Sample_Material/underground/underground_output_qft_integrated_demo_c10.wav
new file mode 100644
index 0000000..01cbf5f
Binary files /dev/null and b/Sample_Material/underground/underground_output_qft_integrated_demo_c10.wav differ