A shining light in the tunnel of darkness.
That's how I see hope, with a longingness.
Sometimes good and sometimes bad,
But somehow makes me glad.

Is it hope that I'm looking for?
Like a drop of water, in a large desert outdoor.
Is it just something made up?
A lie told even after I slipup.

Hope is a dangerous thing.
The results can feel like a swing.
But is it enough to justify my life?
The way I'm living, with so much strife.

I keep clinging to this hope.
Even with my life being a downward slope.
Sometimes I fear it won't be there.
At that point, would I still care?

I find myself in an abyss.
At times, devoid of any bliss.
Hope is the only thing in my mind.
Alas it is hard to see, perhaps I left it too far behind.

The prices are there for if you'd like to store associated PDFs on the cloud and makes sense if two or more people would like to share the same bibliography data. What this blogpost helps with is storing the files locally and syncing them peer-to-peer.

Best part is it's free!

Prior situation

Usually if you're employed at a university/research institution, the institute has a subscription to various journals. I would use this with Zotero, strictly only storing the metadata and journal links and opening them on the browser. The PDF can then be downloaded if you're on the institute's intranet.

Storage location for PDFs

On Linux1 this guide assumes you're using linux but i see no reason why it cannot be adapted for windows and macos. , by default I believe Zotero creates a directory ~/Zotero/ for storage of files, notes and metadata. I usually create my own custom location for the directory, ~/.zotero/ in this case as I don't like having my home directory cluttered.2 To actually keep your `~/` uncluttered, the best approach would be something along the lines of `~/.local/share/zotero` which is `XDG_DATA_HOME` according to XDG standards.

To change this, go to Edit -> Settings -> Advanced and under "Data Directory Location" you can specify a custom path.

Now assuming you already have a sizeable zotero database, we go to this location and are interested in the ~/.zotero/storage folder. This is where the PDFs are stored.

Changing a few settings

Now, by default Zotero syncs all your files to the cloud. We don't want that. To disable it, go to Edit -> Settings -> Sync and under File Syncing uncheck both "Sync attachment files in My Library" and "Sync attachment files in group libraries using Zotero storage".

Now that we have unchecked the boxes, one can simply save the PDFs as we like and use it on their computer. But what if we need to access files on a different computer? That's where peer-to-peer syncing comes in.

Syncing with Syncthing

Syncthing is an excellent piece of software. As described on their website:

Syncthing is a continuous file synchronization program.

Basically it helps sync files between different computers in a peer-to-peer fashion.

Quickstart guide

I would highly recommend the official user-guide for using syncthing. However, the following covers a quick and brief guide to getting syncing setup with Zotero.

Launching syncthing in a terminal opens up localhost:8384 on your web browser and you're greeted with the GUI.

The GUI shows three components, two of which we are concerned with. On the left are the folders that are synced. The right bottom section consists of the devices to which certain folders are being synced. In my case, I have the zotero storage folder synced with my office PC and some other folders synced with my Android phone.

The "Add Folder" button is a good starting point. Clicking it leads us to a dialog box asking for a folder label and a folder path. The latter is important. For now, just ignore the folder ID variable. It is auto-generated by syncthing and is meant to let syncthing know which folders to sync across different computers based on this ID.

Now, just set the folder path to ~/.zotero/storage (or whatever is the custom folder path you've set in Zotero) and click save.

Adding remote device

On the secondary device that you'd like to access your PDFs on (laptop or perhaps a desktop at your office like me), then you need to launch syncthing on the remote device and add it on your main computer by clicking "Add Remote Device" at the bottom right corner in the GUI.

The device can be added either via a device ID or via a QR-code, which is accessible under the "Actions" tab and clicking "Show ID".

Follow similar instructions on the remote device for setting up a sync folder (should be empty as for the first sync, we're really transferring PDFs from the main device to the remote one). Make sure to have the same path in your Zotero settings on the remote device!

After adding the remote device, we need to share the folder we had set with the remote device. To do this, simply go to the zotero-storage folder under the "Folders" section and click edit. This will bring up a dialog box that we had previously edited. Under the "Sharing" tab, check the box for the added remote device.3 Don't worry about the "enter encryption password". You only need it if you're concerned with security and would like to have encrypted folders. I don't really care about that for zotero so I leave it unchecked. And just hit save.

If you have everything setup properly, the folder should get synced across both the devices and you should be able to access the PDFs in both these device! Of course, you can add more devices if you'd like.

I've been extremely happy with this setup and I hope it's useful to you as it has been for me, thanks to my friend Marci who introduced me to the idea.

When did I stop being a child?
It's been so long, but I used to be quite beguiled.
While I reminisce the days of not caring about the world.
I wonder, when that child stopped being one, as an adult labelled.

Perhaps it was when my interests changed.
Things that I used to like, now feel estranged.
Oh, how I wish I could go back to those simpler times.
That child exists no more, but an adult begrimed.

Carefree is the emotion I took for granted.
Now that I'm older, responsibilities have been handed.
I remember a time when I used to run wild.
Oh, but when did I stop being a child?

As I grow old, my anxiety only becomes stronger.
Is adulthood really supposed to be this way, with nothing more to offer?
Alas, it is too late now to think about a time bygone.
But the only way forward, is to look ahead and march into the unknown.

What is my purpose but a tiny speck on this big blue dot?
Is it already decided or do I get myself taught?
I do wonder how the rest of my life shall continue.
Will it be the same things I now pursue?

Family it is for some people.
For others, it is their career to excel.
But does it matter in the end?
Perhaps the greater reason is to make oneself enlighten.

Often I find myself asking such questions.
I keep looking for entities of substance
in this rollercoaster that is life.
What can I do to make it more rife?

For far too long I've been looking far away.
Always fearing that my life might go astray.
Is it deep down something more precious?
Only to find myself asking, "what is my purpose?".

Now you might ask, why am I switching to GNU Emacs, the opposing contender to Vim in the well known editor war? Well, the more "silly" reason is that it gives me an opportunity to learn a new piece of software, understand it's inner workings, etc. The more pragmatic reason is that, like any rivalry, both sides have their pros and cons. GNU Emacs presents itself as a truly hackable editor in any way the user desires. This is thanks to the editor being written and configured in Emacs lisp, a dialect of the Lisp family of languages. Vim on the other hand is written mostly in C but is configured in an obscure language that is Vimscript. The advantage with Emacs lisp is that one can write not only specific functions to help in any form of text editing and beyond (one of the charms of Emacs) but also supplements more experienced users in contributing to the core development of Emacs. This appeals to me from a FOSS perspective as I truly believe that free software development being run by volunteers should be tightly knit with its user community. This helps not only in raising issues with the software better but also in users contributing to the development.

This truly hackable experience, presented by Emacs also benefits in the form of tasks that are not necessarily based around text-editing. Thanks to the wonderful community, Emacs boasts a wide-range of well-written packages such as org-mode (Task management system with a markup style of its own) and Magit (A Git porcelain inside Emacs). One of the primary reasons I've decided to switch is due to org-mode (which I intend to cover in detail in subsequent blog entries).

Some people might argue that Emacs goes against the UNIX philosophy of minimalism and "doing one thing right". Technically Emacs is more of a Lisp environment than a text editor, or like the more famous vim adage: "Emacs is a great operating system, but it lacks a good text editor". I cannot really comment here because I'm still very new to Emacs but the quote does hold some truth. Emacs (atleast from my first impressions) has esoteric keybindings which are completely foreign to new users let alone someone coming from a vim background. Ctrl and Alt (known as Meta in Emacs parlance) are the most common keys which form part of the key-chord style of using emacs. These keys obviously are placed at positions on a standard QWERTY keyboard layout that when used frequently leads to the more infamous Emacs pinky which is basically repetitive strain injury (RSI). For this reason, I will be using emacs with Evil which is the Vi-emulation package in emacs, atleast until I get the hang of working with Emacs before perhaps trying the stock keybindings (which apparently most of the emacs community adheres to).

For the next couple weeks I will try to steadily convert to using Emacs and hopefully perform all of my computing needs with emacs in the not-so-long future. This blog post is mainly for me to make this commitment. As a first step, this blog entry is written entirely in Emacs.

The Problem

With modern day laptops, often there are backlit keys on certain media keys like mute sound, mute mic, airplane mode and so on. The light being switched on, for obvious reasons indicates that the particular function is in operation. This is easy on Windows for which these machines are always tested against.1 The travesty being that laptop manufacturers being the profit oriented businesses that they are, cater to the masses which unfortunately sides with malicious, proprietary garbage like Windows. Similarly, macOS works well on Apple devices. With GNU/Linux2 Technically Linux is the kernel and not the operating system (the rest is supplied by the GNU operating system sans its own kernel). Here is a better explanation. however, almost all machines work but the tiny quality of life improvements like those media key lights can be a hit or miss.

As usual, I went ahead and installed Arch Linux on my machine with dwm as my window manager. After the installation and a test drive of my laptop, I see this...

At first I thought perhaps it's a driver issue but all my drivers were up-to-date. Looking through the Arch wiki didn't help with the issue. Knowing the vibrant thinkpad community, I ended up posting about my problem on r/thinkpad.

Simple Fix

I'd much rather have the backlight fully off than have it functional. So, a fellow redditor let me know to check for the output in a particular system file:

~: $ cat /sys/class/leds/platform::micmute/brightness
1

'1' here represents the light in the ON state, which is exactly the problem! Changing the value to '0' in the file instantly fixes the problem! Changing it to '0' only fixes it temporarily until the next time the machine is booted up. A rather simple "hack" is to make this change every time the user logs into the machine. This is done simply through the .xprofile or .xinitrc file (most people would use .xinitrc) by adding the following line in said file:

echo "0" > /sys/class/leds/platform::micmute/brightness

This line simply replaces whatever the file previously had, with '0'. This works rather well until I find a more permanent solution.

Edit

Unfortunately, the above method doesn't work anymore. I'm not exactly sure what changed but apparently it isn't supposed to work in the first place simply because /sys/class/leds/platform::micmute/brightness isn't a real directory.

In any case, here's an updated method for the same that is slightly more involved. It is adapted for any Linux distribution running systemd. For other init systems (openrc, runit, etc.), I assume it's fairly simply to make the relevant changes.

• Create a shell script disable-mute.sh in your preferred directory (~/.local/bin/ in my case) containing the following:

#!/bin/shecho 0 | tee /sys/class/leds/platform::micmute/brightness

• With root privileges, create a file disable-mute.service in /etc/systemd/system/ with the following content:3 See here for a detailed tutorial on writing systemd service files.

[Unit]
Description=Disables the annoying mute light on keyboard
After=multi-user.target[Service]
ExecStart=/bin/sh /home/ashish/.local/bin/disable-mute.sh
Type=simple[Install]
WantedBy=multi-user.target

• Simply run sudo systemctl enable disable-mute.service and the LED should turn off the next time you boot up your machine.

Late 2024 Update: This method works so far for the 6.6-LTS Kernel, NOT the bleeding edge one.

Qiskit [kiss-kit] is an open-source SDK for working with quantum computers at the level of pulses, circuits and application modules.

I plan on writing a series of tutorials on getting started with quantum computing using qiskit, as I learn as well. Like any other programming tutorial, we start with a simple "Hello, world" program.

Measuring a quantum state

With conventional computers, the simplest program that one could perhaps make is printing out "hello, world". However, in contrast to this, in quantum systems, we go ahead and measure a quantum state (this seems to be the most rudimentary but complete program in quantum terms). Let's proceed to do just that!

Defining a quantum state

We import the necessary modules from Qiskit for this operation. To define a quantum circuit, we require the classes QuantumCircuit, QuantumRegister, ClassicalRegister and define a state variable psi as

Notice that the state \(| \psi \rangle\) is normalized. This is important, otherwise we'll end up with an error.

from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from math import sqrt# define an initial state
psi = [1/sqrt(2), 1/sqrt(2)]

We then define a function prepare() which takes two parameters: a QuantumCircuit object named qc and the initial state psi. Remember that the quantum circuit that we define, only uses 1 qubit (notice the vector representation of \(| \psi \rangle\)).

def prepare(qc, psi):
    qc.initialize(psi, [0])     # [0] indicates the zeroth index (or) the first qubit

Python by default, calls by reference, so we don't have to worry about returning anything from prepare().

Building a quantum circuit

Let's proceed with making an actual quantum circuit. For this, we define a QuantumRegister object qr, which stores the qubits and a ClassicalRegister object cr which stores the measured values of those qubits.

qr = QuantumRegister(1)
cr = ClassicalRegister(1)

Combining the two registers, we now make a quantum circuit:

qc = QuantumCircuit(qr, cr)

Initializing and measuring the qubit

We then call our function prepare() to initialize the first qubit (the only qubit) of our quantum circuit qc.

prepare(qc, psi)

How do we go about measuring our state? That's where the ClassicalRegister object cr comes in. We use the measure method under the qc object to actually measure the qubit.

qc.measure(qr[0], cr[0])

The above syntax generally means that we're measuring the state of qr[0] (the first qubit) onto the classical register cr[0] where we store the measured value.

Visualizing the circuit

Ok so all of this is nice, but one can only describe so much. Let's see how our circuit actually looks like after applying the above operations. For this, we use the draw() method with the matplotlib backend.

>>> qc.draw(output='mpl')

Choosing a backend for measurement

To measure the qubit and store the result in the classical register cr, we use the qasm_simulator backend. As we know from basic quantum mechanics,

from qiskit import Aer
backend = Aer.get_backend('qasm_simulator')

We then transpile our circuit for the qasm_simulator backend to understand and execute the circuit.

from qiskit import transpile
qc_compiled = transpile(qc, backend)

Now, we simply execute the circuit and gather the measurement results.

job = backend.run(qc_compiled, shots=1024)  # shots is the number of times we run the experiment
results = job.result()

We store the value of the result object and can further access the number of times we end up with a certain value of expected outcome with the get_counts() method.

counts = results.get_counts(qc_compiled)
print(counts)

{'0': 518, '1': 506}

Here we end up with a dictionary of key values '0' and '1', which indicate the following quantum states:

As expected, we get a 50-50 distribution of the states \(|0\rangle\) and \(|1\rangle\), since our starting state was \(|\psi\rangle\). We can also calculate this probability via the inner-product,

Let's visualize this in the form of a histogram. For this, we import the plot_histogram function.

>>> from qiskit.visualization import plot_histogram
>>> plot_histogram(counts)

You can find the entire script in this gist.

My personal odyssey

Recently I had made the switch from firefox to brave, for the naive reason that fonts were just rendered better (and LaTeX looks like it) on it (being a chromium based browser). However, I really missed the customizability and other nifty features of firefox. It just felt like home. I knew for sure that I'm missing something, because surely firefox couldn't be responsible for messing fonts, right? (atleast I hoped).

On firefox, you may have come across the font settings that look something like this:

My past self would unselect the option Allow pages to choose their own fonts, instead of your selections above, just so that I can have my custom fonts rendered. But oh boy, would that turn out disastrous to say the least. I visit a good number of websites that render math equations in TeX, but with this setting turned off, LaTeX looked more like some flunky '90s PC trying to render math.

What was the fix you might ask? Well, just select the option that I had unselected earlier. But this would bring that the atrocious fonts back on many websites.

The fix

I later came across this blog post where I got to know that firefox depends on an OS-level font configuration called fontconfig and is located at ~/.config/fontconfig/fonts.conf.

Create a fontconfig file

If you don't have one, just create it at the specific location.

<?xml version='1.0'?>
<!DOCTYPE fontconfig SYSTEM 'fonts.dtd'>
<fontconfig>
    <alias>
        <family>Helvetica</family>
        <prefer><family>IBM Plex Sans</family></prefer>
    </alias>
    <alias>
        <family>sans-serif</family>
        <prefer><family>IBM Plex Sans</family></prefer>
    </alias>
    <alias>
        <family>monospace</family>
        <prefer><family>DejaVu Sans Mono</family></prefer>
    </alias>
</fontconfig>

A lot of websites these days use Helvetica as their serif font, and firefox will fallback to a specific font if Helvetica is not found. By default, this fallback seems to be Nimbus Sans, which is not pretty to say the least. This is where fontconfig comes in.

The above XML file tells firefox that, "Hey! If you're trying to render Helvetica, just use IBM Plex Sans", and similar font rules for sans-serif and monospace fonts.

The result

I was really happy when I came across this fix! and I hope this has helped you as well.

Unitary transform:

An operator \(U\) is unitary if

where \(U^\dagger\) is the complex conjugate (interchange rows & columns and replace \(i\) with \(-i\)) of \(U\).

Tensor product:

Let there be 2 matrices \(A\) and \(B\) where

The tensor product of \(A\) and \(B\) is represented as \(A \otimes B\) and is evaluated as

Disclaimer

I have used the term unitary transform and unitary operation interchangeably (since they mean the same thing).

Introduction

Given a quantum state \(\left| \psi \right> = \alpha \left| 0 \right> + \beta \left| 1 \right>\) with unknown complex coefficients \(\alpha\) and \(\beta\), is it possible to replicate the state onto another qubit? In other words, is it possible to go from \(\left| \psi \right>\) to \(\left| \psi \right> \otimes \left| \psi \right>\)? Let us form a hypothesis.

Hypothesis:

Given an unknown quantum state \(\left| \psi \right>\), there exists a unitary transform \(U\) such that it replicates the state \(\left| \psi \right>\) to \(\left| \psi \right> \otimes \left| \psi \right>\).

From the postulates of quantum mechanics, any transformation of a quantum system must be unitary. Hence, we are trying to look for a unitary operation \(U\) to make the following transform:

Here the inputs are \(\left| \psi \right>\) and an ancilla qubit (in our case \(\left | 0 \right>\)).

The no cloning theorem tells us that such a unitary transform does not exist. Let us see how this is true, algebraically. We will do this by disproving the hypothesis. Let us look at the cases when \(\left| \psi \right> = \left| 0 \right>\) and when \(\left| \psi \right> = \left| 1 \right>\). On applying the operation \(U\), the 2-qubit state becomes,

Now let us apply \(U\) to the original state \(\left| \psi \right> (= \alpha \left| 0 \right> + \beta \left| 1 \right>)\) based on the above transformations.

Based on our original hypothesis, the output is

In matrix notation this looks like

Now comparing the coefficients of the output states, such a case is only possible if \(\alpha = 1\) or \(\beta = 1\). This disproves the hypothesis, hence proving the no cloning theorem.

References

1. Quantum Computing lectures by Dr. Umesh Vazirani

2. Principles of Quantum Mechanics - Shankar

3. Quantum Computation and quantum information - Nielsen & Chuang

In layman terms, cryptography is the study of securing messages between two parties without a third party knowing what the message is. Encryption is the process of securing these messages.

Think of encryption as a process which is easy to do in one direction but rather difficult to do in reverse. One such example is colour mixing. One can mix various colours and make a mixture out of it. However, if you ask another person, it would be almost impossible to tell the constituent colours from the mixture.

The barebones method - symmetric encryption

The most basic and easy to understand method is the symmetric encryption method. It basically involves the following: Alice, who wants to send a message; Bob, who receives the message; and a secret key used to encrypt the message (essentially turning the message into gibberish).

Alice has a message, encrypts the message using the secret key, sends the message. Bob now decrypts the message using the same secret key and reads the message. This way during the process when the message is sent, even if a third party gets a hold of the message; they cannot read the message since they do not have the secret key.

Caveats

The above method has a major flaw, which is that both the parties must have a common key. That means that the key to be used for encryption must be decided upon by the two parties beforehand. So the two parties have to meet at a place or send the key to the other through some means which isn't secure, unless one encrypts this key information which requires another key.

A better method - asymmetric encryption

Asymmetric encryption AKA public-key cryptography involves the same scenario as that of symmetric encryption, the only difference being that instead of one secret key, two keys are used (called a key pair). Let them be key A and key B.

Let us use the same scenario as before: Alice wishes to send a message; she encrypts it with key A and sends it to Bob; he receives it and decrypts it using key B. Note that there was no exchange regarding the information of the keys themselves. Key A cannot be guessed from key B and vice-versa however they are linked in such a way that a message encrypted with key A can only be decrypted with key B and a message encrypted with key B can only be decrypted with key A.

Real-world implications

When using asymmetric encryption, a key-pair is generated i.e. a public key and a private key.

The public key is made public (who knew!) and is published everywhere, on websites, posters and so on. The private key is kept to yourself. Any messages intended for you could be then encrypted using your public-key that only you can decrypt since you have the private-key.

What about the other way round? You could encrypt a message that you wish to send, using your private-key. But then you might ask, why should I encrypt a message that can be decrypted using my public-key since anyone can decrypt the message? (since you've made your public-key, public)

Signature algorithms

By encrypting the message using your private-key, one can know that the message is authentic since it can be decrypted using your public-key meaning, it must have been encrypted using your private-key which only you have access to.

A proper communication

So the best way to communicate using this protocol would be as follows: Alice has a key-pair and Bob has a key-pair. Alice wishes to send a message; she encrypts it using her private-key ensuring that the message is authentic and then encrypts it again using Bob's public key ensuring that only Bob can read the message. Bob upon receiving the gibberish decrypts it using his private-key and then once again using Alice's public-key establishing a secure channel for communication.

Note that in this method no keys were exchanged, in fact, Alice and Bob might not have even met before and this method still works. Isn't that amazing?

Disclaimer

I understand that I have over-simplified things. This post is only meant to get a brief overview of encryption. For a better understanding refer the Crypto 101 textbook linked below.

This post was inspired by the book, Crypto 101 by Laurens Van Houtven and this video from the YouTube channel Computerphile where Dr. Robert Miles explains about public-key encryption.

Lastly, I would like to end this post with a quote from Bruce Schneier:

There are two kinds of cryptography in this world: cryptography that will stop your kid sister from reading your files, and cryptography that will stop major governments from reading your files.