diff --git a/_posts/2024-06-02-Quantum Computing with Cirq.md b/_posts/2024-06-02-Quantum Computing with Cirq.md
new file mode 100644
index 0000000..3d62af1
--- /dev/null
+++ b/_posts/2024-06-02-Quantum Computing with Cirq.md	
@@ -0,0 +1,480 @@
+# Introduction to Quantum Computing with Cirq
+
+## Overview
+
+Welcome to this introductory tutorial on quantum computing using Cirq! In this tutorial, you'll learn the basics of quantum computing and how to use Cirq, an open-source quantum computing framework by Google. By the end of this tutorial, you'll have a good understanding of quantum bits (qubits), superposition, entanglement, and quantum gates. We'll also implement a simple quantum algorithm, Grover's algorithm, to demonstrate these concepts in action.
+
+## Prerequisites
+
+- Basic understanding of classical computing and programming.
+- Familiarity with Python programming language.
+
+## Setting Up Your Environment
+
+### Step 1: Install Python
+
+Make sure you have Python 3.7 or later installed on your machine. You can download it from [python.org](https://www.python.org/downloads/).
+
+### Step 2: Install Cirq
+
+Open your terminal or command prompt and run the following command to install Cirq:
+
+```bash
+pip install cirq
+```
+
+## Tutorial Structure
+
+1. [Introduction to Quantum Computing](#introduction-to-quantum-computing)
+2. [Setting Up Cirq](#setting-up-cirq)
+3. [Quantum Bits (Qubits) and Basic Gates](#quantum-bits-qubits-and-basic-gates)
+4. [Superposition and Entanglement](#superposition-and-entanglement)
+5. [Implementing Grover's Algorithm](#implementing-grovers-algorithm)
+6. [Conclusion and Next Steps](#conclusion-and-next-steps)
+7. [Personal Note](#personal-note)
+
+## Introduction to Quantum Computing
+
+### What is Quantum Computing?
+
+Quantum computing uses the principles of quantum mechanics to process information. Unlike classical computers that use bits (0 or 1), quantum computers use quantum bits or qubits, which can exist in multiple states simultaneously.
+
+### Classical vs. Quantum Computing
+
+| Feature            | Classical Computing | Quantum Computing              |
+|--------------------|---------------------|--------------------------------|
+| Basic Unit         | Bit (0 or 1)        | Qubit (0, 1, or both)          |
+| State              | Deterministic       | Probabilistic                  |
+| Computation Speed  | Polynomial/Exponential | Exponential for specific problems |
+
+### Key Concepts
+
+- **Qubit**: The basic unit of quantum information, represented as |0⟩ and |1⟩.
+- **Superposition**: A qubit can be in a combination of |0⟩ and |1⟩ states.
+- **Entanglement**: A unique quantum phenomenon where qubits become interconnected and the state of one qubit can depend on the state of another.
+
+## Setting Up Cirq
+
+### Installing Cirq
+
+Open your terminal and run:
+
+```bash
+pip install cirq
+```
+
+### Overview of Cirq Components
+
+- **cirq**: Main package for creating and simulating quantum circuits.
+
+## Quantum Bits (Qubits) and Basic Gates
+
+### Creating a Quantum Circuit
+
+Open a Jupyter notebook and start with the following code:
+
+```python
+import cirq
+
+# Create a qubit
+qubit = cirq.GridQubit(0, 0)
+
+# Create a quantum circuit
+circuit = cirq.Circuit()
+
+# Add operations to the circuit
+circuit.append(cirq.X(qubit))
+
+# Display the circuit
+print(circuit)
+```
+
+Expected Output:
+
+```
+(0, 0): ───X───
+```
+
+### Applying Basic Quantum Gates
+
+- **X Gate (NOT Gate)**: Flips the state of a qubit.
+- **H Gate (Hadamard Gate)**: Creates superposition.
+- **CX Gate (CNOT Gate)**: Creates entanglement between two qubits.
+
+```python
+# Create two qubits
+qubit_1 = cirq.GridQubit(0, 0)
+qubit_2 = cirq.GridQubit(0, 1)
+
+# Create a quantum circuit
+circuit = cirq.Circuit()
+
+# Apply X gate
+circuit.append(cirq.X(qubit_1))
+
+# Apply H gate
+circuit.append(cirq.H(qubit_1))
+
+# Apply CX gate
+circuit.append(cirq.CNOT(qubit_1, qubit_2))
+
+# Display the circuit
+print(circuit)
+```
+
+Expected Output:
+
+```
+(0, 0): ───X───H───@───
+                   │
+(0, 1): ───────────X───
+```
+
+### Measuring Qubits
+
+Add measurement to your circuit:
+
+```python
+# Create a quantum circuit
+circuit = cirq.Circuit()
+
+# Apply H gate
+circuit.append(cirq.H(qubit_1))
+
+# Measure the qubits
+circuit.append(cirq.measure(qubit_1, qubit_2))
+
+# Display the circuit
+print(circuit)
+```
+
+Expected Output:
+
+```
+(0, 0): ───H───M───
+                │
+(0, 1): ────────M───
+```
+
+## Superposition and Entanglement
+
+### Demonstrating Superposition
+
+```python
+# Create a qubit
+qubit = cirq.GridQubit(0, 0)
+
+# Create a quantum circuit
+circuit = cirq.Circuit()
+
+# Apply H gate
+circuit.append(cirq.H(qubit))
+
+# Measure the qubit
+circuit.append(cirq.measure(qubit))
+
+# Display the circuit
+print(circuit)
+
+# Simulate the circuit
+simulator = cirq.Simulator()
+result = simulator.run(circuit, repetitions=1000)
+
+# Display the results
+print(result)
+```
+
+Expected Output:
+
+```
+(0, 0): ───H───M───
+
+0=000000111111...
+```
+
+This result shows that the qubit is measured in the |0⟩ state about half the time and in the |1⟩ state about half the time, demonstrating superposition.
+
+### Creating and Measuring Entangled States
+
+```python
+# Create two qubits
+qubit_1 = cirq.GridQubit(0, 0)
+qubit_2 = cirq.GridQubit(0, 1)
+
+# Create a quantum circuit
+circuit = cirq.Circuit()
+
+# Apply H gate
+circuit.append(cirq.H(qubit_1))
+
+# Apply CX gate
+circuit.append(cirq.CNOT(qubit_1, qubit_2))
+
+# Measure the qubits
+circuit.append(cirq.measure(qubit_1, qubit_2))
+
+# Display the circuit
+print(circuit)
+
+# Simulate the circuit
+result = simulator.run(circuit, repetitions=1000)
+
+# Display the results
+print(result)
+```
+
+Expected Output:
+
+```
+(0, 0): ───H───@───M───
+               │   │
+(0, 1): ───────X───M───
+
+0,1=00 11 00 11...
+```
+
+The result shows that the qubits are measured in the |00⟩ and |11⟩ states, demonstrating entanglement.
+
+## Implementing Grover's Algorithm
+
+### Introduction to Grover's Algorithm
+
+Grover's algorithm is used for searching an unsorted database with \( N \) entries in \( O(\sqrt{N}) \) time, providing a quadratic speedup over classical algorithms.
+
+### Step-by-Step Implementation in Cirq
+
+1. **Initialize the Circuit**
+
+```python
+# Number of qubits
+n = 2
+qubits = [cirq.GridQubit(i, 0) for i in range(n)]
+
+# Create a quantum circuit
+circuit = cirq.Circuit()
+
+# Apply H gate to all qubits
+circuit.append([cirq.H(qubit) for qubit in qubits])
+
+print(circuit)
+```
+
+Expected Output:
+
+```
+(0, 0): ───H───
+(1, 0): ───H───
+```
+
+2. **Oracle for the Marked State**
+
+Define an oracle for the marked state (e.g., |11⟩):
+
+```python
+# Define the oracle
+oracle = cirq.Circuit()
+
+oracle.append(cirq.Z(qubits[0]))
+oracle.append(cirq.CNOT(qubits[0], qubits[1]))
+oracle.append(cirq.Z(qubits[1]))
+oracle.append(cirq.CNOT(qubits[0], qubits[1]))
+
+# Apply the oracle
+circuit.append(oracle)
+
+print(circuit)
+```
+
+Expected Output:
+
+```
+(0, 0): ───H───Z───@───Z───@───
+                   │       │
+(1, 0): ───H───────X───Z───X───
+```
+
+3. **Grover's Diffusion Operator**
+
+```python
+# Define the diffuser
+diffuser = cirq.Circuit()
+
+diffuser.append([cirq.H(qubit) for qubit in qubits])
+diffuser.append([cirq.X(qubit) for qubit in qubits])
+diffuser.append(cirq.H(qubits[1]))
+diffuser.append(cirq.CNOT(qubits[0], qubits[1]))
+diffuser.append(cirq.H(qubits[1]))
+diffuser.append([cirq.X(qubit) for qubit in qubits])
+diffuser.append([cirq.H(qubit) for qubit in qubits])
+
+# Apply the diffuser
+circuit.append(diffuser)
+
+print(circuit)
+```
+
+Expected Output:
+
+```
+(0, 0): ───H───Z───@───Z───@───H──
+
+─X───H───@───H───X───H───
+                   │       │           │       │       │
+(1, 0): ───H───────X───Z───X───────H───X───────H───X───H───
+```
+
+4. **Measure the Qubits**
+
+```python
+# Measure the qubits
+circuit.append([cirq.measure(qubit) for qubit in qubits])
+
+# Display the final circuit
+print(circuit)
+```
+
+Expected Output:
+
+```
+(0, 0): ───H───Z───@───Z───@───H───X───H───@───H───X───H───M───
+                   │       │           │       │       │   │
+(1, 0): ───H───────X───Z───X───────H───X───────H───X───H───M───
+```
+
+5. **Simulate the Circuit**
+
+```python
+# Simulate the circuit
+result = simulator.run(circuit, repetitions=1000)
+
+# Display the results
+print(result)
+```
+
+Expected Output:
+
+```
+0,1=11 11 11 11...
+```
+
+This result shows that the qubits are measured in the |11⟩ state, demonstrating the effectiveness of Grover's algorithm.
+
+## Conclusion and Next Steps
+
+Congratulations on completing this introductory tutorial on quantum computing with Cirq! You have learned the basics of quantum computing, including qubits, superposition, entanglement, and quantum gates. You have also implemented a simple quantum algorithm, Grover's algorithm.
+
+### Next Steps
+
+1. Explore more advanced quantum algorithms such as Shor's algorithm and the Quantum Fourier Transform.
+2. Dive deeper into quantum error correction and noise mitigation techniques.
+3. Experiment with different quantum hardware and simulators available on cloud platforms.
+
+## Personal Note
+
+As a student, exploring the field of quantum computing can be both challenging and rewarding. This tutorial is just the beginning of your journey. Keep experimenting, learning, and contributing to the exciting world of quantum computing. Good luck!
+
+### Jupyter Notebook Version
+
+To provide an interactive experience, here's the tutorial in a Jupyter notebook format. You can run the cells and see the results directly.
+
+```python
+# Introduction to Quantum Computing with Cirq
+
+# Setting Up Your Environment
+
+!pip install cirq
+
+import cirq
+
+# Creating a Quantum Circuit
+qubit = cirq.GridQubit(0, 0)
+circuit = cirq.Circuit()
+circuit.append(cirq.X(qubit))
+print(circuit)
+
+# Applying Basic Quantum Gates
+qubit_1 = cirq.GridQubit(0, 0)
+qubit_2 = cirq.GridQubit(0, 1)
+circuit = cirq.Circuit()
+circuit.append(cirq.X(qubit_1))
+circuit.append(cirq.H(qubit_1))
+circuit.append(cirq.CNOT(qubit_1, qubit_2))
+print(circuit)
+
+# Measuring Qubits
+circuit = cirq.Circuit()
+circuit.append(cirq.H(qubit_1))
+circuit.append(cirq.measure(qubit_1, qubit_2))
+print(circuit)
+
+# Superposition
+qubit = cirq.GridQubit(0, 0)
+circuit = cirq.Circuit()
+circuit.append(cirq.H(qubit))
+circuit.append(cirq.measure(qubit))
+print(circuit)
+simulator = cirq.Simulator()
+result = simulator.run(circuit, repetitions=1000)
+print(result)
+
+# Entanglement
+qubit_1 = cirq.GridQubit(0, 0)
+qubit_2 = cirq.GridQubit(0, 1)
+circuit = cirq.Circuit()
+circuit.append(cirq.H(qubit_1))
+circuit.append(cirq.CNOT(qubit_1, qubit_2))
+circuit.append(cirq.measure(qubit_1, qubit_2))
+print(circuit)
+result = simulator.run(circuit, repetitions=1000)
+print(result)
+
+# Grover's Algorithm
+n = 2
+qubits = [cirq.GridQubit(i, 0) for i in range(n)]
+circuit = cirq.Circuit()
+circuit.append([cirq.H(qubit) for qubit in qubits])
+print(circuit)
+
+oracle = cirq.Circuit()
+oracle.append(cirq.Z(qubits[0]))
+oracle.append(cirq.CNOT(qubits[0], qubits[1]))
+oracle.append(cirq.Z(qubits[1]))
+oracle.append(cirq.CNOT(qubits[0], qubits[1]))
+circuit.append(oracle)
+print(circuit)
+
+diffuser = cirq.Circuit()
+diffuser.append([cirq.H(qubit) for qubit in qubits])
+diffuser.append([cirq.X(qubit) for qubit in qubits])
+diffuser.append(cirq.H(qubits[1]))
+diffuser.append(cirq.CNOT(qubits[0], qubits[1]))
+diffuser.append(cirq.H(qubits[1]))
+diffuser.append([cirq.X(qubit) for qubit in qubits])
+diffuser.append([cirq.H(qubit) for qubit in qubits])
+circuit.append(diffuser)
+print(circuit)
+
+circuit.append(cirq.measure(*qubits))
+print(circuit)
+result = simulator.run(circuit, repetitions=1000)
+print(result)
+```
+
+You can copy and paste the above code into a Jupyter notebook cell and run it to see the results interactively.
+
+This concludes our tutorial on quantum computing with Cirq. We hope you found it informative and engaging. Happy quantum coding!
+
+### Technical Terms Explained
+
+- **Quantum Bit (Qubit)**: The basic unit of quantum information. Unlike a classical bit that can be either 0 or 1, a qubit can be in a superposition of both states simultaneously.
+- **Superposition**: A principle of quantum mechanics where a qubit can exist in multiple states at once. For example, a qubit can be in a state that is a combination of both |0⟩ and |1⟩.
+- **Entanglement**: A quantum phenomenon where two qubits become linked, and the state of one qubit depends on the state of the other, even if they are separated by large distances.
+- **Quantum Gate**: A basic quantum circuit operating on a small number of qubits. Quantum gates are the building blocks of quantum circuits, similar to classical logic gates in classical circuits.
+- **X Gate (NOT Gate)**: A quantum gate that flips the state of a qubit. If a qubit is in the |0⟩ state, applying an X gate will change it to |1⟩, and vice versa.
+- **H Gate (Hadamard Gate)**: A quantum gate that creates superposition. When applied to a qubit in state |0⟩ or |1⟩, it puts the qubit into an equal superposition of both states.
+- **CX Gate (CNOT Gate)**: A two-qubit gate that flips the state of the second qubit (target) if the first qubit (control) is in state |1⟩. It is used to create entanglement.
+- **Grover's Algorithm**: A quantum algorithm that searches an unsorted database or solves the search problem more efficiently than any classical algorithm. It provides a quadratic speedup over classical search algorithms.
+- **Oracle**: A black-box function used in quantum algorithms to mark the correct answer. In Grover's algorithm, the oracle marks the state we are searching for.
+- **Diffuser (Inversion about the Mean)**: A quantum operation used in Grover's algorithm to amplify the probability of the marked state.
+
+These explanations should help clarify the concepts and terms used in this tutorial.