wy_qcos.transpiler.cmss.compiler package

Subpackages

• wy_qcos.transpiler.cmss.compiler.openqasm3 package
  • Submodules
  • wy_qcos.transpiler.cmss.compiler.openqasm3.convertor module
  • wy_qcos.transpiler.cmss.compiler.openqasm3.data module
  • wy_qcos.transpiler.cmss.compiler.openqasm3.exceptions module
  • wy_qcos.transpiler.cmss.compiler.openqasm3.expression module
  • wy_qcos.transpiler.cmss.compiler.openqasm3.parser module
  • wy_qcos.transpiler.cmss.compiler.openqasm3.state module
  • wy_qcos.transpiler.cmss.compiler.openqasm3.types module
  • Module contents

Submodules

wy_qcos.transpiler.cmss.compiler.decomposer module

wy_qcos.transpiler.cmss.compiler.decomposer.decompose_gates(ir, supp_basis_gates)

将中间表示中的门分解到硬件脉冲直接支持的门上.

参数:

• ir (list) -- 中间表示，类型为list

• supp_basis_gates (list) -- 支持的基础门列表，类型为list

返回:

硬件支持的门，类型为list

wy_qcos.transpiler.cmss.compiler.decomposer.decompose_gates_to_1q2q(ir)

参数:

ir (list)

wy_qcos.transpiler.cmss.compiler.linked_list module

class wy_qcos.transpiler.cmss.compiler.linked_list.LinkedNode(data)

基类：object

作用域节点类.

class wy_qcos.transpiler.cmss.compiler.linked_list.LinkedList

基类：object

作用域链表类.

get_tail()

获取最内部的符号表节点，一般用于获取当前作用域的符号表。.

返回:

链表的尾节点

返回类型:

LinkedNode

get_head()

头节点，只作为头部，不存放符号表数据.

返回:

链表的头节点

返回类型:

LinkedNode

add_tail(tail, scope)

新增一个最内部的符号表节点，用在visitor新的作用域之前。.

参数:

• tail (LinkedNode) -- 作用域节点

• scope (TreeNode) -- 抽象语法树节点

remove_tail()

删除最内部的符号表，一般用于删除当前作用域的符号表.

返回:

节点是否删除成功

返回类型:

bool

wy_qcos.transpiler.cmss.compiler.parser module

wy_qcos.transpiler.cmss.compiler.parser.p_main_program(main_program)

main_program : OPENQASM REAL ';' incfile ';' program

wy_qcos.transpiler.cmss.compiler.parser.p_array_type(array_type)

array_type : ARRAY '[' scalar_type ',' exp ']'

wy_qcos.transpiler.cmss.compiler.parser.p_array_literal(array_literal)

array_literal'{' exp_or_array_literal comma_or_array_literal_list '}'

'{' exp_or_array_literal comma_or_array_literal_list ',' '}'

'{' empty '}'

wy_qcos.transpiler.cmss.compiler.parser.p_exp_or_array_literal(exp_or_array_literal)

exp_or_array_literalexp

array_literal

wy_qcos.transpiler.cmss.compiler.parser.p_comma_or_array_literal_list(comma_or_array_literal_list)

comma_or_array_literal_listempty

',' exp_or_array_literal

comma_or_array_literal_list ',' exp_or_array_literal

wy_qcos.transpiler.cmss.compiler.parser.p_assign_statement(assign_statement)

assign_statement : indexed_identifier '=' exp ';'

wy_qcos.transpiler.cmss.compiler.parser.p_indexed_identifier(indexed_identifier)

indexed_identifierID

indexed_identifier index_operator

wy_qcos.transpiler.cmss.compiler.parser.p_index_operator(index_operator)

index_operator : '[' exp ']'

wy_qcos.transpiler.cmss.compiler.parser.p_incfile(incfile)

incfile : INCLUDE '"' STDFILE '"'

wy_qcos.transpiler.cmss.compiler.parser.p_program(program)

programstatement

program statement

wy_qcos.transpiler.cmss.compiler.parser.p_statement(statement)

statementdecl

decl3

gate_decl

qop

BARRIER qlist ';'

if_statement

for_statement

classical_declare_statement

assign_statement

RESET qlist ';'

wy_qcos.transpiler.cmss.compiler.parser.p_for_statement(for_stmt)

for_statementFOR scalar_type ID IN NUMBER '{' block_body '}'

FOR scalar_type ID IN '[' range_exp ']' '{' block_body '}'

FOR scalar_type ID IN ID '{' block_body '}'

FOR scalar_type ID IN array_literal '{' block_body '}'

wy_qcos.transpiler.cmss.compiler.parser.p_range_exp(range)

range_expexpression01 ':' expression01 ':' exp

expression01 ':' expression01

wy_qcos.transpiler.cmss.compiler.parser.p_expression01(expression01)

expression01empty

exp

wy_qcos.transpiler.cmss.compiler.parser.p_classical_declare_statement(p)

classical_declare_statementscalar_type ID '=' exp ';'

scalar_type ID '=' NUMBER ';'

array_type ID '=' array_literal ';'

scalar_type ID '=' REAL ';'

scalar_type ID '=' BOOL ';'

scalar_type ID ';'

wy_qcos.transpiler.cmss.compiler.parser.p_scalar_type(scalar_type)

scalar_typeINT designator01

FLOAT designator01

BOOL

wy_qcos.transpiler.cmss.compiler.parser.p_designator(designator)

designator : '[' exp ']'

wy_qcos.transpiler.cmss.compiler.parser.p_designator01(designator01)

designator01 : empty | designator

wy_qcos.transpiler.cmss.compiler.parser.p_block_body(block_body)

block_body : empty | statement | block_body statement

wy_qcos.transpiler.cmss.compiler.parser.p_empty(empty)

empty :

wy_qcos.transpiler.cmss.compiler.parser.p_decl(decl)

declQREG ID '[' NUMBER ']' ';'

CREG ID '[' NUMBER ']' ';'

wy_qcos.transpiler.cmss.compiler.parser.p_decl3(decl3)

decl3QUBIT '[' NUMBER ']' ID ';'

QUBIT ID ';'

BIT '[' NUMBER ']' ID ';'

BIT ID ';'

wy_qcos.transpiler.cmss.compiler.parser.p_gatedecl(gate_decl)

gate_declGATE ID idlist '{' goplist '}'

GATE ID '(' idlist ')' idlist '{' goplist '}'

wy_qcos.transpiler.cmss.compiler.parser.p_idlist(idlist)

idlistID

idlist ',' ID

wy_qcos.transpiler.cmss.compiler.parser.p_goplist(goplist)

goplistempty

uop

BARRIER idlist ';'

goplist uop

goplist BARRIER idlist ';'

RESET idlist ';'

goplist RESET idlist ';'

wy_qcos.transpiler.cmss.compiler.parser.p_qop(qop)

qopuop

MEASURE argument ARROW argument ';'

wy_qcos.transpiler.cmss.compiler.parser.p_argument(argument)

argumentID

ID '[' NUMBER ']'

ID '[' ID ']'

ID '[' exp ']'

wy_qcos.transpiler.cmss.compiler.parser.p_qlist(qlist)

qlistargument

qlist ',' argument

wy_qcos.transpiler.cmss.compiler.parser.p_uop(uop)

uopID qlist ';'

ID '(' explist ')' qlist ';'

wy_qcos.transpiler.cmss.compiler.parser.p_explist(explist)

explistexp

explist ',' exp

wy_qcos.transpiler.cmss.compiler.parser.p_exp(exp)

expREAL

NUMBER

PI

ID

BOOL

'(' exp ')'

exp '+' exp

exp '-' exp

exp '*' exp

exp '/' exp

'-' exp

unaryop '(' exp ')'

wy_qcos.transpiler.cmss.compiler.parser.p_unaryop(unaryop)

unaryopSIN

COS

TAN

EXP

LN

SQRT

wy_qcos.transpiler.cmss.compiler.parser.p_if_statement(if_statement)

if_statement : IF '(' ID EQ NUMBER ')' qop

wy_qcos.transpiler.cmss.compiler.parser.p_error(error)

wy_qcos.transpiler.cmss.compiler.parser.get_abs_tree(data)

解析OpenQASM，得到抽象语法树

参数:

data -- OpenQASM 语句

返回:

解析后的抽象语法树头节点

wy_qcos.transpiler.cmss.compiler.parser.get_ir(abs_tree)

解析抽象语法树，得到中间表示，其为Gate列表

参数:

abs_tree -- 抽象语法树

返回:

量子电路中间表示

返回类型:

circuit(QuantumCircuit)

wy_qcos.transpiler.cmss.compiler.parser.compile(data)

解析OpenQASM，得到抽象语法树

参数:

data -- OpenQASM 语句

返回:

量子比特总数 operations(list[BaseOperation]): 解析得到的量子门列表

返回类型:

num_qubits(int)

class wy_qcos.transpiler.cmss.compiler.parser.Parser(src_code)

基类：object

Parser class.

The Parser class is used to parse quantum circuit files or directly provided quantum circuit objects.

It can convert quantum circuits into circuits containing only single-qubit and two-qubit gates, and provides methods to export the circuit as a string in OpenQASM 2 format.

wy_qcos.transpiler.cmss.compiler.qtypes module

class wy_qcos.transpiler.cmss.compiler.qtypes.Node(node_type, children=[], leaf=None, pos=None)

基类：object

抽象语法树节点类.

参数:

• node_type (str)

• children (list[Any])

• leaf (Any)

class wy_qcos.transpiler.cmss.compiler.qtypes.RegType(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

基类：Enum

寄存器变量类型，QREG为量子寄存器变量，CREG为经典寄存器变量.

QREG = 1

CREG = 2

wy_qcos.transpiler.cmss.compiler.tokrules module

wy_qcos.transpiler.cmss.compiler.tokrules.t_error(lex_error)

wy_qcos.transpiler.cmss.compiler.tokrules.t_newline(line_num)

n+

wy_qcos.transpiler.cmss.compiler.tokrules.t_ignore_comment(comments)

//[^n]*

wy_qcos.transpiler.cmss.compiler.tokrules.t_REAL(real)

([0-9]+.[0-9]*|[0-9]*.[0-9]+)([eE][-+]?[0-9]+)?

wy_qcos.transpiler.cmss.compiler.tokrules.t_NUMBER(number)

[1-9]+[0-9]*|0

wy_qcos.transpiler.cmss.compiler.tokrules.t_BOOL(boolean)

true|false

wy_qcos.transpiler.cmss.compiler.tokrules.t_STDFILE(t)

qelib1.inc|stdgates.inc

wy_qcos.transpiler.cmss.compiler.tokrules.t_ID(t)

[a-zA-Z_][a-zA-Z_0-9]*

wy_qcos.transpiler.cmss.compiler.visitor module

class wy_qcos.transpiler.cmss.compiler.visitor.Visitor(allow_undefined=False)

基类：object

抽象语法树遍历类

add_reg(reg_id, reg_size, reg_type, pos)

添加变量到相关字典中

参数:

• reg_id -- 变量名

• reg_size -- 变量的长度

• reg_type -- 变量类型

• pos -- 所在位置

Returns:

check_reg(reg, reg_type, pos)

检查量子寄存器变量或者经典寄存器变量是否越界，若没有越界则返回其对应的物理比特下标 否则报错。

参数:

• reg -- 寄存器变量

• reg_type (RegType) -- 寄存器变量类型

• pos -- 所在位置

Return List:

寄存器变量对应下标 reg_type: RegType:

Returns:

check_in_gate_qubit(qubit, pos)

检查门作用的量子比特是否已经定义

参数:

• qubit -- 门作用的量子比特

• pos -- 所在位置

Returns:

check_qlist(qids, pos)

检查量子比特是否重复使用在同一操作中

参数:

• qids -- 量子比特

• pos -- 所在位置

Returns:

visit_program(s)

遍历抽象语法树的入口函数，通过dfs方法遍历根节点的所有子节点来完成遍历

参数:

s (Node) -- mainprogram节点

返回:

量子电路的中间表示

返回类型:

circuit(QuantumCircuit)

visit_state(s)

遍历所有语句，语句主要包括

变量定义: 更新相关成员变量，将其添加至相关字典中 门定义: 更新相关成员变量，将其添加至相关字典中 量子操作: 递归遍历

参数:

• s (Node) -- 抽象语法树节点

• s -- Node:

Returns:

visit_barrier(s)

检查量子比特已定义且无重复，若在自定义门中则添加相关元组以便后续解析 否则直接添加同步操作的中间表示到结果列表中。

参数:

• s (Node) -- barrier节点

• s -- Node:

Returns:

visit_reset(s)

检查量子比特已定义且无重复，若在自定义门中则添加相关元组以便后续解析 否则直接添加Reset操作的中间表示到结果列表中。

参数:

• s (Node) -- reset 节点

• s -- Node:

Returns:

visit_qop(s)

量子操作分为三种

• 同步：递归遍历

• 测量：测量操作首先判断量子变量和经典变量是否可用，且比特没有重复测量 在结果中添加测量的中间表示。

• 门操作：递归遍历

参数:

• s (Node) -- qop节点

• s -- Node:

Returns:

eval_gate(uid, args, qids, pos, func_dict=None)

解析自定义门中的子语句 如果是全局的量子操作，则直接添加对应的中间表示, 否则生成参数对应字典，该字典的键值对为自定义门的参数以及调用时实际使用值， 用该字典以及eval函数来实现内联操作，将自定义门中的子语句转换为中间表示。

参数:

• uid -- 量子门类型

• args -- 量子门参数

• qids -- 量子门作用的量子比特

• pos -- 所在位置

• func_dict -- 函数字典 (Default value = None)

Returns:

visit_for_statement(s)

for 循环条件处理，创建for作用域符号表

参数:

• s (Node) -- for_statement 节点

• s -- Node:

Returns:

visit_range_expression(s)

处理 range_exp 节点, 用在for语句中

参数:

• s (Node) -- range_exp 节点

• s -- Node:

返回:

循环起点、步长、循环终点

返回类型:

Tuple (int, int, int)

visit_for_block_body(s, iterator_type, iterator_name, cur_loop_count)

处理for循环体中的每条语句

参数:

• s (Node) -- block_body 节点

• iterator_type -- for循环体索引类型

• iterator_name -- for循环体索引名

• cur_loop_count -- 当前索引值

• s -- Node:

Returns:

visit_uop_v3(s)

为支持openqasm 3.0特性而写， 基于visitUop方法，新增对exp节点的处理

参数:

• s (Node) -- uop节点

• s -- Node:

Returns:

var_to_number(in_var, pos)

如果in_var[1]是整数返回值， 如果in_var[1]是表达式节点，遍历处理表达式节点， 如果in_var[1]是字符串，从符号表中取值

参数:

• in_var -- 变量

• pos -- 所在位置

Return Any:

变量对应的值

Returns:

visit_classical_declaration_statement(s)

遍历经典变量声明语句，把变量的值放到符号表中。 对于 scalar_type 类型变量，语法树支持声明和定义分开，但是变量使用时必须定义 对于arrayType类型变量，声明时必须定义

参数:

s -- Node): classical_declare_statement 节点

Returns:

visit_array_literal(s)

处理数组字面值。 如果元素是bool，int，float等基本类型，保存值。 其他类型目前不考虑。

参数:

s (Node) -- array_literal 节点

Return List:

数组类型 s: Node:

返回类型:

list

Returns:

visit_array_type(s)

获取数组的类型与长度

参数:

s (Node) -- array_type 节点

Return Tuple (str, int):

数组类型、长度 s: Node:

Returns:

visit_assignment_statement(s)

处理赋值语句

参数:

• s (Node) -- assign_statement 节点

• s -- Node:

Returns:

find_symbol_table(var_name)

获取变量名所在的符号表

参数:

var_name (str) -- 变量名

Return LinkedNode:

变量所在作用域 var_name: str:

Returns:

add_to_symbol_table(var_type, var_name, value, pos)

把变量名和变量值作为键值对放到符号表中 对于普通变量a，在字典中的存储格式是： {a:{"val":1,"type":"int","category":"default"}}

参数:

• var_type -- 变量类型

• var_name -- 变量名

• value -- 变量值

• pos -- 所在位置

Returns:

add_array_to_symbol_table(var_type, var_name, length, elements, pos)

把数组变量和它的元素放入符号表中， 对于int数组变量arr，存储结构为： {"arr":{"type":"int","category":"array","length":1,"val":[1,2,3]}} 目前数组在声明时必须定义。

参数:

• var_type -- 数组类型

• var_name -- 数组名

• length -- 数组长度

• elements -- 数组元素

• pos -- 所在位置

Returns:

visit_exp(exp_node, is_recursion, pos)

遍历处理表达式节点，用于获取表达式具体的值， 具体情况参考parser.py p_exp方法中exp节点的定义 is_recursion 表示是否查询外层作用域的符号表

参数:

• exp_node -- 表达式节点

• is_recursion -- 是否在当前作用域外查找

• pos -- 所在位置

Return Any:

表达式计算结果

Returns:

modify_in_symbol_table(var_name, value, pos, is_recursion=True)

在符号表中修改变量的值

参数:

• var_name (str) -- 变量名

• value (Any) -- 变量值

• pos (int) -- 所在位置

• is_recursion (bool) -- 是否在当前作用域外查找

• var_name -- str:

• value -- Any:

• pos -- int:

• is_recursion -- bool: (Default value = True)

Returns:

find_val_in_symbol_table(var_name, pos, is_recursion=True)

在符号表中找到变量的值

参数:

• var_name (str) -- 变量名

• pos (int) -- 所在位置

• is_recursion (bool) -- 是否在当前作用域外查找

Return Any:

变量的值 var_name: str: pos: int: is_recursion: bool: (Default value = True)

Returns:

find_type_in_var_dict(var_dict, var_name, pos)

在变量字典中找到变量类型type,如果type为None，报错

参数:

• var_dict (dict) -- 变量字典

• var_name (str) -- 变量名

• pos (int) -- 所在位置

Return Any:

变量的类型 var_dict: dict: var_name: str: pos: int:

Returns:

find_val_in_var_dict(var_dict, var_name, pos)

在变量字典中找到变量值val, 如果val为None，报错

参数:

• var_dict (dict) -- 变量字典

• var_name (str) -- 变量名

• pos (int) -- 所在位置

Return Any:

变量的值 var_dict: dict: var_name: str: pos: int:

Returns:

find_in_symbol_table(var_name, is_recursion)

在符号表中找到变量

参数:

• var_name (str) -- 变量名

• is_recursion -- 是否在当前作用域外查找

Return Any:

变量的值 var_name: str:

Returns:

is_float_regex(s)

判断字符串是否是浮点数

参数:

s -- 字符串

Return bool:

是否为浮点数

Returns:

is_id(s)

判断字符串是否是变量名

参数:

s -- 字符串

Return bool:

是否为变量名

Returns:

get_call_param_value(arg, func_dict, pos)

获取自定义门入参的值

参数:

• arg -- 自定义门入参

• func_dict -- 函数字典

• pos -- 所在位置

Return Any:

自定义门入参的值

Returns:

check_node_type(node, expect_type)

检测节点类型是否复合预期, 用于visit语法树节点方法中，防止对节点进行了错误的遍历

参数:

• node (Node) -- 抽象语法树节点

• expect_type (str) -- 期望的节点类型

• node -- Node:

• expect_type -- str:

Returns:

check_var_name(var_name, pos)

检测变量命名是否重复

参数:

• var_name (str) -- 变量名

• pos -- 所在位置

• var_name -- str:

Returns:

Module contents