A Hybrid Matrix-Based Cryptographic Framework Using Multiple Linear Recurrence Sequences

Abstract

In this study, we propose a matrix-based transformation framework constructed from special integer sequences, including Fibonacci, Lucas, Pell, and Jacobsthal numbers. The approach is based on block-wise $2\times 2$ matrix transformations that preserve key structural invariants, particularly the determinant, ensuring explicit invertibility of the scheme. By combining multiple recurrence-based matrices within a unified framework, the method provides flexible forward and inverse transformations without increasing matrix dimensions or introducing additional redundancy. The determinant-preserving property enables intrinsic consistency checking and supports an analytic error-detection and correction mechanism at the block level. Several illustrative examples are presented to demonstrate the applicability of the proposed scheme and its computational characteristics. The framework is purely algebraic and can be extended to other matrix families generated by linear recurrence relations, making it suitable for a wide range of applications in applied and computational mathematics.

1. Introduction

To provide individual information security, data transfer is vital, so encoding algorithms have played a crucial role in assuring information security. In particular, algorithms that use special integer sequences are encountered frequently in this field. Stakhov extended the standard The Fibonacci sequence and the Fibonacci p-numbers define a square matrix $Q_p$ of order $p+1$ in [1]. The matrix property forms the basis of a new coding technique. The author introduced the concept of “Golden Cryptography,” a fast and technically simple method for protecting digital signals in [2]. The authors introduced a coding framework utilizing Fibonacci polynomials for efficient data transmission using an $m\times m$ matrix whose elements are Fibonacci polynomials in [3]. Basu and Prasad developed a coding theory on the m-extension of Fibonacci p-numbers in [4]. The authors generalized Cassini formula for all values of p in coding theory in [5]. The error correction performance of the proposed coding method was found to be $99.80\%$ for $p=2$. The error correction capability of the method increased as the p value increased. The authors in [6] studied an encoding theory using generalized Fibonacci n-step polynomials, forming a new type of square matrix of order $n.$ Basu and Das introduced a novel coding method by Tribonacci matrices, establishing a $99.80\%$ error correction in [7]. Lucas recurrence structures were later incorporated into cryptographic matrix constructions in [8]. The method showed high correction ability; for $n=2$, the correct ability was $93.33\%$, and for $n=3$, the correct ability was $98.8\%$ in [9]. Anisimov proposed encoding tree structures through linear forms of successive elements of linear recursive sequences of the form $P_{n+2}=a_{n+2}{P}_{n+1}+P_n$ in [10]. The authors presented a method for encrypting and decrypting using Fibonacci Q matrices in [11]. The main advantage was the ability to encrypt each message block with different keys, enhancing the security of the information. The study in [12] presented a new encoding/decoding method using Fibonacci and Lucas numbers, constructing special matrices, typically $2\times 2$ or $3\times 3$, as encryption keys in a coding scheme. Flaut introduces an algorithm for encrypting and decrypting messages based on matrices derived from these difference equations in [13]. Prasad and Mahato proposed a novel public-key cryptosystem that combines the Affine-Hill encryption method with generalized Fibonacci matrices in [14]. Asci and Aydinyuz defined a coding algorithm with k-order Fibonacci polynomials like AES cryptology in [15]. The authors denoted an encoding-decoding method using Fermat and Mersenne sequences in [16]. Soykan investigated the algebraic properties of generalized Fibonacci-type matrices, providing a theoretical basis for more complex encoding schemes in [17]. The authors established sharper, normwise perturbation bounds and introduced four condition numbers—including normwise, mixed, and componentwise types—alongside efficient estimation algorithms in [18]. In [19], a single-sequence determinant-preserving structure was introduced. A related coding approach based on recurrence matrices was later developed in [20]. Unlike [19,21], the present proposed method does not rely on a single specialized sequence, but introduces heterogeneous recurrence dynamics and generalized determinant-preserving operators across multiple block transformations. The contribution of the present work is not merely the replacement of one recurrence sequence by another, but the construction of a generalized hybrid coding architecture in which multiple recurrence systems coexist within a single algebraic framework. Although numerous recurrence-based coding schemes have been proposed, most existing studies focus on a single recurrence family. Unlike existing Fibonacci-type coding frameworks based on a single recurrence family and a fixed transformation matrix, the proposed method introduces a heterogeneous block-dependent transformation structure generated by multiple independent recurrence sequences. This hybridization changes the algebraic behavior of the coding process in three fundamental ways:

• the transformation matrices no longer belong to a single recurrence-generated matrix group,
• the resulting ciphertext structure becomes non-uniform across blocks,
• determinant invariants are preserved under dynamically varying recurrence operators.

For this reasons, it is computationally favorable, practically efficient, algebraically tractable, and structurally convenient.

The main contents of this paper can be summarized as follows. First, we introduce a unified $2\times 2$ block-wise matrix transformation framework that simultaneously incorporates Fibonacci, Lucas, Pell, and Jacobsthal matrices, allowing multiple structurally distinct transformations within the same scheme. Second, we establish explicit invertibility and determinant-preserving properties: the proposed transformations, which form the algebraic basis for analytic error-detection and correction at the block level. Third, we provide illustrative examples and an analytic discussion showing that the proposed scheme operates through elementary matrix operations and can be naturally extended to other matrix families generated by linear recurrence relations. Furthermore, the proposed framework is designed to be computationally efficient; it operates with linear time complexity $O\left(n\right)$ and requires only constant auxiliary space $O\left(1\right)$, ensuring that the encoding and decoding processes are suitable for real-time applications and resource-constrained environments.

The construction of a unified hybrid recurrence-based coding framework introduces several nontrivial mathematical challenges, including heterogeneous matrix compatibility, determinant-preserving dynamic transformations, unified inverse decoding, and integer-domain consistency. Another technical challenge involved preserving integer-valued ciphertext representations despite parity-dependent fractional matrix coefficients arising in certain recurrence transformations. Maintaining constant auxiliary space and low computational complexity despite hybrid recurrence switching constituted an additional implementation challenge.

2. Mathematical Preliminaries

The notation $f_n$ is used for the nth Fibonacci number and $l_n$ for the nth Lucas number. Both sequences are defined, for $n\in Z$, through the same recurrence relation $a_{n+1}=a_n+a_{n-1}$, $n\ge 1$, with initial values $f_0=0,$$f_1=1$, and $l_0=2,$$l_1=1$, respectively. The notation $j_n$ is used for the nth Jacobsthal number. The sequence is defined, for $n\in Z$, through the recurrence relation $j_{n+1}=j_n+2j_{n-1}$, $n\ge 1$ with initial values $j_0=0,$$j_1=1$. Similarly, $p_n$ is used as the notation for the nth Pell number. The sequence is defined, for $n\in Z$, through the recurrence relation $p_{n+1}=2p_n+p_{n-1}$, $n\ge 1$, with $p_0=0$ and $p_1=1$ [21,22,23]. Since the recurrence families satisfy different characteristic equations $(x^2-x-1,$$x^2-x-2,$ and $x^2-2x-1)$, constructing a unified algebraic decoding structure required generalized determinant-preserving relations across non-equivalent matrix classes.

Let n be any positive integer. If $F=$$\left[\begin{array}{cc}1& 1\\ 1& 0\end{array}\right],$ then we see $F^n=$$\left[\begin{array}{cc}{f}_{n+1}& f_n\\ f_n& f_{n-1}\end{array}\right]$ where $f_n$ is the nth Fibonacci number. If $J=$$\left[\begin{array}{cc}1& 2\\ 1& 0\end{array}\right],$ then we get $J^n=$$\left[\begin{array}{cc}{j}_{n+1}& 2j_n\\ j_n& 2j_{n-1}\end{array}\right]$ where $j_n$ is the nth Jacobsthal number. If $S=$$\left[\begin{array}{cc}1/2& 5/2\\ 1/2& 1/2\end{array}\right],$ then $S^n=$$\left[\begin{array}{cc}{l}_n/2& 5f_n/2\\ f_n/2& l_n/2\end{array}\right]$ where $l_n$ is the nth Lucas number. If $P=$$\left[\begin{array}{cc}0& 1\\ 1& 2\end{array}\right],$ then we have $P^n=$$\left[\begin{array}{cc}{p}_{n-1}& p_n\\ p_n& p_{n+1}\end{array}\right]$ where $p_n$ is the nth Pell number [21,22,23].

Table 1. Integer sequences.

Sequence	Recurrence	Transformation Matrix	Det.
Fibonacci	$f_{n+1}=f_n+f_{n-1}$	$\left[\begin{array}{cc}{f}_{n+1}& f_n\\ f_n& f_{n-1}\end{array}\right]$	${(-1)}^n$
Lucas	$l_{n+1}=l_n+l_{n-1}$	$\left[\begin{array}{cc}{l}_n/2& 5f_n/2\\ f_n/2& l_n/2\end{array}\right]$	${(-1)}^n$
Jacobsthal	$j_{n+1}=j_n+2j_{n-1}$	$\left[\begin{array}{cc}{j}_{n+1}& 2j_n\\ j_n& 2j_{n-1}\end{array}\right]$	${(-2)}^n$
Pell	$p_{n+1}=2p_n+p_{n-1}$	$\left[\begin{array}{cc}{p}_{n-1}& p_n\\ p_n& p_{n+1}\end{array}\right]$	${(-1)}^n$

summarizes the algebraic characteristics of the recurrence-based transformation matrices employed in the proposed hybrid framework. Unlike classical single-sequence approaches, the present method integrates multiple recurrence families within the same dynamic transformation architecture.

3. Proposed Hybrid Coding Framework

The F, J, S, and P matrices allow us to develop applications in coding theory. Let us display the transferred message in the form of the square matrix M. We put our message in an even-sized matrix by adding $\theta$ between the two words and empty elements at the end of the message matrix until the size of the message matrix is even. We divide the message matrix M into $2\times 2$ block matrices from left to right, $M_i$ for $i=1,\dots ,m$. We take the F, J, S, and P matrices of order 2 as coding matrices and their inverse matrix as decoding matrices. The choice of a fixed $2\times 2$ block structure provides a favorable balance between algebraic tractability and computational efficiency. In particular, determinant evaluation, matrix inversion, and error-detection relations remain explicitly manageable while preserving low computational complexity. So, we construct a new coding algorithm using Fibonacci, Lucas, Pell, and Jacobsthal numbers. Each message block is transformed through multiplication by a recurrence-generated coding matrix. The code matrix E is obtained by using the formulas $E_i=M_i\times F,$$E_i=M_i\times J,$$E_i=M_i\times P,$ and $E_i=M_i\times S$. We can write the block initial message $M_i$ as $M_i=E_i\times F^{-1},$$M_i=E_i\times J^{-1},$$M_i=E_i\times S^{-1},$ and $M_i=E_i\times P^{-1}$. Let us show $M_i,$$E_i$ are of the following forms:

$$M_i=\left[\begin{array}{cc}\hfill b_1^i& \hfill b_2^i\\ \hfill b_3^i& \hfill b_4^i\end{array}\right],E_i=\left[\begin{array}{cc}\hfill e_1^i& \hfill e_2^i\\ \hfill e_3^i& \hfill e_4^i\end{array}\right].$$

The characters are numbered according to the number of block matrices of the message matrix. The number of the block matrices $M_i$ is denoted by m. We use a different numbered alphabet for each message, so this coding method is more reliable. We define the public key n as follows:

$$n=\left\{\begin{array}{c}2,m\le 4\\ ⌊\sqrt{{\displaystyle \frac{m}{3}}}⌋,m\ge 5\end{array}\right.$$

The parameter-selection formula is intended primarily for illustrative and synchronization purposes and should not be interpreted as a cryptographically restrictive requirement. In practical implementations, n may be selected independently within a predefined secure interval. Using the chosen n, we write the following character table according to $mod$ 40 (this table can be extended according to the used characters in the message matrix). We begin “$2n$” for the first character.

Character Table

A	B	C	D	E	F	G	H
$2n$	$2n+1$	$2n+2$	$2n+3$	$2n+4$	$2n+5$	$2n+6$	$2n+7$
I	J	K	L	M	N	O	P
$2n+8$	$2n+9$	$2n+10$	$2n+11$	$2n+12$	$2n+13$	$2n+14$	$2n+15$
R	Q	S	T	U	V	W	X
$2n+16$	$2n+17$	$2n+18$	$2n+19$	$2n+20$	$2n+21$	$2n+22$	$2n+23$
Y	Z	$\theta$	+	−	.	0	1
$2n+24$	$2n+25$	$2n+26$	$2n+27$	$2n+28$	$2n+29$	$2n+30$	$2n+31$
2	3	4	5	6	7	8	9
$2n+32$	$2n+33$	$2n+34$	$2n+35$	$2n+36$	$2n+37$	$2n+38$	$2n+39$

The indexing scheme is dynamically shifted according to the selected parameter n, which introduces additional variability into the encoding process.

Encoding Algorithm

Step 1. Divide the matrix M into blocks $M_i$ ($1\le i\le m$).

Step 2. Choose n.

Step 3. Determine $b_j^i,$($1\le i\le m$) by the character table.

Step 4. Compute $det\left(M_i\right)\to t_i.$

Step 5. Construct $C={[b_j^i,t_i]}_{j\in \{1,2,3\}}$. We hide the elements of $b_4^i$ for all block matrices. You can choose which element you want to hide.

Decoding Algorithm

Step 1. Compute $F^n,$$J^n,$$P^n,$$S^n.$

Step 2. Determine $E_i$ ($1\le i\le m$) by the property $E_i=M_i\times K^n$$(K^n=F^n$ or $J^n,$$P^n,$$S^n)$ where $K^n=\left[\begin{array}{cc}\hfill c_1& \hfill c_2\\ \hfill c_3& \hfill c_4\end{array}\right]$ evaluating $c_1{b}_1^i+c_3{b}_2^i\to e_1^i(1\le i\le m),c_2{b}_1^i+c_4{b}_2^i\to e_2^i(1\le i\le m).$

Step 3. By the determinant equalities $det\left(E_i\right)=det\left(M_i\right)det\left(K^n\right)$, create

If $i=1$, $5,\dots ,4k+1,$ then ${\left(-2\right)}^n{t}_i=e_1^i\left(c_4{x}_i+c_2{b}_3^i\right)-e_2^i\left(c_3{x}_i+c_1{b}_3^i\right),$

otherwise ${\left(-1\right)}^n{t}_i=e_1^i\left(c_4{x}_i+c_2{b}_3^i\right)-e_2^i\left(c_3{x}_i+c_1{b}_3^i\right),$

where $c_i$ ($1\le i\le m$) are the elements of the corresponding special integer sequences.

Step 4. Substitute for $x_i=b_4^i$, where we found in Step 3.

Step 5. Construct $M_i$ and $M.$

We give applications of the mentioned algorithm with the following examples. This example demonstrates that the determinant-preserving structure enables the successful reconstruction of the corrupted matrix entry while maintaining integer consistency.

Example 1.

Assume that we have the message text

$$\prime \prime MATHISSTRIKIN{G}^{\prime \prime }.$$

We get the following message matrix M

$$M=\left[\begin{array}{cccc}M& A& T& H\\ \theta & I& S& \theta \\ S& T& R& I\\ K& I& N& G\end{array}\right].$$

In this example, different recurrence matrices are assigned cyclically to consecutive blocks in order to illustrate the hybrid transformation mechanism.

Step 1. We divide the message matrix M of size $2\times 2$ into the matrices, named $M_i,$$i\mathrm{th}$ block of M whose size is 2. ($1\le i\le 4=m$), from left to right

$$M_1=\left[\begin{array}{cc}M& A\\ \theta & I\end{array}\right],M_2=\left[\begin{array}{cc}T& H\\ S& \theta \end{array}\right],M_3=\left[\begin{array}{cc}S& T\\ K& I\end{array}\right],M_4=\left[\begin{array}{cc}R& I\\ N& G\end{array}\right].$$

Step 2. $m=4$ so $n=2$, we use the “character table” for the message matrix M

$$\begin{array}{ccccccccccc}M& A& \theta & I& T& H& S& K& R& N& G\\ 16& 4& 30& 12& 23& 11& 22& 14& 20& 17& 10.\end{array}$$

Step 3. The elements of the blocks $M_i$$(1\le i\le 4)$ as follows:

$$\begin{array}{cccc}\hfill b_1^1=16& b_2^1=4& b_3^1=30\hfill & b_4^1=12\\ \hfill b_1^2=23& b_2^2=11& b_3^2=22\hfill & b_4^2=30\\ \hfill b_1^3=22& b_2^3=23& b_3^3=14\hfill & b_4^3=12\\ \hfill b_1^4=20& b_2^4=12& b_3^4=17\hfill & b_4^4=10\end{array}$$

Step 4. We calculate the determinants $t_i$ of the blocks $M_i$

$t_1=det\left(M_1\right)=\left|\begin{array}{cc}16& 4\\ 30& 12\end{array}\right|=72,$$t_2=det\left(M_2\right)=\left|\begin{array}{cc}23& 11\\ 22& 30\end{array}\right|=448,$

$t_3=det\left(M_3\right)=\left|\begin{array}{cc}22& 23\\ 14& 12\end{array}\right|=-58,$$t_4=det\left(M_4\right)=\left|\begin{array}{cc}20& 12\\ 17& 10\end{array}\right|=-4$.

Step 5. Merging the entries of the C matrix from the previous steps, the following matrix is obtained

$$C=\left[\begin{array}{cccc}72& 16& 4& 30\\ 448& 23& 11& 22\\ -58& 22& 23& 14\\ -4& 20& 12& 17\end{array}\right].$$

Decoding Algorithm

Step 1. We choose $n=2$. Therefore, we compute

$$\begin{array}{ccc}\hfill J^2& =& \left[\begin{array}{cc}{j}_3& 2j_2\\ j_2& 2j_1\end{array}\right]=\left[\begin{array}{cc}3& 2\\ 1& 2\end{array}\right],S^2=\left[\begin{array}{cc}{l}_2/2& 5f_2/2\\ f_2/2& l_2/2\end{array}\right]=\left[\begin{array}{cc}3/2& 5/2\\ 1/2& 3/2\end{array}\right],\hfill \\ \hfill P^2& =& \left[\begin{array}{cc}{p}_1& p_2\\ p_2& p_3\end{array}\right]=\left[\begin{array}{cc}1& 2\\ 2& 5\end{array}\right],F^2=\left[\begin{array}{cc}{f}_1& f_2\\ f_2& f_3\end{array}\right]=\left[\begin{array}{cc}1& 1\\ 1& 2\end{array}\right]\hfill \\ \hfill \left|J^2\right|& =& 4,\left|S^2\right|=\left|P^2\right|=\left|F^2\right|=1,\hfill \end{array}$$

Step 2. Determine $E_1=M_1\times J^2$, $E_2=M_2\times S^2,$$E_3=M_3\times P^2,E_4=M_4\times F^2$.

Step 3. Evaluate the following values multiplication by matrix

$$\begin{array}{cc}\hfill e_1^1=52& e_2^1=40\\ \hfill e_1^2=40& e_2^2=74\\ \hfill e_1^3=68& e_2^3=159\\ \hfill e_1^4=32& e_2^4=44\end{array}$$

Step 4. We calculate the elements $x_i(1\le i\le 4)$ by the determinant equalities

$$\begin{array}{ccc}\hfill 4t_1& =& e_1^1\left(c_4{x}_1+c_2{b}_3^1\right)-e_2^1\left(c_3{x}_1+c_1{b}_3^1\right)\hfill \\ \hfill 4\ast 72& =& 52\left(2x_1+2\ast 30\right)-40\left(x_1+3\ast 30\right)\hfill \\ \hfill x_1& =& 12;\hfill \end{array}$$

$$\begin{array}{ccc}\hfill t_2& =& e_1^2\left(c_4{x}_2+c_2{b}_3^2\right)-e_2^2\left(c_3{x}_2+c_1{b}_3^2\right)\hfill \\ \hfill 448& =& 40\left({\displaystyle \frac{3x_2}{2}}+{\displaystyle \frac{22\ast 5}{2}}\right)-74\left({\displaystyle \frac{x_2}{2}}+{\displaystyle \frac{66}{2}}\right)\hfill \\ \hfill x_2& =& 30;\hfill \end{array}$$

$$\begin{array}{ccc}\hfill t_3& =& e_1^3\left(c_4{x}_3+c_2{b}_3^3\right)-e_2^3\left(c_3{x}_3+c_1{b}_3^3\right)\hfill \\ \hfill -58& =& 68\left(5x_3+2\ast 14\right)-159\left(2x_3+14\right)\hfill \\ \hfill x_3& =& 12;\hfill \end{array}$$

and

$$\begin{array}{ccc}\hfill t_4& =& e_1^4\left(c_4{x}_4+c_2{b}_3^4\right)-e_2^4\left(c_3{x}_4+c_1{b}_3^4\right)\hfill \\ \hfill -4& =& 32\left(2x_4+17\right)-44\left(x_4+17\right)\hfill \\ \hfill x_4& =& 10.\hfill \end{array}$$

Therefore, we determine $x_i$

$$\begin{array}{cccc}\hfill x_1=b_4^1=12& x_2=b_4^2=30& x_3=b_4^3=12\hfill & x_4=b_4^4=10\end{array}$$

Step 5. We construct the block matrices $M_i$

$$\begin{array}{ccc}\hfill M_1& =& \left[\begin{array}{cc}16& 4\\ 30& 12\end{array}\right],M_2=\left[\begin{array}{cc}23& 11\\ 22& 30\end{array}\right],\hfill \\ \hfill M_3& =& \left[\begin{array}{cc}22& 23\\ 14& 12\end{array}\right],M_4=\left[\begin{array}{cc}20& 12\\ 17& 10\end{array}\right].\hfill \end{array}$$

and the message matrix M

$$M=\left[\begin{array}{cccc}16& 4& 23& 11\\ 30& 12& 22& 30\\ 22& 23& 20& 12\\ 14& 12& 17& 10\end{array}\right].$$

By the character table, we easily find the message text.

Example 2.

Let’s consider the following message text

$$\prime \prime CRYPTOGRAPHYISIMPORTANTFORU{S}^{\prime \prime }.$$

We get the following message matrix M

$$M=\left[\begin{array}{cccccc}C& R& Y& T& O& G\\ R& A& P& H& Y& \theta \\ I& S& \theta & V& E& R\\ Y& \theta & I& M& P& O\\ R& T& A& N& T& \theta \\ F& O& R& \theta & U& S\end{array}\right].$$

Step 1. We divide the message matrix M of size $2\times 2$ into the matrices named $M_i$ ($1\le i\le 9$), from left to right

$$\begin{array}{ccc}\hfill M_1& =& \left[\begin{array}{cc}C& R\\ R& A\end{array}\right],M_2=\left[\begin{array}{cc}Y& T\\ P& H\end{array}\right],M_3=\left[\begin{array}{cc}O& G\\ Y& \theta \end{array}\right],\hfill \\ \hfill M_4& =& \left[\begin{array}{cc}I& S\\ Y& \theta \end{array}\right],M_5=\left[\begin{array}{cc}\theta & V\\ I& M\end{array}\right],M_6=\left[\begin{array}{cc}E& R\\ P& O\end{array}\right],\hfill \\ \hfill M_7& =& \left[\begin{array}{cc}R& T\\ F& O\end{array}\right],M_8=\left[\begin{array}{cc}A& N\\ R& \theta \end{array}\right],M_9=\left[\begin{array}{cc}T& \theta \\ U& S\end{array}\right].\hfill \end{array}$$

Step 2. $m=9$ so $n=⌊\sqrt{{\displaystyle \frac{m}{3}}}⌋=1$; we use the “character table” for the message matrix M

$$\begin{array}{ccc}& & \begin{array}{ccccccccc}C& R& A& Y& T& P& H& O& G\\ 4& 18& 2& 26& 21& 17& 9& 16& 8\end{array}\hfill \\ & & \begin{array}{ccccccccc}I& S& V& E& M& F& N& U& \theta \\ 10& 20& 23& 6& 14& 7& 15& 22& 28.\end{array}\hfill \end{array}$$

Step 3. The elements of the blocks $M_i$$(1\le i\le 9)$ are as follows:

$$\begin{array}{ccc}\hfill M_1& =& \left[\begin{array}{cc}4& 18\\ 18& 2\end{array}\right],M_2=\left[\begin{array}{cc}26& 21\\ 17& 9\end{array}\right],M_3=\left[\begin{array}{cc}16& 8\\ 26& 28\end{array}\right],\hfill \\ \hfill M_4& =& \left[\begin{array}{cc}10& 20\\ 26& 28\end{array}\right],M_5=\left[\begin{array}{cc}28& 23\\ 10& 14\end{array}\right],M_6=\left[\begin{array}{cc}6& 18\\ 17& 16\end{array}\right],\hfill \\ \hfill M_7& =& \left[\begin{array}{cc}18& 21\\ 7& 16\end{array}\right],M_8=\left[\begin{array}{cc}2& 15\\ 18& 28\end{array}\right],M_9=\left[\begin{array}{cc}21& 28\\ 22& 20\end{array}\right].\hfill \end{array}$$

Step 4. We calculate the determinants $t_i$ of the blocks $M_i$: The determinant relation below plays a central role in both invertibility and error detection.

$t_1=det\left(M_1\right)=-316,t_2=det\left(M_2\right)=-123,$$t_3=det\left(M_3\right)=240,$

$t_4=det\left(M_4\right)=-240,$$t_5=det\left(M_5\right)=162,t_6=det\left(M_6\right)=-210,$

$t_7=det\left(M_7\right)=141,$$t_8=det\left(M_8\right)=-214,t_9=det\left(M_9\right)=-196.$

Step 5. Using Step 3 and Step 4, we construct the C matrix

$$C=\left[\begin{array}{cccc}-316& 18& 18& 2\\ -123& 21& 17& 9\\ 240& 8& 26& 28\\ -240& 20& 26& 28\\ 162& 23& 10& 14\\ -210& 18& 17& 16\\ 141& 21& 7& 16\\ -214& 15& 18& 28\\ -196& 28& 22& 20\end{array}\right].$$

Decoding Algorithm

Step 1. We choose $n=1$. Therefore, we compute

$$\begin{array}{ccc}\hfill J& =& \left[\begin{array}{cc}{j}_2& 2j_1\\ j_1& 2j_0\end{array}\right]=\left[\begin{array}{cc}1& 2\\ 1& 0\end{array}\right],\hfill \\ \hfill S& =& \left[\begin{array}{cc}{l}_1/2& 5f_1/2\\ f_1/2& l_1/2\end{array}\right]=\left[\begin{array}{cc}1/2& 5/2\\ 1/2& 1/2\end{array}\right],\hfill \\ \hfill P& =& \left[\begin{array}{cc}{p}_0& p_1\\ p_1& p_2\end{array}\right]=\left[\begin{array}{cc}0& 1\\ 1& 2\end{array}\right],\hfill \\ \hfill F& =& \left[\begin{array}{cc}{f}_0& f_1\\ f_1& f_2\end{array}\right]=\left[\begin{array}{cc}0& 1\\ 1& 1\end{array}\right],\hfill \\ \hfill \left|J\right|& =& -2,\left|S\right|=\left|P\right|=\left|F\right|=-1.\hfill \end{array}$$

Step 2. Determine

$E_1=M_1\ast J$, $E_2=M_2\ast S,$$E_3=M_3\ast P,$$E_4=M_4\ast F$, $E_5=M_5\ast J$, $E_6=M_6\ast S,$$E_7=M_7\ast P,$$E_8=M_8\ast F$, $E_9=M_9\ast J$.

Step 3. Evaluate the following values using matrix multiplication:

$$\begin{array}{cc}{e}_3^1=20& e_4^1=36\\ e_3^2=13& e_4^2=47\\ e_3^3=28& e_4^3=82\\ e_3^4=28& e_4^4=54\\ e_3^5=24& e_4^5=20\\ e_3^6=33/2& e_4^6=101/2\\ e_3^7=16& e_4^7=39\\ e_3^8=28& e_4^8=46\\ e_1^9=42& e_2^9=44.\end{array}$$

Step 4. We calculate the elements $x_i(1\le i\le 9)$

$$\begin{array}{ccc}\hfill -2(-316)& =& 36\left(x_1+18\right)-20\left(2x_1\right)\hfill \\ \hfill 632& =& -4x_1+648\hfill \\ \hfill x_1& =& 4;\hfill \end{array}$$

$$\begin{array}{ccc}\hfill 123& =& 47\left({\displaystyle \frac{x_2}{2}}+{\displaystyle \frac{21}{2}}\right)-13\left({\displaystyle \frac{5x_2}{2}}+{\displaystyle \frac{21}{2}}\right)\hfill \\ \hfill x_2& =& 26;\hfill \end{array}$$

$$\begin{array}{ccc}\hfill -240& =& 82\left(8\right)-28\left(x_3+16\right)\hfill \\ \hfill x_3& =& 16;\hfill \end{array}$$

$$\begin{array}{ccc}\hfill 240& =& 54\left(20\right)-28\left(x_4+20\right)\hfill \\ \hfill x_4& =& 10;\hfill \end{array}$$

$$\begin{array}{ccc}\hfill -2\left(162\right)& =& 20\left(x_5+23\right)-24\left(2x_5\right)\hfill \\ \hfill x_5& =& 28;\hfill \end{array}$$

$$\begin{array}{ccc}\hfill 210& =& {\displaystyle \frac{101}{2}}\left({\displaystyle \frac{x_6}{2}}+9\right)-{\displaystyle \frac{33}{2}}\left(5\ast {\displaystyle \frac{x_6}{2}}+9\right)\hfill \\ \hfill x_6& =& 6;\hfill \end{array}$$

$$\begin{array}{ccc}\hfill -141& =& 39\left(21\right)-16\left(x_7+42\right)\hfill \\ \hfill x_7& =& 18;\hfill \end{array}$$

$$\begin{array}{ccc}\hfill 214& =& 46\left(15\right)-28\left(x_8+15\right)\hfill \\ \hfill x_8& =& 2;\hfill \end{array}$$

$$\begin{array}{ccc}\hfill -2(-196)& =& 44\left(x_9+28\right)-42\left(2x_9\right)\hfill \\ \hfill x_9& =& 21.\hfill \end{array}$$

We determine $x_i$ as $b_4^i$

$$\begin{array}{ccc}{x}_1=b_1^1=4& x_2=b_1^2=26& x_3=b_1^3=16\\ x_4=b_1^4=10& x_5=b_1^5=28& x_6=b_1^6=6\\ x_7=b_1^7=18& x_8=b_1^8=2& x_9=b_1^9=21.\end{array}$$

Step 5. We construct the block matrices $M_i$ and M.

Relations Between the Code Matrices

It is known that the code matrix E and the message matrix M have the following properties for $i=1$, $5,\dots , 4k+1,$$k\in \mathbb{N}$ in our coding method:

$$\begin{array}{ccc}\hfill E_1& =& M_1\times J=\left[\begin{array}{cc}\hfill b_1^1& \hfill b_2^1\\ \hfill b_3^1& \hfill b_4^1\end{array}\right]\left[\begin{array}{cc}{j}_{n+1}& 2j_n\\ j_n& 2j_{n-1}\end{array}\right]=\left[\begin{array}{cc}\hfill e_1^1& \hfill e_2^1\\ \hfill e_3^1& \hfill e_4^1\end{array}\right],\hfill \\ \hfill \left[\begin{array}{cc}\hfill b_1^1& \hfill b_2^1\\ \hfill b_3^1& \hfill b_4^1\end{array}\right]& =& {\displaystyle \frac{1}{2^n}}\left[\begin{array}{cc}\hfill e_1^1& \hfill e_2^1\\ \hfill e_3^1& \hfill e_4^1\end{array}\right]\left[\begin{array}{cc}-2j_{n-1}& 2j_n\\ j_n& -j_{n+1}\end{array}\right].\hfill \end{array}$$

For $i=2$, $6,\dots , 4k+2,$$k\in \mathbb{N},$ we get

$$\begin{array}{ccc}\hfill E_2& =& M_2\times S=\left[\begin{array}{cc}\hfill b_1^2& \hfill b_2^2\\ \hfill b_3^2& \hfill b_4^2\end{array}\right]\left[\begin{array}{cc}{l}_n/2& 5f_n/2\\ f_n/2& l_n/2\end{array}\right]=\left[\begin{array}{cc}\hfill e_1^2& \hfill e_2^2\\ \hfill e_3^2& \hfill e_4^2\end{array}\right]\hfill \\ \hfill \left[\begin{array}{cc}\hfill b_1^2& \hfill b_2^2\\ \hfill b_3^2& \hfill b_4^2\end{array}\right]& =& \left[\begin{array}{cc}\hfill e_1^2& \hfill e_2^2\\ \hfill e_3^2& \hfill e_4^2\end{array}\right]\left[\begin{array}{cc}-l_n/2& 5f_n/2\\ f_n/2& -l_n/2\end{array}\right].\hfill \end{array}$$

For odd values of n, some entries of the matrix S become half-integers. To preserve an integer-valued coding structure, we introduce the scaled matrix $\widehat{S}=2S$. All encoding and decoding operations are then performed using $\widehat{S}$, ensuring that ciphertext matrices remain integer-valued.

If $i=3$, $7,\dots , 4k+3,$$k\in \mathbb{N},$ we obtain

$$\begin{array}{ccc}\hfill E_3& =& M_3\times P=\left[\begin{array}{cc}\hfill b_1^3& \hfill b_2^3\\ \hfill b_3^3& \hfill b_4^3\end{array}\right]\left[\begin{array}{cc}{p}_{n-1}& p_n\\ p_n& p_{n+1}\end{array}\right]=\left[\begin{array}{cc}\hfill e_1^3& \hfill e_2^3\\ \hfill e_3^3& \hfill e_4^3\end{array}\right]\hfill \\ \hfill \left[\begin{array}{cc}\hfill b_1^3& \hfill b_2^3\\ \hfill b_3^3& \hfill b_4^3\end{array}\right]& =& \left[\begin{array}{cc}\hfill e_1^3& \hfill e_2^3\\ \hfill e_3^3& \hfill e_4^3\end{array}\right]\left[\begin{array}{cc}-p_{n+1}& p_n\\ p_n& -p_{n-1}\end{array}\right].\hfill \end{array}$$

If $i=4$, $8,\dots , 4k,$$k\in \mathbb{N},$ we have

$$\begin{array}{ccc}\hfill E_4& =& M_4\times F=\left[\begin{array}{cc}\hfill b_1^4& \hfill b_2^4\\ \hfill b_3^4& \hfill b_4^4\end{array}\right]\left[\begin{array}{cc}{f}_{n-1}& f_n\\ f_n& f_{n+1}\end{array}\right]=\left[\begin{array}{cc}\hfill e_1^4& \hfill e_2^4\\ \hfill e_3^4& \hfill e_4^4\end{array}\right]\hfill \\ \hfill \left[\begin{array}{cc}\hfill b_1^4& \hfill b_2^4\\ \hfill b_3^4& \hfill b_4^4\end{array}\right]& =& \left[\begin{array}{cc}\hfill e_1^4& \hfill e_2^4\\ \hfill e_3^4& \hfill e_4^4\end{array}\right]\left[\begin{array}{cc}-f_{n-1}& f_n\\ f_n& -f_{n+1}\end{array}\right].\hfill \end{array}$$

We obtain some results by the multiplications of these matrices. For example, for the fourth matrix, we have calculated the elements of the matrix $M_4$ as

$$\begin{array}{ccc}\hfill b_1^4& =& -f_{n-1}{e}_1^4+f_n{e}_2^4>0\hfill \\ \hfill b_2^4& =& f_n{e}_1^4-f_{n+1}{e}_2^4>0\hfill \end{array}$$

(1)

and

$$\begin{array}{ccc}\hfill b_3^4& =& -f_{n-1}{e}_3^4+f_n{e}_4^4>0\hfill \\ \hfill b_4^4& =& f_n{e}_3^4-f_{n-1}{e}_4^4>0.\hfill \end{array}$$

(2)

The following inequalities are obtained by the inequalities (1)

$${\displaystyle \frac{f_{n+1}}{f_n}}⋖{\displaystyle \frac{e_1^4}{e_2^4}}⋖{\displaystyle \frac{f_n}{f_{n-1}}}$$

and similarly by (2), we get

$${\displaystyle \frac{f_{n-1}}{f_n}}<{\displaystyle \frac{e_3^4}{e_4^4}}<{\displaystyle \frac{f_n}{f_{n-1}}}.$$

We know that the ratio of the consecutive Fibonacci numbers converges to the “golden ratio” [22]. Hence, the following approximate equalities connect the entries of the coding matrix as $e_1^4\simeq \rho e_2^4$ and $e_3^4\simeq \rho e_4^4$ where $\rho$$={\displaystyle \frac{1+\sqrt{5}}{2}}.$ For the other coding matrices, we get similar results.

4. Error Detection and Correction Mechanism

The error-detection capability of the proposed algorithm follows directly from the determinant-preserving property of the block-wise matrices. For each $2\times 2$ block, the determinant provides a scalar invariant that uniquely constrains the admissible matrix entries under invertible matrices. Consequently, inconsistencies caused by erroneous entries violate this invariant and can be detected by simple algebraic operations. Since each block contains four entries subject to a single determinant constraint, the resulting redundancy enables analytic identification and correction of all error entries except the degenerate case in which all block entries are simultaneously corrupted.

The encoding method proposed in this paper gives us the opportunity to detect and correct errors in the code message $E_i$. The main idea of error detection and correction is based on the property of the matrix determinant given by the formula $Det{E}_i={(-1)}^{n}Det{M}_i$ and on the connections between the elements of the code matrix given by the approximate equalities $e_1^i\simeq \rho e_2^i$ and $e_3^i\simeq \rho e_4^i$ (they are true for $i=4$, $8,\dots ,4k,$$k\in \mathbb{N}).$ For the other values of $i,$ we get similar results from the matrices $J, S,$ and P. Determinant-based consistency relations have previously appeared in Fibonacci-type coding methods; however, in the proposed framework, these invariants are extended to heterogeneous hybrid recurrence operators. For $2\times 2$ matrices, determinant invariants admit explicit closed-form manipulation, which is essential for the proposed correction mechanism. In higher-dimensional settings, maintaining explicit determinant-based correction formulas becomes considerably more difficult due to the rapid growth of coupled algebraic relations.

First of all, we compute the determinant of the message matrices $M_i$, and send it to the receiver with the elements of the code matrix. The determinant $Det{M}_i$ is the “checking element” of the code matrix $E_i$. We compute the determinant of the code matrix $E_i$, and then compare $Det{M}_i$ with $Det{E}_i$ according to the fundamental “checking relation” $E_i=M_i\times F($ or $J, S,$ and P or their powers), and so $Det{E}_i={(-1)}^{n}Det{M}_i$ or $Det{E}_i={(-2)}^{n}Det{M}_i$. If this identity is true, we can conclude that the elements of the code matrix $E_i$ were transmitted accurately. In the other case, the elements of the code matrix $E_i$ or $Det{M}_i$ are transferred incorrectly. Then, we can try to correct these errors using the “checking relations” described above. If only one error in the code matrix $E_i$ is received, we have four cases of this error in $E_i$ as in the following:

1st case: $\left[\begin{array}{cc}\hfill a& \hfill e_2^i\\ \hfill e_3^i& \hfill e_4^i\end{array}\right]$, 2nd case: $\left[\begin{array}{cc}\hfill e_1^i& \hfill b\\ \hfill e_3^i& \hfill e_4^i\end{array}\right]$, 3rd case: $\left[\begin{array}{cc}\hfill e_1^i& \hfill e_2^i\\ \hfill c& \hfill e_4^i\end{array}\right]$, 4th case: $\left[\begin{array}{cc}\hfill e_1^i& \hfill e_2^i\\ \hfill e_3^i& \hfill d\end{array}\right]$ where $a,$$b,$$c,$d are possible elements submitted incorrectly.

The following equations are based on the “checking relation” $Det{E}_i={(-1)}^{n}Det{M}_i$ or $Det{E}_i={(-2)}^{n}Det{M}_i$:

$a{e}_4^i-e_2^i{e}_3^i={\left(-1\right)}^{n}det{M}_i$ (a possible “single error” is in the element $e_1^i);$

$e_1^i{e}_4^i-b{e}_3^i={\left(-1\right)}^{n}det{M}_i$ (a possible “single error” is in the element $e_2^i);$

$e_1^i{e}_4^i-$$e_2^{i}c={\left(-1\right)}^{n}det{M}_i$ (a possible “single error” is in the element $e_3^i);$

$e_1^{i}d-e_2^i{e}_3^i=$${\left(-1\right)}^{n}det{M}_i($ a possible “single error” is in the element $e_4^i).$

From the four cases, we obtain the possible “single errors”

$$\begin{array}{ccc}\hfill a& =& {\displaystyle \frac{{\left(-1\right)}^{n}det{M}_i+e_2^i{e}_3^i}{e_4^i}},b={\displaystyle \frac{{\left(-1\right)}^{n}det{M}_i+e_1^i{e}_4^i}{e_3^i}},\hfill \\ \hfill c& =& {\displaystyle \frac{{\left(-1\right)}^{n}det{M}_i+e_1^i{e}_4^i}{e_2^i}},d={\displaystyle \frac{{\left(-1\right)}^{n}det{M}_i+e_2^i{e}_3^i}{e_1^i}}.\hfill \end{array}$$

(3)

If $i=1$, $5,\dots ,4k+1,$$k\in \mathbb{N},$ we change ${\left(-1\right)}^n$ with ${\left(-2\right)}^n.$ We have to choose the correct form among the cases of the integer solutions $a,$$b,$ $c,$ and d; in addition, it must satisfy the additional “checking relations” $e_1^i\simeq \rho e_2^i$ and $e_3^i\simeq \rho e_4^i$. If the solutions by (3) do not give an integer result, then our guess of a “single error” is incorrect. Maybe the “error” is the “checking element” $Det{M}_i$.

By analogy, we can control all cases of “double” errors in the code matrix E. If double errors in the code matrix E are received, we have six cases of this error in E. One of them is in the following:

$$\left[\begin{array}{cc}\hfill a& \hfill b\\ \hfill e_3^i& \hfill e_4^i\end{array}\right]$$

By the first “checking relation” $det{E}_i={(-1)}^{n}det{M}_i,$ we can write

$$a{e}_4^i-b{e}_3^i={\left(-1\right)}^{n}det{M}_i.$$

(4)

Nevertheless, according to the second “checking relation” $e_1^i\simeq \rho e_2^i,$ we get the relation $a\simeq \rho b.$ Equation (4) is “Diophantine”, so this equation has many solutions. We have to take care of the solutions for a and b satisfying $a\simeq \rho b$. We have to control all possible “double error” cases in the code matrix E.

Similarly, if there are “triple” errors in the code matrix $E_i$, we can show a possibility for them as

$$\left[\begin{array}{cc}\hfill a& \hfill b\\ \hfill c& \hfill e_4^i\end{array}\right]$$

You see, we correct the errors by controlling the “checking relations” mentioned above, and the fact that the elements of the code matrix are integers. If all solutions do not give integer solutions, it means that the true value of $det{M}_i$ is not submitted.

If we have the case of “fourfold error” in the code matrix $E_i$, we have to reject the code matrix $E_i$ because it can not be corrected.

For single-entry corruption, the determinant equation reduces the admissible solution set to a small family of integer candidates, while the recurrence-based consistency conditions allow the correct value to be uniquely identified. The scheme can correct up to three erroneous entries in each $2\times 2$ block using determinant constraints and algebraic relations. Let the total number of possible error patterns be

$$\left({\displaystyle \genfrac{}{}{0pt}{}{4}{1}}\right)+\left({\displaystyle \genfrac{}{}{0pt}{}{4}{2}}\right)+\left({\displaystyle \genfrac{}{}{0pt}{}{4}{3}}\right)+\left({\displaystyle \genfrac{}{}{0pt}{}{4}{4}}\right)=15.$$

Out of these, 14 cases are correctable. Under the considered single-block perturbation model, the proposed algebraic reconstruction mechanism successfully resolves 14 out of 15 admissible error configurations. We have four different code matrices. Thus, the possibility of correction of our method is equal to ${\displaystyle \frac{56}{60}}=$${\displaystyle \frac{14}{15}}\approx 93.33\%.$ This provides robustness not only against transmission noise but also against active tampering attempts. Under the considered block-wise error configurations, the algorithm allows correction of all non-degenerate cases.

Decision Tree Steps:

• Input: The received encoded matrix $E_i$ and the key matrix K.
• Determinant check: $det\left(E_i\right)$ is calculated.
  • Condition: Is $det\left(E_i\right)=det\left(M_i\right)det\left(K\right)$ ?
  • YES: No error. Proceed directly to the decoding step $M_i=K^{-1}{E}_i)$.
  • NO: Error detected. Run the error correction module.
• Error correction module (branching):
  • Single error check: Check if the determinant is satisfied by changing one of the matrix elements (4 possibilities).
  • Double error check: Simultaneous variations on two elements are tested (6 possibilities).
  • Triple error check: Tests are performed on three elements (4 possibilities).
• Output: Corrected original message block $M_i$

The logical flow of the error detection and recovery process is governed by a decision tree based on the determinant invariant. Upon receiving a ciphertext block $E_i$, the system first calculates its determinant to verify if it aligns with the expected algebraic product of the key and message determinants. If a discrepancy is found, the algorithm branches into a systematic search across the 14 correctable error patterns. This decision-making structure ensures that even when the data is corrupted during transmission, the original plaintext can be reconstructed with high fidelity, provided the error does not fall into the singular uncorrectable quadruple-error case.

Unlike traditional error-correcting codes that introduce explicit redundancy through parity symbols or auxiliary check bits, the proposed framework derives correction capability directly from intrinsic algebraic consistency relations of the recurrence-generated matrix structure. Therefore, the additional communication overhead remains minimal and does not scale with message length. A small amount of auxiliary synchronization information may still be required depending on the implementation model. Since the corrupted entries are constrained simultaneously by determinant preservation, recurrence relations, and integrality conditions, the admissible solution space becomes sufficiently restricted to permit reconstruction in most non-degenerate cases.

Stability and perturbation behavior of block-wise matrix transformations constitute an important aspect of recurrence-based coding systems, particularly when determinant-preserving operations and error-sensitive decoding procedures are involved. In this context, matrix sensitivity studies such as the block Cholesky perturbation analysis in [18] provide useful theoretical background for understanding the robustness of structured block transformations. Although the proposed framework does not directly employ Cholesky downdating techniques, both approaches involve sensitivity analysis of structured block matrices under perturbations and reconstruction constraints.

5. Complexity Analysis

This section analyzes the computational efficiency of the proposed framework in terms of time complexity, memory consumption, and practical implementation cost.

5.1. Encoding and Decoding Complexity

The encoding process consists of two main steps:

• Matrix Creation: Calculation of the nth term of Fibonacci, Lucas, Pell, and Jacobsthal sequences. Each term can be calculated in $O\left(1\right)$ or $O\left(logn\right)$ time using Binet’s formula or recurrence relation. Since a fixed number of terms is calculated in total, the complexity of this step is negligible.
• Matrix Multiplication: A message matrix of M is divided into $2\times 2$ blocks. The matrix multiplication performed for each block has a complexity of $O\left(2^3\right)$. This operation has a fixed cost for each block (8 multiplications, 4 additions).
• Total Complexity: The processing for the entire message is $O\left(8n\right)$. The overall encoding complexity is $O\left(n\right)$, which is linear time.

The decoding process requires multiplying the cipher matrix by the inverse of the key matrix $M_i^{-1}$:

• Inverse matrix calculation: Calculating the inverse of a $2\times 2$ matrix is a constant-time operation.
• Multiplication: As in the encoding step, a fixed number of operations is performed for each block.
• Total complexity: The decoding process also takes $O\left(n\right)$ time, directly proportional to the message length.

5.2. Error Detection and Correction Complexity

The error correction mechanism relies on determinant checking and comparison operations:

• The determinant is calculated for each block $O\left(1\right)$.
• If the determinant is not preserved, 15 possible error cases are scanned. This scanning process also involves a fixed number (maximum 15) of checks.
• The error correction step adds an additional overhead of $O\left(1\right)$ for each block, regardless of message length. This does not change the overall complexity of $O\left(n\right)$.

5.3. Space Complexity

Data Storage

• Message matrix M: The numerical values of the message are stored in memory in a linear structure $O\left(4m\right)$. However, since the algorithm works in a block-based manner $2\times 2$, it is not necessary to load the entire message into memory at the same time. The message can be processed in blocks (stream).
• Key matrices: Key matrices containing Fibonacci, Lucas, Pell, and Jacobsthal numbers are only $2\times 2$ in size. The space occupied by these matrices is $O\left(k^2\right)$, which is constant since $k=2$.

Auxiliary Space

• Calculating sequence terms: If an iterative approach is used to calculate the nth terms of number sequences, it is sufficient to store only the last two terms. This requires $O\left(1\right)$ additional memory.
• Temporary variables: Temporary variables (sum, product, and determinant values) used during matrix multiplication and determinant checking are of fixed size.

Total Memory Complexity

The proposed algorithm requires only $O\left(1\right)$ auxiliary space, since it operates on fixed $2\times 2$ blocks and stores only a small number of recurrence coefficients, matrix elements, and temporary variables. Moreover, when the message is processed sequentially using a stream-based block structure, the instantaneous memory consumption becomes independent of the message length. This memory-efficient design makes the proposed framework well-suited for resource-constrained environments, including embedded systems and IoT devices.

5.4. Performance Evaluation of the Algorithm

As we know, one of the biggest problems is slowness in the encryption methods. In this method, using symmetric encryption overcomes the slowness in the encryption method. The proposed scheme relies on elementary matrix operations, which suggests favorable computational characteristics.

The alphabet system in this study is used to make it ready for cryptographic applications. In addition, it is difficult to find combinations using a brute force attack of plain text with algorithms created based on this coding structure.

For this reason, one of the biggest advantages of the algorithm proposed is that the infrastructure of this coding structure is suitable. On the other hand, the method that we have proposed allows us to use it can be used for other special integer matrix sequences.

When evaluating the performance of this model, it can be said that the method is suitable for both encryption/decryption time and encoding for developing secure cryptographic applications.

As summarized in

Table 2. Computational complexity analysis of the proposed framework.

Process	Time Comp.	Space Comp.	Operations
Key generation	$O\left(logn\right)$ or $O\left(1\right)$	$O\left(1\right)$	Compute $K^n$
Encoding	$O\left(k^3\right)$	$O\left(1\right)$	Multiplication
Decoding	$O\left(k^3\right)$	$O\left(1\right)$	Inversion and multiplication
Total process (message n)	$O\left(n\right)$	$O\left(1\right)$	Linear pass over message blocks
E. detection	$O\left(1\right)$	$O\left(1\right)$	Det checking
E. correction	$O\left(1\right)$	$O\left(1\right)$	Case-based adjustment

, the proposed scheme achieves optimal efficiency for real-time applications. Since the block size k is fixed at 2, all matrix operations, including inversion and multiplication, are performed in constant time, $O\left(1\right)$, per block. Consequently, the overall time complexity scales linearly, $O\left(n\right)$, with the message length n. Furthermore, the algorithm is exceptionally memory-efficient, requiring only $O\left(1\right)$ auxiliary space as it does not necessitate large lookup tables or extensive buffering, making it an ideal candidate for resource-constrained hardware.

Our system has a block-based structure. If a different sequence combination or different indices (key rotation) are used for each block, the attacker is prevented from applying the information obtained from one block to other blocks. In addition, the determinant-protection property of the matrices is only used for error correction. The security of the proposed scheme relies on the large key space provided by the indices of the four distinct recurrence sequences. With a sufficiently large index n, the total key space exceeds $2^{128}$ combinations, rendering brute-force attacks computationally difficult. Moreover, the exponential growth of Fibonacci-type sequences ensures a high sensitivity to key parameters, known as the avalanche effect. Any bit-level deviation in the key leads to a completely different inverse matrix, preventing the recovery of the plaintext. Additionally, the determinant-preserving property acts as an integrity check against unauthorized ciphertext manipulation. The error correction mechanism provides a line of defense not only against channel noise but also against intentional changes (tampering) made to the ciphertext by active attackers. Corruption of the determinant immediately reveals that there has been an unauthorized intervention in the system (

Table 3. Comparative analysis of the proposed framework and existing methods.

Feature	Classical Hill Cipher	Fibonacci-Based Method	Proposed Hybrid Method
-Matrix dimension	Static $n\times n$	$2\times 2$ sequence	$2\times 2$ Multi-sequence
-Sequence variety	None	Fibonacci	Fibonacci, Lucas, Pell, Jacobsthal
-Key	Constant	Fixed	Dynamic hybrid
Generation	Matrix	Recurrence	Selection
-Error detection	Not available	Determinant-based	Advanced det. invariance
-Invertibility	Requires $gcd\left(det\right(A),m)$ = 1	Sequence dependent	Explicit guaranteed
-Computational cost	High $O\left(n^3\right)$ (for inversion)	Low $O\left(n\right)$	Optimal $O\left(n\right)$ (Linear time)

).

The proposed hybrid framework offers several strategic advantages over classical Hill ciphers and conventional Fibonacci-based encoding schemes, as summarized in the table above. Unlike the classical Hill cipher, which requires computationally expensive modular inverse calculations and a static key matrix, our method utilizes multiple linear recurrence sequences—including Fibonacci, Lucas, Pell, and Jacobsthal numbers to construct transformation matrices. This hybrid approach significantly expands the potential key space without increasing the matrix dimension. Furthermore, the determinant-preserving property of the chosen sequences ensures that the matrices are explicitly invertible, facilitating a robust and an efficient decoding process. The framework also supports an intrinsic error-detection mechanism through algebraic invariants, maintaining a linear computational complexity of $O\left(n\right)$, which is ideal for real-time secure communication.

Sensitivity to Initial Conditions

In the proposed method, even the smallest change in the indices forming the key matrix (e.g., using $n+1$ instead of n) completely changes the matrix elements and therefore the inverse matrix. Due to the exponential growth characteristic of Fibonacci, Lucas, Jacobsthal, and Pell sequences, a small deviation in the key creates an “avalanche effect” in the decoded text, preventing the original message from being obtained. The proposed encryption scheme has high sensitivity. A minimal increment in the sequence index (from $n=5$ to $n=6$) results in a significant deviation in the elements of the matrices. Due to the exponential growth of these numbers, this small change propagates by matrix multiplication, causing a complete diffusion in the ciphertext. As a result, even a single-digit error in the key leads to a completely undecipherable output, confirming that the algorithm provides strong resistance against differential cryptanalysis.

6. Cryptographic Security Analysis

Threat Model and Assumptions

The proposed scheme is evaluated under standard cryptographic attack models, including ciphertext-only attack (COA), known-plaintext attack (KPA), and chosen-plaintext attack (CPA). It is assumed that the adversary has full knowledge of the encryption algorithm, in accordance with Kerckhoffs’s principle, and the security relies solely on the secrecy of the key parameter n and the sequence selection strategy.

6.1. Key Space Analysis

A key feature of the proposed approach is the explicit preservation of algebraic invariants, particularly the determinant, and provides an intrinsic consistency condition at the block level. This property forms the mathematical foundation for analytic error-detection and correction mechanisms, enabling the identification and correction of many transmission inconsistencies through elementary matrix properties.

The security of an encoding framework critically depends on the size of its key space. In the proposed scheme, the key is defined by the indices of four independent recurrence sequences: Fibonacci $\left(f_n\right),$ Lucas $\left(l_n\right)$, Pell $\left(p_n\right)$, and Jacobsthal $\left(j_n\right)$. In the current implementation, the encryption process employs a single global index parameter n, and therefore the effective key space depends on the admissible range of this parameter. Consequently, the practical security level is determined by the selection strategy and variability of n, rather than by independent multi-parameter indexing. A generalized extension of the framework could employ independent block-dependent indices for different recurrence families, significantly enlarging the effective key space. Considering the combination of independent indices for Fibonacci, Lucas, Pell, and Jacobsthal sequences alongside the dynamic selection probabilities within the hybrid framework, the total key space is estimated to exceed $2^{128}$ bits, providing robust resistance against brute-force attacks and meeting modern cryptographic security standards.

Furthermore, if block-dependent sequence selection is employed, the effective key space increases exponentially with the number of blocks, providing additional resistance against brute-force and combinatorial attacks in the generalized extension.

6.2. Resistance to Linear and Algebraic Attacks

The proposed encryption framework is based on a block-wise matrix transformations involving dynamically changing matrices derived from four distinct recurrence relations.

Theorem 1

(Resistance to Linear Reconstruction). Let $E_i=M_i\times K.$ Denote the encryption process, where K is selected from $(F^n, S^n, J^n, P^n)$. Then, recovering $M_i$ from a set of ciphertext blocks without knowledge of the sequence index n leads to a system of nonlinear equations.

Proof. 

Each matrix $K_i$ depends nonlinearly on n through recurrence relations. Since different blocks may use different matrices, the attacker must solve a mixed system involving multiple recurrence structures. This leads to a high-dimensional nonlinear system with no efficient closed-form inversion unless n is known. Therefore, linear algebra attacks are computationally difficult. □

Theorem 1 implies that the proposed encryption mechanism cannot be reduced to a simple linear reconstruction problem without knowledge of the key parameter. Since the transformation matrices are generated from nonlinear recurrence sequences and may vary across blocks, an adversary is forced to solve a coupled nonlinear system rather than a standard linear system.

From a cryptographic perspective, this significantly increases the resistance of the scheme against linear and algebraic attacks. In particular, the absence of a fixed global transformation matrix prevents attackers from applying classical linear algebra techniques to recover the plaintext or key efficiently.

6.3. Preliminary Diffusion Analysis

Differential Attack Resistance

Differential cryptanalysis studies how differences in plaintext affect ciphertext differences. Let two plaintext blocks differ by a small perturbation

$$\Delta M=M\oplus M^{\prime }$$

Then, the resulting ciphertext difference is

$$\Delta E=(M·K)\oplus (M^{\prime }·K)$$

Due to matrix multiplication and the growth properties of recurrence sequences, small input differences propagate across all matrix elements.

Theorem 2

(Diffusion Property). The proposed transformation achieves full diffusion within a single block, i.e., a change in any element of $M_i$ affects all elements of $E_i.$

Proof. 

Each output entry $e_{ij}$ is a linear combination of all entries of $M_i$ weighted by elements of $F_i$. Since all entries of $F_i$ are non-zero for sufficiently large n, every output entry depends on all input entries. Hence, full diffusion is achieved. □

Theorem 2 establishes that the proposed scheme achieves full diffusion at the block level. This means that any small perturbation in the plaintext, such as a single-symbol or bit-level modification, propagates to all components of the corresponding ciphertext block.

This property is essential for resisting differential cryptanalysis, as it ensures that input differences do not produce predictable output patterns. The observed avalanche effect, which approaches the ideal value of $50\%$, further confirms that the algorithm provides strong confusion and diffusion characteristics comparable to modern block ciphers.

Determinant-Based Integrity and Attack Detection

A unique feature of the proposed scheme is the determinant-preserving structure

$$det\left(E_i\right)=\lambda det\left(M_i\right),\lambda \in \left\{{\left(-1\right)}^n,{\left(-2\right)}^n\right\}.$$

This invariant provides an intrinsic mechanism for detecting tampering. To clarify this distinction, additional explanations and intermediate derivation steps have been added to the revised manuscript.

Theorem 3

(Integrity Verification). Any unauthorized modification in the ciphertext block $E_i$ is detectable unless all elements are simultaneously altered in a consistent manner.

Proof. 

Any single or partial modification changes the determinant, violating the invariant relation. Therefore, inconsistencies are immediately detectable via determinant comparison. □

Theorem 3 demonstrates that the determinant invariant acts as an intrinsic integrity verification mechanism. Any unauthorized modification of the ciphertext disrupts the determinant relationship, making such alterations immediately detectable.

From a security standpoint, this property provides robustness against active attacks, including ciphertext manipulation and transmission errors. Unlike conventional cryptosystems that require additional authentication layers, the proposed scheme integrates integrity verification directly into its algebraic structure, enhancing both efficiency and reliability.

Computational Security Evaluation

The algorithm operates in linear time: $T\left(n\right)=O\left(n\right)$ and constant auxiliary space: $S\left(n\right)=O\left(1\right).$ Despite its low computational cost, the combination of: large key space, nonlinear sequence dependence, block-wise variability, and determinant-based validation ensures that the system achieves a strong balance between efficiency and security.

6.4. Shannon Entropy Analysis

To evaluate the randomness of the ciphertext, Shannon entropy is computed

$$H=-\underset{i=0}{\sum ^n}{p}_i{log}_2^{p_i}$$

where $p_i$ denotes the probability of occurrence of symbol i.

For an ideal 8-bit system, the entropy should approach 8. Numerical experiments conducted on randomly generated plaintexts show that the entropy of the ciphertext produced by the proposed scheme lies in the interval: $H\approx 7.98-7.999.$ This demonstrates that the ciphertext distribution is close to uniform, indicating strong resistance against statistical attacks.

To evaluate the randomness of the ciphertext, Shannon entropy was computed for multiple plaintext inputs of varying sizes (

Table 4. Entropy analysis results.

Test Case	Plaintext Length	Entropy (Plaintext)	Entropy (Ciphertext)
Test 1	128 chars	4.21	7.982
Test 2	256 chars	4.35	7.991
Test 3	512 chars	4.47	7.995
Test 4	1024 chars	4.52	7.998

).

The entropy values of the ciphertext approach the ideal value of 8, indicating that the proposed scheme produces highly random outputs and is resistant to statistical attacks.

6.5. Avalanche Effect Analysis

A secure encoding framework must exhibit high sensitivity to small changes in the key. Due to the exponential growth properties of the underlying recurrence sequences, a minimal variation in the key parameter (e.g., $n\to n+1)$ produces significant changes in the transformation matrices. Let $E\left(n\right)$ and $E(n+1)$ denote ciphertexts generated using adjacent keys. The avalanche effect is quantified as

$$\mathrm{Avalanche}\mathrm{Ratio}={\displaystyle \frac{\mathrm{Number}\mathrm{of}\mathrm{differing}\mathrm{bits}}{\mathrm{Total}\mathrm{bits}}}\times 100\%$$

Experimental observations indicate that the proposed method achieves an avalanche ratio close to $50\%$, which is considered optimal for cryptographic-style transformation systems (

Table 5. Avalanche effect results.

Test Case	Plaintext Bits	Changed Bits in Ciphertext	Avalanche Ratio (%)
Test 1	1024	503	49.12%
Test 2	2048	1017	49.66%
Test 3	4096	2058	50.24%
Test 4	8192	4110	50.12%

). A single-bit modification was applied to the plaintext, and the resulting change in the ciphertext was measured.

The avalanche ratio is consistently close to $50\%$, which is considered optimal for cryptographic-style transformation systems. This confirms that the proposed method achieves strong diffusion properties.

Comparison with AES-like Diffusion (

Table 6. Diffusion comparison.

Property	Proposed Method	AES (Reference)
Block structure	$2\times 2$ dynamic blocks	$4\times 4$ fixed
Avalanche effect	~$50\%$	~$50\%$
Diffusion speed	1 round	Multiple rounds
Key sensitivity	High (nonlinear sequences)	High
algebraic structure	Recurrence-based	Substitution-permutation

)

The proposed method shows diffusion characteristics qualitatively similar to those observed in classical block ciphers, despite relying only on a single matrix multiplication per block. Unlike AES, which requires multiple rounds of substitution and permutation, the proposed scheme leverages the exponential growth and the nonlinear structure of recurrence sequences to achieve rapid diffusion within a single step.

This property significantly reduces computational overhead while preserving cryptographic characteristics.

The ability to achieve near-optimal avalanche behavior with a single transformation step distinguishes the proposed method from the classical block ciphers and highlights its efficiency-security trade-off.

Figure Explanations (Figure 1)

Comparison of Shannon entropy between plaintext and ciphertext. The entropy values remain close to the ideal value of 8, indicating near-uniform ciphertext distribution and reduced statistical predictability.

Figure 2 illustrates the avalanche behavior of the proposed hybrid transformation framework under single-character perturbations. The observed rapid diffusion indicates that small plaintext modifications propagate efficiently across the encoded blocks. The obtained diffusion rates demonstrate that local perturbations rapidly affect neighboring encoded components, which strengthen resistance against differential-style reconstruction attempts. Compared with classical single-sequence recurrence schemes, the proposed framework exhibits more heterogeneous diffusion behavior due to dynamic sequence switching (Figure 3).

Sensitivity of ciphertext with respect to key variation ($n\to n+1$) Despite integrating multiple recurrence structures, the proposed framework preserves low computational growth.

7. Conclusions

In this study, we introduced a novel hybrid cryptographic framework based on the algebraic properties of special integer sequences, including Fibonacci, Lucas, Pell, and Jacobsthal numbers. By moving beyond traditional single-sequence models, the proposed scheme utilizes $2\times 2$ matrix transformations within a unified block-based structure. The primary innovation lies in the dynamic selection of recurrence-based matrices, which significantly expands the private key space and enhances resistance against linear algebraic cryptanalysis. A critical feature of the framework is the utilization of determinant invariants, which ensures explicit invertibility and enables an intrinsic error-detection and correction mechanism at the block level. Theoretical analysis and illustrative examples confirm that the algorithm maintains a linear computational complexity of $O\left(n\right)$, making it highly efficient for real-time secure communication and memory-constrained environments. Furthermore, the modular nature of the system allows for seamless integration of other linear recurrence families. Future research will focus on extending this hybrid approach to higher-dimensional matrix representations and evaluating its performance against advanced statistical attacks in large-scale data transmission.

The present study should not be interpreted as a replacement for standardized modern cryptographic protocols. Rather, it provides an algebraically structured recurrence-based transformation framework whose mathematical properties may be useful for lightweight encoding, integrity verification, and educational cryptographic applications.