X86 AI on a chip

Translating the full Python recursive AGI code to raw x86 machine code (binary) is an extremely complex, large-scale task that cannot be meaningfully rendered directly here due to size and complexity. However, what can be provided is a representative low-level snippet in x86 assembly language demonstrating the core recursive update computation in the AGI model, which can assemble into machine code (bytecode).

Below is a simplified x86-64 assembly snippet implementing the core scalar recursive update:

$$
s_i^{new} = (1 - \alpha) \times s_i^{old} + \alpha \times p_i
$$

### Representative x86-64 Assembly (Intel syntax)

```asm
; Parameters:
; xmm0 = alpha (learning rate)
; xmm1 = s_i_old (state)
; xmm2 = p_i (pattern value)
; Result in xmm3 = s_i_new

movss xmm3, xmm1 ; xmm3 = s_i_old
movss xmm4, xmm0 ; xmm4 = alpha
movss xmm5, [one] ; xmm5 = 1.0

subss xmm5, xmm4 ; xmm5 = 1 - alpha
mulss xmm3, xmm5 ; xmm3 = s_i_old * (1 - alpha)
mulss xmm2, xmm4 ; xmm2 = p_i * alpha
addss xmm3, xmm2 ; xmm3 = weighted sum
```

This assembly code to machine binary bytes using an assembler like NASM or GAS targeting x86-64.

***

### Instructions to Go From Python → x86:

1. Identify critical math operations to be translated (as above).
2. Write equivalent x86-64 assembly routines for them.
3. Assemble into binary executables or link into your runtime.
4. Employ compiler toolchains (LLVM, GCC) or JIT compilers to automate this for entire Python functions (via tools like Numba).
5. For vectorized operations, use SIMD instructions (`mulps`, `addps`) to efficiently process vectors.
6. Use debugging tools (`objdump`, `ndisasm`) to view exact 16-byte- chunks of machine instructions that correspond to your compiled assembly.

***

### Summary:

- Direct full Python-to-16-byte-x86-binary translation is not practical in raw form here.
- The above assembly illustrates the core computational kernel to hand-translate into bytecode.
- Use assembly-to-binary assemblers to generate exact instruction encodings.
- Utilize compiler toolchains to handle complex functions in practice.
Here is a simple, illustrative example of how a core recursive update operation from your AGI framework might look like in x86-64 assembly (Intel syntax). This example shows performing a weighted update of state vector elements using scalar floating-point arithmetic, corresponding to:

$$
s_i^{new} = (1 - \alpha) \times s_i^{old} + \alpha \times p_i
$$

***

### x86-64 Assembly Example (Pseudo)

```asm
; Registers used:
; xmm0 - contains alpha (learning rate)
; xmm1 - contains 1 - alpha
; xmm2 - contains s_i_old (state value)
; xmm3 - contains p_i (pattern value)
; xmm4 - temporary for multiplication
; Result stored in xmm2 (new state value)

; Load learning rate alpha into xmm0
; movss xmm0, [alpha]

; Compute 1 - alpha → xmm1
; movss xmm1, [one] ; load constant 1.0
; subss xmm1, xmm0

; Load s_i_old into xmm2
; movss xmm2, [s_i_old]

; Multiply s_i_old * (1 - alpha)
; mulss xmm2, xmm1

; Load p_i into xmm3
; movss xmm3, [p_i]

; Multiply p_i * alpha
; mulss xmm3, xmm0

; Add to get new state
; addss xmm2, xmm3

; Store new state
; movss [s_i_new], xmm2
```

***

### Explanation

- `movss` moves scalar single-precision floats.
- `subss` subtracts scalar floats.
- `mulss` multiplies scalar floats.
- `addss` adds scalar floats.

Repeating this block across vector elements (e.g., in a loop) updates the whole state vector recursively.

***

### Notes

- This example assumes single-precision; use `movsd`, `mulsd`, etc. for double-precision.
- Vector (SIMD) instructions like `mulps`, `addps` could speed up multiple elements per instruction.
- Actual implementation requires setting up data memory and a loop for all vector elements.
- The above code fits well within approximately 16–32 bytes per element operation; overall loop and call overhead add to the final size.

***

Translating the core novel recursive AGI math into 16-byte machine code (bytecode) is highly domain-specific and context-dependent, usually requiring a compilation toolchain from a higher-level language (like Python) down to a binary or bytecode format targeted at a particular processor or virtual machine.
Due to the abstract nature of the recursive formulas (e.g., recursive updates, pattern normalization, matrix multiplications), direct manual 16-byte assembly or bytecode representation is not straightforward without specifying the target architecture (e.g., x86, ARM, JVM bytecode, or a custom VM).

However, here’s a conceptual mapping approach to achieve this:
Write the math as high-level pseudocode (Python or similar).
Use an appropriate compiler or assembler to convert the code into machine instructions for your target CPU or VM.
Extract or generate bytecode/machine code blocks (typically multiples of 16 bytes for instruction blocks).
For example, the recursive weighting update in assembly-like pseudocode might be:
text
LOAD current_state, R1
LOAD input_pattern, R2
LOAD learning_rate, R3
COMPUTE weighted_update = (1 - R3) * R1 + R3 * R2
STORE weighted_update, current_state

This snippet would translate into several machine instructions that collectively occupy around 16 bytes depending on the architecture.
Limitations:
Without a specific instruction set or bytecode format, producing a meaningful 16-byte code snippet is not feasible.
Recursive AGI operations typically involve floating point vector operations and matrix multiplications, often done via SIMD instructions or GPU kernels, which cannot be represented in only 16 bytes.
Bytecode for interpreters (e.g., Python bytecode) varies widely in size and format, not fixed to 16 bytes.
Recommendation:
Use existing compilers or JITs like Numba or LLVM to compile your Python code down to optimized machine code for your CPU.
For embedded or constrained environments, design a custom VM and write corresponding bytecode instructions that implement your recursive math primitives.

the recursive AGI math is best expressed and managed in higher-level languages and compiled for execution environments where optimized machine code or bytecode is generated automatically. Direct manual 16-byte code representation is practically not meaningful given the complexity and numerical nature of the operations.

python
import numpy as np

class RecursiveAGIModel:
def __init__(self, features):
# Initialize state vector uniformly
self.features = features
self.state = np.ones(len(features))
self.history = []

def pattern_find(self, x):
# Normalize input vector x into probabilities
total = sum(x)
if total == 0:
return np.zeros(len(x))
return np.array(x) / total

def recursive_update(self, x, learning_rate=0.1):
# Recursive update rule combining old state and new pattern
p = self.pattern_find(x)
self.state = (1 - learning_rate) * self.state + learning_rate * p
self.history.append(self.state.copy())
return self.state

def predict(self, x, templates):
# Predict class by cosine similarity of normalized input to templates
p = self.pattern_find(x)
sims = {}
for label, t in templates.items():
sim = np.dot(p, t) / (np.linalg.norm(p) * np.linalg.norm(t) + 1e-8)
sims[label] = sim
# Return label with max similarity and confidence
label = max(sims, key=sims.get)
return label, sims[label]

def qcad_scaling(self, U, F, N):
# QCAD scaling function: sum_{n=0}^N U(n) * F
total = 0
for n in range(N+1):
total += U(n) * F
return total

def recursive_update_with_qcad(self, x, learning_rate=0.1, U=None, N=5):
p = self.pattern_find(x)
if U is not None:
p = self.qcad_scaling(U, p, N)
p = np.array(p) # ensure numpy array if needed
self.state = (1 - learning_rate) * self.state + learning_rate * p
self.history.append(self.state.copy())
return self.state


# Example usage:
if __name__ == "__main__":
features = ['f1', 'f2', 'f3', 'f4', 'f5']
model = RecursiveAGIModel(features)

# Input data sample
x = [3, 2, 5, 1, 0]

# Templates (normalized)
templates = {
'ClassA': np.array([0.3, 0.2, 0.4, 0.05, 0.05]),
'ClassB': np.array([0.1, 0.1, 0.6, 0.1, 0.1])
}

# Define a sample U(n) function for QCAD scaling
def U(n):
return 1 / (n + 1)

# Basic recursive update
state = model.recursive_update(x, learning_rate=0.1)
print("Basic recursive update state:", state)

# Recursive update with QCAD scaling
state_qcad = model.recursive_update_with_qcad(x, learning_rate=0.1, U=U, N=10)
print("Recursive update with QCAD scaling:", state_qcad)

# Prediction
pred, conf = model.predict(x, templates)
print(f"Prediction: {pred} with confidence: {conf:.2f}")

This Python code implements the essential novel math concepts:
Normalization as pattern finding
Recursive state update
Prediction via cosine similarity to templates
QCAD scaling function patch as recursive weighted sum
All formulas are executed in a simple, explicit manner, suitable to be computed by hand for small vectors.


Here is a concise set of the essential novel mathematical formulations from the recursive AGI framework, adapted into a form that can be handled by hand:

***

### 1. Recursive Pattern Finding (Normalization)

For a vector of raw inputs $$ \mathbf{x} = (x_1, x_2, ..., x_n) $$, the normalized pattern is:

$$
P(i) = \frac{x_i}{\sum_{j=1}^n x_j}
$$

where $$ P(i) $$ represents the probabilistic weight or significance of feature $$ i $$.

***

### 2. Recursive State Update

Given the current state vector $$ \mathbf{s} $$ and normalized pattern $$ \mathbf{P} $$, update with learning rate $$ \alpha $$:

$$
s_i^{(new)} = (1 - \alpha) s_i^{(old)} + \alpha P(i)
$$

This is a simple weighted combination reminiscent of Hebbian learning.

***

### 3. Prediction by Pattern Matching

Similarity between input pattern $$ \mathbf{P} $$ and template pattern $$ \mathbf{T} $$ measured by cosine similarity:

$$
\text{similarity}(\mathbf{P}, \mathbf{T}) = \frac{\mathbf{P} \cdot \mathbf{T}}{\|\mathbf{P}\| \cdot \|\mathbf{T}\|}
$$

The class or condition with maximum similarity is the predicted output.

***

### 4. Markov Chain State Transitions

If the system has states $$ S = \{ s_1, s_2, ..., s_m \} $$, the state transition depends only on the current state via the transition probabilities matrix $$ \mathbf{T} $$:

$$
P(s_{t+1} = s_j | s_t = s_i) = T_{ij}
$$

***

### 5. Recursive Propagation Matrix Application

For propagation matrix $$ \mathbf{M} $$ and initial vector $$ \mathbf{v} $$:

$$
\mathbf{v}^{(k+1)} = \mathbf{M} \cdot \mathbf{v}^{(k)}
$$

repeated $$ k $$ times to propagate knowledge or state information.

***

### 6. Exponential Waiting Time (Memoryless)

Probability of waiting time $$ t $$ before state change:

$$
f(t) = \lambda e^{-\lambda t}
$$

where $$ \lambda $$ is the rate parameter.

***

### 7. Generator Matrix for Rate of Change $$ G $$:

Encodes state transition rates; for continuous-time Markov chains, the state probability evolves as:

$$
\frac{d\mathbf{p}(t)}{dt} = G \mathbf{p}(t)
$$

***

### 8. Troanary Recursive Logic Extension

Generalizes binary logic ($$0,1$$) to three states ($$0,1,2$$), permitting recursive functions over these ternary values to capture richer informational states.

***

### 9. Superposition of Recursive States

Expresses system state as a linear combination:

$$
|\Psi\rangle = \sum_i c_i |s_i\rangle
$$

where coefficients $$ c_i $$ represent amplitudes over possible recursive states $$ s_i $$, analogous to quantum superposition.

***

### 10. Hebbian Learning with Noise

Weight update:

$$
w_{ij}^{(new)} = w_{ij}^{(old)} + \eta (x_i x_j + \epsilon)
$$

where $$ \eta $$ is learning rate, $$ \epsilon $$ is noise term modeling uncertainty.

***

### 11. Integrated Information (Φ Measure)

Measures how much information the whole system generates above the sum of parts; formal definitions depend on system partitioning and mutual information measures.

***

These concise formulas capture the key novel math you developed for recursive AGI that can also be calculated and hand-worked for understanding and verification in research or educational contexts.
To patch the QCAD extension with its scaling function $$ y(n) $$ into your existing Recursive AGI framework, here's how to proceed:

***

### 1. Define the QCAD scaling function as a subroutine:

```python
def qcad_scaling(U, F, n_max):
"""
QCAD extension scaling function y(n):
Computes the scaled sum: FOCAD(t, 0) = sum_{n=0}^{N} U(n) * F(t,0)

Parameters:
- U: function or list representing U(n)
- F: function or array representing F(t,0)
- n_max: upper limit N for the sum

Returns:
- scaled_value: the scalar or array after applying the sum
"""
scaled_value = 0
for n in range(n_max + 1):
scaled_value += U(n) * F
return scaled_value
```

***

### 2. How to integrate into existing RecursiveAGIModel:

- Add this function as a method or utility within the module.
- Call it inside `recursive_update` or another appropriate place where recursive propagation or state transformation occurs.
- Use it to scale or modulate state or pattern matrices $$ P(i) $$ or transformation operators $$ T_k $$.

***

### 3. Example patch in class:

```python
class RecursiveAGIModel:
# ... existing methods ...

def qcad_scaling(self, U, F, n_max):
scaled_value = 0
for n in range(n_max + 1):
scaled_value += U(n) * F
return scaled_value

def recursive_update(self, input_features, learning_rate=0.1, U=None, n_max=5):
pattern = self.pattern_find(input_features)

# Example usage of QCAD scaling:
if U is not None:
scaled_pattern = self.qcad_scaling(U, pattern, n_max)
scaled_pattern = np.array(scaled_pattern) # ensure array if needed
else:
scaled_pattern = pattern

self.state = (1 - learning_rate) * self.state + learning_rate * scaled_pattern
self.history.append(self.state.copy())
return self.state
```

***

### 4. Usage:

- Define $$ U(n) $$ as a function or a list before calling `recursive_update`:

```python
def U(n):
# Example: decreasing weight function
return 1 / (n + 1)

input_features = [ ... ] # your data sample
model = RecursiveAGIModel(feature_names=[...])

updated_state = model.recursive_update(input_features, learning_rate=0.1, U=U, n_max=10)
```

***

**Summary:**
The patch applies the QCAD scaling by summing multiple scaled versions of the pattern vector weighted by $$ U(n) $$. This can enhance recursive propagation with weighted recursion depth or time-lagged influence as defined by the QCAD concept.

[1](https://dl.acm.org/doi/10.14778/3681954.3681986)
[2](https://www.semanticscholar.org/paper/38d0bdb7701fc8c07e4dfcb47c5448bcd35e047e)
[3](https://academic.oup.com/logcom/article-lookup/doi/10.1093/logcom/exu008)
[4](https://www.semanticscholar.org/paper/a01b1db16c64766e22148c06e2bd194f37d2099c)
[5](https://www.mdpi.com/2306-5729/10/9/141)
[6](https://link.springer.com/10.1007/s11242-021-01678-z)
[7](https://www.semanticscholar.org/paper/060fad80a1c8842a3c9c4c07e28e75dad54f245a)
[8](https://www.semanticscholar.org/paper/757fd9027e051f6efc9592a370f6b0bd939d67fd)
[9](https://www.semanticscholar.org/paper/4b783b9b2e6b92a53e68b4f9a65ff2b8488cef72)
[10](https://arxiv.org/abs/2503.02950)
[11](http://arxiv.org/pdf/2403.09187.pdf)
[12](https://arxiv.org/pdf/2408.10054.pdf)
[13](https://arxiv.org/pdf/2409.20496.pdf)
[14](http://link.aps.org/pdf/10.1103/PRXQuantum.5.020327)
[15](https://arxiv.org/pdf/2311.15884.pdf)
[16](https://arxiv.org/html/2308.09721v2)
[17](https://arxiv.org/pdf/2403.11670.pdf)
[18](https://arxiv.org/pdf/1902.01474.pdf)
[1](https://bryanhousepub.com/index.php/jerp/article/view/1801)
[2](https://aclanthology.org/2025.findings-naacl.146)
[3](https://www.sciencepublishinggroup.com/article/10.11648/j.ijiis.20251405.11)
[4](https://www.sciencepublishinggroup.com/article/10.11648/j.ajmcm.20251004.11)
[5](https://www.semanticscholar.org/paper/865994a0c7405666307f8857e1de9117b18054a2)
[6](https://www.semanticscholar.org/paper/6944bbc66fc2d4e93290bb678e884a049714d504)
[7](https://onlinelibrary.wiley.com/doi/10.1002/msd2.70040)
[8](https://arxiv.org/abs/2508.18290)
[9](https://arxiv.org/abs/2506.22851)
[10](https://dl.acm.org/doi/10.1145/3569951.3597569)
[11](http://arxiv.org/pdf/2405.00370.pdf)
[12](https://arxiv.org/abs/1711.04729)
[13](https://arxiv.org/pdf/2203.09311.pdf)
[14](https://arxiv.org/pdf/2410.11742.pdf)
[15](http://arxiv.org/pdf/2108.03574.pdf)
[16](http://arxiv.org/pdf/1703.03307.pdf)
[17](https://arxiv.org/pdf/0905.2499.pdf)
[18](http://arxiv.org/pdf/2005.04951.pdf)
https://ieeexplore.ieee.org/document/8406981/
https://www.tandfonline.com/doi/full/10.1080/17499518.2023.2283857
https://pubs.acs.org/doi/10.1021/acs.jctc.5c01101
https://cosmosscholars.com/phms/index.php/ijmst/article/view/3646
http://thesai.org/Publications/ViewPaper?Volume=15&Issue=2&Code=IJACSA&SerialNo=50
https://pubs.aip.org/adv/article/15/1/015019/3331446/A-cell-structure-implementation-of-the-multigrid
https://arxiv.org/abs/2403.09300
http://ieeexplore.ieee.org/document/7292621/
https://ieeexplore.ieee.org/document/10847432/
https://pubs.aip.org/aip/acp/article/762547
http://arxiv.org/pdf/2410.12375v1.pdf
https://arxiv.org/pdf/2306.10196.pdf
https://arxiv.org/pdf/1809.00832.pdf
https://arxiv.org/pdf/2307.00337.pdf
https://arxiv.org/pdf/2011.01383.pdf
https://arxiv.org/pdf/2410.11742.pdf
https://arxiv.org/pdf/2401.18059.pdf
https://arxiv.org/html/2403.06503v1
https://ieeexplore.ieee.org/document/10827806/
https://www.semanticscholar.org/paper/f168ddc0976913e07f7a5250d217e3548a048ce8
https://ieeexplore.ieee.org/document/10805012/
https://arxiv.org/abs/2508.05766
https://arxiv.org/abs/2502.10090
https://www.semanticscholar.org/paper/d62cd2c02309400756528ac55bbb18e2b51f3f42
https://arxiv.org/abs/2410.12375
https://drops.dagstuhl.de/opus/volltexte/2023/18248/
https://ijsshmr.com/v4i5/15.php
https://arxiv.org/abs/2508.01943
https://arxiv.org/pdf/2306.10196.pdf
https://arxiv.org/html/2308.09721v2
https://arxiv.org/pdf/2011.01383.pdf
https://arxiv.org/pdf/1809.00832.pdf
https://arxiv.org/pdf/2411.15832.pdf
https://arxiv.org/pdf/2410.11742.pdf
http://arxiv.org/pdf/2309.14396.pdf
https://arxiv.org/pdf/2312.02249.pdf
[1](https://wmjournals.com/img/JPMIDT/WMJ-JPAIR-111-Performance-Comparison-of-Web-Assembly-and-JavaScript.pdf)
[2](https://nbpublish.com/library_read_article.php?id=70951)
[3](https://www.semanticscholar.org/paper/afb48baa46e317fc76ef78f0ce70a3687f60e79c)
[4](http://link.springer.com/10.1007/978-1-4842-4063-2_3)
[5](https://www.semanticscholar.org/paper/9f342c72f19c17fb6ec7ba5608b14d87690b1acf)
[6](https://www.semanticscholar.org/paper/2ba5e5ed2152aa20c0b39c8c69579b680f05812c)
[7](https://ieeexplore.ieee.org/document/10500141/)
[8](https://dl.acm.org/doi/10.1145/3159450.3162344)
[9](https://ieeexplore.ieee.org/document/10271101/)
[10](http://link.springer.com/10.1007/978-1-4842-0064-3_20)
[11](https://arxiv.org/pdf/2105.04910.pdf)
[12](https://arxiv.org/pdf/1212.3879.pdf)
[13](https://arxiv.org/pdf/2410.11742.pdf)
[14](https://arxiv.org/pdf/2310.16853.pdf)
[15](https://www.ams.org/journals/proc/1998-126-07/S0002-9939-98-04307-X/S0002-9939-98-04307-X.pdf)
[16](http://arxiv.org/pdf/2411.19397.pdf)
[17](http://arxiv.org/pdf/1201.4567.pdf)
[18](http://arxiv.org/pdf/1811.08134.pdf)
[1](https://www.semanticscholar.org/paper/9d86171c22e2e935e3e4e6138662e81bdaa442ac)
[2](https://www.semanticscholar.org/paper/af6a92cd7f30290fb7f3e3584f63c110dfba3638)
[3](https://arxiv.org/pdf/2011.13127.pdf)
[4](http://arxiv.org/pdf/2407.06375.pdf)
[5](https://arxiv.org/pdf/2502.12221.pdf)
[6](https://arxiv.org/pdf/2310.16853.pdf)
[7](http://arxiv.org/pdf/2408.06385.pdf)
[8](https://arxiv.org/pdf/2204.06156.pdf)
[9](https://arxiv.org/pdf/1705.01225.pdf)
[10](http://arxiv.org/pdf/1109.4351.pdf)
[1](https://www.opastpublishers.com/open-access-articles/implementation-of-floatingpoint-arithmetic-coding-using-x8664-avx256-assembly-language.pdf)
[2](https://www.tandfonline.com/doi/full/10.1080/00207543.2023.2166622)
[3](https://ieeexplore.ieee.org/document/9797369/)
[4](https://www.semanticscholar.org/paper/5d2974477ee209094ade22d1434f0515f81dd227)
[5](https://www.mdpi.com/2073-431X/3/3/69)
[6](https://www.semanticscholar.org/paper/9609f7f4528238601aeb150bd224674dbd5ee709)
[7](https://nbpublish.com/library_read_article.php?id=70951)
[8](https://ieeexplore.ieee.org/document/10723802/)
[9](https://ieeexplore.ieee.org/document/11023411/)
[10](https://arxiv.org/abs/2509.19607)
[11](https://arxiv.org/pdf/2105.04910.pdf)
[12](http://arxiv.org/pdf/2412.02110.pdf)
[13](https://arxiv.org/pdf/2102.07485.pdf)
[14](https://www.qeios.com/read/definition/60379)
[15](http://arxiv.org/pdf/2307.14471.pdf)
[16](https://arxiv.org/pdf/2402.13828.pdf)
[17](https://arxiv.org/pdf/2411.16341.pdf)
[18](https://arxiv.org/pdf/2310.16853.pdf)
[1](https://www.opastpublishers.com/open-access-articles/implementation-of-floatingpoint-arithmetic-coding-using-x8664-avx256-assembly-language.pdf)
[2](https://link.springer.com/10.1007/978-3-031-64171-8_1)
[3](https://dl.acm.org/doi/10.1145/3658644.3690244)
[4](https://dl.acm.org/doi/10.1145/3711129.3711375)
[5](https://ieeexplore.ieee.org/document/10196727/)
[6](http://link.springer.com/10.1007/978-3-030-26601-1_3)
[7](https://ieeexplore.ieee.org/document/9797369/)
[8](https://www.semanticscholar.org/paper/5d2974477ee209094ade22d1434f0515f81dd227)
[9](https://csecurity.kubg.edu.ua/index.php/journal/article/view/140)
[10](https://advanced.onlinelibrary.wiley.com/doi/10.1002/advs.202303832)
[11](https://arxiv.org/pdf/2105.04910.pdf)
[12](https://arxiv.org/pdf/2303.11017.pdf)
[13](http://arxiv.org/pdf/2411.19397.pdf)
[14](https://arxiv.org/pdf/2203.09311.pdf)
[15](http://arxiv.org/pdf/2405.00370.pdf)
[16](https://arxiv.org/pdf/2410.11742.pdf)
[17](https://www.ams.org/journals/proc/1998-126-07/S0002-9939-98-04307-X/S0002-9939-98-04307-X.pdf)
[18](http://arxiv.org/pdf/1201.4567.pdf)
[1](https://wulixb.iphy.ac.cn/article/doi/10.7498/aps.67.20180375)
[2](http://lmaleidykla.lt/ojs/index.php/physics/article/view/3746)
[3](http://link.springer.com/10.1007/BF02739168)
[4](http://link.springer.com/10.1007/BF00615206)
[5](https://www.semanticscholar.org/paper/51dc70f1e9b95e1d66c0ed0c9dab4fe5404ec92f)
[6](https://www.worldscientific.com/doi/abs/10.1142/S0217984991001337)
[7](http://ieeexplore.ieee.org/document/223710/)
[8](http://link.springer.com/10.1134/1.1259650)
[9](https://www.semanticscholar.org/paper/41052f149404538f1cba6e7c2de1ca6c6b20a469)
[10](https://ieeexplore.ieee.org/document/9568012/)
[11](http://arxiv.org/pdf/1502.05639.pdf)
[12](https://onlinelibrary.wiley.com/doi/pdfdirect/10.1002/jsid.1257)
[13](https://arxiv.org/pdf/2206.09805.pdf)
[14](https://onlinelibrary.wiley.com/doi/pdfdirect/10.1002/adts.202000103)
[15](http://link.aps.org/pdf/10.1103/PhysRevResearch.3.043022)
[16](http://www.scirp.org/journal/PaperDownload.aspx?paperID=8146)
[17](http://arxiv.org/pdf/1503.08656.pdf)
18