Logic – Automatic proofing

Sorry for the noob question: is there an automatic proof checker?

I mean, a kind of programming language that validates the steps of a proof.

I'm not talking about an automatic proofer, just a way to computationally validate a proof using axioms and previously validated proofs.

What I am looking for is a way to produce evidence that repeats the programming of a computer.

Proofing – How to prove the function of a recursive big theta without using repeated substitution, mastering the sentence, or having the closed form?

I have defined a function: $ V (j, k) $ Where $ j, k in mathbb {N} $ and $ t> 0 in mathbb {N} $ and $ 1 leq q leq j – 1 $, Note $ mathbb {N} $ includes $ 0 $,

$ V (j, k) = begin {cases} tj & k leq 2 tk & j leq 2 tjk + V (q, k / 2) + T (j – q, k / 2) & j , k> 2 end {cases} $

I am not allowed to use repeated substitution and I want to prove this by induction. I can not use the main clause because the recursive part is not in that form. Any ideas how I can solve it with given limitations?

When I start induction: I fix $ j, q $ and introduce $ k $, Then the base case $ k = 0 $, Then $ V (j, 0) = tj $, The question indicated that the function may be $ Theta (jk) $ or maybe $ Theta (j ^ 2k ^ 2) $ (but it does not necessarily have to be either).

I choose $ Theta (j, k) $, In the base case, this would mean that I had to prove that $ tj = theta (j, k) $ when $ j = 0 $, But if I start with the big-oh, I have to show it $ km leq mn = m cdot0 = 0 $ which I currently do not think possible.

I am not sure if I did the basic case wrong or if there is another approach.

Proofing – How to prove in contradiction that every non-empty hereditary language contains the empty string?

A language L is called hereditary if it has the following property:

For every non-empty string x in L, there is a character in x that can be deleted from x to get another string in L.

Prove inconsistently that any non-empty hereditary language contains the empty string.

Here is my attempt:

To prove the contradiction, suppose that for every non-empty string x in L, there is no character in x that can be deleted from x to yield another string in L.

This means that deleting a character in x leaves an empty string. Because an empty string is also a string, any non-empty hereditary language contains the empty string.

I am not quite sure how to prove by contradiction. Can someone help to verify this?

Proofing – How do we prove the temporal complexity of this simple probabilistic problem problem in a Bayesian network?

Maybe a rather trivial question, but I try to refresh the evidence in CS …

Suppose we have a simple Bayesian network with two node rows: $ x_1, x_2, ldots, x_n $ and $ y_1, y_2, ldots, y_n $, Every node $ x_k $ assumes a state of 0 or 1 with equal probability. Every node $ y_k $ Probably assumes state 1 $ p_k $ if $ x_k $ is state 1 and probability $ q_k $ if $ x_k $ is state 0.

Exponential time is required to calculate the probability of all $ y_k $ are 1 and if so, what is a suitable CS proof for that?

Proofing Techniques – Prove that every complete prefix-free language is maximal

I am practicing a problem where I have to prove that every prefix-free language is maximal.

I know that a prefix-free language A is a maximum if it is not a proper subset of a prefix-free language, where a prefix-free language is full if

$$ sum_ {x in A} 2 ^ {- | x |} = 1 $$

Also, I know that a language A 0 {0, 1} * is a prefix-free if no element of A is a prefix of another element of A and that the force inequality says that for each prefix-free language A .

$$ sum_ {x in A} 2 ^ {- | x |} leqslant 1 $$

I'm pretty sure that a full free prefix language is maximal because it belongs to the maximum prefix-free set. But I do not know how to prove it formally. Should I deal with Kraft's inequality and what I know about the relationship between maximum and prefix-free quantities?

Any help would be appreciated!

Proofing techniques – Turing machine with semi infinite band – Prove by construction

I am studying restricted Turing machines.

There is a theorem that proves that both infinite and semi-infinite Band TM have the same computational power. The theorem proves this by emulating an infinite band TM1 with a multi-track band TM2, one track emulating the right part of the TM1 band and the other track emulating the left TM1 band.

Could I emulate the infinite tape machine like this:

  • Let the alphabet of TM1 be {0,1}
  • Construct a TM2 machine with half tape to the right of alfabet {0,1} U {#}
  • To let w = 011101
  • When the execution starts, the tape looks like
    | 011101BBB ...

  • The first step of TM2 should be to call a Subrutine TM2 that shifts w on the tape N turn right and set # in the first position of the band, so: | #BB ... 011101BBB ...

  • When the controller is running during execution # Symbol, then call up the shifting subrutine again.

I know that this is not a formal proof, it's just an idea. I also know that this is neither efficient nor elegant, but could it work?