10
1
mirror of https://gitlab.com/scemama/QCaml.git synced 2024-12-22 04:13:33 +01:00

F12 Diagrams to fix + dressing integrals

This commit is contained in:
Anthony Scemama 2019-12-18 19:04:32 +01:00
parent 3edbf9ca78
commit fade04dda5

View File

@ -143,6 +143,17 @@
" basis\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"let n_elec_alfa, n_elec_beta, n_elec = \n",
" let e = Simulation.electrons simulation in\n",
" Electrons.(n_alfa e, n_beta e, n_elec e)"
]
},
{
"cell_type": "markdown",
"metadata": {},
@ -589,9 +600,12 @@
]
},
{
"cell_type": "raw",
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"(*\n",
"let m_H_aux, m_F_aux = \n",
" \n",
" let rec col_vecs_list accu_H accu_F = function\n",
@ -622,7 +636,7 @@
" in\n",
" Mat.of_col_vecs_list h,\n",
" Mat.of_col_vecs_list f\n",
" "
"*) "
]
},
{
@ -789,29 +803,33 @@
"outputs": [],
"source": [
"let check n integral_value exc cabs lexc rexc =\n",
" let det_list =\n",
" match n with\n",
" | 0 -> det_I\n",
" | n -> Array.sub det_I 0 n\n",
" in\n",
" let result =\n",
" let det_list =\n",
" match n with\n",
" | 0 -> det_I\n",
" | n -> Array.sub det_I 0 n\n",
" in\n",
" let result =\n",
" Printf.printf \"Checking ... \\n%!\";\n",
" let percent = ref 0 in\n",
" Array.mapi (fun i ki -> \n",
" let p = (10 * (i+1))/(Array.length det_list) in\n",
" (let p = (10 * (i+1))/(Array.length det_list) in\n",
" if p <> !percent then\n",
" ( percent := p ; Printf.printf \" - %3d %%\\n%!\" (p*10) );\n",
" ( percent := p ; Printf.printf \" - %3d %%\\n%!\" (p*10) ));\n",
" Array.mapi (fun j kj -> \n",
" if i > j then (0,0,0.,0.) else\n",
" if Determinant.degree ki kj <> exc then (0,0,0.,0.) else\n",
" let alphas = generate_alphas ki kj exc cabs lexc rexc in\n",
" let det_value =\n",
" compute_HaaF ki alphas kj\n",
" in\n",
" let int_value = \n",
" integral_value ki kj\n",
" in\n",
" (i,j,det_value,int_value)\n",
" if i > j || Determinant.degree ki kj <> exc then\n",
" (0,0,0.,0.)\n",
" else\n",
" begin\n",
" let alphas = generate_alphas ki kj exc cabs lexc rexc in\n",
" let det_value =\n",
" compute_HaaF ki alphas kj\n",
" in\n",
" let int_value = \n",
" integral_value ki kj\n",
" in\n",
"(* Printf.printf \"%d %d %e %e\\n%!\" i j det_value int_value; *)\n",
" (i,j,det_value,int_value)\n",
" end\n",
" ) det_list\n",
" ) det_list\n",
" |> Array.to_list\n",
@ -829,11 +847,14 @@
" else\n",
" aux (k-1) imax jmax emax dmax vmax\n",
" in\n",
" aux (n-1) 0 0 0. 0. 0.\n",
" aux (Array.length result - 1) 0 0 0. 0. 0.\n",
" in\n",
" let error = abs_float (d -. v) in\n",
" if error < epsilon_float then\n",
" (*\n",
" Printf.printf \"OK: %e\\n%!\" error\n",
" *)\n",
" Printf.printf \"OK: (%d, %d) | %e %e | %e\\n%!\" i j d v error\n",
" else\n",
" Printf.printf \"Failed: (%d, %d) | %e %e | %e\\n%!\" i j d v error\n",
"\n",
@ -841,6 +862,43 @@
"let sum l f = List.fold_left (fun accu i -> accu +. f i) 0. l"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"let array_3_init d1 d2 d3 f =\n",
" let result = \n",
" Bigarray.(Array3.create Float64 fortran_layout) d1 d2 d3\n",
" in\n",
" for k=1 to d3 do\n",
" for j=1 to d2 do\n",
" for i=1 to d1 do\n",
" result.{i,j,k} <- f i j k\n",
" done\n",
" done\n",
" done;\n",
" result\n",
"\n",
"let array_4_init d1 d2 d3 d4 f =\n",
" let result = \n",
" Bigarray.(Genarray.create Float64 fortran_layout) [| d1;d2;d3;d4 |]\n",
" in\n",
" for l=1 to d4 do\n",
" for k=1 to d3 do\n",
" for j=1 to d2 do\n",
" for i=1 to d1 do\n",
" result.{i,j,k,l} <- f i j k l\n",
" done\n",
" done\n",
" done\n",
" done;\n",
" result\n",
"\n",
"(* ----- *)"
]
},
{
"cell_type": "markdown",
"metadata": {},
@ -926,6 +984,108 @@
" "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"let m_0111_1H_1F = \n",
" Vec.init mo_num (fun i -> \n",
" sum mos_cabs (fun a ->\n",
" h_one i a Spin.Alfa *. f_one a i Spin.Alfa ))\n",
"\n",
" \n",
"let m_0111_1H_2Fa = \n",
" Mat.init_cols mo_num mo_num (fun i j -> sum mos_cabs (fun a ->\n",
" h_one i a Spin.Alfa *. f_two a j i j Spin.Alfa Spin.Alfa ))\n",
"\n",
" \n",
"let m_0111_1H_2Fb = \n",
" Mat.init_cols mo_num mo_num (fun i j -> sum mos_cabs (fun a ->\n",
" h_one i a Spin.Alfa *. f_two a j i j Spin.Alfa Spin.Beta ))\n",
"\n",
"\n",
"let m_0111_2Ha_1F = \n",
" Mat.init_cols mo_num mo_num (fun i j -> sum mos_cabs (fun a ->\n",
" h_two i j a j Spin.Alfa Spin.Alfa *. f_one a j Spin.Alfa ))\n",
"\n",
" \n",
"let m_0111_2Hb_1F = \n",
" Mat.init_cols mo_num mo_num (fun i j -> sum mos_cabs (fun a ->\n",
" h_two i j a j Spin.Alfa Spin.Beta *. f_one a j Spin.Alfa ))\n",
"\n",
"\n",
"let m_0111_2Ha_2Fa =\n",
" array_3_init mo_num mo_num mo_num (fun i j k ->\n",
" sum mos_cabs (fun a ->\n",
" h_two i j a j Spin.Alfa Spin.Alfa *.\n",
" f_two a k i k Spin.Alfa Spin.Alfa \n",
" )\n",
" )\n",
"\n",
"\n",
"let m_0111_2Hb_2Fa =\n",
" array_3_init mo_num mo_num mo_num (fun i j k ->\n",
" sum mos_cabs (fun a ->\n",
" h_two i j a j Spin.Alfa Spin.Beta *.\n",
" f_two a k i k Spin.Alfa Spin.Alfa \n",
" )\n",
" )\n",
"\n",
"\n",
"let m_0111_2Ha_2Fb =\n",
" array_3_init mo_num mo_num mo_num (fun i j k ->\n",
" sum mos_cabs (fun a ->\n",
" h_two i j a j Spin.Alfa Spin.Alfa *.\n",
" f_two a k i k Spin.Alfa Spin.Beta \n",
" )\n",
" )\n",
"\n",
"\n",
"let m_0111_2Hb_2Fb =\n",
" array_3_init mo_num mo_num mo_num (fun i j k ->\n",
" sum mos_cabs (fun a ->\n",
" h_two i j a j Spin.Alfa Spin.Beta *.\n",
" f_two a k i k Spin.Alfa Spin.Beta \n",
" )\n",
" )\n",
"\n",
"\n",
"\n",
"let integral_value ki kj = \n",
"\n",
" let mos_a, mos_b = mos_a ki, mos_b ki in\n",
" \n",
" sum mos_a (fun i ->\n",
" m_0111_1H_1F.{i} +. \n",
" sum mos_a (fun j ->\n",
" m_0111_1H_2Fa.{i,j} +. m_0111_2Ha_1F.{i,j} +.\n",
" sum mos_a (fun k -> m_0111_2Ha_2Fa.{i,j,k}) +.\n",
" sum mos_b (fun k -> m_0111_2Ha_2Fb.{i,j,k})) +.\n",
" sum mos_b (fun j ->\n",
" m_0111_1H_2Fb.{i,j} +. m_0111_2Hb_1F.{i,j} +.\n",
" sum mos_a (fun k -> m_0111_2Hb_2Fa.{i,j,k}) +.\n",
" sum mos_b (fun k -> m_0111_2Hb_2Fb.{i,j,k}))\n",
" )\n",
" +.\n",
" sum mos_b (fun i ->\n",
" m_0111_1H_1F.{i} +. \n",
" sum mos_b (fun j ->\n",
" m_0111_1H_2Fa.{i,j} +. m_0111_2Ha_1F.{i,j} +.\n",
" sum mos_b (fun k -> m_0111_2Ha_2Fa.{i,j,k}) +.\n",
" sum mos_a (fun k -> m_0111_2Ha_2Fb.{i,j,k})) +.\n",
" sum mos_a (fun j ->\n",
" m_0111_1H_2Fb.{i,j} +. m_0111_2Hb_1F.{i,j} +.\n",
" sum mos_b (fun k -> m_0111_2Hb_2Fa.{i,j,k}) +.\n",
" sum mos_a (fun k -> m_0111_2Hb_2Fb.{i,j,k}))\n",
" )\n",
" \n",
"let _ =\n",
" check 0 integral_value 0 1 1 1\n",
" "
]
},
{
"cell_type": "markdown",
"metadata": {},
@ -1022,6 +1182,65 @@
" "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"let m_0122_Haa = \n",
" array_3_init mo_num mo_num mo_num (fun i j k ->\n",
" sum mos_cabs (fun a ->\n",
" h_two i j a k Spin.Alfa Spin.Alfa *. f_two a k i j Spin.Alfa Spin.Alfa\n",
" ) )\n",
" \n",
"let m_0122_Hab = \n",
" array_3_init mo_num mo_num mo_num (fun i j k ->\n",
" sum mos_cabs (fun a ->\n",
" h_two i j a k Spin.Alfa Spin.Beta *. f_two a k i j Spin.Alfa Spin.Beta\n",
" ) )\n",
"\n",
"\n",
"let integral_value ki kj = \n",
" (* mos unoccupied in both I and J *)\n",
" let mos_virt_a, mos_virt_b = \n",
" Array.init mo_num (fun i -> Some (i+1)) , \n",
" Array.init mo_num (fun i -> Some (i+1)) \n",
" in\n",
" List.iter (fun i -> mos_virt_a.(i-1) <- None) (mos_a ki);\n",
" List.iter (fun i -> mos_virt_a.(i-1) <- None) (mos_a kj);\n",
" List.iter (fun i -> mos_virt_b.(i-1) <- None) (mos_b ki);\n",
" List.iter (fun i -> mos_virt_b.(i-1) <- None) (mos_b kj);\n",
" \n",
" let mos_virt_a, mos_virt_b = \n",
" Array.to_list mos_virt_a |> Util.list_some,\n",
" Array.to_list mos_virt_b |> Util.list_some\n",
" in\n",
" \n",
" let result = \n",
" sum (mos_a ki) (fun i -> \n",
" sum (mos_b ki) (fun j -> \n",
" sum mos_virt_b (fun k -> m_0122_Hab.{i,j,k} )))\n",
" +.\n",
" sum (mos_b ki) (fun i -> \n",
" sum (mos_a ki) (fun j -> \n",
" sum mos_virt_a (fun k -> m_0122_Hab.{i,j,k} )))\n",
" +.\n",
" (* Alpha-Alpha / Beta-Beta *)\n",
" List.fold_left (fun accu (mos_virt,mos) -> \n",
" accu +.\n",
" sum mos (fun j -> \n",
" sum mos (fun i -> if i <= j then 0. else\n",
" sum mos_virt (fun k -> m_0122_Haa.{i,j,k} )))\n",
" ) 0. [ (mos_virt_a,mos_a ki) ; (mos_virt_b,mos_b ki)]\n",
" in \n",
" result\n",
" \n",
"let _ =\n",
" check 0 integral_value 0 1 2 2\n",
" "
]
},
{
"cell_type": "markdown",
"metadata": {},
@ -1096,6 +1315,49 @@
" "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"let m_0222_Haa = \n",
" Mat.init_cols mo_num mo_num (fun i j ->\n",
" sum mos_cabs (fun a ->\n",
" sum mos_cabs (fun b -> if b >= a then 0. else\n",
" h_two i j a b Spin.Alfa Spin.Alfa *. f_two a b i j Spin.Alfa Spin.Alfa\n",
" ) )\n",
" )\n",
" \n",
"let m_0222_Hab = \n",
" Mat.init_cols mo_num mo_num (fun i j ->\n",
" sum mos_cabs (fun a ->\n",
" sum mos_cabs (fun b ->\n",
" h_two i j a b Spin.Alfa Spin.Beta *. f_two a b i j Spin.Alfa Spin.Beta\n",
" ) )\n",
" )\n",
" \n",
"let integral_value ki kj = \n",
" (* Alpha-Beta *)\n",
" sum (mos_a ki) (fun i -> \n",
" sum (mos_b ki) (fun j -> \n",
" m_0222_Hab.{i,j} \n",
" ))\n",
" +.\n",
" (* Alpha-Alpha / Beta-Beta *)\n",
" List.fold_left (fun accu (mos) -> \n",
" accu +.\n",
" sum mos (fun j -> \n",
" sum mos (fun i -> if i < j then 0. else\n",
" m_0222_Haa.{i,j} \n",
" ))\n",
" ) 0. [ (mos_a ki) ; (mos_b ki)]\n",
" \n",
"let _ =\n",
" check 0 integral_value 0 2 2 2\n",
" "
]
},
{
"cell_type": "markdown",
"metadata": {},
@ -1176,6 +1438,115 @@
"let _ = check 0 integral_value 1 1 1 1"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"scrolled": true
},
"outputs": [],
"source": [
"let m_1111_1H_1F = \n",
" Mat.init_cols mo_num mo_num (fun i k -> \n",
" sum mos_cabs (fun a ->\n",
" h_one i a Spin.Alfa *. f_one a k Spin.Alfa ))\n",
"\n",
"\n",
"let m_1111_1H_2Fa = \n",
" array_3_init mo_num mo_num mo_num (fun i j k ->\n",
" sum mos_cabs (fun a ->\n",
" h_one i a Spin.Alfa *. f_two a j k j Spin.Alfa Spin.Alfa ))\n",
"\n",
" \n",
"let m_1111_1H_2Fb = \n",
" array_3_init mo_num mo_num mo_num (fun i j k ->\n",
" sum mos_cabs (fun a ->\n",
" h_one i a Spin.Alfa *. f_two a j k j Spin.Alfa Spin.Beta ))\n",
"\n",
"\n",
"let m_1111_2Ha_1F = \n",
" array_3_init mo_num mo_num mo_num (fun i j k ->\n",
" sum mos_cabs (fun a ->\n",
" h_two i j a j Spin.Alfa Spin.Alfa *. f_one a k Spin.Alfa ))\n",
"\n",
" \n",
"let m_1111_2Hb_1F = \n",
" array_3_init mo_num mo_num mo_num (fun i j k ->\n",
" sum mos_cabs (fun a ->\n",
" h_two i j a j Spin.Alfa Spin.Beta *. f_one a k Spin.Alfa ))\n",
"\n",
"\n",
"let m_1111_2Ha_2Fa =\n",
" array_4_init mo_num mo_num mo_num mo_num (fun i j k l ->\n",
" sum mos_cabs (fun a ->\n",
" h_two i j a j Spin.Alfa Spin.Alfa *.\n",
" f_two a l k l Spin.Alfa Spin.Alfa \n",
" )\n",
" )\n",
"\n",
"\n",
"let m_1111_2Hb_2Fa =\n",
" array_4_init mo_num mo_num mo_num mo_num (fun i j k l ->\n",
" sum mos_cabs (fun a ->\n",
" h_two i j a j Spin.Alfa Spin.Beta *.\n",
" f_two a l k l Spin.Alfa Spin.Alfa \n",
" )\n",
" )\n",
"\n",
"\n",
"let m_1111_2Ha_2Fb =\n",
" array_4_init mo_num mo_num mo_num mo_num (fun i j k l ->\n",
" sum mos_cabs (fun a ->\n",
" h_two i j a j Spin.Alfa Spin.Alfa *.\n",
" f_two a l k l Spin.Alfa Spin.Beta \n",
" )\n",
" )\n",
"\n",
"\n",
"let m_1111_2Hb_2Fb =\n",
" array_4_init mo_num mo_num mo_num mo_num (fun i j k l ->\n",
" sum mos_cabs (fun a ->\n",
" h_two i j a j Spin.Alfa Spin.Beta *.\n",
" f_two a l k l Spin.Alfa Spin.Beta \n",
" )\n",
" )\n",
"\n",
"\n",
"let integral_value ki kj = \n",
" let i, k, s, phase =\n",
" match Excitation.of_det ki kj with\n",
" | Excitation.(Single (phase, { hole ; particle ; spin })) ->\n",
" hole, particle, spin, phase\n",
" | _ -> assert false\n",
" in\n",
" \n",
" let mos_a, mos_b =\n",
" match s with\n",
" | Spin.Alfa -> mos_a ki, mos_b ki\n",
" | Spin.Beta -> mos_b ki, mos_a ki\n",
" in \n",
" \n",
" let result = \n",
" m_1111_1H_1F.{i,k} +. \n",
" sum mos_a (fun j -> if j = i then 0. else\n",
" m_1111_1H_2Fa.{i,j,k} +. m_1111_2Ha_1F.{i,j,k} +.\n",
" sum mos_a (fun l -> if l = i then 0. else m_1111_2Ha_2Fa.{i,j,k,l}) +.\n",
" sum mos_b (fun l -> m_1111_2Ha_2Fb.{i,j,k,l})) +.\n",
" sum mos_b (fun j ->\n",
" m_1111_1H_2Fb.{i,j,k} +. m_1111_2Hb_1F.{i,j,k} +.\n",
" sum mos_a (fun l -> if l = i then 0. else m_1111_2Hb_2Fa.{i,j,k,l}) +.\n",
" sum mos_b (fun l -> m_1111_2Hb_2Fb.{i,j,k,l}))\n",
" in\n",
" \n",
" match phase with\n",
" | Phase.Pos -> result\n",
" | Phase.Neg -> -. result\n",
" \n",
"let _ =\n",
" check 0 integral_value 1 1 1 1\n",
" "
]
},
{
"cell_type": "markdown",
"metadata": {},
@ -1606,7 +1977,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"# 9. 2 1 12"
"# 9. *2 1 12*"
]
},
{
@ -2119,6 +2490,195 @@
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Packed diagrams"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Diagonal elements"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Two electrons in CABS"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"(* 0 2 22 *)\n",
"\n",
"\n",
"let integral_value ki kj = \n",
" (* Alpha-Beta *)\n",
" let s, s' = Spin.(Alfa, Beta) in\n",
" sum mos_cabs (fun a -> \n",
" sum mos_cabs (fun b -> \n",
" sum (mos_a ki) (fun i -> \n",
" sum (mos_b ki) (fun j -> \n",
" h_two i j a b s s' *. f_two a b i j s s'\n",
" ))))\n",
" +.\n",
" (* Alpha-Alpha / Beta-Beta *)\n",
" List.fold_left (fun accu (mos,s) -> \n",
" let s' = s in accu +.\n",
" sum mos_cabs (fun b -> \n",
" sum mos_cabs (fun a -> if b > a then 0. else\n",
" sum mos (fun j -> \n",
" sum mos (fun i -> if i < j then 0. else\n",
" h_two i j a b s s' *. f_two a b i j s s'\n",
" ))))\n",
" ) 0. [ (mos_a ki,Spin.Alfa) ; (mos_b ki,Spin.Beta)]\n",
" \n",
"let _ =\n",
" check 0 integral_value 0 2 2 2\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### One electron in CABS"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"(* 0 1 11 *)\n",
"\n",
"\n",
"let integral_value ki kj = \n",
" (* Alpha-Beta *)\n",
" let s, s' = Spin.(Alfa, Beta) in \n",
" let mos_a, mos_b = mos_a ki, mos_b ki in\n",
" \n",
" sum mos_cabs (fun a ->\n",
" sum mos_a (fun i -> \n",
" (h_one i a s +.\n",
" sum mos_a (fun j -> h_two i j a j s s ) +.\n",
" sum mos_b (fun j -> h_two i j a j s s') ) *. \n",
" (f_one a i s +.\n",
" sum mos_a (fun j -> f_two a j i j s s ) +.\n",
" sum mos_b (fun j -> f_two a j i j s s') )\n",
" )\n",
" +.\n",
" sum mos_b (fun i -> \n",
" (h_one i a s +.\n",
" sum mos_b (fun j -> h_two i j a j s' s') +.\n",
" sum mos_a (fun j -> h_two i j a j s' s ) ) *. \n",
" (f_one a i s +.\n",
" sum mos_a (fun j -> f_two a j i j s' s ) +.\n",
" sum mos_b (fun j -> f_two a j i j s' s') )\n",
" ) \n",
" ) \n",
" \n",
"\n",
"(* 0 1 22 *)\n",
"\n",
"let integral_value ki kj = \n",
" (* mos unoccupied in both I and J *)\n",
" let mos_virt_a, mos_virt_b = \n",
" Array.init mo_num (fun i -> Some (i+1)) , \n",
" Array.init mo_num (fun i -> Some (i+1)) \n",
" in\n",
" List.iter (fun i -> mos_virt_a.(i-1) <- None) (mos_a ki);\n",
" List.iter (fun i -> mos_virt_a.(i-1) <- None) (mos_a kj);\n",
" List.iter (fun i -> mos_virt_b.(i-1) <- None) (mos_b ki);\n",
" List.iter (fun i -> mos_virt_b.(i-1) <- None) (mos_b kj);\n",
" \n",
" let mos_virt_a, mos_virt_b = \n",
" Array.to_list mos_virt_a |> Util.list_some,\n",
" Array.to_list mos_virt_b |> Util.list_some\n",
" in\n",
" \n",
" (* Alpha-Beta *)\n",
" let s, s' = Spin.(Alfa, Beta) in\n",
" sum mos_cabs (fun a ->\n",
" sum (mos_b ki) (fun j -> \n",
" sum (mos_a ki) (fun i -> \n",
" sum mos_virt_b (fun k -> \n",
" h_two i j a k s s' *. f_two a k i j s s'\n",
" )))\n",
" +.\n",
" sum (mos_a ki) (fun j -> \n",
" sum (mos_b ki) (fun i -> \n",
" sum mos_virt_a (fun k -> \n",
" h_two i j a k s s' *. f_two a k i j s s'\n",
" )))) \n",
" +.\n",
" (* Alpha-Alpha / Beta-Beta *)\n",
" List.fold_left (fun accu (mos_virt,mos,s) -> \n",
" let s' = s in accu +.\n",
" sum mos (fun j -> \n",
" sum mos (fun i -> if i < j then 0. else\n",
" sum mos_virt (fun k -> \n",
" sum mos_cabs (fun a -> \n",
" h_two i j a k s s' *. f_two a k i j s s'\n",
" )))) \n",
" ) 0. [ (mos_virt_a,mos_a ki,Spin.Alfa) ; (mos_virt_b,mos_b ki,Spin.Beta)]\n",
" \n",
"let _ =\n",
" check 0 integral_value 0 1 2 2\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Single excitations"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Two electrons in CABS"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### One electron in CABS"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Double excitations"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Two electrons in CABS"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### One electron in CABS"
]
},
{
"cell_type": "code",
"execution_count": null,