text:
ArticlePDF Available

# Use of Formal Verification at Centaur Technology

Authors:
• Centaur Technology

## Abstract and Figures

We describe the formal methodology we are using to verify components of a commercial 64-bit, x86-compatible microprocessor design at Centaur Technology. This methodology is based on the ACL2 theorem prover. In this methodology, we mechanically translate the RTL design into a formal HDL for which we have an interpreter in ACL2. We use AIG-and BDD-based symbolic simulation and theorem proving techniques to show that the hardware models satisfy their specifications, which are ACL2 functions. Completed verifications yield theorems admitted by ACL2, ensuring that the verification is based on sound reasoning. We have used this methodology to verify instructions such as SIMD floating-point addition and subtraction, integer and floating-point multiplication, comparisons, bit-wise logical operations, and integer/float conversions. We discuss our floating-point addition verification as a case study.
Content may be subject to copyright.
A preview of the PDF is not available
... At Centaur Technology, we have been doing formal verification of execution units-those that perform logical, integer, SIMD integer, and floating-point operations-for over a decade [19,9,14]. Formal methods have proven to be very effective in the validation of data-path intensive designs. With the size of operands in the x86 ISA growing to 512 bits, targeted or random simulations have become inadequate to cover arithmetic and cryptographic units. ...
... In contrast to these approaches, we extended our prior work on the execution unit [19,9] as well as microcode [17] verification, and along with proofs about instruction decoding and composition of uops, are able to prove instruction implementations correct. Notably, the operational semantics of uops provably reflects behavior of the RTL design. ...
Preprint
Verification of modern microprocessors is a complex task that requires a substantial allocation of resources. Despite significant progress in formal verification, the goal of complete verification of an industrial design has not been achieved. In this paper, we describe a current contribution of formal methods to the validation of modern x86 microprocessors at Centaur Technology. We focus on proving correctness of instruction implementations, which includes the decoding of an instruction, its translation into a sequence of micro-operations, any subsequent execution of traps to microcode ROM, and the implementation of these micro-operations in execution units. All these tasks are performed within one verification framework, which includes a theorem prover, a verified symbolic simulator, and SAT solvers. We describe the work of defining the needed formal models for both the architecture and micro-architecture in this framework, as well as tools for decomposing the requisite properties into smaller lemmas which can be automatically checked. We additionally cover the advantages and limitations of our approach. To our knowledge, there are no similar results in the verification of implementations of an x86 microprocessor.
... This approach works only when the reference design is structurally close to the original under verification and relies on the correctness of the reference design and proof maintenance whenever designers make structural changes. Another approach is to find a suitable decomposition of a design into parts that can be verified automatically and compose those results into a top-level theorem [13,15,30]. The drawback of this method is that it requires manual intervention by the verification engineer who decides about the boundaries of the decomposition. ...
... Rewriting with Lemmas 12-17 does not affect the value of f 4 since they are restricted to rewrite terms that contain only the + and − functions, and minterms. For Lemmas 12,13,and 14, x can only be unified with a positive minterm. Therefore, rewriting with these lemmas does not change f 3 . ...
Chapter
Full-text available
The automatic formal verification of multiplier designs has been pursued since the introduction of BDDs. We present a new rewriter-based method for efficient and automatic verification of signed and unsigned integer multiplier designs. We have proved the soundness of this method using the ACL2 theorem prover, and we can verify integer multiplier designs with various architectures automatically, including Wallace, Dadda, and 4-to-2 compressor trees, designed with Booth encoding and various types of final stage adders. Our experiments have shown that our approach scales well in terms of time and memory. With our method, we can confirm the correctness of $$1024\times 1024$$-bit multiplier designs within minutes.
... However, these methods, as well as SAT Solvers [22], do not scale for automatic verification of more common multiplier architectures, i.e., Wallace-tree like multipliers and Booth Encoding. Their irregular and more advanced structure complicates the process for automatic tools; therefore, verification of industrial designs is carried out mostly manually [10,11,12,21,23]. Recent studies have focused on computer algebra based methods and they have shown significant improvements [5,13,17,18,31]. ...
Preprint
Full-text available
Automatic and efficient verification of multiplier designs, especially through a provably correct method, is a difficult problem. We show how to utilize a theorem prover, ACL2, to implement an efficient rewriting algorithm for multiplier design verification. Through a basic understanding of the features and data structures of ACL2, we created a verified program that can automatically verify various multiplier designs much faster than the other state-of-the-art tools. Additionally, users of our system have the flexibility to change the specification for the target design to verify variations of multipliers. We discuss the challenges we tackled during the development of this program as well as key implementation details for efficiency and verifiability. Those who plan to implement an efficient program on a theorem prover or those who wish to implement our multiplier verification methodology on a different system may benefit from the discussions in this paper.
... Some engineers verify reference designs using mechanized proof systems [20]. Another common analysis method is to decompose a design into smaller parts, reason about these parts separately, and then compose these proofs into a top-level theorem [21]- [23]. Finding a workable decomposition and combining individual proofs of multiplier fragments can be a cumbersome task. ...
Preprint
Full-text available
We have developed an algorithm, S-C-Rewriting, that can automatically and very efficiently verify arithmetic modules with embedded multipliers. These include ALUs, dot-product, multiply-accumulate designs that may use Booth encoding, Wallace-trees, and various vector adders. Outputs of the target multiplier designs might be truncated, right-shifted, or a combination of both. We evaluate the performance of other state-of-the-art tools on verification problems beyond isolated multipliers and we show that our method applies to a broader range of design techniques encountered in real-world modules. Our verification software is verified using the ACL2 theorem prover, and we can soundly verify 1024x1024-bit isolated multipliers and similarly large dot-product designs in minutes. We can also generate counterexamples in case of a design bug. Our tool and benchmarks are available online.
Chapter
Formal methods are becoming an indispensable part of the design process in software and hardware industry. It takes robust tools and proofs to make formal validation of large scale projects reliable. In this paper, we will describe the current status of formal verification at Centaur Technology. We will explain our challenges and our methodology—how various proofs and verification artifacts are interconnected and how we keep them consistent over the duration of a project. We also describe our main engine—a powerful symbolic simulator with rewriting capabilities that is integrated in a theorem prover and proven correct.
Article
Full-text available
We present a methodology for formal verification of arithmetic RTL designs that combines sequential logic equivalence checking with interactive theorem proving. An intermediate model of a Verilog module is hand-coded in Restricted Algorithmic C (RAC), a primitive subset of C augmented by the integer and fixed-point register class templates of Algorithmic C. The model is designed to be as abstract and compact as possible, but sufficiently faithful to the RTL to allow efficient equivalence checking with a commercial tool. It is then automatically translated to the logic of ACL2, enabling a mechanically checked proof of correctness with respect to a formal architectural specification. In this paper, we describe the RAC language, the translation process, and some techniques that facilitate formal analysis of the resulting ACL2 code.
Article
We present a tool that primarily supports the ability to check bounded properties starting from a sequence of states in a run. The target design is compiled into an AIGNET which is then selectively and iteratively translated into an incremental SAT instance in which clauses are added for new terms and simplified by the assignment of existing literals. Additional applications of the tool can be derived by the user providing alternative attachments of constrained functions which guide the iterations and SAT checks performed. Some Verilog RTL examples are included for reference.
Conference Paper
Full-text available
One obstacle to mathematical verification of industrial hard- ware designs is that the commercial hardware description languages in which they are usually encoded are too complicated and poorly spec- ified to be readily susceptible to formal analysis. As an alternative to these commercial languages, AMD1 has developed an RTL language for microprocessor designs that is simple enough to admit a clear semantic definition, providing a basis for formal verification. We describe a me- chanical proof system for designs represented in this language, consisting of a translator to the ACL2 logical programming language and a method- ology for verifiying properties of the resulting programs using the ACL2 prover. As an illustration, we present a proof of IEEE compliance of the floating-point adder of the AMD Athlon processor.
Conference Paper
Full-text available
Formal verification of arithmetic datapaths has been part of the established methodology for most Intel processor designs over the last years, usually in the role of supplementing more traditional coverage oriented testing activities. For the recent Intel \circledR^{\tiny\circledR} CoreTM i7 design we took a step further and used formal verification as the primary validation vehicle for the core execution cluster, the component responsible for the functional behaviour of all microinstructions. We applied symbolic simulation based formal verification techniques for full datapath, control and state validation for the cluster, and dropped coverage driven testing entirely. The project, involving some twenty person years of verification work, is one of the most ambitious formal verification efforts in the hardware industry to date. Our experiences show that under the right circumstances, full formal verification of a design component is a feasible, industrially viable and competitive validation approach.
Conference Paper
In this paper, we present a "black box" version of verification of FP adders. In our approach, FP adders are verified by an extended word-level SMV using reusable specifications without knowing the circuit implementation. Word-level SMV is improved by using Multiplicative Power HDDs (*PHDDs), and by incorporating conditional symbolic simulation as well as a short-circuiting technique. Based on a case analysis, the adder specification is divided into several hundred implementation-independent sub-specifications. We applied our system and these specifications to verify the IEEE double precision FP adder in the Aurora III Chip from the University of Michigan. Our system found several design errors in this FP adder. Each specification can be checked in less than 5 minutes. A variant of the corrected FP adder was created to illustrate the ability of our system to handle different FP adder design. For each adder, the verification task finished in 2 CPU hours on a Sun UltraSPARC-II server.
Article
A data structure is presented for representing Boolean functions and an associated set of manipulation algorithms. Functions are represented by directed, acyclic graphs in a manner similar to the representations introduced by C. Y. Lee (1959) and S. B. Akers (1978), but with further restrictions on the ordering of decision variables in the graph. Although, in the worst case, a function requires a graph where the number of vertices grows exponentially with the number of arguments, many of the functions encountered in typical applications have a more reasonable representation. The algorithms have time complexity proportional to the sizes of the graphs being operated on, and hence are quite efficient as long as the graphs do not grow too large. Experimental results are presented from applying these algorithms to problems in logic design verification that demonstrate the practicality of the approach.
Conference Paper


text:
# Worksheet on Properties of Division of Rational Numbers

Practice the questions given in the worksheet on properties of division of rational numbers. The questions are based on verifying the rational numbers using the division properties.

We know, for every rational number a/b, (a/b ÷ 1) = a/b and (a/b ÷ a/b) = 1.

1. Verify whether the given statement is true or false:

(i) 2/9 ÷ 5/11 = 7/9 ÷ 6/13

(ii) 13/5 ÷ 26/10 = 26/10 ÷ 13/5

(iii) -9 ÷ 3/4 = 3/4 ÷ (-9)

(iv) -8/9 ÷ -4/3 = -4/3 ÷ (-8/9)

(v) - 7/24 ÷ 3/-16 = (3/-16) ÷ (-7/24)

2. Verify whether the given statement is true or false:

(i) {-8/9 ÷ 2/7} ÷ 8/5 = -8/9 ÷ {2/7 ÷ 8/5}

(ii) {4/9 ÷ -2/11} ÷ 1/2 = 4/9 ÷ {-2/11 ÷ 1/2}

(iii) {5/9 ÷ 1/3} ÷ 5/2 = 5/9 ÷ {1/3 ÷ 5/2}

(iv) {(-16) ÷ 6/5} ÷ -9/10 = (-16) ÷ {6/5 ÷ (-9/10)}

(v) {-3/5 ÷ (-12/35)} ÷ 1/14 = -3/5 ÷ {-12/35 ÷ 1/14}

(i) Are rational numbers always closed under division?

(ii) Are rational numbers always commutative under division?

(iii) Are rational numbers always associative under division?

(iv) Can we divide 1 by 0?

Answers for the worksheet on properties of division of rational numbers are given below to check the exact answers of the above questions.

1. (i) False

(ii) False

(iii) False

(iv) False

(v) False

2. (i) False

(ii) False

(iii) False

(iv) False

(v) False

3. (i) No

(ii) No

(iii) No

(iv) No

Rational Numbers - Worksheets

Worksheet on Rational Numbers

Worksheet on Lowest form of a Rational Number

Worksheet on Standard form of a Rational Number

Worksheet on Equality of Rational Numbers

Worksheet on Comparison of Rational Numbers

Worksheet on Representation of Rational Number on a Number Line

Worksheet on Properties of Addition of Rational Numbers

Worksheet on Rational Expressions Involving Sum and Difference

Worksheet on Multiplication of Rational Number

Worksheet on Division of Rational Numbers

Worksheet on Finding Rational Numbers between Two Rational Numbers

Worksheet on Word Problems on Rational Numbers

Objective Questions on Rational Numbers

format: plain


text:
# I am having trouble measuring the amplitude of a 97 MHz signal with an oscilloscope with a bandwidth of 100 MHz

First, I designed a Colpitts oscillator with a frequency of around 94-97 MHz. I added a common emitter amplifier to the design to increase the output amplitude of the oscillator, then I connected the probe of the oscilloscope to the output and measured the amplitude of the signal with the oscilloscope.

When the probe is at 1x, the amplitude of the signal is 633 mV.

Here is the screenshot of the signal while the probe is at 1x:

When the probe is at 10x, the amplitude of the signal is around 380 mV.

Here is the screenshot of the signal while the probe is at 10x:

I'm not sure if the signal is measured correctly since the bandwidth of the oscilloscope and probes is 100MHz.

What is the actual amplitude of the signal?

If the measurement is correct when the probe is 10x, the amplitude of the signal should be 380mVx10=3.8V.

I am attaching the circuit diagram.

I recorded the operation of the circuit on video.I am testing the modulation in the video via a radio. There are also FFT and oscilloscope measurements of the modulation in the video.Please warn me if I have done something wrong.link is here https://drive.google.com/file/d/1YryFCI-n6-iACd4vVtxXLwiRebVg5j8W/view?usp=sharing

• The bandwidth of an oscilloscope is typically the frequency at which the amplitude is down -3 dB. Thus, if the the bandwidth is 100 MHz and your signal source is 97 MHz, it is very likely your amplitude measurement could be off by 20% or or more. Mar 22 at 23:55
• Some thoughts. X10 lightens the load on the circuit by about a factor of 10 (which may increase the signal as it is loaded less), but there's a compensation cap and you need to go through a procedure to make sure it is set correctly. The X1 doesn't need that procedure. The X10 also diminishes the signal to the scope. The scope may, or may not, automatically adjust things on the display, accordingly. Also, the scope limit typically means that the signal is already reduced by that point. So it won't be an accurate reflection when you are that close to the limit, either.
– jonk
Mar 22 at 23:56
• @jonk Is the amplitude of the signal 3.8V or 633mV ? Which one is right? Mar 23 at 0:01
• @MathKeepsMeBusy Is the amplitude of the signal 3.8V or 633mV ? Which one is right? Mar 23 at 0:02
• In the X1 position the scope input capacitance is probably about 100pF or more. Also note that the probe bandwidth is only 6Mhz in the X1 setting. That will load the circuit a great deal. Even in the x10 position the input capacitance will probably be 10pF or so that is a significant load at ~100MHz. Mar 23 at 0:13

These are a few observations with assumptions due to lack of design details.

• 3dB DSO @ 100 MHz = 70.7% of signal or 30% attenuation

• 1:1 Probes can never be use >20 MHz due to cable capacitance 100 pF /m and ground inductance <10 nH/cm

• A 10: 1 probe calibrated, is always your best bet for RF for signals >= 20 MHz BUT the ground clip must be very short (<1") or never used and only with spring coil differential sig/gnd. on tip/ring

• output impedance = Rc is unknown but assumed low enough

• Most likely your signal is 3.8V/0.7 ~ 5.3Vpp with a 10V supply @ 30mA implies Rc < = 330 ohms

Although my design is simple, by changing your design specs, for Vpp, Zo, Imax and THD, you can get a decent square or sine wave by changing R ratios and bias for symmetry.

This one is > 9V square wave. with the right transistor and probe methods.

• I have attached the circuit diagram. Mar 23 at 1:20
• Should I buy a larger bandwidth oscilloscope or buy a larger bandwidth probe to measure the signal accurately? Do I have any other choice? My budget is not enough. Mar 23 at 7:23
• It depends why you need this. Learn to simulate tinyurl.com/ycbtqsgk and search for 10:1 probe solutions with coil spring on this site and also make 10:1 attenuators to reduce load and lower source impedance tinyurl.com/ycbtqsgk Mar 23 at 12:46
• tinyurl.com/y6wzwjnc interactive sim with 10: 1 divider to emitter to sample collector Mar 23 at 12:59
• You can't measure a 100 MHz 9Vpp square wave accurately with a 10:1 probe due to C and 1GHz BW. You need a FET Diff Probe  tinyurl.com/y7watbba Mar 23 at 13:32

As people stated in the comments, the oscilloscope plus probe (x10 setting) -3dB bandwidth is 100MHz. Thus, at 97 MHz, which is very close to 100MHz, the amplitude could be down by 0.71 times (-3dB point).

At x1 setting, the input capacitance of your probe is likely to be in the 100pF range when coupled to an oscilloscope. Depending on your amplifier circuit (you don't show a schematic), you could be severely loading the amplifier output and causing extra loading on the oscillator circuit due to Miller capacitance of your output amplifier. Plus, at x1 setting, the bandwidth of the probe is likely to be around 10MHz (couldn't find any data on your probe, so numbers are from a Tektronix P6129B probe manual).

At x10 setting, the probe capacitance is like to be in the 18pF range which will provide less loading on the output of your amplifier. The x10 setting on your probe is likely to be more accurate, but since you are so close to the bandwidth of the measurement system, the output voltage is likely to be higher than 3.8V.

To make things more complicated, a x10 probe's impedance has a complex nature. The following image is the input impedance of a Tektronix P6105A 100MHz, x10 probe. You can see that the impedance at 100MHz is Rp=400 ohms in parallel with XCp=200 ohms (8pF). Thus, the x10 probe may have significant loading on your amplifier at 100MHz (depends on your amplifier design).

Tektronix P6105A probe impedance taken from the manual.

• @grk The last three photos in the post contain prop and oscillator input resistor and capacitor information. Mar 23 at 0:51
• @OzGtZt A schematic of your circuit would be useful as the output structure of your amplifier is unknown. The whole point of my post is an oscilloscope probe has a complex impedance which changes over frequency. Note at 100MHz, the example graph shows that the input impedance of a x10 probe is much lower than 10Mohm. Just noticed the y-axis of the graph is inconsistent. I'll replace that with a scan from a paper copy.
– qrk
Mar 23 at 1:14
• @grk I have attached the circuit diagram. Mar 23 at 1:21
• Should I buy a larger bandwidth oscilloscope or buy a larger bandwidth probe to measure the signal accurately? Do I have any other choice? My budget is not enough. Mar 23 at 7:23

You are falling into the same trap I did: Help with 144Mhz small signal amplifier not amplifying

Main issue is the scope probe loads down the circuit. To avoid this I used a resistor divider and put the 10x probe on that and used that to measure the circuit, both input and output. This gave me a relative value that could be compared, and it was more accurate since the probe wasn't loading down the circuit.

• You made an explanation but I did not understand it. Could you please explain your solution method by drawing a circuit diagram? It would be nice if it was detailed. Mar 23 at 20:21
• electronics.stackexchange.com/questions/591298/… use this or 75 ohm to 1:1 probe with 750 ohm on DSO using BNC T for 20 dB pad or whatever probe coax Zo is. Mar 23 at 22:37


text:
An engineering topic that catch my interest  is reliability engineering. It mainly because of this topic seems to have intimate relation with safety engineering, maintenance engineering, can be implemented with enterprise resource software, and use mathematical modeling as its tools.

According to wikipedia, reliability engineering is an engineering field that deals with the study of reliability: the ability of a system or component to perform its required functions under stated conditions for a specified period of time.

Hm .. sounds interesting. But how could we quantify the “ability”? Are there any performance indicator that can help us to indicate that one system is more reliable than the other? What are tools, preferrably mathematical tools, that we can used to analyze the reliability of a complex system? How can we improve reliability, given a not reliable system. It seems that we need to give a more “formal “treatment. Here I try to explain in formal fashion, or better to say: to re-write, by mainly refer to [1]

Definition 1.1 (reliability): Reliability is the probability that a device will operate successfully for a specified period of time, and under specified conditions when used in the manner, and for purposes, intended.

Theorem 1.2 (series system): The system reliability $R_s$ for $n$ devices connected in series is $R_s = R_1 times R_2 times ... times R_n$, where $R_n$ is the reliability of the $n$th components.

Example 1.3:  The following figure is the simple example of control system loop

Let $R_x$ is the reliability of system $x$. Given the probabilityof failure over a 10-year period is 0.25 for the transmitter, 0.05 for the controller, and 0.3 for the valve. Thus, according to Definition 1.1:

$R_{transmitter} = 1-0.25 = 0.75$

$R_{controller} = 1-0.05 = 0.95$

$R_{valve} = 1-0.3 = 0.7$

According to Theorem 1.2 then the complete system reliability for the next 10 years is:

$R_{system} = R_{transmitter} times R_{controller} times R_{valve} = 0.75 times 0.95 times 0.7 = 0.499$

To be continued …

References

1. Cheddie, H.L., Reliability Engineering Concepts, in Instrument’s Engineer Handbook: Process Software and Digital Networks, Liptak, B.G-Editor in Chief, CRC Press, 2000

2. As one of the resource from the computer science point of view, I find a nice course by prof. Stefan Kowalewski from RWTH Aachen on Safety and Reliability Engineering. The video presentation are also provided on the website.


text:
# BUG: MSGBOX after DETACH returns early with 0 on Win7

#### jabelli

I noticed the MSGBOXs in one of my batch files closing on their own, and investigated the problem. I have reduced a demonstration to the simplest method:

(detach dir) & MSGBOX OK OK & echo %_?

TCC 10.00.75 Windows 7 [Version 6.1.7600]

#### rconn

jabelli wrote:

> I noticed the MSGBOXs in one of my batch files closing on their own, and investigated the problem. I have reduced a demonstration to the simplest method:
>
> (detach dir) & MSGBOX OK OK & echo %_?

It's a (known) Windows 7 bug. If MS doesn't fix in in the Windows 7
release I'll try to hack around it.

Rex Conn
JP Software

#### jabelli

It's a (known) Windows 7 bug. If MS doesn't fix in in the Windows 7 release I'll try to hack around it.
Sorry; I didn't state that this is RTM (from MSDN), not the RC. I suppose they may patch it before October 22; I'll keep an eye on it. Is there a KB# associated with the issue?

In the mean time, is there anything I can add to the batch file as a temporary workaround?

#### rconn

jabelli wrote:

> ---Quote (Originally by rconn)---
> It's a (known) Windows 7 bug. If MS doesn't fix in in the Windows 7 release I'll try to hack around it.
> ---End Quote---
> Sorry; I didn't state that this is RTM (from MSDN), not the RC. I suppose they may patch it before October 22; I'll keep an eye on it.
>
> In the mean time, is there anything I can add to the batch file as a temporary workaround?

You can put a short delay after the DETACH; i.e., something like:

(detach dir) & delay 10 10 & msgbox ok ok

Rex Conn
JP Software

Replies
1
Views
169
Replies
0
Views
199
Replies
5
Views
326
Replies
7
Views
492
Replies
2
Views
825
Replies
14
Views
948
Replies
6
Views
631
Replies
8
Views
639
Replies
1
Views
540
Replies
6
Views
991
Replies
2
Views
752
Replies
7
Views
1K
Replies
3
Views
1K
Replies
6
Views
1K
Replies
11
Views
2K
Replies
2
Views
1K
Replies
4
Views
2K
Replies
4
Views
1K
Replies
6
Views
1K
Replies
2
Views
1K
Replies
2
Views
1K
Replies
6
Views
1K
Replies
4
Views
1K
Replies
1
Views
986
Replies
3
Views
986
Replies
6
Views
2K
Replies
7
Views
1K
Replies
4
Views
1K
Replies
12
Views
2K
Replies
3
Views
1K
Replies
7
Views
1K
Replies
8
Views
2K
Replies
2
Views
2K
Replies
4
Views
2K
Replies
4
Views
1K
Replies
15
Views
2K
Replies
8
Views
2K
Replies
8
Views
2K
Replies
4
Views
2K
Replies
9
Views
2K
Replies
4
Views
2K
Replies
3
Views
1K
Replies
1
Views
1K
Replies
17
Views
2K
Replies
3
Views
2K
Replies
1
Views
1K
Replies
2
Views
2K
Replies
4
Views
2K
Replies
1
Views
1K
Replies
1
Views
1K


text:
## electronics applications

Find the charge q as a function of time for the electrical circuit described. Assume that q(0) = 0 and q’(0) = 0 R = 20, C = 0.02, L = 2, E(t)=35 q"+R/L q'+1/LC q=1/L E(t) where R is resistance (in Ohms), C is capacitance (in Farads), L is the inductance (in Henrys), E(t) is the electromotive force (in Volts), and q is the charge on the capacitor (in Coulombs).


text:
CAS：78-93-3

CAS：108-94-1

CAS：67-64-1

CAS：64-19-7

CAS：141-78-6

CAS：108-88-3

CAS：71-43-2

CAS：64-17-5

CAS：67-56-1

### Molar mass of CH3COCH2CH3

Molar Mass, Molecular Weight and Elemental Composition Calculator. Molar mass of CH3COCH2CH3 is 72.1057 g/mol. Get control of 2022! Track your food intake, exercise, sleep …

### How to calculate the molar mass of hydrate

1/7/2018· This means after calculating the mass of water (H 2 O), we must multiply the mass by 5 to get the total mass of 5 molecules of water, and then add this value to the mass of CuSO 4 to get the total mas of CuSO 4 .5H 2 O. Having said all that, let’s now construct a table to calculate the molar mass of CuSO 4, and another to calculate the mass

### Methyl Ethyl Ketone CH3coch2CH3/The Lowest Price

CAS nuer: 78-93-3 Molecular formula: CH 3 -CH 2 -CO-CH 3 Molar mass: 72.11 UN NO.: 1193 Class: 3 Appearance: Colorless and Transparent Liquid Specifiions: ITEM UNIT SPECIFIIONS Purity % 99.9 Methyl Ethyl Ketone CH3coch2CH3/The Lowest

### CHEM 111 - Chapters 1-5 Flashcards Quizlet

Calculate the molar mass of the following: C4H8 56.12 g/mol C4 48.04 H8 8.08 56.12g/mol Calculate the molar mass of the following: CH3COCH2CH3 (Methyl Ethyl Ketone) 72.12 g/mol C4 48.04 H8 8.08 O 16.00 72.12g/mol Determine the nuer of moles of 0.

### How to Calculate Molar Mass: 7 Steps (with Pictures) - wikiHow

25/8/2022· For hydrogen chloride, the molar mass is 1.007 + 35.453 = 36.460 g/mol. 36.46 grams is the mass of one mole of hydrogen chloride. For glucose, the molar mass is 72.0642 + 12.084 + 95.9964 = 180.1446 g/mol. 180.14 grams is the mass of one mole of glucose. Community Q&A Search Add New Question Question What is the molar mass of Helium? …

### Unit 8 HW#6 KEY - OCHS Chemistry

Homework #6 - Percent Composition and Empirical/Molecular Formulas Percent Composition 1. Calculate the percent composition of methyl ethyl ketone, CH3COCH2CH3. 1 -n. Il : bb.GL% C u 9.00 17 Z .11 10-00/ .11 2. What is the percent composition o u

### Question #c2038 Socratic

31/3/2016· This means that if you use the mass of one mole of MEK, i.e. its molar mass, you can determine how many grams of each constituent element it contains by using the molar masses of the three elements. MEK has a molar mass of #"72.11 g mol"^(-1)# , which means that one mole of MEK has a mass of #"72.11 g"# .

### Calculate the molar mass of the following:(i) H2O (ii) CO2 (iii) …

Molar mass of (CO 2)=(1×atomic mass of C)+(2×atomic mass of O) =(1×12)+(2×16)= 44g/mol (iii) Molar mass of methane (CH 4) Atomic mass of C=12 u Atomic mass of H=1 u Molar …

Calculate the molecular mass of the following: Mg3N2 Give atomic mass of Na = 23, H = 1, O …Calculate the molar mass of the following substances.
• Calculate the molar mass of H3PO4 Chemistry Q&A/cite>

Molecular mass of Orthophosphoric acid H 3 PO 4 = (Atomic mass of Hydrogen) x 3 + (Atomic mass of Phosphorous) x 1 + (Atomic mass of Oxygen) x 4 = ( 1 x 3 ) + ( 31 x 1 ) + ( 16 x 4 ) = 3 …

• What is the formula mass of ethyl alcohol, C2H5OH?Calculate the molar mass of : a EthyneCalculate the molar mass of benzene
• Molecular weight of Methyl Acetate - Convert Units/cite>

Methyl Acetate molecular weight. Molar mass of CH3COOCH3 = 74.07854 g/mol. Convert grams Methyl Acetate to moles or moles Methyl Acetate to grams. Molecular weight calculation: …

### Molecular weight of Methyl Acetate - Convert Units

Molar mass of CH3COOCH3 = 74.07854 g/mol Convert grams Methyl Acetate to moles or moles Methyl Acetate to grams Molecular weight calculation: 12.0107 + 1.00794*3 + 12.0107 + 15.9994 + 15.9994 + 12.0107 + 1.00794*3 Percent composition by element Similar chemical formulas Note that all formulas are case-sensitive.

### Molar Mass Calculator - ChemicalAid

The molar mass will be equal to: (1 atom x 56 grams/mole Fe) + (2 atoms x 35.5 grams/mole of chlorine) = 127 grams/mole of iron (II) chloride For other compounds, this might get a little bit …

### Learn How to Calculate Molarity of a Solution - ThoughtCo

2/10/2019· Molar mass of K = 39.1 g Molar mass of Mn = 54.9 g Molar mass of O = 16.0 g Molar mass of KMnO 4 = 39.1 g + 54.9 g + (16.0 g x 4) Molar mass of KMnO 4 = 158.0 g Use this nuer to convert grams to moles. moles of KMnO 4 = 23.7 g KMnO 4 x (1 mol KMnO 4 /158 grams KMnO 4) moles of KMnO 4 = 0.15 moles KMnO 4 Now the liters of solution is needed.

### Calculate the molar mass of the following substances - Vedantu

So, the molar mass of ethyne, 2$\times$12 + 2$\times$1 = 26 g.-The second part (B) is sulphur molecule S$_8$, atomic mass of sulphur is 32. Thus, the molar mass of the sulphur molecule, 8$\times$32 = 256 g.-The third part (C) is phosphorus molecule

### 1. Calculate the molecular mass of the following Chegg

Expert Answer. 1. Calculate the molecular mass of the following compounds: a) Acetone, CH3COCH b) ethyl ether, C4H1O 2. Find the nuer of molecules in 0.846 moles of HF molecules. 3. Calculate the mass in grams of 0.35 moles benzene, C5H6. Benzene is a …

### Molarity Calculator Convert To Moles!

Substitute all known values for the calculation of molarity: molarity = 5 / (1.2 * 36.46) = 0.114 mol/l = 0.114 M. You can also use the molarity calculator for mass concentration and molar masses. Simply enter the values that you are interested in and let it do all of the work.

### Molarity Calculator - Sigma-Aldrich

How to calculate mass Mass, molar concentration, volume, and formula weight are related to each other as follows: Mass (g) = Concentration (mol/L) * Volume (L) * Formula Weight (g/mol) What is mass? Mass (m) is the amount of matter present in a substance. The value is constant and, unlike weight, is not affected by gravity. What is formula weight?

### Molecular weight of CH3COOCH2CH3 - Convert Units

Molar mass of CH3COOCH2CH3 = 88.10512 g/mol. This compound is also known as Ethyl Acetate. Convert grams CH3COOCH2CH3 to moles or moles CH3COOCH2CH3 to grams. …

### Molar Mass of Methyl Ethyl Ketone / Molecular Weight of CH3COCH2CH3

Molar Mass of Methyl Ethyl Ketone Molecular Weight of CH 3 COCH 2 CH 3 Formula Calculate Formatted Formula CH 3 COCH 2 CH 3 Empirical Formula C 4 H 8 O Molar Mass 72.11 Percents C 66.6% H 11.2% O 22.2% Definitions used in is a

### Ch. 3 Exercises - Chemistry 2e OpenStax

16. Determine the nuer of moles of compound and the nuer of moles of each type of atom in each of the following: (a) 25.0 g of propylene, C 3 H 6. (b) 3.06 × 10 −3 g of the amino acid glycine, C 2 H 5 NO 2. (c) 25 lb of the herbicide Treflan, C 13 H 16 N 2 O 4 F (1 lb = 454 g)

### Molar Mass Calculator - How to Calculate Molecular Weight

What is the molar mass of NaOH? Solution: Na + O + H = NaOHa + O + H = NaOH Now, molecular mass calculator add all masses of substances together: 16 g / mol + 23 g / mol + 1 g / mol = 16 g / mol + 40 g / mol 23 g / mol + 1 g / mol = 40 g / mole The molar mass of the NaOH compound is 40 g/mol. Avogadro’s Nuer:

### How to calculate the molar mass of hydrate

1/7/2018· This means, we simply loe Na on the periodic table and read its atomic mass. If you read it correctly and rounded it to two decimal places, you should get 22.99. Now, to get its molar mass, we must attach the unit grams per mol to its atomic mass.

### Calculate the molecular mass of the following in u. NH3

Calculate the molecular mass of the following in u. NH 3 Advertisement Remove all ads Solution Show Solution Molecular mass of NH 3 = (1 × Average atomic mass of N) + (3 × Average atomic mass of H) = (1 × 14.0 u) + (3 × 1.0 u) = 17 u The molecular mass

### Mass to Mole Calculator - ezcalc.me

This all-in-one online Mass to Mole Calculator performs calculations using the formula linking the mass of a substance, its molar mass and the molar content of the substance. You can enter the values of any two known parameters in the input fields of this calculator and find the missing parameter. Substance mass (g): Molar mass (g/mol): Moles:

### 4.2: Formula Mass, Percent Composition, and the Mole (Problems)

PROBLEM 4.2.10. Determine the nuer of moles of compound and the nuer of moles of each type of atom in each of the following: (a) 25.0 g of propylene, C 3 H 6. (b) 3.06 × 10 −3 g of the amino acid glycine, C 2 H 5 NO 2. (c) 25 lb of the herbicide Treflan, C 13 H 16 N 2 …

### How to Calculate Molar Mass: 7 Steps (with Pictures) - wikiHow

From the periodic table the molar masses of the compounds will be extracted. For KMnO4: Molar mass of K = 39.1 g Molar mass of Mn = 54.9 g Molar mass of O = 16.0 g Molar mass of KMnO4 …

### Molarity Calculator - Sigma-Aldrich

How to calculate mass Mass, molar concentration, volume, and formula weight are related to each other as follows: Mass (g) = Concentration (mol/L) * Volume (L) * Formula Weight (g/mol) …

### Calculating the Molar Mass of a Gas - GeeksforGeeks

1/11/2022· The molar mass is the ratio of the mass of gas and the nuer of moles of gas. M = m/n M= 1.211/0.0275 M= 44 gram / moles Example 2: Calculate the density of Nitrogen gas at STP. Solution: Molecular mass is 2 × 14 grams per mole = 28 1 mole of gas has 22.4 liters density = 28/22.4 d = 1.25 grams per liters.

### CHEM 111 - Chapters 1-5 Flashcards Quizlet

Calculate the molar mass of the following: C4H8 56.12 g/mol C4 48.04 H8 8.08 56.12g/mol Calculate the molar mass of the following: CH3COCH2CH3 (Methyl Ethyl Ketone) 72.12 g/mol C4 48.04 H8 8.08 O 16.00 72.12g/mol Determine the nuer of moles of 0.

### Molar Mass Calculator - Free Online Calculator - BYJUS

How to Use the Molar Mass Calculator? The procedure to use the molar mass calculator is as follows: Step 1: Enter the chemical compound in the respective input field Step 2: Now click the …

### Calculate the molecular mass of the following: (NH4)2CO3 Given: atomic mass …

Calculate the molecular mass of the following: (NH 4) 2CO 3 Given: atomic mass of Na=23,H=1,O=16,C=12,N=14,Mg=24,S=32 Medium Solution Verified by Toppr The relative molecular mass of - (NH 4) 2CO 3=N 2H 8CO 3 =14×2+1×8+12+3×16 =28+8+12+48 =96g/mol Was this answer helpful? 0 0 Similar questions

### Unit 8 HW#6 KEY - OCHS Chemistry

Homework #6 - Percent Composition and Empirical/Molecular Formulas Percent Composition 1. Calculate the percent composition of methyl ethyl ketone, CH3COCH2CH3. 1 -n. Il : bb.GL% C u 9.00 17 Z .11 10-00/ .11 2. What is the percent composition o u

• Guan di miao, Yulong town

XingYang, Henan, China

7*24 Hours 365 Days


text:
A collection of boolean logic tools

## Project description

electruth is a collection of boolean logic tools. It can be used as both a command-line tool and a Python library. It understands boolean algebra (to some extent) and can be used to simplify boolean expressions using the Quine-McClusky method. This can be useful if you have a truth table in need of basic shortening. electruth can also be used to compare boolean expressions, which can be very useful if you need to compare a truth table with a schematic you created based on that truth table. electruth can also be used to transform complex boolean expressions into simpler ones consisting only of ANDS, ORS and NOTS.

electruth is free software under the terms of the GNU General Public License version 3 (or any later version). The author of electruth is Niels Serup, contactable at ns@metanohi.org. This is version 0.2.0 of the program, the first version to support Python 3.1+ (if you need support for Python 2.6+, you should download v0.1.1).

The libraries used by electruth are GPL-compatible.

## Installation

### Way #1

Just run this (requires that you have python-setuptools installed):

## This document

Copyright (C) 2010, 2011 Niels Serup

Copying and distribution of this file, with or without modification, are permitted in any medium without royalty provided the copyright notice and this notice are preserved. This file is offered as-is, without any warranty.

## Project details

Uploaded source


text:
Ask Your Question

# Revision history [back]

(1) This is almost certainly a case of len being overwritten. The fact that it worked when cut and pasted is a giveaway. 90% of the time when something that usually works stops working, this is the problem. (The other 10% often involves Maxima, at least for me -- I have very bad luck with it.)

(2) Yeah, that looks like a performance bug. Here's what's going on, and it's kind of quirky..

In some cases, log(n,b) is automatically simplified. If you use the (default) Sage Integers, for example:

sage: time log(4,2)
2
Time: CPU 0.00 s, Wall: 0.00 s
sage: time ceil(log(4,2))
2
Time: CPU 0.00 s, Wall: 0.00 s

so it's not surprising ceil is so fast. OTOH, if you do the same with Python ints, or you break the log apart, this doesn't happen:

sage: log(int(4),2)
log(4)/log(2)
sage: log(4)/log(2)
log(4)/log(2)

So in these cases Sage has to try harder. First it checks to see if this object has its own ceiling method, and it doesn't. So it builds a RealInterval object out of log(4)/log(2), and it turns out that this is about the worst thing it could do! It checks to see whether the lower and upper parts of the interval agree (so that it knows for certain what the ceiling is). But in this case, this is always going to look like:

sage: y = log(4)/log(2)
sage: rif = RealIntervalField(53)(y)
sage: rif
2.000000000000000?
sage: rif.endpoints()
(1.99999999999999, 2.00000000000001)

These two aren't equal, so it keeps increasing the precision (to 20000 bits) to see if it can prove that they are, but by construction it's never going to work. Finally Sage gives up and tries to simplify it, which succeeds:

sage: time (log(4)/log(2)).full_simplify()
CPU times: user 0.02 s, sys: 0.00 s, total: 0.02 s
Wall time: 0.02 s

This is a little perverse: the very cases that give Sage the most trouble are precisely the integer cases, which should be the easiest!

It's actually a little unclear what the right way to address the problem is in general. One way might be to call full_simplify earlier in the process to see if we can short-circuit the more common cases (and looking at integers is definitely a common enough use case to optimize.)

(1) This is almost certainly a case of len being accidentally overwritten. The fact that it worked when cut and pasted is a giveaway. 90% of the time when something that usually works stops working, this is the problem. (The other 10% often involves Maxima, at least for me -- I have very bad luck with it.)

If you could show a worksheet that demonstrates that it wasn't this, I'd be happy to have a look.

(2) Yeah, that looks like a performance bug. Here's what's going on, and it's kind of quirky..

In some cases, log(n,b) is automatically simplified. If you use the (default) Sage Integers, for example:

sage: time log(4,2)
2
Time: CPU 0.00 s, Wall: 0.00 s
sage: time ceil(log(4,2))
2
Time: CPU 0.00 s, Wall: 0.00 s

so it's not surprising ceil is so fast. OTOH, if you do the same with Python ints, or you break the log apart, this doesn't happen:

sage: log(int(4),2)
log(4)/log(2)
sage: log(4)/log(2)
log(4)/log(2)

So in these cases Sage has to try harder. First it checks to see if this object has its own ceiling method, and it doesn't. So it builds a RealInterval object out of log(4)/log(2), and it turns out that this is about the worst thing it could do! It checks to see whether the lower and upper parts of the interval agree (so that it knows for certain what the ceiling is). But in this case, this is always going to look like:

sage: y = log(4)/log(2)
sage: rif = RealIntervalField(53)(y)
sage: rif
2.000000000000000?
sage: rif.endpoints()
(1.99999999999999, 2.00000000000001)

These two aren't equal, so it keeps increasing the precision (to 20000 bits) to see if it can prove that they are, but by construction it's never going to work. Finally Sage gives up and tries to simplify it, which succeeds:

sage: time (log(4)/log(2)).full_simplify()
CPU times: user 0.02 s, sys: 0.00 s, total: 0.02 s
Wall time: 0.02 s

This is a little perverse: the very cases that give Sage the most trouble are precisely the integer cases, which should be the easiest!

It's actually a little unclear what the right way to address the problem is in general. One way might be to call full_simplify earlier in the process to see if we can short-circuit the more common cases (and looking at integers is definitely a common enough use case to optimize.)

(BTW, one of the things that I like most about Sage is that I don't have to wonder what it's doing: I simply typed "ceil??" and looked at the actual algorithm, and it became pretty clear pretty quickly what was happening. Warning: it can become addictive. :^)

(1) This is almost certainly a case of len being accidentally overwritten. The fact that it worked when cut and pasted is a giveaway. 90% of the time when something that usually works stops working, this is the problem. (The other 10% often involves Maxima, at least for me -- I have very bad luck with it.)

If you could show a worksheet that demonstrates that it wasn't this, I'd be happy to have a look.

(2) Yeah, that looks like a performance bug. Here's what's going on, and it's kind of quirky..

In some cases, log(n,b) is automatically simplified. If you use the (default) Sage Integers, for example:

sage: time log(4,2)
2
Time: CPU 0.00 s, Wall: 0.00 s
sage: time ceil(log(4,2))
2
Time: CPU 0.00 s, Wall: 0.00 s

so it's not surprising ceil is so fast. OTOH, if you do the same with Python ints, ints (such as the bare "range" command produces) or you break the log apart, this doesn't happen:

sage: log(int(4),2)
log(4)/log(2)
sage: log(4)/log(2)
log(4)/log(2)

So in these cases Sage has to try harder. First it checks to see if this object has its own ceiling method, and it doesn't. So it builds a RealInterval object out of log(4)/log(2), and it turns out that this is about the worst thing it could do! It checks to see whether the lower and upper parts of the interval agree (so that it knows for certain what the ceiling is). But in this case, this is always going to look like:

sage: y = log(4)/log(2)
sage: rif = RealIntervalField(53)(y)
sage: rif
2.000000000000000?
sage: rif.endpoints()
(1.99999999999999, 2.00000000000001)

These two aren't equal, so it keeps increasing the precision (to 20000 bits) to see if it can prove that they are, but by construction it's never going to work. Finally Sage gives up and tries to simplify it, which succeeds:

sage: time (log(4)/log(2)).full_simplify()
CPU times: user 0.02 s, sys: 0.00 s, total: 0.02 s
Wall time: 0.02 s

This is a little perverse: the very cases that give Sage the most trouble are precisely the integer cases, which should be the easiest!

It's actually a little unclear what the right way to address the problem is in general. One way might be to call full_simplify earlier in the process to see if we can short-circuit the more common cases (and looking at integers is definitely a common enough use case to optimize.)

(BTW, one of the things that I like most about Sage is that I don't have to wonder what it's doing: I simply typed "ceil??" and looked at the actual algorithm, and it became pretty clear pretty quickly what was happening. Warning: it can become addictive. :^)

(1) This is almost certainly a case of len being accidentally overwritten. The fact that it worked when cut and pasted is a giveaway. 90% of the time when something that usually works stops working, this is the problem. (The other 10% often involves Maxima, at least for me -- I have very bad luck with it.)

If you could show a worksheet that demonstrates that it wasn't this, I'd be happy to have a look.

(2) Yeah, that looks like a performance bug. Here's what's going on, and it's kind of quirky..

In some cases, log(n,b) is automatically simplified. If you use the (default) Sage Integers, for example:

sage: time log(4,2)
2
Time: CPU 0.00 s, Wall: 0.00 s
sage: time ceil(log(4,2))
2
Time: CPU 0.00 s, Wall: 0.00 s

so it's not surprising ceil is so fast. OTOH, if you do the same with Python ints (such as the bare "range" command produces) or you break the log apart, this doesn't happen:

sage: log(int(4),2)
log(4)/log(2)
sage: log(4)/log(2)
log(4)/log(2)

So in these cases Sage has to try harder. First it checks to see if this object has its own ceiling method, and it doesn't. So it builds a RealInterval object out of log(4)/log(2), and it turns out that this is about the worst thing it could do! It checks to see whether the lower and upper parts of the interval agree (so that it knows for certain what the ceiling is). But in this case, this is always going to look like:

sage: y = log(4)/log(2)
sage: rif = RealIntervalField(53)(y)
sage: rif
2.000000000000000?
sage: rif.endpoints()
(1.99999999999999, 2.00000000000001)

These two bounds aren't equal, so it keeps increasing the precision (to 20000 bits) to see if it can prove that they are, but by construction it's never going to work. Finally Sage gives up and tries to simplify it, which succeeds:

sage: time (log(4)/log(2)).full_simplify()
CPU times: user 0.02 s, sys: 0.00 s, total: 0.02 s
Wall time: 0.02 s

This is a little perverse: the very cases that give Sage the most trouble are precisely the integer cases, which should be the easiest!

It's actually a little unclear what the right way to address the problem is in general. One way might be to call full_simplify earlier in the process to see if we can short-circuit the more common cases (and looking at integers is definitely a common enough use case to optimize.)

(BTW, one of the things that I like most about Sage is that I don't have to wonder what it's doing: I simply typed "ceil??" and looked at the actual algorithm, and it became pretty clear pretty quickly what was happening. Warning: it can become addictive. :^)

(1) This is almost certainly a case of len being accidentally overwritten. The fact that it worked when cut and pasted is a giveaway. 90% of the time when something that usually works stops working, this is the problem. (The other 10% often involves Maxima, at least for me -- I have very bad luck with it.)

If you could show a worksheet that demonstrates that it wasn't this, I'd be happy to have a look.

(2) Yeah, that looks like a performance bug. Here's what's going on, and it's kind of quirky..

In some cases, log(n,b) is automatically simplified. If you use the (default) Sage Integers, for example:

sage: time log(4,2)
2
Time: CPU 0.00 s, Wall: 0.00 s
sage: time ceil(log(4,2))
2
Time: CPU 0.00 s, Wall: 0.00 s

so it's not surprising ceil is so fast. OTOH, if you do the same with Python ints (such as the bare "range" command produces) or you break the log apart, this doesn't happen:

sage: log(int(4),2)
log(4)/log(2)
sage: log(4)/log(2)
log(4)/log(2)

So in these cases Sage has to try harder. First it checks to see if this object has its own ceiling method, and it doesn't. So it builds a RealInterval object out of log(4)/log(2), and it turns out that this is about the worst thing it could do! It checks to see whether the lower and upper parts of the interval agree (so that it knows for certain what the ceiling is). But in this case, this is always going to look like:

sage: y = log(4)/log(2)
sage: rif = RealIntervalField(53)(y)
sage: rif
2.000000000000000?
sage: rif.endpoints()
(1.99999999999999, 2.00000000000001)

These two bounds aren't equal, so it keeps increasing the precision (to 20000 bits) to see if it can prove that they are, but by construction it's never going to work. Finally Sage gives up and tries to simplify it, which succeeds:

sage: time (log(4)/log(2)).full_simplify()
CPU times: user 0.02 s, sys: 0.00 s, total: 0.02 s
Wall time: 0.02 s

This is a little perverse: the very cases that give Sage the most trouble are precisely the integer cases, which should be the easiest!

It's actually a little unclear what the right way to address the problem is in general. One way might be to call full_simplify earlier in the process to see if we can short-circuit the more common cases (and looking at integers is definitely a common enough use case to optimize.)optimize.) Alternatively, we could try bool(x == round(x)), which seems a little faster. I'd probably try one or two interval rounds first, to make sure we're not increasing the burden too much for noninteger cases.

(BTW, one of the things that I like most about Sage is that I don't have to wonder what it's doing: I simply typed "ceil??" and looked at the actual algorithm, and it became pretty clear pretty quickly what was happening. Warning: it can become addictive. :^)

(1) This is almost certainly a case of len being accidentally overwritten. The fact that it worked when cut and pasted is a giveaway. 90% of the time when something that usually works stops working, this is the problem. (The other 10% often involves Maxima, at least for me -- I have very bad luck with it.)

If you could show a worksheet that demonstrates that it wasn't this, I'd be happy to have a look.

(2) Yeah, that looks like a performance bug. Here's what's going on, and it's kind of quirky..

In some cases, log(n,b) is automatically simplified. If you use the (default) Sage Integers, for example:

sage: time log(4,2)
2
Time: CPU 0.00 s, Wall: 0.00 s
sage: time ceil(log(4,2))
2
Time: CPU 0.00 s, Wall: 0.00 s

so it's not surprising ceil is so fast. OTOH, if you do the same with Python ints (such as the bare "range" command produces) or you break the log apart, this doesn't happen:

sage: log(int(4),2)
log(4)/log(2)
sage: log(4)/log(2)
log(4)/log(2)

So in these cases Sage has to try harder. First it checks to see if this object has its own ceiling method, and it doesn't. So it builds a RealInterval object out of log(4)/log(2), and it turns out that this is about the worst thing it could do! It checks to see whether the lower and upper parts of the interval agree [on the ceiling, I mean] (so that it knows for certain what the ceiling is). But in this case, this is always going to look like:

sage: y = log(4)/log(2)
sage: rif = RealIntervalField(53)(y)
sage: rif
2.000000000000000?
sage: rif.endpoints()
(1.99999999999999, 2.00000000000001)

These two bounds [have ceilings which] aren't equal, so it keeps increasing the precision (to 20000 bits) to see if it can prove that they are, but by construction it's never going to work. Finally Sage gives up and tries to simplify it, which succeeds:

sage: time (log(4)/log(2)).full_simplify()
CPU times: user 0.02 s, sys: 0.00 s, total: 0.02 s
Wall time: 0.02 s

This is a little perverse: the very cases that give Sage the most trouble are precisely the integer cases, which should be the easiest!

It's actually a little unclear what the right way to address the problem is in general. One way might be to call full_simplify earlier in the process to see if we can short-circuit the more common cases (and looking at integers is definitely a common enough use case to optimize.) Alternatively, we could try bool(x == round(x)), which seems a little faster. I'd probably try one or two interval rounds first, to make sure we're not increasing the burden too much for noninteger cases.

(BTW, one of the things that I like most about Sage is that I don't have to wonder what it's doing: I simply typed "ceil??" and looked at the actual algorithm, and it became pretty clear pretty quickly what was happening. Warning: it can become addictive. :^)


text:
# Visual proof of convergence for Steiner's symmetrization

I want to find a visual proof of the following fact:

For any convex figure in the plane there is a sequence of Steiner's symmetrizations that makes it arbitrary close to a circular disc.

All proofs I know require some integral estimates. I would prefer a more visual proof (even if it is more involved).

• Do you consider Blaschke selection theorem visual? – Ivan Izmestiev Aug 1 '18 at 15:07
• @IvanIzmestiev, no I want a direct proof. (I guess you want to say that optimal shape exists and it must be round disc and therefore everything converges to the disc --- no I do not want it.) – Anton Petrunin Aug 1 '18 at 15:16

(1) Let $$C = {\rm conv}\ B\bigcup \{x\}$$ where $B$ is a closed ball of center $o$ and $x$ is not in $B$.

Consider arc $A\subset B$, $$\partial B \bigcap {\rm Int}\ C$$

Note that by any Steiner symmetrization $S_L$, $A$ is still in the interior ${\rm Int}\ S_L( C)$.

If $x_1$ is close to $x$ s.t. $\overrightarrow{ox}$ and $\overrightarrow{ox_1}$ are different, then $S_L(C)$ where $L=( \overrightarrow{ox_1})^\perp$ has arc $A_1$ which contains $A$. After a finite process, $\partial B-A_n$ is a one point set. Hence through a some Steiner symmetrization, $A_{n+1}=\partial B$. Hence the resulting convex and compact set contains a ball $B'$ whose radius is strictly larger than that of $B$.

(2) Fix a point $o\in \mathbb{E}^2$ which is the origin. Here assume that all hyperplane pass through $o$.

Assume that $C$ is a convex and compact subset. If $x$ is interior point in $C$, then define $v=\overrightarrow{ox}$ so that $o$ is an interior point of $S_L(C)$ for $v^\perp=L$.

In further, if $B$ is a largest closed ball in $C$ of center $o$, then there is an open arc of non-zero length in $\partial B \bigcap {\rm Int}\ C$.

Hence we have $B'$ in $(1)$. So repeat the process.

If there is no such arc in $\partial B \bigcap {\rm Int}\ C$, then $B=C$.

Just for illustration, here is an animation of one step of a Steiner symmetrization applied to a rasterized version of a polygon.

First: a histogram of vertical lengths. Second: lengths lifted to be symmetric around horizontal.

• Thanks for the visualization. I think it would be a nice addition to the Wikipedia article on Steiner symmetrization :) – Shamisen Aug 6 '18 at 15:37
• @Shamisen: Yes, I was thinking of that myself. Requires a block of time to master exactly how to incorporate a new image into a Wikipedia article. On my ToDo list... – Joseph O'Rourke Aug 6 '18 at 16:04


text:
# Shape Analysis, Stochastic Geometric Mechanics and Applied Optimal Transport

## Videos from BIRS Workshop 18w5151

, University of Toronto
- 09:43
Beyond Arnold’s geodesic framework of an ideal hydrodynamics
, University of Notre Dame
- 10:22
The $L^2$ exponential map in 2D and 3D hydrodynamics
, Chalmers University of Technology / University of Gothenburg
- 11:30
Semi-invariant metrics on diffeos
, University of Lisbon
- 15:00
On some relations between Optimal Transport and Stochastic Geometric Mechanics
, Universite Paris Nanterre
- 15:58
, Université de Bordeaux
- 16:35
A duality formula and a particle Gibbs sampler for continuous time Feynman-Kac measures on path spaces
, Imperial College London
- 17:26
Geometric modelling of uncertainties
, University of Münster
- 09:38
Semi-discrete unbalanced optimal transport and quantization
, University of Cambridge
- 10:22
Wasserstein for learning image regularisers
, University of California, Irvine
- 11:32
Interpolation of Gaussian mixture models and other directions in Optimal Mass Transport
, John Hopkins University
- 12:20
Normal coordinates and equivolumic layers estimation in the cortex (tentative)
, Université Pierre-et-Marie-Curie
- 17:12
Analyze shape variability via deformations
, University of Ottawa
- 17:56
Convnets, a different view of approximating diffeomorphisms in medical image registration
, Brooklyn College
- 09:40
Solar models for Euler-Arnold equations
, University of Toronto
- 10:15
Vanishing geodesic distance for right-invariant Sobolev metrics on diffeomorphism groups
, University of Freiburg
- 11:26
Smooth perturbations of the functional calculus and applications to Riemannian geometry on spaces of metrics
, Florida State University
- 12:12
Comparing Shapes of Curves, Surfaces, and Higher Dimensional Immersions in Euclidean Space
, The Ohio State University
- 09:44
Metrics on the collection of dynamic shapes
, Ohio State University
- 10:37
Gromov-Monge Quasimetrics and Distance Distributions
, INRIA Rocquencourt
- 11:27
Dynamic formulations of optimal transportation and variational relaxation of Euler equations.
, Shanghai Jiao Tong University
- 12:10
Group valued momentum maps


text:
# An observer moves towards a stationary source of sound with a speed $1/5^{th}$ of the speed of sound. The wavelength and frequency of the source emitted are $\lambda$ and $f$ respectively. The apparent frequency and wavelength recorded by the observer are respectively :
( A ) f, 1.2$\lambda$
( B ) 1.2f, 1.2$\lambda$
( C ) 0.8f, 0.8 $\lambda$
( D ) 1.2f, $\lambda$


text:
## View abstract

### Session S12 - Delay and functional differential equations and applications

Monday, July 12, 12:50 ~ 13:25 UTC-3

## On stability and asymptotics of Mackey-Glass equations with two delays and neutral systems

### Elena Braverman

In the first part of our talk, we observe that introduction of two variable delays can change properties of the Mackey-Glass equation $$\dot{x}(t) = r(t) \left[ \frac{a x(h(t))}{1+x^{\nu}(g(t))} - x(t) \right], \quad a>1, ~\nu >0.$$ There may exist non-oscillatory about the positive equilibrium unstable solutions, the effect of possible absolute stability for certain $a$ and $\nu$ disappears. We obtain sufficient conditions for local and global stability of the positive equilibrium and illustrate the stability tests, as well as new effects of two different delays, with examples.
In the second part of the talk, we analyze exponential stability and solution estimates for a delay system $$\dot{x}(t) - A(t)\dot{x}(g(t))=\sum_{k=1}^m B_k(t)x(h_k(t))$$ of a neutral type, where $A$ and $B_k$ are $n\times n$ bounded matrix functions, and $g, h_k$ are delayed arguments. Stability tests are applicable to a wide class of linear neutral systems with time-varying coefficients and delays. In addition, explicit exponential estimates for solutions of both homogeneous and non-homogeneous neutral systems are obtained for the first time. These inequalities are not just asymptotic estimates, they are valid on every finite segment and evaluate both short- and long-term behaviour of solutions.