I'm making the argument (as are Oracle in the courts) that it's the software patents that are the case, the copyright violations (the things that are behind the license) have been pretty much shot down - certainly all I'm hearing about is the patents and the big OMG Android copied Java appears to have been removed.
The license you (assuming you are the same person) linked to was a Sun/Oracle SDK End user agreement. There is no guarantee that this applies to Google engineers creating Android (or the company that Google bought that originally created Android).
You are making the stupid assumption that because you have found a license it is somehow magically applied to everyone. This particular license requires that the person to whom it applies have downloaded the SDK. I'm missing the point where you show that Google engineers in relation to Android have downloaded the SDK.
Unfortunately for you that isn't the only way to license the Java SDK, I know for a fact (having worked there on Java) that large companies, especially those that create their own VMs (completely legally under license, like Apple, HP, IBM etc) have different agreements. Your EULA that you linked has absolutely NOTHING to do with the licensing that they operate under - you are confusing individuals with large companies.
Harmony, the 'base libraries' that you are complaining about are owned by the Apache Foundation, they were pretty much written by IBM originally and IBM I believe has a completely different licensing agreement with Sun/Oracle as part of the fact they have multiple platforms and create their own VMs for them. Oracle hasn't sued or in any way protested the Harmony project other than the fact that due to the field of use restrictions Harmony is not TCK / JCK certified and as such can't be called Java - this by the way led to the rather public divorce of the Apache Foundation from the JCP.
If your assertion that the "license explicitly denies you the permission to create your own VM," applied to everyone then there is no way that IBM could create their own VM for AIX and zOS, there's no way that Apple could have created a VM to run on MacOS and there's no way that HP could have created a VM to run on HPUX. All these companies (and more) did this, and all of them entered into different agreements with Sun (and now Oracle).
You are not privy to the contents of these agreements, neither am I, but I can posit that they are different from the the EULA you quoted as according to you that license prevents them creating a VM.
Since you have no idea as to the legal agreements in force between Google and Sun/Oracle your assumption that the EULA for the SDK download applies is moronic - you might be correct, but you're more likely to be incorrect. Basing your entire argument on a document you have no evidence is even in force isn't the way to go about proving anything.
What I've tried to point out to you is that anyone could do the same thing - you never need to touch the license as you can access everything you need elsewhere.
Jikes(http://jikes.sourceforge.net/) - a java compiler (originally written by IBM again) means you'd not need the JDK to convert java code into bytecode.
Kaffe(http://www.kaffe.org/) - a 'java' VM technically not Java but can execute java bytecode, open source cleanroom implemented legal... means you'd not need the JDK in order to execute your program.
Harmony(http://harmony.apache.org/) - java class libraries , means you'd not need the JDK to use similar base libraries.
You can develop Android without ever getting near that license you're so wedded to, so I ask you how is that license in force? You're assuming that the license has to be in force whereas I've demonstrated multiple ways that it may not be.
As a quick aside, your mention of "pay 6 billion dollars" was cut down to 100 million dollars by the Judge, the 6 billion was Oracles made up number to try and get as much as they can - part of the negotiating and media position but not based in reality.
To violate a contract there has to be a contract in place - I've missed the point where Oracle has argued breach of contract... They've argued copyright violation (your license you're talking about) but had that shot down, they've argued patent infringement (which is ongoing and may have a point) but there's been no mention of breech of contract. It's possible it's there but just hidden under the redacted sections, but it's more likely that hasn't occurred. Certainly I would be surprised if Oracle tried the copyright angle if it had them under breech of contract, it would have been so much more cut and dried whereas they wasted time, failed and resorted to patents.
Google claiming they got implicit endorsement? Hadn't heard that but I'm not following it too closely, the arguments in a legal case pretty much don't relate to the reality.
"Google did not write a java program. Google massively changed the VM, compiler, rewrote the jit, changed the base library and so on. None of that was allowed."
Google wrote a new VM, cleanroom. This means that they didn't change the VM (if they had changed it then they would have been nailed - quite rightly - on the copyright charges, you know the ones that have pretty much died) they wrote a new one. I hope you're aware of the differences between copyright IP and patent IP, because you can always reimplement to get around copyright (as in it protects you from copying but you don't own the idea) but patents don't matter who wrote it because the idea itself is 'protected'. The JIT is part of the VM, it seems odd to mention it again...
Google uses (or should I say Android Developers use) the Sun/Oracle J2SE compiler to compile their programs. Nothing in this violates the license. It is just like you've created any other Java program. The resulting class files are then modified again to a completely different format. This doesn't involve a compiler, just a translator and there is currently (that I'm aware of ) no way to compile from source code to Dalvik bytecode, so they really really didn't change or even write a new compiler.
Google didn't change the base library, these (as I'm getting tired of telling you) are the Harmony libraries, written originally by IBM now owned and open sourced under the Apache2 license by the Apache Foundation. So I'm missing where Google did this, they use Harmony yes, but that's legal.
When you get down to it, none of that was liked by Sun/Oracle but also (and importantly) it wasn't forbidden, you might like it if it was but the legal systems unfortunately for you do not support your contention.
"Your argument hinges on the entire android java system being nothing more than just another java program, running within the confines of the jdk licence (in other words, on a desktop machine in a sun-approved jvm without any special libraries). I find it hard to believe you can even claim this with a straight face."
For the time that the code is subject to the Java license in the case of a developer (Android's java like component is pretty much just apps running ontop of linux), yes that is the argument, and that's the argument because that is what happens. I'm not as clued up as to how the build process for an Android image works but I'd imagine it can be done in a similar fashion.
The code you write uses all Sun/Oracle libraries (all the java.* etc libraries are UNCHANGED on the desktop) and as such (other than not working, everything you link into in 'Android' is just a stub) you can run it, on the desktop on the Sun/Oracle VM and using the Sun/Oracle libraries. Please note that these 'base libraries' are not included in the application they are included in the VM, you merely call out to them. Then you translate the bytecode from Java to Dalvik and put it into a Dalvik VM with different libraries and you're good to go.
The important thing to remember (and I'm getting the impression you have issues with this) is that the license dictates terms for the JDK but nowhere in that license does it dictate terms for the programs you create on the JDK. Therefore, your program which you then take away from the JDK is not subject to the JDK's licensing restrictions. Android doesn't run Java, it runs Dalvik, which means that even your much vaunted clause
"D. Java Technology Restrictions. You may not create, modify, or change the behavior of, or authorize your licensees to create, modify, or change the behavior of, classes, interfaces, or subpackages that are in any way identified as "java", "javax", "sun" or similar convention as specified by Sun in any naming convention designation." does not apply as that is a Java Technology Restriction, not a Dalvik Technology restriction.
Android is Linux, a version that contains a Dalvik VM that executes Dalvik bytecode. Your assumption that Android is pure Java is wrong (it isn't any kind of Java), the apps that run on Android are Dalvik apps, and the way that you write the Dalvik app is to write a Java app and then translate it (this isn't the only way possible, a direct Java sourcecode to Dalvik bytecode compile would be plausible, any language to Dalvik bytecode would also be possible). The JDK license is precisely that, the license for the JDK, if you no longer use the JDK you're not subject to the license. For example, installing the JDK does not then mean you can't call a C++ library java.lang.String for example - the license relates to your usage of the JDK not you in everything you do.
The license (and please spend some time actually reading it) does not claim any ownership of the code you write, the sole restrictions are those to do with changes to the JDK. So if you leave the JDK alone (as Android apps do) then you've not run afoul of any of it. Once you have written the code and compiled it into bytecode you are free to do whatever you wish with it. You can run in on an Open Source VM, you can run it on an Apple VM, you can convert it to machine code and run without a VM, and quite importantly you can convert it to any other language or format you desire. There are no restrictions to what you can do with your code (bytecode or otherwise) because of using the JDK. What you cannot do is modify the JDK and the enclosed VM, which is fine because the Android Dalvik VM doesn't do that.
"And try to formulate an argument that doesn't involve the existence of another set of magical legal documents which are stated in the article not to exist. There was *no* agreement of any kind made with Google. Java is *not* English. Android is quite a bit more than a few com.google... classes, and Java is (still) very much non-free software, except in the GPL sense (with the viral clause in full force)."
And to respond, in your case try to formulate an argument that doesn't rely on Android being something completely different to what it is, and try not to base your argument on a license that need not apply.
Obviously Java is not English, English is English. In reference to your book analogy Java is like English in that it is the language that the book (or program) is written in. You made the incorrect analogy I merely corrected it.
The article does not state that no license agreement exists (merely that Google rejected a $100 million licensing agreement for Android). You are inferring that because licensing for Android does not exist that there is no licensing at Google for Java, the article doesn't state that isn't the case and it wouldn't have much in the way of bearing for Oracle's lawsuit - licensing internally is not the same as licensing to ship. Which means that your assumption that the only license agreement that could operate is the EULA is rubbish, it doesn't have to operate and there could be other internal licenses.
For crying out loud, Java is not software (the commands javac and java are software but the language itself isn't). You write software in Java, Java is a language. The tools that help you write software in Java (the compiler and in the case of Java the VM) are software and the license applies to them.
The Sun/Oracle supplied Java compiler and the Sun/Oracle supplied Java VM are non-free software, the Java programming language is a programming language - these are very different things.
At some point I would suggest that you sit down and actually write a program so that you begin to understand what you're talking about.
Programming languages != Software - Licenses cannot be in force as there is nothing to license.
Programming language tools == Software - Licenses can be in force, as you can license the tools.