고전적 표현들
qiskit.circuit.classical
이 모듈에는 회로 실행 중 클래식 값에 대한 실시간 연산에 대한 탐색적 표현이 포함되어 있습니다.
현재는 부울 값을 반환하는 비트 및 레지스터에 대한 간단한 표현식만 지원되며, 이러한 표현식은 (IfElseOp) 및 QuantumCircuit.while_loop() (WhileLoopOp)의 QuantumCircuit.if_test() 조건부 표현식과 (SwitchCaseOp)의 QuantumCircuit.switch() 대상 부분에서만 사용할 수 있습니다.
이 모듈은 탐색용 모듈이며, 이 모듈 내에서 표준 키스킷 지원 중단 정책을 준수할 것이지만, 초기에는 의도적으로 범위가 제한될 것이며 초기 버전이 최종 버전으로 깔끔하게 진화하지 못할 수도 있다는 점에 유의해 주세요. 이 모듈의 다양한 구성 요소가 새로운 형태로 개선되는 대신 대체될 수 있습니다(사용 중단될 수 있음).
타입 시스템과 표현식 트리는 시간이 지남에 따라 확장될 것이며, 기존 처리 기능이 발전함에 따라 일부 연산의 허용된 타입이 키스킷 버전 간에 변경될 수 있습니다.
표현식
qiskit.circuit.classical.expr
표현식을 작성하는 데 필요한 구성 요소는 모두 표현식 내의 expr 네임스페이스에서 내보내므로 qiskit.circuit.classical의 네임스페이스에서 내보내므로 정규화된 액세스를 사용할지(예를 들어 expr.Value) 또는 필요한 이름을 직접 가져와 접두사 없이 호출할지 선택할 수 있습니다.
표현식을 구성하는 데는 두 가지 경로가 있습니다. 표현식 시스템의 표현을 형성하는 클래스에는 제로 타입 검사를 수행하는 생성자가 있으며, 유효한 객체를 생성하는지 확인하는 것은 호출자의 몫입니다. 보다 사용자 친화적인 인터페이스로 직접 구성할 수 있도록 유형 유효성 검사 및 추론을 수행하는 대부분의 클래스와 관련된 헬퍼 함수가 있습니다. 이에 대한 자세한 내용은 아래 건설에 설명되어 있습니다.
표현
표현식 시스템은 트리 표현을 기반으로 합니다. 트리의 모든 노드는 추상 베이스 클래스의 최종(상속 불가) 인스턴스입니다:
Expr
class qiskit.circuit.classical.expr.Expr
베이스: object
표현식 트리에 있는 모든 노드의 루트 베이스 클래스입니다. 기본 케이스는 절대로 직접 인스턴스화해서는 안 됩니다.
서브클래스는 표현식 표현의 내부 데이터를 형성하며, 키스킷 라이브러리 코드 외부에 더 추가하는 것은 의미가 없습니다.
__init__모든 하위 클래스는 자신의 에서 해당 type 속성을 설정할 책임이 있으며, 부모 클래스의 초기화자를 호출해서는 안 됩니다.
이러한 개체는 변경 가능하므로 복사본 없이 다른 위치에서 재사용해서는 안 됩니다.
All Expr 인스턴스는 컴파일 타임에 표현식을 평가할 수 있는지 여부를 나타내는 부울 const 속성을 정의합니다. 대부분의 표현식 클래스는 피연산자의 구성에 따라 구성 중에 이를 추론합니다.
동적 변수의 베이스는 Var이며, 이는 임의로 입력된 실시간 변수이거나, 또는 Clbit 또는 ClassicalRegister.
변수
class qiskit.circuit.classical.expr.Var(var, type, *, name=None)
베이스: Expr
고전적인 변수입니다.
이러한 변수는 저장 위치를 소유하고 연관된 이름을 가진 새로운 스타일의 변수와 이전 스타일의 변수를 감싸는 Clbit 또는 ClassicalRegister 인스턴스를 감싸는 구형 변수입니다. 일반적으로 프로그램에서 사용할 변수의 구성은 Var.new() 또는 QuantumCircuit.add_var().
변수는 생성된 후에는 변경할 수 없으므로, 사전의 키로 사용할 수 있습니다.
name
new
classmethod new(name, ty)
자체 백업 저장소를 소유하는 새 명명된 변수를 생성합니다.
var
인스턴스의 Var 백업 데이터 저장소를 가리킵니다. ClassicalRegisterVar구식 Clbit 인스턴스나 ClassicalRegister 인스턴스를 로 가져올 때, 이것이 바로 또는 Clbit 입니다. 변수가 새로운 형식의 클래식 변수(기존 Clbit/ClassicalRegister 모델과는 별도로 자체 저장 공간을 소유하는 변수)인 경우, 이 필드는 해당 변수를 고유하게 식별하는 식별자가 UUID 됩니다.
마찬가지로 표현식에 사용된 리터럴(예: 정수)은 연관된 유형이 있는 Value 노드로 옮겨야 합니다. A Value 는 항상 상수 표현식으로 간주됩니다.
값
기간 표현식에 사용할 스트레치 변수는 Stretch 노드로 표현됩니다.
늘리기
class qiskit.circuit.classical.expr.Stretch(var, name)
베이스: Expr
스트레치 변수입니다.
일반적으로 프로그램에서 사용하기 위한 스트레치 변수의 구성은 Stretch.new() 또는 QuantumCircuit.add_stretch()
name
스트레치 변수의 이름입니다.
new
classmethod new(name)
새 명명된 스트레치 변수를 생성합니다.
var
A UUID 를 사용하여 이 스트레치를 고유하게 식별할 수 있습니다.
프로그래밍에서 전통적으로 접두사, 접미사 또는 접미사 연산자와 관련된 연산은 Unary 및 Binary 노드를 적절히 사용합니다. 이들은 각각 연산 유형 코드를 취하며, 각 클래스 내에서 열거형으로 노출됩니다 Unary.Op 와 Binary.Op 로 각각 노출됩니다.
단항
class qiskit.circuit.classical.expr.Unary(op, operand, type)
베이스: Expr
단항식입니다.
매개변수
- op – 어떤 작업이 수행되고 있는지 설명하는 명령어입니다.
- 피연산자 - 연산의 피연산자입니다.
- 유형 - 결과의 해결된 유형입니다.
Op
class Op(*values)
베이스: Enum
단항 연산에 대한 연산 코드의 열거입니다.
비트 단위 부정( BIT_NOT )은 단일 비트 또는 알려진 너비의 부호 없는 정수를 취하고 동일한 유형의 값을 반환합니다.
논리적 부정 LOGIC_NOT 은 암시적으로 부울로 강제 지정된 입력을 받아 부울을 반환합니다.
산술 부정 연산은 float 또는 duration NEGATE 형식의 입력을 받아 동일한 형식의 값을 반환합니다.
2진
class qiskit.circuit.classical.expr.Binary(op, left, right, type)
베이스: Expr
이진 표현식입니다.
매개변수
- op – 어떤 작업이 수행되고 있는지 설명하는 명령어입니다.
- 왼쪽 - 왼쪽 피연산자입니다.
- 오른쪽 - 오른쪽 피연산자입니다.
- 유형 - 결과의 해결된 유형입니다.
Op
class Op(*values)
베이스: Enum
이진 연산을 위한 연산 코드의 열거입니다.
비트 연산 BIT_AND, BIT_OR 및 BIT_XOR 은 동일한 유형의 피연산자 두 개에 적용되며, 피연산자는 단일 비트 또는 고정 폭의 부호 없는 정수여야 합니다. 결과 유형은 두 입력 유형과 동일합니다.
논리 연산 LOGIC_AND 및 LOGIC_OR 은 먼저 인수를 부울에 암시적으로 강제한 다음 논리 연산을 적용합니다. 결과 유형은 항상 부울입니다.
이진 수학 관계 EQUAL, NOT_EQUAL, LESS, LESS_EQUAL, GREATER , GREATER_EQUAL 는 부호 없는 정수를 취하고(같은 너비로 만들기 위해 암시적 형변환 사용) 부울을 반환합니다.
비트 시프트 연산 SHIFT_LEFT 및 SHIFT_RIGHT 은 비트와 유사한 컨테이너 유형(예: 부호 없는 정수)을 왼쪽 피연산자로, 모든 정수 유형을 오른쪽 피연산자로 사용할 수 있습니다. 모든 경우에 출력 비트 폭은 입력과 동일하며 '노출된' 공간에는 0이 채워집니다.
이진 산술 연산자 ADD, SUB, MUL, 및 는 두 개의 부동 소수점 수나 두 DIV 개의 부호 없는 정수에 적용할 수 있으며, 이를 위해 변환(cast)을 통해 생성 시 두 수를 동일한 비트 폭으로 맞춰야 합니다. , SUB, 및 DIV``ADD 연산자는 두 개의 기간에 적용되어 또 다른 기간을 산출하거나, 의 경우에는 실수를 DIV산출할 수 있습니다. 이 MUL 연산자는 기간과 숫자형에 적용하여 또 다른 기간을 생성할 수도 있습니다. 마지막으로, DIV 연산자를 사용하여 지속 시간을 숫자형으로 나누어 지속 시간을 구할 수 있습니다.
비트 유사 유형(부호 없는 정수)은 정수 유형으로 인덱싱할 수 있습니다 Index. 결과는 단일 비트입니다. 결과 표현식에는 연관된 메모리 위치가 있으므로(따라서 대상도 l값인 경우 Store등의 l값으로 사용할 수 있습니다) 대상도 l값인 경우.
색인
class qiskit.circuit.classical.expr.Index(target, index, type)
베이스: Expr
인덱싱 표현식입니다.
매개변수
- 대상 - 인덱싱되는 개체입니다.
- index - 인덱싱을 수행하는 표현식입니다.
- 유형 - 결과의 해결된 유형입니다.
표현식을 구성할 때는 해당 유형이 연산에 유효한지 확인해야 합니다. 유효하지 않은 유형으로 표현식을 만들려고 하면 일반 Python TypeError 이 발생합니다.
이 시스템의 표현식은 특정 유형 집합에만 작동하도록 정의되어 있습니다. 그러나 입력 요구 사항을 충족하기 위해 값을 적절한 상위 유형으로 캐스팅할 수 있습니다. 이러한 경우 표현식 트리의 노드가 프로모션을 나타내는 데 사용됩니다. 연산이 인수를 '암시적으로 캐스팅' 또는 '강제'하는 모든 경우, 표현식 트리에는 변환을 나타내는 이 노드가 있어야 합니다.
캐스트
class qiskit.circuit.classical.expr.Cast(operand, type, implicit=False)
베이스: Expr
한 유형에서 다른 유형으로 형 변환하는 것으로, 다른 컨텍스트에서 표현식을 사용할 때 암시됩니다.
생성
트리 표현을 직접 구성하는 것은 장황하고 입력 실수가 발생하기 쉽습니다. 많은 경우, 입력의 많은 부분을 유추할 수 있고, 스칼라 값을 자동으로 Value 인스턴스로 자동 승격될 수 있으며, 필요한 모든 승격은 적절한 Cast 노드로 해결할 수 있습니다.
이 섹션에서 설명하는 함수와 메서드는 내부 표현에 가깝게 유지하면서 표현식 트리를 구축하는 보다 사용자 친화적인 방법입니다. 이 모든 함수는 유효한 Python 스칼라 값을 자동으로 해당하는 Var 또는 Value 객체로 변환하고 필요한 모든 암시적 형변환을 대신 해결합니다. 일부 스칼라 값을 노드로 직접 사용하려면 Expr 노드로 직접 사용하려면 수동으로 lift() 직접 설정할 수 있습니다.
lift
qiskit.circuit.classical.expr.lift(value, /, type=None)
주어진 Python value 을 Value 또는 Var.
명시적으로 type 을 지정하면 출력에 입력할 때 이를 반영합니다.
예제
간단한 회로 객체를 다음과 같이 리프팅합니다 Var 인스턴스로 리프팅합니다:
>>> from qiskit.circuit import Clbit, ClassicalRegister
>>> from qiskit.circuit.classical import expr
>>> expr.lift(Clbit())
Var(<clbit>, Bool())
>>> expr.lift(ClassicalRegister(3, "c"))
Var(ClassicalRegister(3, "c"), Uint(3))반환 값의 형식은, 주어진 값이 손실 없이 지정된 형식으로 해석될 수 있는 경우 영향을 받을 수 있습니다(손실이 발생하는 형변환을 포함한 모든 형변환 작업을 수행하려면 를 cast() 사용하십시오):
>>> from qiskit.circuit import ClassicalRegister
>>> from qiskit.circuit.classical import expr, types
>>> expr.lift(ClassicalRegister(3, "c"), types.Uint(5))
Var(ClassicalRegister(3, "c"), Uint(5))
>>> expr.lift(5, types.Uint(4))
Value(5, Uint(4))매개변수
리턴 유형
일반적으로 메모리 소유 인스턴스를 생성하려면 Var 인스턴스를 만들려면 QuantumCircuit.add_var() 메서드를 사용하여 일부 회로 컨텍스트에서 선언해야 합니다 QuantumCircuit 는 아직 선언되지 않은 변수를 포함하는 Expr 는 저장소를 할당하는 방법과 변수가 초기화되는 방법을 알아야 하므로 아직 선언되지 않은 변수를 포함하는 인스턴스를 허용하지 않습니다. 그러나 이 작업을 수동으로 수행하려면 낮은 수준의 Var.new() 호출을 사용하여 사용할 네임드 변수를 안전하게 생성해야 합니다.
명시적인 형식으로 형 변환이 허용되지만 손실이 발생할 수 있는 경우(예: 높은 정밀도의 형 변환을 낮은 정밀도의 형 변환으로 Uint 를 낮은 정밀도로 캐스팅하는 것과 같이).
cast
qiskit.circuit.classical.expr.cast(operand, type, /)
지정된 값에서 지정된 유형으로 명시적 형변환을 생성합니다.
예제
고정밀 유형을 저정밀 유형으로 명시적으로 캐스팅하는 명시적 캐스팅 노드를 추가합니다:
>>> from qiskit.circuit.classical import expr, types
>>> value = expr.value(5, types.Uint(32))
>>> expr.cast(value, types.Uint(8))
Cast(Value(5, types.Uint(32)), types.Uint(8), implicit=False)매개변수
리턴 유형
각 단항 연산에 대한 도우미 생성자 함수가 있습니다.
bit_not
qiskit.circuit.classical.expr.bit_not(operand, /)
주어진 값에서 비트 단위의 'not' 표현식 노드를 생성하여 암시적 형변환을 해결하고 필요한 경우 값을 Value 노드로 리프팅합니다.
예제
비트 단위의 부정 ClassicalRegister:
>>> from qiskit.circuit import ClassicalRegister
>>> from qiskit.circuit.classical import expr
>>> expr.bit_not(ClassicalRegister(3, "c"))
Unary(Unary.Op.BIT_NOT, Var(ClassicalRegister(3, 'c'), Uint(3)), Uint(3))매개변수
operand (Any)
리턴 유형
logic_not
qiskit.circuit.classical.expr.logic_not(operand, /)
주어진 값에서 논리적 'not' 표현식 노드를 생성하여 암시적 형변환을 해결하고 필요한 경우 값을 Value 노드로 리프팅합니다.
예제
의 논리적 부정 ClassicalRegister:
>>> from qiskit.circuit import ClassicalRegister
>>> from qiskit.circuit.classical import expr
>>> expr.logic_not(ClassicalRegister(3, "c"))
Unary(Unary.Op.LOGIC_NOT, Cast(Var(ClassicalRegister(3, 'c'), Uint(3)), Bool(), implicit=True), Bool())매개변수
operand (Any)
리턴 유형
negate
qiskit.circuit.classical.expr.negate(operand, /)
주어진 값을 사용하여 표현식 노드를 부정하고, 암시적 형변환을 해결하며, 필요한 경우 해당 값을 노드로 Value 변환합니다.
예제
부동 소수점 숫자의 부호 반전:
>>> from qiskit.circuit.classical import expr
>>> expr.negate(5.0)
Unary(Unary.Op.NEGATE, Value(5.0, Float()), Float())기간의 부정:
>>> from qiskit.circuit import Duration
>>> from qiskit.circuit.classical import expr
>>> expr.negate(Duration.dt(1000))
Unary(Unary.Op.NEGATE, Value(Duration.dt(1000), Duration()), Duration())매개변수
operand (Any)
리턴 유형
마찬가지로 이진 연산과 관계에도 도우미 함수가 정의되어 있습니다.
bit_and
qiskit.circuit.classical.expr.bit_and(left, right, /)
주어진 값에서 비트 단위의 'and' 표현식 노드를 생성하여 암시적 형변환을 해결하고 필요한 경우 값을 Value 노드로 리프팅합니다.
예제
기존 레지스터와 정수 리터럴의 비트 단위 'and':
>>> from qiskit.circuit import ClassicalRegister
>>> from qiskit.circuit.classical import expr
>>> expr.bit_and(ClassicalRegister(3, "c"), 0b111)
Binary(Binary.Op.BIT_AND, Var(ClassicalRegister(3, 'c'), Uint(3)), Value(7, Uint(3)), Uint(3))매개변수
리턴 유형
bit_or
qiskit.circuit.classical.expr.bit_or(left, right, /)
주어진 값에서 비트 단위의 '또는' 표현식 노드를 생성하여 암시적 형변환을 해결하고 필요한 경우 값을 Value 노드로 리프팅합니다.
예제
기존 레지스터의 비트 단위 '또는' 및 정수 리터럴입니다:
>>> from qiskit.circuit import ClassicalRegister
>>> from qiskit.circuit.classical import expr
>>> expr.bit_or(ClassicalRegister(3, "c"), 0b101)
Binary(Binary.Op.BIT_OR, Var(ClassicalRegister(3, 'c'), Uint(3)), Value(5, Uint(3)), Uint(3))매개변수
리턴 유형
bit_xor
qiskit.circuit.classical.expr.bit_xor(left, right, /)
주어진 값에서 비트 단위의 '배타적 또는' 표현식 노드를 생성하여 암시적 형변환을 해결하고 필요한 경우 값을 Value 노드로 리프팅합니다.
예제
기존 레지스터와 정수 리터럴의 비트 단위 '배타적 또는' 리터럴입니다:
>>> from qiskit.circuit import ClassicalRegister
>>> from qiskit.circuit.classical import expr
>>> expr.bit_xor(ClassicalRegister(3, "c"), 0b101)
Binary(Binary.Op.BIT_XOR, Var(ClassicalRegister(3, 'c'), Uint(3)), Value(5, Uint(3)), Uint(3))매개변수
리턴 유형
logic_and
qiskit.circuit.classical.expr.logic_and(left, right, /)
주어진 값에서 논리적 'and' 표현식 노드를 생성하여 암시적 형변환을 해결하고 필요한 경우 값을 Value 노드로 리프팅합니다.
예제
두 개의 고전적인 비트의 논리적 '그리고':
>>> from qiskit.circuit import Clbit
>>> from qiskit.circuit.classical import expr
>>> expr.logic_and(Clbit(), Clbit())
Binary(Binary.Op.LOGIC_AND, Var(<clbit 0>, Bool()), Var(<clbit 1>, Bool()), Bool())매개변수
리턴 유형
logic_or
qiskit.circuit.classical.expr.logic_or(left, right, /)
주어진 값에서 논리적 '또는' 표현식 노드를 생성하여 암시적 형변환을 해결하고 필요한 경우 값을 Value 노드로 리프팅합니다.
예제
두 개의 클래식 비트의 논리적 '또는' 조합
>>> from qiskit.circuit import Clbit
>>> from qiskit.circuit.classical import expr
>>> expr.logic_or(Clbit(), Clbit())
Binary(Binary.Op.LOGIC_OR, Var(<clbit 0>, Bool()), Var(<clbit 1>, Bool()), Bool())매개변수
리턴 유형
equal
qiskit.circuit.classical.expr.equal(left, right, /)
주어진 값에서 '같음' 표현식 노드를 생성하여 암시적 형변환을 해결하고 필요한 경우 값을 Value 노드로 리프팅합니다.
예제
클래식 레지스터와 정수 사이의 등식:
>>> from qiskit.circuit import ClassicalRegister
>>> from qiskit.circuit.classical import expr
>>> expr.equal(ClassicalRegister(3, "c"), 7)
Binary(Binary.Op.EQUAL, Var(ClassicalRegister(3, "c"), Uint(3)), Value(7, Uint(3)), Uint(3))매개변수
리턴 유형
not_equal
qiskit.circuit.classical.expr.not_equal(left, right, /)
주어진 값에서 '같지 않음' 표현식 노드를 생성하여 암시적 형변환을 해결하고 필요한 경우 값을 Value 노드로 리프팅합니다.
예제
기존 레지스터와 정수 사이의 부등식:
>>> from qiskit.circuit import ClassicalRegister
>>> from qiskit.circuit.classical import expr
>>> expr.not_equal(ClassicalRegister(3, "c"), 7)
Binary(Binary.Op.NOT_EQUAL, Var(ClassicalRegister(3, "c"), Uint(3)), Value(7, Uint(3)), Uint(3))매개변수
리턴 유형
less
qiskit.circuit.classical.expr.less(left, right, /)
주어진 값에서 '보다 작음' 표현식 노드를 생성하여 암시적 형변환을 해결하고 필요한 경우 값을 Value 노드로 리프팅합니다.
예제
기존 레지스터가 정수보다 작은지 쿼리합니다:
>>> from qiskit.circuit import ClassicalRegister
>>> from qiskit.circuit.classical import expr
>>> expr.less(ClassicalRegister(3, "c"), 5)
Binary(Binary.Op.LESS, Var(ClassicalRegister(3, "c"), Uint(3)), Value(5, Uint(3)), Uint(3))매개변수
리턴 유형
less_equal
qiskit.circuit.classical.expr.less_equal(left, right, /)
주어진 값에서 '보다 작거나 같은' 표현식 노드를 생성하여 암시적 형변환을 해결하고 필요한 경우 값을 Value 노드로 리프팅합니다.
예제
클래식 레지스터가 다른 레지스터보다 작거나 같은지 쿼리합니다:
>>> from qiskit.circuit import ClassicalRegister
>>> from qiskit.circuit.classical import expr
>>> expr.less_equal(ClassicalRegister(3, "a"), ClassicalRegister(3, "b"))
Binary(Binary.Op.LESS_EQUAL, Var(ClassicalRegister(3, "a"), Uint(3)), Var(ClassicalRegister(3, "b"), Uint(3)), Uint(3))매개변수
리턴 유형
greater
qiskit.circuit.classical.expr.greater(left, right, /)
주어진 값에서 '보다 큰' 표현식 노드를 생성하여 암시적 형변환을 해결하고 필요한 경우 값을 Value 노드로 리프팅합니다.
예제
기존 레지스터가 정수보다 큰지 쿼리합니다:
>>> from qiskit.circuit import ClassicalRegister
>>> from qiskit.circuit.classical import expr
>>> expr.greater(ClassicalRegister(3, "c"), 5)
Binary(Binary.Op.GREATER, Var(ClassicalRegister(3, "c"), Uint(3)), Value(5, Uint(3)), Uint(3))매개변수
리턴 유형
greater_equal
qiskit.circuit.classical.expr.greater_equal(left, right, /)
주어진 값에서 '보다 크거나 같은' 표현식 노드를 생성하여 암시적 형변환을 해결하고 필요한 경우 값을 Value 노드로 리프팅합니다.
예제
클래식 레지스터가 다른 레지스터보다 크거나 같은지 쿼리합니다:
>>> from qiskit.circuit import ClassicalRegister
>>> from qiskit.circuit.classical import expr
>>> expr.greater_equal(ClassicalRegister(3, "a"), ClassicalRegister(3, "b"))
Binary(Binary.Op.GREATER_EQUAL, Var(ClassicalRegister(3, "a"), Uint(3)), Var(ClassicalRegister(3, "b"), Uint(3)), Uint(3))매개변수
리턴 유형
shift_left
qiskit.circuit.classical.expr.shift_left(left, right, /, type=None)
주어진 두 값에서 '비트 시프트 왼쪽' 표현식 노드를 생성하여 암시적 형변환을 해결하고 필요한 경우 값을 Value 노드로 리프팅합니다.
type 이 주어지면 left 피연산자가 강제로 지정됩니다(가능한 경우).
예제
독립형 변수의 값을 얼마만큼 왼쪽으로 이동합니다:
>>> from qiskit.circuit.classical import expr, types
>>> a = expr.Var.new("a", types.Uint(8))
>>> expr.shift_left(a, 4)
Binary(Binary.Op.SHIFT_LEFT, Var(<UUID>, Uint(8), name='a'), Value(4, Uint(3)), Uint(8))리터럴의 유형을 강제로 지정하여 정수 리터럴을 가변량만큼 이동합니다:
>>> expr.shift_left(3, a, types.Uint(16))
Binary(Binary.Op.SHIFT_LEFT, Value(3, Uint(16)), Var(<UUID>, Uint(8), name='a'), Uint(16))매개변수
리턴 유형
shift_right
qiskit.circuit.classical.expr.shift_right(left, right, /, type=None)
주어진 값에서 '비트 시프트 오른쪽' 표현식 노드를 생성하여 암시적 형변환을 해결하고 필요한 경우 값을 Value 노드로 리프팅합니다.
type 이 주어지면 left 피연산자가 강제로 지정됩니다(가능한 경우).
예제
클래식 레지스터의 값을 일정 금액만큼 오른쪽으로 이동합니다:
>>> from qiskit.circuit import ClassicalRegister
>>> from qiskit.circuit.classical import expr
>>> expr.shift_right(ClassicalRegister(8, "a"), 4)
Binary(Binary.Op.SHIFT_RIGHT, Var(ClassicalRegister(8, "a"), Uint(8)), Value(4, Uint(3)), Uint(8))매개변수
리턴 유형
add
qiskit.circuit.classical.expr.add(left, right, /)
주어진 값에서 덧셈 표현식 노드를 생성하고, 암시적 형변환을 해결하고, 필요한 경우 값을 Value 노드로 리프팅합니다.
예제
부동 소수점 숫자 두 개를 추가합니다:
>>> from qiskit.circuit.classical import expr
>>> expr.add(5.0, 2.0)
Binary(Binary.Op.ADD, Value(5.0, Float()), Value(2.0, Float()), Float())두 개의 지속 시간이 추가됩니다:
>>> from qiskit.circuit import Duration
>>> from qiskit.circuit.classical import expr
>>> expr.add(Duration.dt(1000), Duration.dt(1000))
Binary(Binary.Op.ADD, Value(Duration.dt(1000), Duration()), Value(Duration.dt(1000), Duration()), Duration())매개변수
리턴 유형
sub
qiskit.circuit.classical.expr.sub(left, right, /)
주어진 값에서 뺄셈 표현식 노드를 생성하여 암시적 형변환을 해결하고 필요한 경우 값을 Value 노드로 리프팅합니다.
예제
두 개의 부동 소수점 숫자 빼기:
>>> from qiskit.circuit.classical import expr
>>> expr.sub(5.0, 2.0)
Binary(Binary.Op.SUB, Value(5.0, Float()), Value(2.0, Float()), Float())두 개의 지속 시간을 뺍니다:
>>> from qiskit.circuit import Duration
>>> from qiskit.circuit.classical import expr
>>> expr.add(Duration.dt(1000), Duration.dt(1000))
Binary(Binary.Op.SUB, Value(Duration.dt(1000), Duration()), Value(Duration.dt(1000), Duration()), Duration())매개변수
리턴 유형
mul
qiskit.circuit.classical.expr.mul(left, right)
주어진 값에서 곱셈 표현식 노드를 생성하여 암시적 형변환을 해결하고 필요한 경우 값을 Value 노드로 리프팅합니다.
같은 타입의 숫자 피연산자를 곱하거나 기간 피연산자에 숫자 피연산자를 곱하는 데 사용할 수 있습니다.
예제
두 부동 소수점 숫자의 곱셈:
>>> from qiskit.circuit.classical import expr
>>> expr.mul(5.0, 2.0)
Binary(Binary.Op.MUL, Value(5.0, Float()), Value(2.0, Float()), Float())기간에 부동 소수점을 곱합니다:
>>> from qiskit.circuit import Duration
>>> from qiskit.circuit.classical import expr
>>> expr.mul(Duration.dt(1000), 0.5)
Binary(Binary.Op.MUL, Value(Duration.dt(1000), Duration()), Value(0.5, Float()), Duration())매개변수
리턴 유형
div
qiskit.circuit.classical.expr.div(left, right)
주어진 값으로 나눗셈 표현식 노드를 생성하고, 암시적 형변환을 해결하고, 필요한 경우 값을 Value 노드로 리프팅합니다.
이는 같은 타입의 숫자 피연산자를 나누거나, 숫자 피연산자로 Duration 피연산자를 숫자 피연산자로 나누거나, 두 개의 Duration 피연산자를 나누면 Float.
예제
두 부동 소수점 숫자를 나눕니다:
>>> from qiskit.circuit.classical import expr
>>> expr.div(5.0, 2.0)
Binary(Binary.Op.DIV, Value(5.0, Float()), Value(2.0, Float()), Float())두 개의 기간으로 나눕니다:
>>> from qiskit.circuit import Duration
>>> from qiskit.circuit.classical import expr
>>> expr.div(Duration.dt(10000), Duration.dt(1000))
Binary(Binary.Op.DIV, Value(Duration.dt(10000), Duration()), Value(Duration.dt(1000), Duration()), Float())기간을 실수로 나눕니다:
>>> from qiskit.circuit import Duration
>>> from qiskit.circuit.classical import expr
>>> expr.div(Duration.dt(10000), 12.0)
Binary(Binary.Op.DIV, Value(Duration.dt(10000), Duration()), Value(12.0, types.Float()), Duration())매개변수
리턴 유형
너비에 상관없이 다른 부호 없는 정수를 사용하여 부호 없는 정수 및 비트 단위로 인덱싱할 수 있습니다. 여기에는 인덱스의 대상이 쓰기 가능한 경우 저장 작업이 포함됩니다.
index
qiskit.circuit.classical.expr.index(target, index, /)
주어진 정수를 사용하여 target 에 인덱싱 index, 필요한 경우 값을 Value 노드에 저장합니다.
의 대상으로 사용할 수 있습니다 Store의 대상으로 사용할 수 있습니다( target 자체가 l값인 경우).
예제
리터럴을 사용하여 클래식 레지스터로 색인합니다:
>>> from qiskit.circuit import ClassicalRegister
>>> from qiskit.circuit.classical import expr
>>> expr.index(ClassicalRegister(8, "a"), 3)
Index(Var(ClassicalRegister(8, "a"), Uint(8)), Value(3, Uint(2)), Bool())매개변수
리턴 유형
조건문에 사용할 평등 조건을 지정하는 키스킷의 기존 방법은 두 개의 튜플인 Clbit 또는 ClassicalRegister 와 정수를 사용하는 것입니다. 이는 정확한 동일성 조건을 나타내며 다른 관계를 지정할 수 있는 방법이 없습니다. 도우미 함수 lift_legacy_condition() 는 이 레거시 형식을 새 표현식 구문으로 변환합니다.
lift_legacy_condition
qiskit.circuit.classical.expr.lift_legacy_condition(condition, /)
레거시 2-튜플 동일성 조건을 새로운 스타일로 전환합니다 Expr.
매개변수
condition (tuple[qiskit.circuit.Clbit |qiskit.circuit.ClassicalRegister, int])
리턴 유형
표현 트리 작업하기
표현식 트리의 일반적인 소비자는 트리를 재귀적으로 탐색하고, 잠재적으로 상태적으로 각 노드의 유형에 따라 각 노드에 다르게 동작하기를 원합니다. '무엇을 해야 하는가'의 로직은 상태 저장형일 가능성이 높고 사용자는 자신의 작업을 자유롭게 정의해야 하지만, 각 노드는 '무엇을 실행할 것인가'를 정의하기 때문에 자연스럽게 이중 파견 문제가 발생합니다. 표현식 트리에 대한 기본 방문자 클래스를 제공하여 이 이중 디스패치를 활성화합니다.
ExprVisitor
class qiskit.circuit.classical.expr.ExprVisitor
베이스: Generic[_T_co]
트리 방문자를 위한 기본 클래스 Expr 트리 방문자를 위한 기본 클래스입니다. 서브클래스는 처리할 수 있는 visit_* 메서드 중 어느 것이든 재정의해야 하며, 존재하지 않는 메서드가 호출되지 않도록 구성해야 합니다.
visit_binary
visit_cast
visit_generic
visit_index
visit_stretch
visit_unary
visit_value
visit_var
표현식 트리의 소비자는 방문자를 서브클래싱하고 처리하려는 visit_* 메서드를 재정의해야 합니다. 재정의되지 않은 모든 메서드는 visit_generic()를 호출하며, 재정의하지 않으면 아직 처리하고 있지 않은 새 노드가 표현식 트리에 추가되었는지 알 수 있도록 RuntimeError 을 발생시킵니다.
일반적인 구조가 아닌 표현식의 변수만 검사해야 하는 간단한 방문자의 편의를 위해 반복자 메서드( iter_vars() 가 제공됩니다.
iter_vars
qiskit.circuit.classical.expr.iter_vars(node)
주어진 레벨에 참조된 Var 노드에 대한 이터레이터를 가져옵니다 Expr.
예제
각각의 이름을 인쇄합니다 ClassicalRegister 이름을 인쇄합니다:
from qiskit.circuit import ClassicalRegister
from qiskit.circuit.classical import expr
cr1 = ClassicalRegister(3, "a")
cr2 = ClassicalRegister(3, "b")
for node in expr.iter_vars(expr.bit_and(expr.bit_not(cr1), cr2)):
if isinstance(node.var, ClassicalRegister):
print(node.var.name)매개변수
node (Expr)
리턴 유형
스트레치 변수를 포함한 모든 변수를 반복하려면 반복자 메서드인 iter_identifiers() 가 제공됩니다.
iter_identifiers
qiskit.circuit.classical.expr.iter_identifiers(node)
에 대한 반복자를 가져옵니다 Var 와 Stretch 노드에 대한 이터레이터를 가져옵니다 Expr.
예제
각각의 이름을 인쇄합니다 ClassicalRegister 이름을 인쇄합니다:
from qiskit.circuit import ClassicalRegister
from qiskit.circuit.classical import expr
cr1 = ClassicalRegister(3, "a")
cr2 = ClassicalRegister(3, "b")
for node in expr.iter_vars(expr.bit_and(expr.bit_not(cr1), cr2)):
if isinstance(node.var, ClassicalRegister):
print(node.var.name)표현식의 노드에 대해서만 Var 노드에 대한 이터레이터를 가져옵니다.
매개변수
node (Expr)
리턴 유형
내장된 Python == 연산자를 사용하여 두 표현식을 직접 구조적으로 동일한지 비교할 수 있습니다. 하지만 일반적으로 두 표현식을 조금 더 의미론적으로 비교하여 두 표현식 내부의 노드가 Var 노드가 서로 다른 두 회로 간에 서로 다른 메모리 위치 설명에 바인딩되도록 할 수 있습니다. 이 경우 structurally_equivalent() 를 두 개의 적절한 '키' 함수와 함께 사용하여 비교를 수행할 수 있습니다.
structurally_equivalent
qiskit.circuit.classical.expr.structurally_equivalent(left, right, left_var_key=None, right_var_key=None)
이 두 표현식은 객체에 대한 일부 주요 함수까지 정확히 동일한 트리 구조를 가지고 있나요? Var 객체에 대한 주요 함수까지 정확히 동일한 트리 구조를 가지고 있나요?
다시 말해, 이 두 표현식은 정확히 동일한 트리인가요? Var.var 필드에 적절한 *_var_key 함수를 호출하고 그 출력을 비교하여 동일성을 확인합니다. 이 함수는 a == b 이 b == a 과 같다고 주장하는 것과 같은 의미론적 '등가성'을 허용하지 않으며, 피연산자의 평가 순서에 따라 일반적으로 이러한 진술이 거짓이 될 수 있습니다(전역 상태에 액세스하는 가상의 extern 함수를 생각해 보세요).
주요 함수에 대한 요구 사항은 없지만 출력에 일반적인 __eq__ 메서드가 있어야 한다는 점 외에는 없습니다. 키 함수가 None 을 반환하면 변수가 그대로 사용됩니다.
매개변수
- left (Expr) – 노드
Expr중 하나. - right (Expr) – 다른
Expr노드. - left_var_key (Callable[[Any], Any] | None) – 속성을 비교할 때 출력을 사용해야 하는 콜러블입니다
Var.var어트리뷰트.left에서 주어진 변수에 대해 이 인수가None이거나 그 출력이None인 경우 변수가 그대로 사용됩니다. - right_var_key (Callable[[Any], Any] | None) –
left_var_key와 동일하지만right의 변수에 사용됩니다.
리턴 유형
예제
변수의 리매핑 없이 두 표현식을 비교하여 구조적 동등성을 확인합니다. 이는 서로 다른 Clbit 인스턴스가 다르게 비교되기 때문입니다:
>>> from qiskit.circuit import Clbit
>>> from qiskit.circuit.classical import expr
>>> left_bits = [Clbit(), Clbit()]
>>> right_bits = [Clbit(), Clbit()]
>>> left = expr.logic_and(expr.logic_not(left_bits[0]), left_bits[1])
>>> right = expr.logic_and(expr.logic_not(right_bits[0]), right_bits[1])
>>> expr.structurally_equivalent(left, right)
False동일한 두 표현식을 비교하지만 이번에는 비트를 간단한 인덱스와 연결하는 매핑 함수를 사용합니다:
>>> left_key = {var: i for i, var in enumerate(left_bits)}.get
>>> right_key = {var: i for i, var in enumerate(right_bits)}.get
>>> expr.structurally_equivalent(left, right, left_key, right_key)
True일부 표현식에는 연관된 메모리 위치가 있고 다른 표현식은 순전히 일시적일 수 있습니다. 를 사용하여 is_lvalue() 를 사용하여 표현식에 연관된 메모리 위치가 있는지 확인할 수 있습니다.
is_lvalue
qiskit.circuit.classical.expr.is_lvalue(node, /)
이 표현식을 L값 위치에서 사용할 수 있는지 여부, 즉 메모리에 쓰기 가능한 위치와 같이 잘 정의된 위치가 있는지 여부를 반환합니다.
이 메모리 위치가 쓰기 가능하기 위해서는 l-값이어야 하지만, 그것만으로는 충분하지 않습니다. 이 메모리 위치를 포함하는 더 큰 객체가, 해당 위치에 쓰기를 시도하는 범위에서의 쓰기를 허용하지 않을 수도 있습니다. 하지만 이는 표현식 시스템의 고유한 속성이 아니라, 이를 포함하는 프로그램의 접근 속성일 것입니다.
상수 표현식은 결코 l값이 아닙니다.
예제
리터럴 값은 절대로 l값이 아니며, 상수 1 와 관련된 메모리 위치가 없습니다:
>>> from qiskit.circuit.classical import expr
>>> expr.is_lvalue(expr.lift(2))
FalseVar 노드는 항상 연관된 메모리 위치를 가지고 있기 때문에 항상 L값입니다:
>>> from qiskit.circuit.classical import types
>>> from qiskit.circuit import Clbit
>>> expr.is_lvalue(expr.Var.new("a", types.Bool()))
True
>>> expr.is_lvalue(expr.lift(Clbit()))
True현재 변수에 대한 단항 연산이나 이진 연산은 없지만, 향후에는 일종의 '인덱싱' 연산이 추가되어 l값 표현식을 생성할 수 있을 것으로 보입니다:
>>> a = expr.Var.new("a", types.Uint(8))
>>> b = expr.Var.new("b", types.Uint(8))
>>> expr.is_lvalue(a) and expr.is_lvalue(b)
True
>>> expr.is_lvalue(expr.bit_and(a, b))
False매개변수
node (Expr)
리턴 유형
입력
qiskit.circuit.classical.types
표현
표현식 트리의 타입 시스템은 이 모듈을 통해 노출됩니다. 이것은 본질적으로 모듈의 표현식 시스템과 연결되어 있습니다 expr 모듈의 표현식 시스템과 본질적으로 연결되어 있는데, 대부분의 표현식은 해당 표현식이 작동하는 유형의 컨텍스트를 통해서만 이해할 수 있기 때문입니다.
모든 유형은 추상 베이스 클래스에서 상속합니다:
유형
class qiskit.circuit.classical.types.Type
베이스: object
타입 트리에 있는 모든 노드의 루트 베이스 클래스입니다. 기본 케이스는 절대로 직접 인스턴스화해서는 안 됩니다.
서브클래스는 표현식 표현의 내부 데이터를 형성하며, 키스킷 라이브러리 코드 외부에 더 추가하는 것은 의미가 없습니다.
타입은 변경할 수 없는 객체로 간주해야 하며, 변경해서는 안 됩니다. 다른 객체에서 가져온 Type 를 복사하지 않고 다른 객체에서 가져오는 것은 허용되며, 일반적으로 이 방법이 성능을 위한 최선의 방법입니다. Type 객체는 소량의 데이터로 설계되었으며, 가능한 경우 동일한 데이터의 새 버전을 힙에 할당하기보다는 동일한 데이터 인스턴스를 가리키는 것이 가장 좋습니다. 가능한 경우 클래스 생성자는 이를 용이하게 하기 위해 싱글톤 인스턴스를 반환합니다.
유형은 Bool 유형은 Clbit 과 리터럴 True 및 False 을 나타냅니다 Uint 유형은 ClassicalRegister 과 Python 정수를 나타내고 Float 유형은 Python 부동 소수점, 그리고 Duration 타입은 타이밍 인식 회로 연산에 사용할 지속 시간을 나타냅니다.
부울
유닛
부동
class qiskit.circuit.classical.types.Float
베이스: Type
IEEE-754 배정밀도 부동 소수점 숫자입니다.
향후에는 다른 고정 폭 플로트를 표현하는 데에도 사용될 수 있습니다.
지속 기간
타입 작업
이러한 유형에 대한 몇 가지 추가 기능은 다음 섹션에 설명되어 있습니다. 이들은 대부분 표현식 트리를 조작할 때만 사용할 것으로 예상되며, 사용자 대면 구성 인터페이스를 사용하여 표현식을 작성하는 사용자는 이 기능을 사용할 필요가 없습니다.
형의 부분 순서
유형 시스템에는 부분 순서가 있으며, 은 " 은 의 엄격한 하위 유형"으로 해석됩니다. 부분 순서는 유형 간에 허용되는 명시적 형 변환 연산을 설명하는 지시 그래프의 하위 집합이라는 점에 유의하세요. 부분 순서는 한 유형이 다른 유형으로 직접 무손실 해석될 수 있는 경우를 정의합니다.
하위 유형 관계를 쿼리하는 저수준 인터페이스는 order() 함수입니다.
order
qiskit.circuit.classical.types.order(left, right, /)
두 유형 간의 순서 관계를 열거형 값으로 가져옵니다.
예제
두 가지 비교 Uint 폭이 다른 두 가지 유형을 비교하세요:
>>> from qiskit.circuit.classical import types
>>> types.order(types.Uint(8), types.Uint(16))
Ordering.LESS두 유형 사이에 순서가 없는 두 가지 유형을 비교합니다:
>>> types.order(types.Uint(8), types.Bool())
Ordering.NONE매개변수
리턴 유형
반환 값은 열거형 Ordering 으로, 두 유형 사이에 존재하는 하위 유형 관계를 설명합니다.
순서 지정
class qiskit.circuit.classical.types.Ordering(*values)
베이스: Enum
두 유형 간의 가능한 관계를 나열하는 열거형입니다. 유형은 부분적인 순서만 있으므로 두 유형이 하위 유형 관계가 없을 수도 있습니다.
서브타입/슈퍼타입 관계는 한 타입에서 다른 타입으로 명시적으로 캐스팅할 수 있는지 여부와 동일하지 않다는 점에 유의하세요.
그런 다음 일부 헬퍼 메서드는 이 저수준의 관점에서 정의됩니다 order() 프리미티브:
is_subtype
qiskit.circuit.classical.types.is_subtype(left, right, /, strict=False)
관계가 유지되나요? 두 유형 사이에 순서 관계가 없는 경우 False 이 반환됩니다. strict 이면 평등도 금지됩니다.
예제
한 유형이 다른 유형의 하위 클래스인지 확인합니다:
>>> from qiskit.circuit.classical import types
>>> types.is_subtype(types.Uint(8), types.Uint(16))
True한 유형이 다른 유형의 엄격한 하위 클래스인지 확인합니다:
>>> types.is_subtype(types.Bool(), types.Bool())
True
>>> types.is_subtype(types.Bool(), types.Bool(), strict=True)
False매개변수
리턴 유형
is_supertype
qiskit.circuit.classical.types.is_supertype(left, right, /, strict=False)
관계가 유지되나요? 두 유형 사이에 순서 관계가 없는 경우 False 이 반환됩니다. strict 이면 평등도 금지됩니다.
예제
한 유형이 다른 유형의 슈퍼클래스인지 확인합니다:
>>> from qiskit.circuit.classical import types
>>> types.is_supertype(types.Uint(8), types.Uint(16))
False한 유형이 다른 유형의 엄격한 상위 클래스인지 확인합니다:
>>> types.is_supertype(types.Bool(), types.Bool())
True
>>> types.is_supertype(types.Bool(), types.Bool(), strict=True)
False매개변수
리턴 유형
greater
qiskit.circuit.classical.types.greater(left, right, /)
두 유형 사이에 순서 관계가 있다고 가정하여 두 유형 중 더 큰 것을 가져옵니다. 기술적으로 이것은 반환값이 입력 중 하나이어야 한다는 점에서 두 유형의 '충족' 개념을 약간 제한한 버전입니다. 실제로 유형 시스템에서는 '합계' 유형의 개념이 없으므로 두 유형 사이에 순서가 있는 경우에만 '충족'이 존재하며, 두 유형 중 더 큰 유형과 동일합니다.
리턴
두 가지 유형 중 더 큰 유형입니다.
레이즈
TypeError - 두 유형 사이에 순서 관계가 없는 경우.
매개변수
리턴 유형
예제
두 가지 유형 중 더 큰 것을 찾습니다 Uint 유형 중 더 큰 것을 찾습니다:
>>> from qiskit.circuit.classical import types
>>> types.greater(types.Uint(8), types.Uint(16))
types.Uint(16)타입 간 캐스팅
한 유형의 값을 다른 유형으로 캐스팅해야 하는 경우가 많습니다. 이를 위한 캐스팅 규칙은 모듈에 내장되어 있습니다 types 모듈에 내장되어 있습니다. 다음을 사용하여 캐스팅 종류를 쿼리할 수 있습니다 cast_kind():
cast_kind
qiskit.circuit.classical.types.cast_kind(from_, to_, /)
왼쪽 유형에서 오른쪽 유형으로 이동하는 데 필요한 캐스트의 종류를 결정합니다.
예제
>>> from qiskit.circuit.classical import types
>>> types.cast_kind(types.Bool(), types.Bool())
<CastKind.EQUAL: 1>
>>> types.cast_kind(types.Uint(8), types.Bool())
<CastKind.IMPLICIT: 2>
>>> types.cast_kind(types.Bool(), types.Uint(8))
<CastKind.LOSSLESS: 3>
>>> types.cast_kind(types.Uint(16), types.Uint(8))
<CastKind.DANGEROUS: 4>매개변수
리턴 유형
이 함수의 반환 값은 왼쪽 유형에서 오른쪽 유형으로 허용되는 형변환 유형을 설명하는 열거형입니다.
와 Float 와 Uint 사이의 캐스트는 어느 방향이든 위험한 것으로 간주되므로 명시적으로 수행해야 합니다.