sQUlearn · MoritzWillmann · Aug 20, 2025 · Aug 14, 2024 · Aug 20, 2024 · Aug 21, 2024
diff --git a/docs/user_guide/encoding_circuits.rst b/docs/user_guide/encoding_circuits.rst
@@ -19,7 +19,7 @@ each gate is applied to all qubits.
 The package facilitate a fully automated pruning algorithm to remove redundant parameters and
 enables the automatic differentiation of arbitrary derivative.
 
-The following functions and classes are are accessible via :class:`squlearn.encoding_circuit`.
+The following functions and classes are accessible via :class:`squlearn.encoding_circuit`.
 
 Implemented Quantum Encoding Circuits
 --------------------------------------
@@ -47,8 +47,8 @@ Feel free to contribute to sQUlearn by adding your own encoding circuits in a Pu
 .. jupyter-execute::
 
    from squlearn.encoding_circuit import HubregtsenEncodingCircuit
-   pqc = HubregtsenEncodingCircuit(num_qubits=4, num_features=2, num_layers=2)
-   pqc.draw(output="mpl")
+   pqc = HubregtsenEncodingCircuit(num_qubits=4, num_layers=2)
+   pqc.draw(output="mpl", num_features=2)
 
 
 Combining Quantum Encoding Circuits
@@ -67,11 +67,11 @@ equal to the sum of the parameters in the two original encoding circuits.
 .. jupyter-execute::
 
    from squlearn.encoding_circuit import HubregtsenEncodingCircuit, ChebyshevPQC
-   fm1 = HubregtsenEncodingCircuit(num_qubits=4, num_features=2, num_layers=1, closed=False)
-   fm2 = ChebyshevPQC(num_qubits=4, num_features=3, num_layers=1)
+   fm1 = HubregtsenEncodingCircuit(num_qubits=4, num_layers=1, closed=False)
+   fm2 = ChebyshevPQC(num_qubits=4, num_layers=1)
    # Combining both encoding circuits
    fm3 = fm1 + fm2
-   fm3.draw(output="mpl")
+   fm3.draw(output="mpl", num_features=2)
 
 
 Wrapping Qiskit Encoding Circuits
@@ -108,14 +108,14 @@ the :class:`LayeredEncodingCircuit` class.
 
    from squlearn.encoding_circuit import LayeredEncodingCircuit
    from squlearn.encoding_circuit.layered_encoding_circuit import Layer
-   encoding_circuit = LayeredEncodingCircuit(num_qubits=4,num_features=2)
+   encoding_circuit = LayeredEncodingCircuit(num_qubits=4)
    encoding_circuit.H()
    layer = Layer(encoding_circuit)
    layer.Rz("x")
    layer.Ry("p")
    layer.cx_entangling("NN")
-   encoding_circuit.add_layer(layer,num_layers=3)
-   encoding_circuit.draw(output="mpl")
+   encoding_circuit.add_layer(layer, num_layers=3)
+   encoding_circuit.draw(output="mpl", num_features=2)
 
 
 **Example: Create your custom layered encoding circuit from a string**
@@ -124,9 +124,9 @@ the :class:`LayeredEncodingCircuit` class.
 
    from squlearn.encoding_circuit import LayeredEncodingCircuit
    encoding_circuit = LayeredEncodingCircuit.from_string(
-      "Ry(p)-3[Rx(p,x;=y*np.arccos(x),{y,x})-crz(p)]-Ry(p)", num_qubits=4, num_features=1, num_layers=2
+      "Ry(p)-3[Rx(p,x;=y*np.arccos(x),{y,x})-crz(p)]-Ry(p)", num_qubits=4, num_layers=2
    )
-   encoding_circuit.draw(output="mpl")
+   encoding_circuit.draw(output="mpl", num_features=1)
 
 
 Pruning of Quantum Encoding Circuits
@@ -152,6 +152,7 @@ sQUlearn features a fully automated pruning algorithm which can be used by calli
    from squlearn.encoding_circuit import LayeredEncodingCircuit, automated_pruning
    from squlearn.util import Executor
    encoding_circuit = LayeredEncodingCircuit.from_string("Rz(p)-Ry(p)-Z-Ry(p)-Rz(p)", num_qubits=2, num_features=0)
+   encoding_circuit._build_layered_pqc(0)
    pruned_encoding_circuit = automated_pruning(encoding_circuit, Executor())
    pruned_encoding_circuit.draw(output="mpl")
 
@@ -184,8 +185,8 @@ is utilized for the arithmetic operations of the derivatives.
 .. jupyter-execute::
 
    from squlearn.encoding_circuit import HubregtsenEncodingCircuit, EncodingCircuitDerivatives
-   fm = HubregtsenEncodingCircuit(num_qubits=2, num_features=2, num_layers=2)
-   fm_deriv = EncodingCircuitDerivatives(fm)
+   fm = HubregtsenEncodingCircuit(num_qubits=2, num_layers=2)
+   fm_deriv = EncodingCircuitDerivatives(fm, num_features=2)
    # From String (gradient of the parameter vector)
    grad_from_string = fm_deriv.get_derivative("dp")
    # From Tuple (second order derivative of the parameter vector; equal to the Hessian)
@@ -202,8 +203,7 @@ To transpile a quantum encoding circuit, you can leverage the functionality prov
 :class:`TranspiledEncodingCircuit` class. By utilizing this class, you can input an existing
 quantum encoding circuit and have its circuit transpiled according to the specified backend and
 transpiler settings, which are the same settings used in Qiskit.
-The transpiled encoding circuit is internally employed in the QNN program and projected kernels,
-where it is employed internally.
+The transpiled encoding circuit is internally employed in the QNN program and projected kernels.
 
 **Example: Transpile a existing Encoding Circuit to a fake backend**
 
@@ -212,6 +212,11 @@ where it is employed internally.
    from squlearn.encoding_circuit import TranspiledEncodingCircuit,ChebyshevRx
    from qiskit_ibm_runtime.fake_provider import FakeManilaV2
 
-   fm = TranspiledEncodingCircuit(ChebyshevRx(3,1),backend=FakeManilaV2(),initial_layout=[0,1,4])
-   fm.draw(output="mpl")
+   fm = TranspiledEncodingCircuit(
+      ChebyshevRx(3,1),
+      backend=FakeManilaV2(),
+      num_features=1,
+      initial_layout=[0,1,4]
+   )
+   fm.draw(output="mpl", num_features=1)
 
diff --git a/docs/user_guide/executor.rst b/docs/user_guide/executor.rst
@@ -370,7 +370,7 @@ We set up a small :class:`QNNRegressor <squlearn.qnn.QNNRegressor>` example and
    backends = [FakeBelemV2(), FakeAthensV2(), FakeManilaV2()]
    executor = Executor(backends, shots=10000)
    qnn = QNNRegressor(
-       ChebyshevPQC(2, 1),
+       ChebyshevPQC(2),
        SummedPaulis(2),
        executor,
        SquaredLoss(),
@@ -392,15 +392,15 @@ the mode is switched to ``"speed"``. The :class:`Executor <squlearn.Executor>` i
    from squlearn import Executor
    from qiskit_ibm_runtime import QiskitRuntimeService
    from squlearn.encoding_circuit import ChebyshevRx
-   from squlearn.kernel import FidelityKernel, QKRR
+   from squlearn.kernel.lowlevel_kernel import FidelityKernel, QKRR
 
    # Executor is initialized with a service, and considers all available backends
    # (except simulators)
    service = QiskitRuntimeService(channel="ibm_quantum", token="INSERT_YOUR_TOKEN_HERE")
    executor = Executor(service, auto_backend_mode="speed")
 
    # Create a QKRR model with a FidelityKernel and the ChebyshevRx encoding circuit
-   qkrr = QKRR(FidelityKernel(ChebyshevRx(4,1),executor))
+   qkrr = QKRR(FidelityKernel(ChebyshevRx(4),executor))
 
    # Backend is automatically selected based on the smallest queue
    # All the following functions will be executed on the selected backend

diff --git a/docs/user_guide/kernel_methods.rst b/docs/user_guide/kernel_methods.rst
@@ -158,7 +158,7 @@ In sQUlearn a FQK (instance) can be defined as shown by the following example:
     from squlearn.util import Executor
     from squlearn.encoding_circuit import ChebyshevPQC
     from squlearn.kernel import FidelityKernel
-    enc_circ = ChebyshevPQC(num_qubits=4, num_features=1, num_layers=2)
+    enc_circ = ChebyshevPQC(num_qubits=4, num_layers=2)
     fqk_instance = FidelityKernel(
         encoding_circuit=enc_circ,
         executor=Executor()
@@ -211,7 +211,7 @@ the following example:
     from squlearn.util import Executor
     from squlearn.encoding_circuit import ChebyshevPQC
     from squlearn.kernel import ProjectedQuantumKernel
-    enc_circ = ChebyshevPQC(num_qubits=4, num_features= 1, num_layers=2)
+    enc_circ = ChebyshevPQC(num_qubits=4, num_layers=2)
     pqk_instance = ProjectedQuantumKernel(
         encoding_circuit=enc_circ,
         executor=Executor(),
@@ -255,7 +255,7 @@ training and test data and shows how to optimize kernels.
         from squlearn.kernel.loss import TargetAlignment
 
         # set up the encoding circuit
-        encoding_circuit = ChebyshevPQC(num_qubits=4, num_features=1, num_layers=2)
+        encoding_circuit = ChebyshevPQC(num_qubits=4, num_layers=2)
 
         # set up the quantum kernel
         pqk_instance = ProjectedQuantumKernel(encoding_circuit, Executor())

diff --git a/docs/user_guide/observables.rst b/docs/user_guide/observables.rst
@@ -100,7 +100,12 @@ The map can be for example obtained in the transpiled encoding circuit.
    from squlearn.encoding_circuit import ChebyshevRx,TranspiledEncodingCircuit
    from squlearn.observables import SummedPaulis
    from qiskit_ibm_runtime.fake_provider import FakeManilaV2
-   fm = TranspiledEncodingCircuit(ChebyshevRx(3,1),backend=FakeManilaV2(),initial_layout=[0,1,4])
+   fm = TranspiledEncodingCircuit(
+    ChebyshevRx(3,1),
+    backend=FakeManilaV2(),
+    num_features=1,
+    initial_layout=[0,1,4]
+   )
    ob = SummedPaulis(num_qubits=3, op_str="Z")
    print("Observable before mapping:\n",ob,"\n\n")
    ob.set_map(fm.qubit_map, fm.num_physical_qubits)

diff --git a/docs/user_guide/quantum_neural_networks.rst b/docs/user_guide/quantum_neural_networks.rst
@@ -93,8 +93,8 @@ method:
 
     from squlearn.encoding_circuit import ChebyshevPQC
 
-    pqc = ChebyshevPQC(num_qubits = 4, num_features = 1, num_layers = 2)
-    pqc.draw("mpl")
+    pqc = ChebyshevPQC(num_qubits = 4, num_layers = 2)
+    pqc.draw("mpl", num_features = 1)
 
 There are several alternative encoding circuits at your disposal in sQUlearn, which you can
 explore in the user guide located at :ref:`quantum_encoding_circuits`.
@@ -136,7 +136,7 @@ and the Adam optimizer for optimization.
     from squlearn import Executor
 
     op = SummedPaulis(num_qubits = 4)
-    pqc = ChebyshevPQC(num_qubits = 4, num_features = 1, num_layers = 2)
+    pqc = ChebyshevPQC(num_qubits = 4, num_layers = 2)
     qnn = QNNRegressor(pqc, op, Executor(), SquaredLoss(), Adam())
 
 The QNN can be trained utilizing the :meth:`fit <squlearn.qnn.QNNRegressor.fit>` method:
@@ -314,7 +314,7 @@ yields a high variance in the model output.
     from squlearn.optimizers import SLSQP
     nqubits = 4
     number_of_layers = 2
-    pqc = ChebyshevRx(nqubits, 1, num_layers=number_of_layers)
+    pqc = ChebyshevRx(num_qubits=nqubits, num_layers=number_of_layers)
     exe = Executor("pennylane", seed=0)
     exe.set_shots(5000)
     ising_op = IsingHamiltonian(nqubits, I="S", Z="S", ZZ="S")
@@ -379,7 +379,7 @@ in the model, as depicted in `figure_qnn 3`_.
     from squlearn.optimizers import SLSQP
     nqubits = 4
     number_of_layers = 2
-    pqc = ChebyshevRx(nqubits, 1, num_layers=number_of_layers)
+    pqc = ChebyshevRx(num_qubits=nqubits, num_layers=number_of_layers)
     exe = Executor("qasm_simulator")
     exe.set_shots(5000)
     ising_op = IsingHamiltonian(nqubits, I="S", Z="S", ZZ="S")

diff --git a/docs/user_guide/quantum_reservoir_computing.rst b/docs/user_guide/quantum_reservoir_computing.rst
@@ -96,8 +96,8 @@ is done in sQUlearn by the :class:`EncodingCircuit` class. For details we refer
 
     from squlearn.encoding_circuit import ChebyshevPQC
 
-    pqc = ChebyshevPQC(num_qubits=8, num_features=2, num_layers=2)
-    pqc.draw("mpl")
+    pqc = ChebyshevPQC(num_qubits=8, num_layers=2)
+    pqc.draw("mpl", num_features=2)
 
 Here we have chosen the :class:`~squlearn.encoding_circuit.ChebyshevPQC` as our encoding circuit, but sQUlearn provides a list of several alternative choices in :ref:`quantum_encoding_circuits`.
 The parameters are all randomly chosen. Next we also initialize our executor and QRCClassifier:
@@ -183,8 +183,8 @@ This time, we choose the :class:`~squlearn.encoding_circuit.HubregtsenEncodingCi
 
     from squlearn.encoding_circuit import HubregtsenEncodingCircuit
 
-    pqc = HubregtsenEncodingCircuit(num_qubits=10, num_features=1, num_layers=2)
-    pqc.draw("mpl")
+    pqc = HubregtsenEncodingCircuit(num_qubits=10, num_layers=2)
+    pqc.draw("mpl", num_features=1)
 
 
 The :class:`QRCRegressor` similar to the classifier example, takes our prepared :class:`EncodingCircuit` and a machine learning method 

diff --git a/examples/encoding_circuits/layered_encoding_circuit.ipynb b/examples/encoding_circuits/layered_encoding_circuit.ipynb