# Getting Started with PennyLane

## What is PennyLane?

PennyLane is a cross-platform Python library for quantum computing, quantum machine learning, and quantum chemistry. It enables training quantum computers like neural networks through automatic differentiation and seamless integration with classical machine learning frameworks.

## Installation

Install PennyLane using uv. PennyLane 0.45.0 requires Python 3.11 or newer:

```bash
uv pip install "pennylane==0.45.0"
```

For specific device plugins (IBM, Amazon Braket, Google, Rigetti, etc.):

```bash
# IBM Qiskit
uv pip install "pennylane-qiskit==0.45.0"

# Amazon Braket
uv pip install "amazon-braket-pennylane-plugin==1.34.1"

# Google Cirq
uv pip install "pennylane-cirq==0.44.0"

# Rigetti
uv pip install "pennylane-rigetti==0.40.0"
```

## Core Concepts

### Quantum Nodes (QNodes)

A QNode is a quantum function that can be evaluated on a quantum device. It combines a quantum circuit definition with a device:

```python
import pennylane as qml

# Define a device
dev = qml.device('default.qubit', wires=2)

# Create a QNode
@qml.qnode(dev)
def circuit(params):
    qml.RX(params[0], wires=0)
    qml.RY(params[1], wires=1)
    qml.CNOT(wires=[0, 1])
    return qml.expval(qml.PauliZ(0))
```

### Devices

Devices execute quantum circuits. PennyLane supports:
- **Simulators**: `default.qubit`, `default.mixed`, `lightning.qubit`
- **Hardware**: Access through plugins (IBM, Amazon Braket, Rigetti, etc.)

```python
# Local simulator
dev = qml.device('default.qubit', wires=4)

# Lightning high-performance simulator
dev = qml.device('lightning.qubit', wires=10)
```

### Measurements

PennyLane supports various measurement types:

```python
@qml.qnode(dev)
def measure_circuit():
    qml.Hadamard(wires=0)
    # Expectation value
    return qml.expval(qml.PauliZ(0))

@qml.qnode(dev)
def measure_probs():
    qml.Hadamard(wires=0)
    # Probability distribution
    return qml.probs(wires=[0, 1])

@qml.qnode(dev)
def measure_samples():
    qml.Hadamard(wires=0)
    # Sample measurements
    return qml.sample(qml.PauliZ(0))
```

## Basic Workflow

### 1. Build a Circuit

```python
import pennylane as qml
import numpy as np

dev = qml.device('default.qubit', wires=3)

@qml.qnode(dev)
def quantum_circuit(weights):
    # Apply gates
    qml.RX(weights[0], wires=0)
    qml.RY(weights[1], wires=1)
    qml.CNOT(wires=[0, 1])
    qml.RZ(weights[2], wires=2)

    # Measure
    return qml.expval(qml.PauliZ(0) @ qml.PauliZ(1))
```

### 2. Compute Gradients

```python
# Automatic differentiation
grad_fn = qml.grad(quantum_circuit)
weights = np.array([0.1, 0.2, 0.3])
gradients = grad_fn(weights)
```

### 3. Optimize Parameters

```python
from pennylane import numpy as np

# Define optimizer
opt = qml.GradientDescentOptimizer(stepsize=0.1)

# Optimization loop
weights = np.array([0.1, 0.2, 0.3], requires_grad=True)
for i in range(100):
    weights = opt.step(quantum_circuit, weights)
    if i % 20 == 0:
        print(f"Step {i}: Cost = {quantum_circuit(weights)}")
```

## Device-Independent Programming

Write circuits once, run anywhere:

```python
# Same circuit, different backends
@qml.qnode(qml.device('default.qubit', wires=2))
def circuit_simulator(x):
    qml.RX(x, wires=0)
    return qml.expval(qml.PauliZ(0))

# Switch to IBM hardware after configuring qiskit-ibm-runtime credentials
from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()
backend = service.least_busy(operational=True, simulator=False, min_num_qubits=2)

@qml.qnode(qml.device('qiskit.remote', wires=backend.num_qubits, backend=backend))
def circuit_hardware(x):
    qml.RX(x, wires=0)
    return qml.expval(qml.PauliZ(0))
```

## Common Patterns

### Parameterized Circuits

```python
@qml.qnode(dev)
def parameterized_circuit(params, x):
    # Encode data
    qml.RX(x, wires=0)

    # Apply parameterized layers
    for param in params:
        qml.RY(param, wires=0)
        qml.CNOT(wires=[0, 1])

    return qml.expval(qml.PauliZ(0))
```

### Circuit Templates

Use built-in templates for common patterns:

```python
from pennylane.templates import StronglyEntanglingLayers

@qml.qnode(dev)
def template_circuit(weights):
    StronglyEntanglingLayers(weights, wires=range(3))
    return qml.expval(qml.PauliZ(0))

# Generate random weights for template
n_layers = 2
n_wires = 3
shape = StronglyEntanglingLayers.shape(n_layers, n_wires)
weights = np.random.random(shape)
```

## Debugging and Visualization

### Print Circuit Structure

```python
print(qml.draw(circuit)(params))
print(qml.draw_mpl(circuit)(params))  # Matplotlib visualization
```

### Inspect Operations

```python
with qml.tape.QuantumTape() as tape:
    qml.Hadamard(wires=0)
    qml.CNOT(wires=[0, 1])

print(tape.operations)
print(tape.measurements)
```

## Next Steps

For detailed information on specific topics:
- **Building circuits**: See `references/quantum_circuits.md`
- **Quantum ML**: See `references/quantum_ml.md`
- **Chemistry applications**: See `references/quantum_chemistry.md`
- **Device management**: See `references/devices_backends.md`
- **Optimization**: See `references/optimization.md`
- **Advanced features**: See `references/advanced_features.md`

## Resources

- Official docs: https://docs.pennylane.ai
- Codebook: https://pennylane.ai/codebook
- QML demos: https://pennylane.ai/qml/demonstrations
- Community forum: https://discuss.pennylane.ai
