量子物理前沿之：量子光学与光子学

      import matplotlib.pyplot as plt
    
      def radii(k):
      return (h*c)/(k*e) / u.nm
    
      k = np.arange(0.1, 5.0+0.1, 0.1)*u.eV   # wavenumber from 0.1 to 5 eV in steps of 0.1 eV
    
      radii = [radii(_) for _ in k]          # compute the corresponding wave length in nanometers
    
      fig, ax = plt.subplots()
      ax.plot(k, radii)                      # plot wave length versus wavenumber
      ax.set_xlabel('Wavenumber (eV)')
      ax.set_ylabel('Radius ($\mu m$)')
      plt.show()
    
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读

      import scipy.constants as const
      from scipy.special import ellipk, ellipe
    
      def beta_factor(n, l, d, alpha):
      """compute the ratio between energy levels and effective anharmonicity"""
      return ((2 * n + l + 1) / 2)**(-alpha) / (pi**2 * hbar**(3*(n-l)/2))
    
      def eigenvalue(n, l, d):
      """return the nth eigenvalue given quantum numbers n, l, and d"""
      return (-const.h**2/(2*m)*(np.sin((n+l+d)/2*pi/d) if abs(d)>0 else 1)).to(ureg.eV)
    
      def gap(n, l, d):
      """compute the gap between adjacent states using semi-classical approximation"""
      return gamma*((eigenvalue(n+1, l, d)-eigenvalue(n, l, d))/
                   (ellipk((eigenvalue(n+1, l, d)-eigenvalue(n, l, d))/(2*gamma)))
                  )
    
      def susceptibility(beta, E1, E2):
      """compute the magnetic susceptibility between two states with different energies"""
      return sqrt(const.epsilon_0 * mu_B/(2*pi*hbar*beta*(E1-E2)))
    
      # define constants and variables
      pi = const.pi
      e = const.elementary_charge
      m = const.electron_mass
      h = const.Planck
      hbar = const.hbar
      c = const.speed_of_light
      mu_B = const.physical_constants['Bohr magneton'][0]*ureg.J/ureg.T
      gamma = (const.hbar/pi).to(ureg.eV)
    
      n = 3                     # principal quantum number of state of interest
      l = 2                     # azimuthal quantum number of state of interest
      d = 1                     # zenith angle or degeneracy factor of state of interest
      alpha = 1                 # exponent in effective anharmonicity expression
      beta = beta_factor(n, l, d, alpha)      # effective anharmonicity of system
    
      gaps = []
      energies = []
    
      for i in range(abs(int(d))+1):    # loop over all possible values of d
      E = eigenvalue(n, l, i)       # get the energy of the state
      gaps.append(gap(n, l, i))     # compute its gap using semi-classical approximation
      energies.append(E.magnitude)  # append both energies and gaps to lists
    
      print("Energy levels:", end=' ')
      for E in energies:
      print("%.4f" % E, end=' ')
    
      print("\nGaps:", end=' ')
      for gap in gaps:
      print("%.4f" % gap.magnitude, end=' ')
    
      # calculate the average gap and magnetic susceptibility between neighboring states
      avg_gap = sum([energies[i]*gaps[i]/sum(gaps) for i in range(len(energies))])
      S = susceptibility(beta, energies[-1], energies[0]).magnitude
      print("\nAveraged gap: %.4f" % avg_gap.magnitude)
      print("Magnetic susceptibility: %.4f" % S)
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读

      import qiskit
    
      # create a QuantumCircuit object with one bit register and one ClassicalRegister object
      qr = qiskit.QuantumRegister(1)
      cr = qiskit.ClassicalRegister(1)
      circuit = qiskit.QuantumCircuit(qr, cr)
    
      # apply a single-bit error to the first qubit using an X-gate 
      prob = 0.1           # probability of applying error
      if random.random() < prob:
     circuit.x(qr[0])
    
      # measure the second qubit
      circuit.barrier()
      circuit.measure(qr[0],cr[0])
    
      simulator = qiskit.Aer.get_backend('qasm_simulator')
      result = qiskit.execute(circuit, backend=simulator, shots=1000).result().get_counts()
    
      corrected_results = {'0': '0', '1':'1'} # empty dictionary to store the results after correction
      for key in list(result):              # iterate through keys (outcomes) in dictionary
    if result[key]!= '':               # check that there are non-zero counts for this outcome
      bitstring = str(bin(int(key))[2:].zfill(1)[::-1])[::-1]  # reverse bits order and remove leading zeros
      if random.random() < prob and len(list(filter(lambda x : x!='', bitstring))) == 1:
        index = int(list(filter(lambda x : x!='', bitstring))[0])         # find the position of the incorrect bit
        new_key = bin((index^1)<<1 | int(key, 2))[2:]                        # flip the value of the correct bit and insert it into the string
        corrected_results[new_key] = corrected_results.get(new_key,'') + str(index) # update the dictionary with the corrected key and indices
      else:                                                                   # no errors detected, just add current key and value to dictionary
        corrected_results[key] = corrected_results.get(key,'') + ''
    
      final_counts = {}                            # use a dictionary comprehension to merge dictionaries together
      for key in set(corrected_results) & set(result): # only include common keys
    final_counts[key+' '+corrected_results[key]] = result[key]
      for key in set(corrected_results) - set(result):  # add missing keys from corrected_results dict
    final_counts[key+''] = corrected_results[key][:-1]+' '+corrected_results[key][-1]
    
      print(final_counts)
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读