## How to apply color scheme to Winmerge under Wine?

I’m running Winmerge (called by Treecomp!) under Wine in Red Hat 7.9
Unfortunately the configuration dialog doesn’t show the color schemes that ship with Winmerge, even if they’re explicitly imported.

So, did anyone make it work ?

## ag.algebraic geometry – Maximal closed subscheme stable under the action of a finite connected group scheme

Let $$k$$ be a field of characteristic $$p>0$$, $$X$$ a smooth projective $$k$$-variety and $$Ysubseteq X$$ a closed irreducible subvariety. Let $$G$$ be a connected finite $$k$$-group scheme acting on $$X$$.

Does there exist a maximal closed subscheme $$T$$ of $$Y$$ stable under the action of $$G$$?

If $$G$$ is étale, then I think one can define $$T:=bigcap_{gin G}g(Y)$$. In case $$T$$ exists, is there a similar description for it?

## differential equations – Can we apply Staggered solution scheme for coupled field problems in MMA

How to solve coupled field problems using staggered solution scheme in MMA 12.2?

To undertand the Fully Coupled vs. Staggered approach, we may check it from Comsol:
https://www.comsol.com/support/knowledgebase/1258

Let us see the example from fully coupled solution:

``````ClearAll(y, x, t);
L = 10;
ode1 = y''(t) == 0;
ic11 = y(0) == 0;
ic12 = x(L)^2*y'(L) == 100;
ode2 = -1 + x(t) + x(t)*(y'(t)^2 + y''(t)^2) - 2 x''(t) == 0;
ic21 = x'(0) == 0;
ic22 = x'(L) == 0;
NDSolve({ode1, ode2, ic11, ic12, ic21, ic22}, {x, y}, {t, 0, 1})
``````

Another example (complex) is from complex nonlinear coupled equations solved by Alex Trounev.

If we use staggered solution scheme, first solve ode1 , then use the solution from “ode1” for solving “ode2”.

Another question is, how to set the time step that we can have a convergence solution using staggered solution scheme in MMA 12.2?

## Construction of the Hilbert Scheme

I am reading the book "Rational Curves on Algebraic Varieties" of János Kollár. Definition-Proposition 1.2, begin like this:

Let $$g:Yrightarrow Z$$ be a projective morphism and $$mathcal{O}(1)$$ a $$g$$-ample line bundle. I would like to know what is a "$$g$$-ample line bundle".

Thank you a lot!

## interpreters – Macros vs lazy evaluation in scheme inspired language

I’m writing a simple scheme inspired interpreter. I’m not calling it a scheme implementation because I don’t really want to implement all the standard, only the minimal set of primitives needed to keep evolving it from it self.

I have two primitives lambda and lazy, lazy is a lazy version of lambda in the sense that it receives its arguments unevaluated and it can chooses on what evaluate

Here are both as examples:

``````(define foo (lambda (x) (+ 1 x)))

(define foo (lazy (x) (+ 1 (eval x))))
``````

The idea to have lazy is not needing macros (at last in the core language, I may implement it afterwards on top of lazy).

My question is, given `lazy` do I need macros/hygienic at all? Isn’t this primitive a lot clearer than macros? What kind of macros I can’t define on top of lazy and why?

## encoding scheme – Coding efficiency of a code representing 50,000 characters, using unicode

I need to find the coding efficiency of a code representing 50,000 characters using unicode.
Here is what I did,

the number of characters is 50,000

and 2 raised to the power of 15 is 32,768

so bits used is 32,768 and bits needed is 50,000

so 32,768/50,000 multiplied by 100 is 65.536%.

I am completely new to this topic, sorry if I am wrong. Thank you.

## currencies – What is an «open Ponzi scheme»?

I recently read that Nassim N. Taleb thinks that Bitcoin is an open Ponzi scheme. An influental and intelligent person like him surely doesn’t say something without thinking about it first. Therefore I asked myself what he means with that term.

In my view the key ingredient of a Ponzi scheme is deception – deception of investors about the real source of their revenue. In order to keep this deception from becoming public knowledge, a Ponzi scheme must remain «closed» in that regard. An «open Ponzi scheme» would mean that there is no deception because «the secret» of the revenue is known to everyone. Isn’t «openness» exactly the necessary ingredient which would legitimize even a Ponzi scheme by making it possible to investors to «add» fair value to it, which would most possibly be Zero?

Wouldn’t any asset be an open Ponzi scheme by Nassim N. Talebs logic?
I mean every investor tries to make money by selling his investment to others for a higher price at some point.
I feel that following his Logic even gold, diamonds, company shares, etc. are «open Ponzi schemes» – our whole economy would be an «open Ponzi scheme».

If my logic would be right, this term has no meaning and someone just added a total useless term to the vocabulary.
(I don’t ask if Bitcoin is a Ponzi-Scheme – I’m interested in the logic behind the idea of «open ponzi sheme»)

## lisp – Scheme allow uppercase define

To define a `square` in scheme I can do the following:

``````(define (square x) (* x x)
``````

However, if I use a capital `DEFINE`, I get an invalid identifier:

``````(DEFINE (square x) (* x x)
``````

Is there a way to do something like the following?

``````#lang sicp
; using DrRacket
(define (DEFINE) define) ; sort of a macro where DEFINE expands to define
``````

## c# – A simple encryption scheme similar to OTP

Basically this scheme uses a key the same length as the data, but it generates the bytes on the fly.
They aren’t truly random, but there aren’t any obvious patterns and the output passes all the NIST tests.

Since a simple password can be used to do the de/encryption it is much easier to hand off to the recipient and any good password generator can create one.

Since only part of the generated sub keys are used, it becomes very difficult if not impossible to reverse engineer the sub key to find the previous or next sub key.

``````class Cipher
{
public static IEnumerable<byte> Encrypt(string key, IEnumerable<byte> data)
{
return GetBytes(key, data);
}
public static IEnumerable<byte> Decrypt(string key, IEnumerable<byte> data)
{
return GetBytes(key, data);
}
private static IEnumerable<byte> GetBytes(string key, IEnumerable<byte> data)
{
if (key == null)
{
key = "";
}
if (data == null)
{
data = new byte() { 0 };
}
var temp = Sha3.Sha3512().ComputeHash(Encoding.UTF8.GetBytes(key));
return data.Select(x => { var y = (byte)(x ^ temp(0)); temp = HashCode(temp); return y; });
}
}
``````

## multi signature – Is this scheme for multisig audit of Trezor + Coldcard ok?

My plan is to make a multisig between coldcard and trezor. I want to audit and verify that I indeed own the 2 keys of these wallets, using a raspberry pi zero (no wifi/bluetooth by definition) on a very old HDMI tv with no internet either, and using a virtual keyboard and simply a mouse on the pi zero.

These are the possible risks I want to mitigate:

To eliminate the risk of the trezor generating a private key I don’t own, I’m gonna put its key on the raspberry pi zero and see that it generates the same master pubkey and shown in trezor. This proves I own this key, but it might be a kew that someone already owns. No problem, that’s why I’m doing multisig.

On the coldcard, I’ll generate a seed using dices, and then verify on the raspberry pi that those dice rolls indeed generate the private key shown by coldcard. This proves that I own a private key that no one owns, because it was generated using dices.

Now that I have 2 private keys that I own, and at least one of them I’m the only owner, I can create a multisig wallet on Ethereum or maybe BlueWallet. I’ll annotate the first 10 addresses generated by the software wallet, and verify if they match on the coldcard and on the trezor. If the 3 show the same 10 set of addresses, I can consider these addresses safe for receiving Bitcoin.

I’ll then receive some Bitcoin on one address, erase both wallets, restore them with the private keys, and then try to spend this Bitcoin, just to make sure I really owned the coins.

What are the possible problems I can encounter? Am I forgetting something important?

PS: I know that if the trezor has a malicious random number generator and it creates a private key that not only myself own, this is a privacy leak, but not a problem. And it’s a privacy leak only when I spend from this address, revealing the public key on the blockchain.

I also plan to use just PBST air-gapped transactions on Coldcard, and a trusted computer to broadcast.