In boolean algebra (P(S),+,.,’) we must have S as 1 and {} as 0 in every possible sub-boolean algebra to hold id elements. We must have S-x for every subset x⊆S to hold complements. It seems like counting every possible partitions in S which is Bell(|S|) if i was not wrong. For example the number of possible sub-boolean algebra of ⟨p({a,b,c,d}),∪,∩⟩ is Bell(4)=15 , is it right ? If it is how we can define a bijection between every n class partitions to boolean algebra with size n ?

# Tag: equal

## Finding $l$ subsets such that their intersection has less or equal than $k$ elements NP-complete or in P?

I have a set $ M$ , subsets $ L_1,…,L_m$ and natural numbers $ k,l\leq m$ .

The problem is:Are there l unique indices $ 1\leq i_1,…,i_l\leq m$ , such that

$ \hspace{5cm}\left|\bigcap_{j=1}^{l} L_{i_{j}}\right| \leq k$

Now my question is whether this problem is $ NP$ -complete or not. What irritates me is the two constraints $ l $ and $ k$ because the NP-complete problems that were conceptually close to it that I took a look on (set cover, vertex cover) only have one constraint respectively that also appears in this problem.

I then tried to write a polynomial time algorithm that looks at which of the sets $ L_1,…,L_m$ share more than $ k$ elements with other sets but even if all sets would share more than $ k$ elements with other this wouldn’t mean that their intersection has more than $ k$ elements…

This question kind of comes close but in it there is no restriction on the amount of subsets to use and the size of the intersection should be exactly $ k$ , but maybe this could be useful anyways.

Can somebody further enlighten me ?

## How to find the size of gaps between entries in an array so that the first and last element of the array is filled and the gaps are all of equal size?

I have an array a of n entries. I need to place a token on the first and last position of that array, so `a[0] = 1`

and `a[n-1] = 1`

.

I now want to place additional tokens into that array with a distance inbetween each index i where `a[i] = 1`

that is greater than 2 (so placing a token on every index is invalid as well as alternating using and not using an entry is invalid). Phrazed differently: I want that `sum(a) < n/2`

. The gap inbetween each token should be the same, so say with an array of size 16,

`a[0] = 1, a[3] = 1, a[6] = 1, a[9] = 1, a[12] = 1, a[15] = 1`

would be a solution with a gap size of 2 (distance of 3).

How do I find all gap sizes that are possible to fill said array with the given constraints?

Imagine a street inbetween two crossroads where a lamppost should be placed on each crossroad and then additional lampposts should be placed equidistant to each other and for some reason only natural number distances are allowed.

(The actual problem I want to solve is where to place Sea Lanterns in my Minecraft Project so do not disregard this problem as an assignment question I want a solution for.)

## Is my reasoning wrong that $PSPACE$ should not equal $EXPTIME$?

It’s impossible for a problem to require exponential space without being exponential-time.

- Consider that if an $ EXPSPACE~~complete$ problem can be solved in $ 2^n$ time.
**It will now fall into the class $ EXPTIME$ .** - Then $ EXPSPACE~~complete$ problems are in $ EXP$
**if they can be solved in $ 2^n$ time**. This means they can reduce into $ EXP~~complete$ problems and vice versa.

To me, this should be easy to write a proof that $ EXPTIME$ = $ EXPSPACE$ .

My intuition tells me that if $ Exptime$ = $ Expspace$ ; then $ PSPACE$ != $ EXPTIME$ ,

**Because $ PSPACE$ already is not equal to $ EXPSPACE$ .**

## Question

As an amateur, what would make this reasoning be wrong or right?

## What are the $EXP^{NP}$, $EXP^{PSPACE}$, and $EXP^{EXP}$ equal to

What are the $ EXP^{NP}$ , $ EXP^{PSPACE}$ , and $ EXP^{EXP}$ equal to?

I suspect that their, NEXP, ESPACE and 2EXPtime respecitvely. And what bout $ NP^{EXP}$

## How to proof that Turing machine that can move right only a limit number of steps is not equal to normal Turing machine

I need to prove that a Turing machine that can move only k steps on the tape after the last latter of the input word is not equal to a normal Turning machine.

My idea is that given a finite input with a finite alphabet the limited machine can write only a finite number of “outputs” on the tape while a normal Turing machine has infinite tape so it can write infinite “outputs” but I have no idea how to make it a formal proof.

any help will be appreciated.

## Number partitioning targeting ratio of subset sums and equal size

I’ve seen a number of questions and answers related to the partitioning problem of dividing a set into 2 subsets of equal size and sum that use greedy or dynamic programming solutions to get approximate answers. However, I am looking to split a set into 2 subsets of minimum difference in size but with a target ratio of sums.

I have tried variations of greedy algorithms that will work to minimize the largest difference of the two metrics at any point in the calculation, but this just results in a result that splits the difference between the two. I’m happy with an approximate solution since it needs to run in a reasonable amount of time.

## Shortest path using less than or equal to m edges in a directed, weighted graph with negative cycles

I’m solving a problem:

Given a directed, weighted graph $ G$ that has $ V$ vertices and $ E$ edges and a positive integer $ m$ , describe an algorithm that finds the length of the shortest path using less than or equal to $ m$ edges. Note that the graph may contain negative cycles.

First, I tried Bellman-Ford algorithm, but I cannot deal with negative cycles. Next, I tried one using recursive DFS, but it takes too much time! I think dynamic programming may solve this problem, but I don’t know how to start with DP. Is there any fancy way to solve this problem in short time?

## decrypted signature using CA public key equal to hash of certificate?

so here is my test setup, I write something “hello world”, created its hash, created signature of hash from private key, then using this openssl command, i can get same hash from which signature was generated openssl rsautl -verify -inkey pubkey.pem -pubin -keyform PEM -in signature

Next I downloaded stackexchange.com public certificate, extracted signature from certificate, decrypted signature from CA (Let’s Encrypt) public key, that is OK but result don’t match hash of stackexchange public certificate. what I’m doing wrong?

## does number of pages equal number of page frames

Im trying to think about mappings between the page table and the physical memory, and I’ve always worked with where the number of entries in a page table equals the number of frames in physical memory.

Is it possible to have a case where we have 256 page table entries but only 128 frames in the physical memory?

And if so, how come?