






import numpy as np
from PIL import Image
def      a_ (      _A      ,   _A      ,   _A  )			->			np.ndarray:







				"""simple docstring"""
				snake_case__									=     np.array(_A  )
				if arr.shape[0] != arr.shape[1]:
								raise ValueError('The input array is not a square matrix'  )
				snake_case__									=     0
				snake_case__									=     0
				snake_case__									=     0
				snake_case__									=     0

				# compute the shape of the output matrix
				snake_case__									=     (arr.shape[0] - size) // stride + 1
				# initialize the output matrix with zeros of shape maxpool_shape
				snake_case__									=     np.zeros((maxpool_shape, maxpool_shape)  )

				while i < arr.shape[0]:
								if i + size > arr.shape[0]:
												# if the end of the matrix is reached, break
												break
								while j < arr.shape[1]:
												# if the end of the matrix is reached, break
												if j + size > arr.shape[1]:
																break
												# compute the maximum of the pooling matrix
												snake_case__									=     np.max(arr[i : i + size, j : j + size]  )
												# shift the pooling matrix by stride of column pixels
												j += stride
												mat_j += 1

								# shift the pooling matrix by stride of row pixels
								i += stride
								mat_i += 1

								# reset the column index to 0
								snake_case__									=     0
								snake_case__									=     0

				return updated_arr
def      a_ (      _A      ,   _A      ,   _A  )			->			np.ndarray:







				"""simple docstring"""
				snake_case__									=     np.array(_A  )
				if arr.shape[0] != arr.shape[1]:
								raise ValueError('The input array is not a square matrix'  )
				snake_case__									=     0
				snake_case__									=     0
				snake_case__									=     0
				snake_case__									=     0

				# compute the shape of the output matrix
				snake_case__									=     (arr.shape[0] - size) // stride + 1
				# initialize the output matrix with zeros of shape avgpool_shape
				snake_case__									=     np.zeros((avgpool_shape, avgpool_shape)  )

				while i < arr.shape[0]:
								# if the end of the matrix is reached, break
								if i + size > arr.shape[0]:
												break
								while j < arr.shape[1]:
												# if the end of the matrix is reached, break
												if j + size > arr.shape[1]:
																break
												# compute the average of the pooling matrix
												snake_case__									=     int(np.average(arr[i : i + size, j : j + size]  )  )
												# shift the pooling matrix by stride of column pixels
												j += stride
												mat_j += 1

								# shift the pooling matrix by stride of row pixels
								i += stride
								mat_i += 1
								# reset the column index to 0
								snake_case__									=     0
								snake_case__									=     0

				return updated_arr


# Main Function
if __name__ == "__main__":
							from doctest import testmod

							testmod(name="""avgpooling""", verbose=True)

							# Loading the image
							__UpperCamelCase					:		int	  =						Image.open("""path_to_image""")

							# Converting the image to numpy array and maxpooling, displaying the result
							# Ensure that the image is a square matrix

							Image.fromarray(maxpooling(np.array(image), size=3, stride=2)).show()

							# Converting the image to numpy array and averagepooling, displaying the result
							# Ensure that the image is a square matrix

							Image.fromarray(avgpooling(np.array(image), size=3, stride=2)).show()












import qiskit
def      a_ (      _A = 2  )			->			qiskit.result.counts.Counts:







				"""simple docstring"""
				snake_case__									=     qubits

				# Using Aer's simulator
				snake_case__									=     qiskit.Aer.get_backend('aer_simulator'  )

				# Creating a Quantum Circuit acting on the q register
				snake_case__									=     qiskit.QuantumCircuit(_A      ,   _A  )

				# Adding a H gate on qubit 0 (now q0 in superposition)
				circuit.h(0  )

				for i in range(1      ,   _A  ):
								# Adding CX (CNOT) gate
								circuit.cx(i - 1      ,   _A  )

				# Mapping the quantum measurement to the classical bits
				circuit.measure(list(range(_A  )  )      ,   list(range(_A  )  )  )

				# Now measuring any one qubit would affect other qubits to collapse
				# their super position and have same state as the measured one.

				# Executing the circuit on the simulator
				snake_case__									=     qiskit.execute(_A      ,   _A      ,   shots=1000  )

				return job.result().get_counts(_A  )


if __name__ == "__main__":
							print(f'''Total count for various states are: {quantum_entanglement(3)}''')




