Wikipedia

Reversible programming language

A reversible programming language is designed to bridge the gap between the theoretical models of reversible computing and practical software development. They provide constructs that allow programmers to write code that is guaranteed, by the language's syntax and semantics, to be executable both forwards and backwards deterministically.

Core concepts and design principles

edit

The fundamental goal of a reversible programming language is to support computation that is deterministic in both the forward and backward directions.[1] This is typically achieved by ensuring that every primitive operation and composite statement within the language is locally invertible.[1] Local invertibility means that each basic computational step has a well-defined inverse, and the inverse of a sequence of steps is the sequence of inverse steps performed in reverse order.

Key in the design of many reversible languages is cleanliness or garbage-free computation.[2] This means avoiding the accumulation of auxiliary information (like computation histories or ancilla bits) that is generated solely for the purpose of enabling reversibility but is not part of the desired output.[3] Clean reversible languages aim to perform computations and their reversals using only the specified input and output variables.

To achieve local invertibility and cleanliness, reversible languages typically incorporate several features:

  • Reversible Updates: Standard assignment statements (x = expression) are inherently irreversible because they overwrite and erase the previous value of x. Reversible languages replace these with reversible updates, often denoted using operators like +=, -=, ^= (bitwise XOR).[4] An important restriction is that the variable being updated (e.g., x in x += e) must not appear in the expression on the right-hand side (e) to ensure the operation is bijective.[4] The swap operation (x <=> y), which exchanges the values of two variables, is another fundamental reversible update.[5]
  • Reversible Control Flow: Conventional control flow structures like If-then-else and While loops merge computational paths, making them irreversible. Reversible languages introduce specialized constructs. Conditionals often require both a test condition (evaluated on entry) and an assertion (a predicate that must hold true on exit from one branch and false on exit from the other).[6] Similarly, loops might require entry assertions and exit tests.[4] These additional predicates store the necessary information to determine the execution path uniquely during backward execution, where the roles of tests and assertions are typically swapped.[6] This explicit management of control flow information is a significant difference from conventional programming.
  • Procedure Calls: Languages need mechanisms to invoke procedures both forwards and backwards. This is often achieved through paired commands like call (forward execution) and uncall or rcall (backward execution).[5]
  • Data Structures: Early reversible languages often restricted data types to simple ones like integers and fixed-size arrays.[4] Handling dynamic data structures like stacks requires careful semantic design to maintain reversibility, such as assuming variables are zero-cleared before being pushed onto a stack, ensuring pop can perfectly reverse push.[5] More recent research has explored reversible object-oriented features, including user-defined types, inheritance, and polymorphism.[7]
  • Computational Power: A common benchmark for the power of a reversible language is r-Turing completeness, which means the language can simulate any Reversible Turing Machine cleanly (without garbage accumulation).[5]

Janus Language

edit

Janus is widely recognized as the first structured, imperative programming language designed explicitly for reversible computation.[4] Originally conceived by Christopher Lutz and Howard Derby at Caltech in the 1980s,[5] it was later rediscovered, formalized, and extended, notably by Tetsuo Yokoyama and Robert Glück.[5]

Design philosophy

edit

Janus embodies the principle of local invertibility. It operates on a global store of variables (no heap allocation or local procedure scope in early versions) and ensures that every statement has a unique inverse.[5]

Syntax and semantics

edit
  • Program Structure: A Janus program consists of global variable declarations followed by procedure declarations. The execution starts at a procedure named main, or the last procedure defined if main is absent.
  • Data Types: Janus primarily uses 32-bit integers (interpreters may differ on signed vs. unsigned) and one-dimensional integer arrays of fixed size.[4] Some versions include stacks.[4] All variables and array elements are initialized to zero.[4]
  • Statements:
    • Assignment: Reversible updates x op= e or x[e] op= e, where op is +, -, or ^ (bitwise XOR). The variable x must not appear in the expression e.[4]
    • Swap: x <=> y exchanges the values of x and y.
    • Conditional: if e1 then s1 else s2 fi e2. The expression e1 is the test evaluated upon forward entry. The expression e2 is an assertion evaluated upon forward exit; it must be true if s1 was executed and false if s2 was executed. For backward execution (e.g., via uncall), e2 acts as the test to determine which inverse branch (s1−1 or s2−1) to take, and e1 becomes the assertion checked upon exiting backward.[6]
    • Loop: from e1 do s1 loop s2 until e2. Upon forward entry, assertion e1 must be true. s1 is executed. Then, test e2 is evaluated. If true, the loop terminates. If false, s2 is executed, after which assertion e1 must now be false for the loop to continue back to s1. In reverse, e2 is the entry assertion, s2−1 is executed, e1 is the test (loop continues if false, terminates if true), and s1−1 is executed if the loop continues.[4]
    • Stack Operations: push(x, stack) and pop(x, stack). Reversibility often relies on assumptions about the state of x (e.g., x must be 0 before push so pop can restore it).[4]** Local Variables: local t x = e in s delocal t x = e This block introduces a local variable x, initializes it reversibly using e, executes s, and then uncomputes x back to its initial state (usually 0) using the inverse of e upon exit.[4]
    • Procedure Call: call id executes procedure id forwards; uncall id executes procedure id backwards.[5] Procedures operate via side effects on the global store.
    • Skip: skip does nothing and is its own inverse.
    • Sequence: s1; s2. The inverse is s2−1; s1−1.

Implementations and code examples

edit

Several online interpreters for Janus exist.[8] Janus has been used to implement various algorithms reversibly, including computing Fibonacci pairs,[4] simulating RTMs,[4] Fast Fourier Transform (FFT)[9], graph algorithms [10], and simulating the Schrödinger wave equation.[11]

The following fibpair procedure in Janus calculates a pair of consecutive Fibonacci numbers.[1] Given an input n, it sets x1 to F(n) and x2 to F(n+1), assuming x1 and x2 are initially 0: 

int n x1 x2 // variable declarations

procedure fibpair
    if n=0 then x1 += 1
                x2 += 1
    else n -= 1
         call fibpair
         x1 += x2
         x1 <=> x2
fi x1=x2

For calling and uncalling the Fibonacci-pair procedure we use 

procedure main_fwd 
    n += 4
    call fibpair 

prodecure main_bwd
    x1 += 5
    x2 += 8 
    uncall fibpair

R Language (MIT)

edit

The R language (distinct from the statistical language R) was developed by Michael P. Frank at MIT in the late 1990s as part of the Reversible Computing project.[5] It is an imperative, compiled language featuring an S-expression (Lisp-like) syntax.[5] A key aspect of R's design was its close integration with hardware development; it was designed to target the Pendulum reversible instruction set architecture (PISA), developed concurrently at MIT for an adiabatic CMOS processor.[5]

Syntax and semantics

edit
  • Program Structure: Programs are defined using (defmain ...) for the main routine and (defsub ...) for subroutines. Global variables and arrays are declared with (defword ...) and (defarray ...).[5]
  • Data Types: R primarily supports integers and integer arrays.[5]
  • Statements:
    • Assignment/Update: Includes increment (loc ++), negation (- loc), swap (loc <-> loc), and reversible updates (loc op= e) using operators like +=, -=, ^=, and specialized comparison-updates (<=<, >=>).[5] Similar restrictions to Janus apply regarding variable dependencies.
    • Conditional: (if e then s*). To ensure reversibility, the language requires that the value of the conditional expression e must be the same before and after the execution of the then block (s*).[5] This acts as an implicit invariant assertion, similar in function to Janus's explicit exit assertion.
    • Loop: (for name = e_start to e_end s*). Reversibility requires that the loop iteration variable (name) must have the same value before entering and after exiting the loop.[5]
    • Local Binding: (let ((name <- e)) s*). Introduces a local variable name initialized with e. Reversibility is ensured by requiring the variable to be returned to a known state (e.g., zero-cleared) before the scope is exited, analogous to Janus's local/delocal.[5]
    • Procedure Call: Explicit forward (call subname e*) and reverse (rcall subname e*) calls are provided.[5]
    • Output: (printword e) and (println) are included for output.[5] These are inherently irreversible operations.

Pendulum/PISA target architecture

edit

The R language was designed with a specific hardware target: the Pendulum processor.[12]

  • Architecture: Pendulum is a 12-bit, RISC-inspired, fully reversible microprocessor implemented in 0.5µm CMOS.[13] It features general-purpose registers and fixed-length instructions.[14]
  • PISA Features: The instruction set includes several features tailored for reversibility:
    • A Direction Bit (DIR) register tracks forward/backward execution mode.[5]
    • A Branch Bit (BR) register assists with reversible control flow.[5]
    • Branch instructions (e.g., BEZ, BLTZ) are conditional and require careful pairing. Reverse branches (RBEZ, RBLTZ) also toggle the DIR bit.[15]
    • Memory access uses a reversible EXCH (exchange) instruction that swaps register and memory contents.[5]
    • Arithmetic and logic instructions (e.g., ADD, ANDX, XOR, SLLX, RL) are designed to be reversible, with some operations' behavior (like addition/subtraction or rotation direction) dependent on the DIR bit.[5]

Code examples

edit

The following PISA assembly code[16] simulates a free-falling object. It includes a main section to call and "uncall" (reverse) a subroutine named Fall, which contains the core simulation logic. 

Call Fall:
10: ADDI h 1000
11: ADDI tend 5
12: BRA 16       ; call

Uncall Fall:
18: ADDI v 40
19: ADDI t 4
20: ADDI tend 4
21: RBRA 7       ; uncall

Subroutine Fall:
27: BRA 9
28: SWAPBR rtn   ; br <=> rtn
29: NEG rtn      ; rtn=-rtn
30: BGTZ t 5     ; t > 0?
31: ADDI v 10    ; v += 10
32: ADDI h 5     ; h += 5
33: SUB h v      ; h -= v
34: ADDI t 1     ; t += 1
35: BNE t tend -5 ; t != tend?
36: BRA -9

The R program defines global variables for height (h), end time (tend), velocity (v), and current time (t). The core logic is encapsulated in the Fall subroutine, which simulates the object's motion. The main routine initializes parameters, calls Fall to simulate forward motion, then modifies parameters and calls Fall in reverse (rcall Fall), mirroring the structure of the PISA example's "Call Fall" and "Uncall Fall" sections.

A key feature of R's if statement is that the conditional expression must evaluate to the same truth value before and after the execution of its then block. The Fall subroutine in PISA (lines 30-36) effectively has a loop that runs as long as t is not equal to tend, but this loop is only entered if an initial condition (implied by BGTZ t 5 meaning skip if t > 0, so run if t <= 0) is met. To translate this faithfully and handle R's if semantics, the R code for Fall uses a let binding to capture the state of the initial condition (t <= 0) before the loop. The if then operates on this captured, unchanging boolean value. The loop itself is represented by R's for construct, iterating tend times, which corresponds to the PISA loop structure (BNE t tend -5). 

;; Global variable declarations
(defword h)
(defword tend)
(defword v)
(defword t)

;; Subroutine to simulate falling
;; Corresponds to PISA "Subroutine Fall" (lines 27-36)
(defsub Fall ()
  ;; The PISA code at line 30 (BGTZ t 5) skips the main simulation
  ;; if t > 0. This means the simulation loop runs if t <= 0.
  ;; We use 'let' to capture this condition, and 'if' operates on the captured value.
  (let ((do_run <- (<= t 0))) ;; Capture condition: t must be <= 0 to run.
                             ;; 'do_run' is a local temporary.
    (if do_run ;; If the condition was true (t was <= 0 initially)
        then
          (progn ;; Execute the simulation loop
            ;; The PISA loop (lines 31-35) effectively iterates 'tend' times,
            ;; incrementing 't' each time, starting from its initial value (which is 0
            ;; when 'do_run' is true). The BNE t tend -5 continues as long as t != tend.
            ;; R's 'for' loop is a suitable high-level representation.
            ;; We assume 'tend' represents the number of iterations *from t=0*.
            (for i = 1 to tend ;; Loop 'tend' times
              (progn
                (+= v 10)      ;; PISA: ADDI v 10
                (+= h 5)       ;; PISA: ADDI h 5
                (-= h v)       ;; PISA: SUB h v
                (++ t)         ;; PISA: ADDI t 1
              )
            )
          )
        ;; else (if 'do_run' is false, meaning t was > 0 initially), do nothing,
        ;; mimicking the PISA BGTZ t 5 branch.
    )
    ;; Upon exiting 'let', 'do_run' is restored/cleared, satisfying R's rules
    ;; for 'let' and ensuring the 'if do_run' invariant holds for 'do_run'.
  )
)

;; Main program routine
(defmain ()
  ;; Initialize global variables to 0.
  ;; While PISA doesn't show explicit zeroing, R programs often start clean.
  ;; These are reversible assignments.
  (-= h h)         ;; h = 0
  (-= tend tend)   ;; tend = 0
  (-= v v)         ;; v = 0
  (-= t t)         ;; t = 0

  ;; --- "Call Fall" section from PISA ---
  ;; Set initial parameters for forward simulation
  (+= h 1000)     ; PISA: ADDI h 1000
  (+= tend 5)     ; PISA: ADDI tend 5
                  ; t and v are 0 from initialization.

  ;; Call the Fall subroutine to simulate forward motion
  ;; PISA: BRA 16 (relative branch to call setup, actual call is implicit)
  (call Fall)

  ;; State after (call Fall) with h_initial=1000, tend_initial=5, t_initial=0, v_initial=0:
  ;; Inside Fall: do_run = (<= 0 0) = true. Loop runs 5 times.
  ;; t becomes 0 + 5 = 5.
  ;; v becomes 0 + 5*10 = 50.
  ;; h becomes 1000 + 5*5 - (10+20+30+40+50) = 1000 + 25 - 150 = 875.
  ;; tend remains 5 (Fall does not modify the 'tend' global it uses for loop count).

  ;; (printword h) (printword v) (printword t) (printword tend) (println)
  ;; Expected: h=875, v=50, t=5, tend=5

  ;; --- "Uncall Fall" section from PISA ---
  ;; The PISA code modifies v, t, and tend before the reverse call.
  ;; Current state from R perspective: h=875, v=50, t=5, tend=5.
  (+= v 40)    ; PISA: ADDI v 40. v = 50 + 40 = 90
  (+= t 4)     ; PISA: ADDI t 4.  t = 5 + 4 = 9
  (+= tend 4)  ; PISA: ADDI tend 4. global 'tend' becomes 5 + 4 = 9
  ;; h remains 875.

  ;; Perform the reverse call to Fall
  ;; PISA: RBRA 7 (relative branch to uncall setup)
  (rcall Fall)

  ;; Behavior of (rcall Fall):
  ;; 'rcall Fall' executes the inverse of 'Fall'.
  ;; Inside 'Fall' (conceptually, during rcall):
  ;;   The (let ((do_run <- (<= t 0))) ...) block is reversed.
  ;;   The (<= t 0) condition is evaluated with current t=9. (<= 9 0) is false.
  ;;   So, 'do_run' (if we consider its "uncomputed" state) would correspond to 'false'.
  ;;   The 'if do_run' block's 'then' part (the loop) was not executed in the forward
  ;;   direction corresponding to this 'false' condition. Thus, its reverse also does nothing.
  ;; The net effect, matching PISA's BGTZ t 5, is that if t > 0, the main body of Fall
  ;; (and its reverse) is skipped.
  ;; Final state after (rcall Fall): h=875, v=90, t=9, tend=9.
  ;; This is because 'Fall' was effectively a no-op due to t=9 > 0.
  ;; The 'rcall' correctly reverses this no-op.

  ;; (printword h) (printword v) (printword t) (printword tend) (println)
  ;; Expected: h=875, v=90, t=9, tend=9
)

Overview of other reversible languages

edit

Research has continued beyond Janus and R, exploring different paradigms and features:

  • Eel (Energy-Efficient Language): Notable for supporting partially reversible computation. It allows mixing reversible operations with irreversible ones.[17] To handle irreversible steps during reversal, Eel uses a "log stack" to save the necessary information (e.g., overwritten values), explicitly trading increased space complexity for the ability to reverse irreversible actions, while associating an energy cost with these actions based on Landauer's principle.[18] It features advanced control logic constructs (protected/general conditionals and loops) offering different points on the energy-space trade-off spectrum.[19] This makes Eel distinct from fully reversible languages like Janus, aiming for more flexibility in algorithm design.[20]
  • Rfun: A reversible functional programming language.[21] Its semantics have been modeled using categorical structures like join inverse rig categories, highlighting the connection between functional programming and abstract algebraic models of reversibility.[22]
  • ROOPL: The first reversible object-oriented programming language.[23] It extends the imperative reversible paradigm with features like user-defined data types (classes), inheritance, and subtype polymorphism.[24] ROOPL demonstrates that higher-level object-oriented abstractions can be integrated into a reversible framework while maintaining local invertibility and r-Turing completeness. It was designed for garbage-free translation to the PISA assembly language.[25]
  • Reversible HDLs: To aid in the complex task of designing reversible logic circuits, specialized Hardware Description Languages have been developed.[26] These are often functional in nature and may include features like linear types to manage resources and ensure garbage-free designs. They facilitate a design flow from high-level descriptions to gate-level implementations.[27]
  • Flowchart Languages: Languages like R-CORE, R-WHILE, and SRL provide structured representations of reversible control flow, often serving as intermediate languages or theoretical models.[6] Their semantics can also be captured using categorical frameworks.[28]
  • Other Languages: A variety of other languages have been proposed, including Psi-Lisp [29], Pi/Pi^o,[5] Inv [30], Yarel [31], SPARCL [32], Hermes (focused on cryptography) [33], and Revs (compiling F# subset to circuits).[34] Reversibility has also been studied in the context of existing languages like Erlang.[35]

Comparison of reversible programming languages

edit

The following table summarizes key characteristics of some prominent reversible programming languages discussed:

Comparison of Reversible Programming Languages[4][5][36]
Feature Janus R (MIT) Eel ROOPL
Paradigm Imperative, Procedural Imperative, Compiled Imperative, Partially Reversible Imperative, Object-Oriented
Reversibility Model Full (Locally Invertible) Full (Locally Invertible) Partial (Allows Irreversible Ops) Full (Locally Invertible)
Key Control Flow if..fi (test+assert),
from..until (assert+test) 		(if..) (invariant),
(for..) (invariant) 		Protected/General if/loop,
Log/Unroll blocks 		Reversible if, loop (similar to Janus),
Method Calls
Data Types Integers, Arrays, Stacks Integers, Arrays Integers, Arrays, Log Stack Integers, Arrays, User-defined Classes (Objects), Inheritance
Inversion Mechanism uncall statement,
Local Inversion 		rcall statement,
Local Inversion 		Unroll statement
(uses Log Stack) 		uncall (for methods),
Local Inversion
Target/Compiler Interpreters,
Partial Evaluator,
Self-Interpreter 		PISA (Pendulum ISA) Compiler Compiler & Interpreter (Java-based),
Energy Simulation 		PISA Compiler
(Garbage-free)

This comparison highlights the different design choices made. Janus and R enforce full reversibility through language constructs, differing primarily in syntax (C-like vs S-expression) and target (interpretation vs PISA compilation). Eel introduces partial reversibility, allowing irreversible operations at the cost of using a log stack for reversal information and incurring a conceptual energy cost, aiming for greater flexibility. ROOPL extends the fully reversible imperative model with object-oriented features, demonstrating the applicability of higher-level abstractions.

References

edit
  1. ^ a b c Glück, Robert; Yokoyama, Tetsuo (2023). "Reversible computing from a programming language perspective". Theoretical Computer Science. 953 113429. doi:10.1016/j.tcs.2022.06.010.
  2. ^ Thomsen, Michael Kirkedal (2023). "Design of Reversible Computing Systems; Large Logic, Languages, and Circuits". arXiv:2309.11832 [cs.PL].
  3. ^ Thomsen, Michael Kirkedal; Axelsen, Holger Bock; Glück, Robert (2011). "A Reversible Processor Architecture and Its Reversible Logic Design". In De Vos, Alexis; Wille, Robert (eds.). Reversible Computation - Third International Workshop, RC 2011, Gent, Belgium, July 4-5, 2011. Revised Papers. Lecture Notes in Computer Science. Vol. 7165. Springer. pp. 30–42. doi:10.1007/978-3-642-29517-1_3. Reversible programming language at DBLP Bibliography Server.
  4. ^ a b c d e f g h i j k l m n o Yokoyama, Tetsuo (2010). "Reversible Computation and Reversible Programming Languages". In Ulidowski, Irek (ed.). Proceedings of the Workshop on Reversible Computation, RC@ETAPS 2009, York, UK, March 22, 2009. Electronic Notes in Theoretical Computer Science. Vol. 253. Elsevier. pp. 71–81. doi:10.1016/J.ENTCS.2010.02.007. Reversible programming language at DBLP Bibliography Server.
  5. ^ a b c d e f g h i j k l m n o p q r s t u v w x y Choudhury, Vikraman (April 2018). "Reversible Programming Languages" (PDF).
  6. ^ a b c d Palazzo, Matteo; Roversi, Luca (2025). "Reversible Computation with Stacks and "Reversible Management of Failures"". arXiv:2501.05259 [cs.PL].
  7. ^ Haulund, Tue; Mogensen, Torben Ægidius; Glück, Robert (2017). "Implementing Reversible Object-Oriented Language Features on Reversible Machines". In Phillips, Iain; Rahaman, Hafizur (eds.). Reversible Computation - 9th International Conference, RC 2017, Kolkata, India, July 6-7, 2017, Proceedings. Lecture Notes in Computer Science. Vol. 10301. Springer. pp. 66–73. doi:10.1007/978-3-319-59936-6_5. Reversible programming language at DBLP Bibliography Server.
  8. ^ "Janus: a reversible imperative programming language". University of Copenhagen (DIKU). Retrieved April 9, 2025.
  9. ^ "Reversible Algorithms" (PDF). Computing Research Association. Retrieved April 9, 2025.
  10. ^ "Reversible Algorithms" (PDF). Computing Research Association. Retrieved April 9, 2025.
  11. ^ Yokoyama, Tetsuo; Glück, Robert (2007). "A reversible programming language and its invertible self-interpreter". In Ramalingam, G.; Visser, Eelco (eds.). Proceedings of the 2007 ACM SIGPLAN Workshop on Partial Evaluation and Semantics-based Program Manipulation, 2007, Nice, France, January 15-16, 2007. ACM. pp. 144–153. doi:10.1145/1244381.1244404. Reversible programming language at DBLP Bibliography Server.
  12. ^ Frank, Michael P. (1999). Reversibility for efficient computing (PhD thesis). Cambridge, MA, USA: Massachusetts Institute of Technology. hdl:1721.1/9464. Reversible programming language at DBLP Bibliography Server.
  13. ^ Vieri, Carlin (1999). Reversible computer engineering and architecture (PhD thesis). Cambridge, MA, USA: Massachusetts Institute of Technology. hdl:1721.1/80144. Reversible programming language at DBLP Bibliography Server.
  14. ^ Vieri, Carlin (1999). Reversible computer engineering and architecture (PhD thesis). Cambridge, MA, USA: Massachusetts Institute of Technology. hdl:1721.1/80144. Reversible programming language at DBLP Bibliography Server.
  15. ^ Vieri, Carlin (1999). Reversible computer engineering and architecture (PhD thesis). Cambridge, MA, USA: Massachusetts Institute of Technology. hdl:1721.1/80144. Reversible programming language at DBLP Bibliography Server.
  16. ^ Axelsen, Holger Bock; Glück, Robert; Yokoyama, Tetsuo (2007). "Reversible Machine Code and Its Abstract Processor Architecture". In Diekert, Volker; Volkov, Mikhail V.; Voronkov, Andrei (eds.). Computer Science - Theory and Applications, Second International Symposium on Computer Science in Russia, CSR 2007, Ekaterinburg, Russia, September 3-7, 2007, Proceedings. Lecture Notes in Computer Science. Vol. 4649. Springer. pp. 56–69. doi:10.1007/978-3-540-74510-5_9. Reversible programming language at DBLP Bibliography Server.
  17. ^ Tyagi, Nirvan; Lynch, Jayson; Demaine, Erik D. (2016). "Toward an Energy Efficient Language and Compiler for (Partially) Reversible Algorithms". arXiv:1605.08475 [cs.PL].
  18. ^ Tyagi, Nirvan; Lynch, Jayson; Demaine, Erik D. (2016). "Toward an Energy Efficient Language and Compiler for (Partially) Reversible Algorithms". arXiv:1605.08475 [cs.PL].
  19. ^ Tyagi, Nirvan; Lynch, Jayson; Demaine, Erik D. (2016). "Toward an Energy Efficient Language and Compiler for (Partially) Reversible Algorithms". arXiv:1605.08475 [cs.PL].
  20. ^ Tyagi, Nirvan; Lynch, Jayson; Demaine, Erik D. (2016). "Toward an Energy Efficient Language and Compiler for (Partially) Reversible Algorithms". arXiv:1605.08475 [cs.PL].
  21. ^ "Reversible Computation" (PDF). Classroom Presentation at Appalachian State University. Retrieved April 9, 2025.
  22. ^ Kaarsgaard, Robin; Rennela, Mathys (2021). "Join inverse rig categories for reversible functional programming, and beyond". In Sokolova, Ana (ed.). Proceedings 37th Conference on Mathematical Foundations of Programming Semantics, MFPS 2021, Hybrid: Salzburg, Austria and Online, 30th August - 2nd September, 2021. EPTCS. Vol. 351. pp. 152–167. arXiv:2105.09929. doi:10.4204/EPTCS.351.10. Reversible programming language at DBLP Bibliography Server.
  23. ^ Haulund, Tue; Mogensen, Torben Ægidius; Glück, Robert (2017). "Implementing Reversible Object-Oriented Language Features on Reversible Machines". In Phillips, Iain; Rahaman, Hafizur (eds.). Reversible Computation - 9th International Conference, RC 2017, Kolkata, India, July 6-7, 2017, Proceedings. Lecture Notes in Computer Science. Vol. 10301. Springer. pp. 66–73. doi:10.1007/978-3-319-59936-6_5. Reversible programming language at DBLP Bibliography Server.
  24. ^ Haulund, Tue (2017). "Design and Implementation of a Reversible Object-Oriented Programming Language". arXiv:1707.07845 [cs.PL].
  25. ^ Haulund, Tue (2017). "Design and Implementation of a Reversible Object-Oriented Programming Language". arXiv:1707.07845 [cs.PL].
  26. ^ Thomsen, Michael Kirkedal (2023). "Design of Reversible Computing Systems; Large Logic, Languages, and Circuits". arXiv:2309.11832 [cs.PL].
  27. ^ Thomsen, Michael Kirkedal (2023). "Design of Reversible Computing Systems; Large Logic, Languages, and Circuits". arXiv:2309.11832 [cs.PL].
  28. ^ Glück, Robert; Kaarsgaard, Robin (2018). "A Categorical Foundation for Structured Reversible Flowchart Languages". In Staton, Sam (ed.). Proceedings of the Thirty-Fourth Conference on the Mathematical Foundations of Programming Semantics, MFPS 2018, Dalhousie University, Halifax, Canada, June 6-9, 2018. Electronic Notes in Theoretical Computer Science. Vol. 341. Elsevier. pp. 155–171. doi:10.1016/J.ENTCS.2018.03.021. Reversible programming language at DBLP Bibliography Server.
  29. ^ Matsuda, Kazutaka; Wang, Meng (2024). "Sparcl: A language for partially invertible computation". Journal of Functional Programming. 34 e2. doi:10.1017/S0956796823000126. Reversible programming language at DBLP Bibliography Server.
  30. ^ Matsuda, Kazutaka; Wang, Meng (2024). "Sparcl: A language for partially invertible computation". Journal of Functional Programming. 34 e2. doi:10.1017/S0956796823000126. Reversible programming language at DBLP Bibliography Server.
  31. ^ Grandi, Claudio; Moshiri, Dariush; Roversi, Luca (2019). "Introducing Yet Another REversible Language". arXiv:1902.05369 [cs.PL].
  32. ^ Matsuda, Kazutaka; Wang, Meng (2024). "Sparcl: A language for partially invertible computation". Journal of Functional Programming. 34 e2. doi:10.1017/S0956796823000126. Reversible programming language at DBLP Bibliography Server.
  33. ^ "Hermes: A Language for Lightweight Encryption" (PDF). Reversible Computation (RC) Lecture. Retrieved April 9, 2025.
  34. ^ Amy, Matthew; Roetteler, Martin; Svore, Krysta M. (2016). "Verified Compilation of Space-Efficient Reversible Circuits". Computer Aided Verification. Lecture Notes in Computer Science. Vol. 10427. pp. 3–21. arXiv:1603.01635. doi:10.1007/978-3-319-63390-9_1. ISBN 978-3-319-63389-3.
  35. ^ Lanese, Ivan; Schultz, Ulrik Pagh; Ulidowski, Irek (2022). "Reversible Computing in Debugging of Erlang Programs". IT Professional. 24 (1): 74–80. Bibcode:2022ITPro..24a..74L. doi:10.1109/MITP.2021.3117920. hdl:11585/884503. Reversible programming language at DBLP Bibliography Server.
  36. ^ Haulund, Tue (2017). "Design and Implementation of a Reversible Object-Oriented Programming Language". arXiv:1707.07845 [cs.PL].
Retrieved from "https://en.wikipedia.org/w/index.php?title=Reversible_programming_language&oldid=1307760333"