Since the material is classified, I can only reveal the structure, and
not the content, but basically, there was a document containing a
"claim" (a sentence in a specification which specifies what is being
claimed in the patent being applied for) which somebody had slightly
mis-translated from English to Japanese, and which was being amended.

The original English clause in the claim had the following structure:

"... an A in communication with a plurality of B, said A configured to
generate a C signal, configured to cause at least one of said
plurality of B to output a said D, said C signal based at least in
part on said E signal."

Unfortunately, whoever translated that clause from English to Japanese
apparently left out the "said A configured to generate a C" portion.

Then this mis-translated Japanese translation of the original English
clause was amended, but was never translated back to English.

Then this amended Japanese clause was re-amended, and I was asked to
"apply" the re-amendment to the English original.  The re-amended
Japanese clause then had the following structure (after I finally
figured out the structure):

"... an A in communication with a plurality of B, said A configured to
generate a C signal, configured to cause the C coupled to said F so
that a positional relationship, for the E which has sent the E signal,
corresponding similarly to a positional relationship between the E
which has sent the E signal and the G of said plurality of B to output
a said force associated with the strength detected by the E, said B
signal based on said E signal."

The first aspect that I noticed was that the previous amendment had
never been translated, requiring me to fill in the details.

However, then I noticed that this previous amendment had itself been
based on a mis-translated original.

In order to figure out which portion was missing from the translation
of the original clause, I needed to map portions of the original
English clause to their Japanese equivalents, but since the structure
itself was not written to reflect the structure of the original
English clause, I then needed to break up the original English clause
into its structural components.

At first, this process seemed very tedious and difficult, until I
noticed that treating these structural components in the clause as if
they were S-expressions in a Scheme program, and then mapping
equivalent components of the English clause to semi-corresponding
components of the Japanese (mis-)translation speeded up and simplified
this process greatly, even though the correspondence was not exact.

For some reason, I have discovered that this kind of mental
equivalence seems to proceed much more smoothly between S-expressions
in Scheme programs and claims in patent documents than between other
kinds of expressions in other functional programming languages and the
same claims in patent documents.  For example, I have not had similar
experiences with finding equivalences between expressions in even
Haskell programs and the claims in patent documents; Haskell
expressions seem to be more equivalent to mathematical equations than
to claims in patent documents.

Therefore, it seems that exposure to the Scheme programming language,
in particular, can help in training non-programmers to think
structurally in analyzing expressions in natural language, which can
have benefits in translating claims in patent documents in such a
manner that they can be more easily and clearly amended.

Perhaps MIT should reinstate Scheme and 6.001, and get rid of Python
and the new C1.  Somehow I feel that MIT is risking creating a new
generation of idiots by getting rid of Scheme and SICP from their
curriculum just for the ostensible reason that the recursive style of
programming does not reflect the way that programming is actually
conducted in industry.  Students do not learn programming just to
program; learning programming also has important ramifications for the
structural thought processes underlying other technical fields, even
those that do not seem superficially related (such as patent
translation), and it seems that watering down a core programming
course for such ostensible reasons undermines the crucial patterns of
thinking which are cross-applicable to such other technical fields as
well.

Have you considered the inverse mapping? Then you can convert your Scheme
programs into patent claims. I'd better patent that!

(lambda ...) => A method

What is claimed is:

1. An _in vitro_ remote-control device, the device comprising:
        a mounting unit for mounting the remote-control device on a
portion of the head of a user;
        a transmitter unit, further comprising:
             a neurotransmitter unit transmitting neural impulses to a
brain of the user;
             a neuro-digital conversion unit converting neural
impulses to digital signals;
        a receiver unit, further comprising:
             a neuroreceptor unit receiving neural impulses from the
brain;
             a digital-neuro conversion unit converting digital
signals to neural impulses; and
        a power source unit converting thermal radiation from brain
cells into electricity, the electricity powering the remote-control
device;
   wherein:
        the transmitter unit transmits digital signals in response to
neural impulses; and
        the receiver unit transmits neural impulses in response to
digital signals.

The above-mentioned claim translates roughly into my personal variety
of pseudo-Scheme as follows (apologies for any deviations from the
syntax or semantics of actual Scheme):

(claim-define (_in-vitro_-remote-control-device mounting-unit
transmitter-unit receiver-unit power-source-unit)
              (claim-comprising
               (mounting-unit
                (lambda (head user)
                  (mount head user)))
               (transmitter-unit
                (lambda (neurotransmitter-unit
neuro-digital-conversion-unit)
                  (claim-define (neutrotransmitter-unit
neural-impulses brain)
                                (transmit neural-impulses brain user))
                  (claim-define (neuro-digital-conversion-unit
neural-impulses digital-signals)
                                (convert (neural-impulses
digital-signals))))
                (receiver-unit
                 (lambda (neuroreceptor-unit
digital-neuro-conversion-unit)
                   (claim-define (neuroreceptor-unit neural-impulses
brain)
                                 (receive neural-impulses brain))
                   (claim-define (digital-neuro-conversion-unit)
                                 (convert digital-signals
neural-impulses))))
                (power-source-unit
                 (lambda (thermal-radiation brain-cells electricity)
                   (power-convert thermal-radiation electricity
brain-cells)))))
                (claim-wherein
                 (transmitter-unit
                  (lambda (digital-signals neural-impulses)
                    (transmit digital-signals neural-impulses)))
                 (receiver-unit
                  (lambda (neural-impulses digital-signals)
                    (transmit neural-impulses digital-signals)))))

This pattern of thinking can greatly simplify verifying equivalence
between an English translation of a claim having a complex structure
and the original Japanese claim.

: Therefore, it seems that exposure to the Scheme programming language,
: in particular, can help in training non-programmers to think
: structurally in analyzing expressions in natural language, which can

You do realize that a very similar argument is often made about studying
Latin to learn to think structurally and learn to analyze language ?

Scheme as the new Latin (and Haskell as the new Ancient Greek ?), I must
say the idea does have some appeal. :-)