qsharp-lang 1.10.2-dev → 1.10.3-dev

package/docs/Std.Diagnostics/CheckAllZero.md

@@ -0,0 +1,38 @@
+---
+uid: Qdk.Std.Diagnostics.CheckAllZero
+title: CheckAllZero operation
+description: "Q# CheckAllZero operation: Checks whether all qubits in the provided array are in the \|0⟩ state. Returns true if they are."
+ms.date: 11/15/2024
+ms.topic: managed-reference
+qsharp.kind: operation
+qsharp.package: __Std__
+qsharp.namespace: Std.Diagnostics
+qsharp.name: CheckAllZero
+qsharp.summary: "Checks whether all qubits in the provided array are in the \|0⟩ state. Returns true if they are."
+---
+
+# CheckAllZero operation
+
+Fully qualified name: Std.Diagnostics.CheckAllZero
+
+```qsharp
+operation CheckAllZero(qubits : Qubit[]) : Bool
+```
+
+## Summary
+Checks whether all qubits in the provided array are in the |0⟩ state. Returns true if they are.
+
+## Description
+This operation checks whether all qubits in the provided array are in the |0⟩ state. It will return true only
+if all qubits are deterministically in the |0⟩ state, and will return false otherwise. This operation
+does not change the state of the qubits.
+
+## Input
+### qubits
+The qubits to check.
+## Output
+True if all qubits are in the |0⟩ state, false otherwise.
+
+## Remarks
+This operation is useful for checking whether a qubit is in the |0⟩ state during simulation. It is not possible to check
+this on hardware without measuring the qubit, which could change the state.

package/docs/Std.Diagnostics/CheckOperationsAreEqual.md

@@ -0,0 +1,49 @@
+---
+uid: Qdk.Std.Diagnostics.CheckOperationsAreEqual
+title: CheckOperationsAreEqual operation
+description: "Q# CheckOperationsAreEqual operation: Given two operations, checks that they act identically for all input states."
+ms.date: 11/15/2024
+ms.topic: managed-reference
+qsharp.kind: operation
+qsharp.package: __Std__
+qsharp.namespace: Std.Diagnostics
+qsharp.name: CheckOperationsAreEqual
+qsharp.summary: "Given two operations, checks that they act identically for all input states."
+---
+
+# CheckOperationsAreEqual operation
+
+Fully qualified name: Std.Diagnostics.CheckOperationsAreEqual
+
+```qsharp
+operation CheckOperationsAreEqual(nQubits : Int, actual : (Qubit[] => Unit), expected : (Qubit[] => Unit is Adj)) : Bool
+```
+
+## Summary
+Given two operations, checks that they act identically for all input states.
+
+## Description
+This check is implemented by using the Choi–Jamiołkowski isomorphism to reduce
+this check to a check on two entangled registers.
+Thus, this operation needs only a single call to each operation being tested,
+but requires twice as many qubits to be allocated.
+This check can be used to ensure, for instance, that an optimized version of an
+operation acts identically to its naïve implementation, or that an operation
+which acts on a range of non-quantum inputs agrees with known cases.
+
+## Remarks
+This operation requires that the operation modeling the expected behavior is
+adjointable, so that the inverse can be performed on the target register alone.
+Formally, one can specify a transpose operation, which relaxes this requirement,
+but the transpose operation is not in general physically realizable for arbitrary
+quantum operations and thus is not included here as an option.
+
+## Input
+### nQubits
+Number of qubits to pass to each operation.
+### actual
+Operation to be tested.
+### expected
+Operation defining the expected behavior for the operation under test.
+## Output
+True if operations are equal, false otherwise.

package/docs/Std.Diagnostics/CheckZero.md

@@ -0,0 +1,38 @@
+---
+uid: Qdk.Std.Diagnostics.CheckZero
+title: CheckZero operation
+description: "Q# CheckZero operation: Checks whether a qubit is in the \|0⟩ state, returning true if it is."
+ms.date: 11/15/2024
+ms.topic: managed-reference
+qsharp.kind: operation
+qsharp.package: __Std__
+qsharp.namespace: Std.Diagnostics
+qsharp.name: CheckZero
+qsharp.summary: "Checks whether a qubit is in the \|0⟩ state, returning true if it is."
+---
+
+# CheckZero operation
+
+Fully qualified name: Std.Diagnostics.CheckZero
+
+```qsharp
+operation CheckZero(qubit : Qubit) : Bool
+```
+
+## Summary
+Checks whether a qubit is in the |0⟩ state, returning true if it is.
+
+## Description
+This operation checks whether a qubit is in the |0⟩ state. It will return true only
+if the qubit is deterministically in the |0⟩ state, and will return false otherwise. This operation
+does not change the state of the qubit.
+
+## Input
+### qubit
+The qubit to check.
+## Output
+True if the qubit is in the |0⟩ state, false otherwise.
+
+## Remarks
+This operation is useful for checking whether a qubit is in the |0⟩ state during simulation. It is not possible to check
+this on hardware without measuring the qubit, which could change the state.

package/docs/Std.Diagnostics/ConfigurePauliNoise.md

@@ -0,0 +1,38 @@
+---
+uid: Qdk.Std.Diagnostics.ConfigurePauliNoise
+title: ConfigurePauliNoise function
+description: "Q# ConfigurePauliNoise function: Configures Pauli noise for simulation."
+ms.date: 11/15/2024
+ms.topic: managed-reference
+qsharp.kind: function
+qsharp.package: __Std__
+qsharp.namespace: Std.Diagnostics
+qsharp.name: ConfigurePauliNoise
+qsharp.summary: "Configures Pauli noise for simulation."
+---
+
+# ConfigurePauliNoise function
+
+Fully qualified name: Std.Diagnostics.ConfigurePauliNoise
+
+```qsharp
+function ConfigurePauliNoise(px : Double, py : Double, pz : Double) : Unit
+```
+
+## Summary
+Configures Pauli noise for simulation.
+
+## Description
+This function configures Pauli noise for simulation. Parameters represent
+probabilities of applying X, Y, and Z gates and must add up to at most 1.0.
+Noise is applied after each gate and before each measurement in the simulator
+backend. Decompositions may affect the number of times noise is applied.
+Use 0.0 for all parameters to simulate without noise.
+
+## Input
+### px
+Probability of applying X gate.
+### py
+Probability of applying Y gate.
+### pz
+Probability of applying Z gate.

package/docs/Std.Diagnostics/DepolarizingNoise.md

@@ -0,0 +1,23 @@
+---
+uid: Qdk.Std.Diagnostics.DepolarizingNoise
+title: DepolarizingNoise function
+description: "Q# DepolarizingNoise function: The depolarizing noise with probability `p`."
+ms.date: 11/15/2024
+ms.topic: managed-reference
+qsharp.kind: function
+qsharp.package: __Std__
+qsharp.namespace: Std.Diagnostics
+qsharp.name: DepolarizingNoise
+qsharp.summary: "The depolarizing noise with probability `p`."
+---
+
+# DepolarizingNoise function
+
+Fully qualified name: Std.Diagnostics.DepolarizingNoise
+
+```qsharp
+function DepolarizingNoise(p : Double) : (Double, Double, Double)
+```
+
+## Summary
+ The depolarizing noise with probability `p`.

package/docs/Std.Diagnostics/DumpMachine.md

@@ -1,7 +1,8 @@
 ---
 uid: Qdk.Std.Diagnostics.DumpMachine
 title: DumpMachine function
-ms.date: 11/01/2024 12:00:00 AM
+description: "Q# DumpMachine function: Dumps the current target machine's status."
+ms.date: 11/15/2024
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.package: __Std__

package/docs/Std.Diagnostics/DumpOperation.md

@@ -1,7 +1,8 @@
 ---
 uid: Qdk.Std.Diagnostics.DumpOperation
 title: DumpOperation operation
-ms.date: 11/01/2024 12:00:00 AM
+description: "Q# DumpOperation operation: Given an operation, dumps the matrix representation of the operation action on the given number of qubits."
+ms.date: 11/15/2024
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__
@@ -31,7 +32,7 @@ The operation that is to be diagnosed.
 ## Remarks
 When run on the sparse-state simulator, the following snippet
 will output the matrix
-$\left(\begin{matrix} 0.0 & 0.707 \\\\ 0.707 & 0.0\end{matrix}\right)$:
+$\left(\begin{matrix} 0.707 & 0.707 \\\\ 0.707 & -0.707\end{matrix}\right)$:
 
 ```qsharp
 operation DumpH() : Unit {

package/docs/Std.Diagnostics/DumpRegister.md

@@ -1,7 +1,8 @@
 ---
 uid: Qdk.Std.Diagnostics.DumpRegister
 title: DumpRegister function
-ms.date: 11/01/2024 12:00:00 AM
+description: "Q# DumpRegister function: Dumps the current target machine's status associated with the given qubits."
+ms.date: 11/15/2024
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.package: __Std__

package/docs/Std.Diagnostics/Fact.md

@@ -1,7 +1,8 @@
 ---
 uid: Qdk.Std.Diagnostics.Fact
 title: Fact function
-ms.date: 11/01/2024 12:00:00 AM
+description: "Q# Fact function: Checks whether a given condition is true, failing with a message if it is not."
+ms.date: 11/15/2024
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.package: __Std__

package/docs/Std.Diagnostics/NoNoise.md

@@ -0,0 +1,23 @@
+---
+uid: Qdk.Std.Diagnostics.NoNoise
+title: NoNoise function
+description: "Q# NoNoise function: No noise for noiseless operation."
+ms.date: 11/15/2024
+ms.topic: managed-reference
+qsharp.kind: function
+qsharp.package: __Std__
+qsharp.namespace: Std.Diagnostics
+qsharp.name: NoNoise
+qsharp.summary: "No noise for noiseless operation."
+---
+
+# NoNoise function
+
+Fully qualified name: Std.Diagnostics.NoNoise
+
+```qsharp
+function NoNoise() : (Double, Double, Double)
+```
+
+## Summary
+ No noise for noiseless operation.

package/docs/Std.Diagnostics/PhaseFlipNoise.md

@@ -0,0 +1,23 @@
+---
+uid: Qdk.Std.Diagnostics.PhaseFlipNoise
+title: PhaseFlipNoise function
+description: "Q# PhaseFlipNoise function: The phase flip noise with probability `p`."
+ms.date: 11/15/2024
+ms.topic: managed-reference
+qsharp.kind: function
+qsharp.package: __Std__
+qsharp.namespace: Std.Diagnostics
+qsharp.name: PhaseFlipNoise
+qsharp.summary: "The phase flip noise with probability `p`."
+---
+
+# PhaseFlipNoise function
+
+Fully qualified name: Std.Diagnostics.PhaseFlipNoise
+
+```qsharp
+function PhaseFlipNoise(p : Double) : (Double, Double, Double)
+```
+
+## Summary
+ The phase flip noise with probability `p`.

package/docs/Std.Diagnostics/StartCountingFunction.md

@@ -0,0 +1,44 @@
+---
+uid: Qdk.Std.Diagnostics.StartCountingFunction
+title: StartCountingFunction operation
+description: "Q# StartCountingFunction operation: Starts counting the number of times the given function is called. Fails if the function is already being counted."
+ms.date: 11/15/2024
+ms.topic: managed-reference
+qsharp.kind: operation
+qsharp.package: __Std__
+qsharp.namespace: Std.Diagnostics
+qsharp.name: StartCountingFunction
+qsharp.summary: "Starts counting the number of times the given function is called. Fails if the function is already being counted."
+---
+
+# StartCountingFunction operation
+
+Fully qualified name: Std.Diagnostics.StartCountingFunction
+
+```qsharp
+operation StartCountingFunction<'In, 'Out>(callable : ('In -> 'Out)) : Unit
+```
+
+## Summary
+Starts counting the number of times the given function is called. Fails if the function is already being counted.
+
+## Description
+This operation allows you to count the number of times a given function is called. If the given function is already
+being counted, calling `StartCountingFunction` again will trigger a runtime failure.
+
+## Input
+### callable
+The function to be counted.
+
+## Remarks
+When counting lambdas, the symbol the lambda is bound to is used to identify the function and it is counted as a separate function. For example,
+```qsharp
+let myFunc = i -> AbsI(i);
+StartCountingFunction(myFunc);
+```
+Will count specifically calls to `myFunc` and not `AbsI`. By contrast, the following code will count calls to `AbsI` itself:
+```qsharp
+let myFunc = AbsI;
+StartCountingFunction(myFunc);
+```
+This is because this code does not define a lambda and instead just creates a binding to `AbsI` directly.

package/docs/Std.Diagnostics/StartCountingOperation.md

@@ -0,0 +1,53 @@
+---
+uid: Qdk.Std.Diagnostics.StartCountingOperation
+title: StartCountingOperation operation
+description: "Q# StartCountingOperation operation: Starts counting the number of times the given operation is called. Fails if the operation is already being counted."
+ms.date: 11/15/2024
+ms.topic: managed-reference
+qsharp.kind: operation
+qsharp.package: __Std__
+qsharp.namespace: Std.Diagnostics
+qsharp.name: StartCountingOperation
+qsharp.summary: "Starts counting the number of times the given operation is called. Fails if the operation is already being counted."
+---
+
+# StartCountingOperation operation
+
+Fully qualified name: Std.Diagnostics.StartCountingOperation
+
+```qsharp
+operation StartCountingOperation<'In, 'Out>(callable : ('In => 'Out)) : Unit
+```
+
+## Summary
+Starts counting the number of times the given operation is called. Fails if the operation is already being counted.
+
+## Description
+This operation allows you to count the number of times a given operation is called. If the given operation is already
+being counted, calling `StartCountingOperation` again will trigger a runtime failure. Counting is based on the specific
+specialization of the operation invoked, so `X` and `Adjoint X` are counted separately.
+Likewise `Controlled X`, `CNOT`, and `CX` are independent operations that are counted separately, as are `Controlled X`
+and `Controlled Adjoint X`.
+
+## Input
+### callable
+The operation to be counted.
+
+## Remarks
+Counting operation calls requires specific care in what operation is passed as input. For example, `StartCountingOperation(H)` will
+count only the number of times `H` is called, while `StartCountingOperation(Adjoint H)` will count only the number of times `Adjoint H` is called, even
+though `H` is self-adjoint. This is due to how the execution treats the invocation of these operations as distinct by their specialization.
+In the same way, `StartCountingOperation(Controlled X)` will count only the number of times `Controlled X` is called, while
+`StartCountingOperation(CNOT)` will count only the number of times `CNOT` is called.
+
+When counting lambdas, the symbol the lambda is bound to is used to identify the operation and it is counted as a separate operation. For example,
+```qsharp
+let myOp = q => H(q);
+StartCountingOperation(myOp);
+```
+Will count specifically calls to `myOp` and not `H`. By contrast, the following code will count calls to `H` itself:
+```qsharp
+let myOp = H;
+StartCountingOperation(myOp);
+```
+This is because this code does not define a lambda and instead just creates a binding to `H` directly.

package/docs/Std.Diagnostics/StartCountingQubits.md

@@ -0,0 +1,39 @@
+---
+uid: Qdk.Std.Diagnostics.StartCountingQubits
+title: StartCountingQubits operation
+description: "Q# StartCountingQubits operation: Starts counting the number of qubits allocated. Fails if qubits are already being counted."
+ms.date: 11/15/2024
+ms.topic: managed-reference
+qsharp.kind: operation
+qsharp.package: __Std__
+qsharp.namespace: Std.Diagnostics
+qsharp.name: StartCountingQubits
+qsharp.summary: "Starts counting the number of qubits allocated. Fails if qubits are already being counted."
+---
+
+# StartCountingQubits operation
+
+Fully qualified name: Std.Diagnostics.StartCountingQubits
+
+```qsharp
+operation StartCountingQubits() : Unit
+```
+
+## Summary
+Starts counting the number of qubits allocated. Fails if qubits are already being counted.
+
+## Description
+This operation allows you to count the number of qubits allocated until `StopCountingQubits` is called.
+The counter is incremented only when a new unique qubit is allocated, so reusing the same qubit multiple times
+across separate allocations does not increment the counter.
+
+## Remarks
+This operation is useful for tracking the number of unique qubits allocated in a given scope. Along with
+`StopCountingQubits`, it can be used to verify that a given operation does not allocate more qubits than
+expected. For example,
+```qsharp
+StartCountingQubits();
+testOperation();
+let qubitsAllocated = StopCountingQubits();
+Fact(qubitsAllocated <= 4, "Operation should not allocate more than 4 qubits.");
+```

package/docs/Std.Diagnostics/StopCountingFunction.md

@@ -0,0 +1,34 @@
+---
+uid: Qdk.Std.Diagnostics.StopCountingFunction
+title: StopCountingFunction operation
+description: "Q# StopCountingFunction operation: Stops counting the number of times the given function is called and returns the count. Fails if the function was not being counted."
+ms.date: 11/15/2024
+ms.topic: managed-reference
+qsharp.kind: operation
+qsharp.package: __Std__
+qsharp.namespace: Std.Diagnostics
+qsharp.name: StopCountingFunction
+qsharp.summary: "Stops counting the number of times the given function is called and returns the count. Fails if the function was not being counted."
+---
+
+# StopCountingFunction operation
+
+Fully qualified name: Std.Diagnostics.StopCountingFunction
+
+```qsharp
+operation StopCountingFunction<'In, 'Out>(callable : ('In -> 'Out)) : Int
+```
+
+## Summary
+Stops counting the number of times the given function is called and returns the count. Fails
+if the function was not being counted.
+
+## Description
+This operation allows you to stop counting the number of times a given function is called and returns the count.
+If the function was not being counted, it triggers a runtime failure.
+
+## Input
+### callable
+The function whose count will be returned.
+## Output
+The number of times the function was called since the last call to `StartCountingFunction`.

package/docs/Std.Diagnostics/StopCountingOperation.md

@@ -0,0 +1,34 @@
+---
+uid: Qdk.Std.Diagnostics.StopCountingOperation
+title: StopCountingOperation operation
+description: "Q# StopCountingOperation operation: Stops counting the number of times the given operation is called and returns the count. Fails if the operation was not being counted."
+ms.date: 11/15/2024
+ms.topic: managed-reference
+qsharp.kind: operation
+qsharp.package: __Std__
+qsharp.namespace: Std.Diagnostics
+qsharp.name: StopCountingOperation
+qsharp.summary: "Stops counting the number of times the given operation is called and returns the count. Fails if the operation was not being counted."
+---
+
+# StopCountingOperation operation
+
+Fully qualified name: Std.Diagnostics.StopCountingOperation
+
+```qsharp
+operation StopCountingOperation<'In, 'Out>(callable : ('In => 'Out)) : Int
+```
+
+## Summary
+Stops counting the number of times the given operation is called and returns the count. Fails
+if the operation was not being counted.
+
+## Description
+This operation allows you to stop counting the number of times a given operation is called and returns the count.
+If the operation was not being counted, it triggers a runtime failure.
+
+## Input
+### callable
+The operation whose count will be returned.
+## Output
+The number of times the operation was called since the last call to `StartCountingOperation`.

package/docs/Std.Diagnostics/StopCountingQubits.md

@@ -0,0 +1,30 @@
+---
+uid: Qdk.Std.Diagnostics.StopCountingQubits
+title: StopCountingQubits operation
+description: "Q# StopCountingQubits operation: Stops counting the number of qubits allocated and returns the count. Fails if the qubits were not being counted."
+ms.date: 11/15/2024
+ms.topic: managed-reference
+qsharp.kind: operation
+qsharp.package: __Std__
+qsharp.namespace: Std.Diagnostics
+qsharp.name: StopCountingQubits
+qsharp.summary: "Stops counting the number of qubits allocated and returns the count. Fails if the qubits were not being counted."
+---
+
+# StopCountingQubits operation
+
+Fully qualified name: Std.Diagnostics.StopCountingQubits
+
+```qsharp
+operation StopCountingQubits() : Int
+```
+
+## Summary
+Stops counting the number of qubits allocated and returns the count. Fails if the qubits were not being counted.
+
+## Description
+This operation allows you to stop counting the number of qubits allocated and returns the count since the
+last call to `StartCountingQubits`. If the qubits were not being counted, it triggers a runtime failure.
+
+## Output
+The number of unique qubits allocated since the last call to `StartCountingQubits`.

package/docs/Std.Diagnostics/index.md

@@ -0,0 +1,35 @@
+---
+uid: Qdk.Std.Diagnostics-toc
+title: Std.Diagnostics namespace
+description: Table of contents for the Q# Diagnostics namespace
+author: {AUTHOR}
+ms.author: {MS_AUTHOR}
+ms.date: 11/15/2024
+ms.topic: landing-page
+---
+
+# Std.Diagnostics
+
+The Std.Diagnostics namespace contains the following items:
+
+| Name | Description |
+|------|-------------|
+| [ApplyIdleNoise](xref:Qdk.Std.Diagnostics.ApplyIdleNoise) | Applies configured noise to a qubit. |
+| [BitFlipNoise](xref:Qdk.Std.Diagnostics.BitFlipNoise) | The bit flip noise with probability `p`. |
+| [CheckAllZero](xref:Qdk.Std.Diagnostics.CheckAllZero) | Checks whether all qubits in the provided array are in the \|0⟩ state. Returns true if they are. |
+| [CheckOperationsAreEqual](xref:Qdk.Std.Diagnostics.CheckOperationsAreEqual) | Given two operations, checks that they act identically for all input states. |
+| [CheckZero](xref:Qdk.Std.Diagnostics.CheckZero) | Checks whether a qubit is in the \|0⟩ state, returning true if it is. |
+| [ConfigurePauliNoise](xref:Qdk.Std.Diagnostics.ConfigurePauliNoise) | Configures Pauli noise for simulation. |
+| [DepolarizingNoise](xref:Qdk.Std.Diagnostics.DepolarizingNoise) | The depolarizing noise with probability `p`. |
+| [DumpMachine](xref:Qdk.Std.Diagnostics.DumpMachine) | Dumps the current target machine's status. |
+| [DumpOperation](xref:Qdk.Std.Diagnostics.DumpOperation) | Given an operation, dumps the matrix representation of the operation action on the given number of qubits. |
+| [DumpRegister](xref:Qdk.Std.Diagnostics.DumpRegister) | Dumps the current target machine's status associated with the given qubits. |
+| [Fact](xref:Qdk.Std.Diagnostics.Fact) | Checks whether a given condition is true, failing with a message if it is not. |
+| [NoNoise](xref:Qdk.Std.Diagnostics.NoNoise) | No noise for noiseless operation. |
+| [PhaseFlipNoise](xref:Qdk.Std.Diagnostics.PhaseFlipNoise) | The phase flip noise with probability `p`. |
+| [StartCountingFunction](xref:Qdk.Std.Diagnostics.StartCountingFunction) | Starts counting the number of times the given function is called. Fails if the function is already being counted. |
+| [StartCountingOperation](xref:Qdk.Std.Diagnostics.StartCountingOperation) | Starts counting the number of times the given operation is called. Fails if the operation is already being counted. |
+| [StartCountingQubits](xref:Qdk.Std.Diagnostics.StartCountingQubits) | Starts counting the number of qubits allocated. Fails if qubits are already being counted. |
+| [StopCountingFunction](xref:Qdk.Std.Diagnostics.StopCountingFunction) | Stops counting the number of times the given function is called and returns the count. Fails if the function was not being counted. |
+| [StopCountingOperation](xref:Qdk.Std.Diagnostics.StopCountingOperation) | Stops counting the number of times the given operation is called and returns the count. Fails if the operation was not being counted. |
+| [StopCountingQubits](xref:Qdk.Std.Diagnostics.StopCountingQubits) | Stops counting the number of qubits allocated and returns the count. Fails if the qubits were not being counted. |

package/docs/Std.Intrinsic/AND.md

@@ -1,13 +1,14 @@
 ---
 uid: Qdk.Std.Intrinsic.AND
 title: AND operation
-ms.date: 11/01/2024 12:00:00 AM
+description: "Q# AND operation: Applies the AND gate that is more efficient for use with decomposition of multi-controlled operations. Note that target qubit must be in \|0⟩ state."
+ms.date: 11/15/2024
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__
 qsharp.namespace: Std.Intrinsic
 qsharp.name: AND
-qsharp.summary: "Applies the AND gate that is more efficient for use with decomposition of multi-controlled operations. Note that target qubit must be in |0⟩ state."
+qsharp.summary: "Applies the AND gate that is more efficient for use with decomposition of multi-controlled operations. Note that target qubit must be in \|0⟩ state."
 ---
 
 # AND operation

package/docs/Std.Intrinsic/CCNOT.md

@@ -1,7 +1,8 @@
 ---
 uid: Qdk.Std.Intrinsic.CCNOT
 title: CCNOT operation
-ms.date: 11/01/2024 12:00:00 AM
+description: "Q# CCNOT operation: Applies the doubly controlled–NOT (CCNOT) gate to three qubits."
+ms.date: 11/15/2024
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

package/docs/Std.Intrinsic/CNOT.md

@@ -1,7 +1,8 @@
 ---
 uid: Qdk.Std.Intrinsic.CNOT
 title: CNOT operation
-ms.date: 11/01/2024 12:00:00 AM
+description: "Q# CNOT operation: Applies the controlled-NOT (CNOT) gate to a pair of qubits."
+ms.date: 11/15/2024
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

package/docs/Std.Intrinsic/Exp.md

@@ -1,7 +1,8 @@
 ---
 uid: Qdk.Std.Intrinsic.Exp
 title: Exp operation
-ms.date: 11/01/2024 12:00:00 AM
+description: "Q# Exp operation: Applies the exponential of a multi-qubit Pauli operator."
+ms.date: 11/15/2024
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

package/docs/Std.Intrinsic/H.md

@@ -1,7 +1,8 @@
 ---
 uid: Qdk.Std.Intrinsic.H
 title: H operation
-ms.date: 11/01/2024 12:00:00 AM
+description: "Q# H operation: Applies the Hadamard transformation to a single qubit."
+ms.date: 11/15/2024
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

package/docs/Std.Intrinsic/I.md

@@ -1,7 +1,8 @@
 ---
 uid: Qdk.Std.Intrinsic.I
 title: I operation
-ms.date: 11/01/2024 12:00:00 AM
+description: "Q# I operation: Performs the identity operation (no-op) on a single qubit."
+ms.date: 11/15/2024
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

package/docs/Std.Intrinsic/M.md

@@ -1,7 +1,8 @@
 ---
 uid: Qdk.Std.Intrinsic.M
 title: M operation
-ms.date: 11/01/2024 12:00:00 AM
+description: "Q# M operation: Performs a measurement of a single qubit in the Pauli _Z_ basis."
+ms.date: 11/15/2024
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

package/docs/Std.Intrinsic/Measure.md

@@ -1,7 +1,8 @@
 ---
 uid: Qdk.Std.Intrinsic.Measure
 title: Measure operation
-ms.date: 11/01/2024 12:00:00 AM
+description: "Q# Measure operation: Performs a joint measurement of one or more qubits in the specified Pauli bases.  If the basis array and qubit array are different lengths, then the operation will fail."
+ms.date: 11/15/2024
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__