qed | minimal continuous integration server running on .NET | Bot library

Just for fun, here's what it would look like in Haskell, where everything dependent-ish is much more annoying. This code uses some very new GHC features, mostly to make the types more explicit, but it could be modified quite easily to work with older GHC versions.

Normally, destruct t applies when t is an inhabitant of an inductive type I, giving you one goal for each possible constructor for I that could have been used to produce t. Here as you remarked H has type P -> False, which is not an inductive type, but False is. So what happens is this: destruct gives you a first goal corresponding to the P hypothesis of H. Applying H to that goal leads to a term of type False, which is an inductive type, on which destruct works as it should, giving you zero goals since False has no constructors. Many tactics for inductive types work like this on hypothesis of the form P1 -> … -> Pn -> I where I is an inductive type: they give you side-goals for P1 … Pn, and then work on I.

I will start by providing some background. You have breached the subject known as calculational reasoning in Isabelle. Calculation reasoning is described in subsection 1.2 of the document The Isabelle/Isar Reference Manual.

Two of the most common patterns for calculational reasoning are

Any assumptions that you need to be part of the induction need to be part of the proof state when you call induct. In particular, that should be all assumptions that contain the thing you do the induction over (i.e. all the ones that contain n in your case).

You should therefore do a using assms before the proof. Then 0 ≥ m will be available to you in the base case, under the name "0.prems" (or just 0 for all of these plus the induction hypothesis, which in this case doesn't exist).

There is probably a way to prove this goal staying in Nat (by using a divisibility argument) but this approach is also feasible. The lemma L1 on which you got stuck can actually be solved in a similar fashion as the theorem T1, leveraging lia for finding the right lemmas. Then, the only thing in your way to apply T1 in the course of proving T2 is to show that Z.of_nat respects addition and multiplication: you can rely another time on lia. All together you obtain the following proof:

Your definition of odd seems wrong. Is it not n+2. Anyway our problem is related to How to prove a odd number is the successor of double of nat in coq?

As @NieDzejkob already mentioned, the proof method chosen by proof is standard. I'm not an expert in Isabelle/ML, but the following ML snippet traverses the proof term and prints the list of used theorems, which may be helpful in trying to find out the specific theorem used by standard:

Because the vmdk file in NFS directory, add this option -o nolock fixed it.

nolock — Disables file locking. This setting is occasionally required when connecting to older NFS servers. noexec — Prevents execution of binaries on mounted file systems. This is useful if the system is mounting a non-Linux file system via NFS containing incompatible binaries.

You can introduce a concrete representation with the theorem int.abs_induct. However, you almost never want to do that manually.

The general method of proving statements about quotients is to first state an equivalent theorem about the underlying relation, and then use the transfer tool. It would've helped if your example wasn't automatically discharged by automation... in fact, let's create our own little int type so that it isn't: