2020-03-18 12:03:56 +00:00
chapter \<open> International System of Quantities \<close>
section \<open> Quantity Dimensions \<close>
2020-02-10 12:03:51 +00:00
2020-03-12 11:11:30 +00:00
theory ISQ_Dimensions
2020-02-10 12:03:51 +00:00
imports Groups_mult
HOL.Transcendental
"HOL-Eisbach.Eisbach"
begin
2020-03-12 11:11:30 +00:00
subsection \<open> Preliminaries \<close>
2020-02-19 13:59:47 +00:00
named_theorems si_def and si_eq
2020-02-18 17:46:13 +00:00
2020-03-12 11:11:30 +00:00
instantiation unit :: comm_monoid_add
begin
definition "zero_unit = ()"
definition "plus_unit (x::unit) (y::unit) = ()"
instance proof qed (simp_all)
end
instantiation unit :: comm_monoid_mult
begin
definition "one_unit = ()"
definition "times_unit (x::unit) (y::unit) = ()"
instance proof qed (simp_all)
end
instantiation unit :: inverse
begin
definition "inverse_unit (x::unit) = ()"
definition "divide_unit (x::unit) (y::unit) = ()"
instance ..
end
instance unit :: ab_group_mult
by (intro_classes, simp_all)
2020-02-10 12:03:51 +00:00
2020-03-12 11:11:30 +00:00
subsection \<open> Dimensions Semantic Domain \<close>
2020-02-10 12:03:51 +00:00
2020-03-12 11:11:30 +00:00
text \<open> Quantity dimensions are used to distinguish quantities of different kinds. Only quantities
of the same kind can be compared and combined: it is a mistake to add a length to a mass, for
example. Dimensions are expressed in terms of seven base quantities, which can be combined to form
derived quantities. Consequently, a dimension associates with each of the seven base quantities an
integer that denotes the power to which it is raised. We use a record to represent this 7-tuple,
to enable code generation and thus efficient proof. \<close>
2020-02-10 12:03:51 +00:00
2020-02-20 17:41:28 +00:00
record Dimension =
Length :: int
Mass :: int
Time :: int
Current :: int
Temperature :: int
Amount :: int
Intensity :: int
2020-02-10 12:03:51 +00:00
2020-03-12 11:11:30 +00:00
text \<open> Next, we define dimension multiplication, and its unit, which corresponds to a dimensionless
quantity. These are then shown to form a commutative monoid. \<close>
2020-02-10 12:03:51 +00:00
2020-02-20 17:41:28 +00:00
instantiation Dimension_ext :: (one) one
2020-02-10 12:03:51 +00:00
begin
\<comment> \<open> Here, $1$ is the dimensionless unit \<close>
2020-02-20 17:41:28 +00:00
definition one_Dimension_ext :: "'a Dimension_ext"
where [code_unfold, si_def]: "1 = \<lparr> Length = 0, Mass = 0, Time = 0, Current = 0
, Temperature = 0, Amount = 0, Intensity = 0, \<dots> = 1 \<rparr>"
2020-02-10 12:03:51 +00:00
instance ..
end
2020-02-20 17:41:28 +00:00
instantiation Dimension_ext :: (times) times
2020-02-10 12:03:51 +00:00
begin
\<comment> \<open> Multiplication is defined by adding together the powers \<close>
2020-02-20 17:41:28 +00:00
definition times_Dimension_ext :: "'a Dimension_ext \<Rightarrow> 'a Dimension_ext \<Rightarrow> 'a Dimension_ext"
2020-02-18 17:46:13 +00:00
where [code_unfold, si_def]:
2020-02-20 17:41:28 +00:00
"x * y = \<lparr> Length = Length x + Length y, Mass = Mass x + Mass y
, Time = Time x + Time y, Current = Current x + Current y
, Temperature = Temperature x + Temperature y, Amount = Amount x + Amount y
, Intensity = Intensity x + Intensity y, \<dots> = more x * more y \<rparr>"
2020-02-10 12:03:51 +00:00
instance ..
end
2020-02-20 17:41:28 +00:00
instance Dimension_ext :: (comm_monoid_mult) comm_monoid_mult
2020-02-10 12:03:51 +00:00
proof
2020-02-20 17:41:28 +00:00
fix a b c :: "'a Dimension_ext"
2020-02-10 12:03:51 +00:00
show "a * b * c = a * (b * c)"
2020-02-20 17:41:28 +00:00
by (simp add: times_Dimension_ext_def mult.assoc)
2020-02-10 12:03:51 +00:00
show "a * b = b * a"
2020-02-20 17:41:28 +00:00
by (simp add: times_Dimension_ext_def mult.commute)
2020-02-10 12:03:51 +00:00
show "1 * a = a"
2020-02-20 17:41:28 +00:00
by (simp add: times_Dimension_ext_def one_Dimension_ext_def)
2020-02-10 12:03:51 +00:00
qed
2020-03-12 11:11:30 +00:00
text \<open> We also define the inverse and division operations, and an abelian group, which will allow
us to perform dimensional analysis. \<close>
2020-02-10 12:03:51 +00:00
2020-02-20 17:41:28 +00:00
instantiation Dimension_ext :: ("{times,inverse}") inverse
2020-02-10 12:03:51 +00:00
begin
2020-02-20 17:41:28 +00:00
definition inverse_Dimension_ext :: "'a Dimension_ext \<Rightarrow> 'a Dimension_ext"
2020-02-18 17:46:13 +00:00
where [code_unfold, si_def]:
2020-02-20 17:41:28 +00:00
"inverse x = \<lparr> Length = - Length x, Mass = - Mass x
, Time = - Time x, Current = - Current x
, Temperature = - Temperature x, Amount = - Amount x
, Intensity = - Intensity x, \<dots> = inverse (more x) \<rparr>"
2020-02-10 12:03:51 +00:00
2020-02-20 17:41:28 +00:00
definition divide_Dimension_ext :: "'a Dimension_ext \<Rightarrow> 'a Dimension_ext \<Rightarrow> 'a Dimension_ext"
2020-02-20 09:53:45 +00:00
where [code_unfold, si_def]:
2020-02-20 17:41:28 +00:00
"divide_Dimension_ext x y = x * (inverse y)"
2020-02-10 12:03:51 +00:00
instance ..
end
2020-02-20 17:41:28 +00:00
instance Dimension_ext :: (ab_group_mult) ab_group_mult
2020-02-10 12:03:51 +00:00
proof
2020-02-20 17:41:28 +00:00
fix a b :: "'a Dimension_ext"
2020-02-10 12:03:51 +00:00
show "inverse a \<cdot> a = 1"
2020-02-20 17:41:28 +00:00
by (simp add: inverse_Dimension_ext_def times_Dimension_ext_def one_Dimension_ext_def)
2020-02-10 12:03:51 +00:00
show "a \<cdot> inverse b = a div b"
2020-02-20 17:41:28 +00:00
by (simp add: divide_Dimension_ext_def)
2020-02-10 12:03:51 +00:00
qed
2020-02-17 15:36:26 +00:00
2020-03-12 11:11:30 +00:00
text \<open> A base dimension is a dimension where precisely one component has power 1: it is the
2020-03-12 17:23:47 +00:00
dimension of a base quantity. Here we define the seven base dimensions. \<close>
2020-02-10 12:03:51 +00:00
2020-03-12 11:11:30 +00:00
definition LengthBD ("\<^bold>L") where [si_def]: "\<^bold>L = (1::Dimension)\<lparr>Length := 1\<rparr>"
definition MassBD ("\<^bold>M") where [si_def]: "\<^bold>M = (1::Dimension)\<lparr>Mass := 1\<rparr>"
definition TimeBD ("\<^bold>T") where [si_def]: "\<^bold>T = (1::Dimension)\<lparr>Time := 1\<rparr>"
definition CurrentBD ("\<^bold>I") where [si_def]: "\<^bold>I = (1::Dimension)\<lparr>Current := 1\<rparr>"
definition TemperatureBD ("\<^bold>\<Theta>") where [si_def]: "\<^bold>\<Theta> = (1::Dimension)\<lparr>Temperature := 1\<rparr>"
definition AmountBD ("\<^bold>N") where [si_def]: "\<^bold>N = (1::Dimension)\<lparr>Amount := 1\<rparr>"
definition IntensityBD ("\<^bold>J") where [si_def]: "\<^bold>J = (1::Dimension)\<lparr>Intensity := 1\<rparr>"
2020-02-10 12:03:51 +00:00
2020-03-12 11:11:30 +00:00
abbreviation "BaseDimensions \<equiv> {\<^bold>L, \<^bold>M, \<^bold>T, \<^bold>I, \<^bold>\<Theta>, \<^bold>N, \<^bold>J}"
2020-02-10 12:03:51 +00:00
2020-03-12 11:11:30 +00:00
text \<open> The following lemma confirms that there are indeed seven unique base dimensions. \<close>
2020-02-17 15:36:26 +00:00
2020-03-12 11:11:30 +00:00
lemma seven_BaseDimensions: "card BaseDimensions = 7"
by (simp add: si_def)
2020-02-10 12:03:51 +00:00
2020-03-12 11:11:30 +00:00
definition is_BaseDim :: "Dimension \<Rightarrow> bool" where [si_def]: "is_BaseDim x \<equiv> x \<in> BaseDimensions"
2020-02-10 12:03:51 +00:00
2020-03-12 11:11:30 +00:00
text \<open> We can use the base dimensions and algebra to form dimension expressions. Some examples
2020-03-12 17:23:47 +00:00
are shown below. \<close>
2020-02-10 12:03:51 +00:00
2020-03-12 11:11:30 +00:00
term "\<^bold>L\<cdot>\<^bold>M\<cdot>\<^bold>T\<^sup>-\<^sup>2"
term "\<^bold>M\<cdot>\<^bold>L\<^sup>-\<^sup>3"
2020-02-10 12:03:51 +00:00
2020-03-12 17:23:47 +00:00
subsection \<open> Dimensions Type Expressions \<close>
2020-03-12 11:11:30 +00:00
2020-03-12 17:23:47 +00:00
subsubsection \<open> Classification \<close>
text \<open> We provide a syntax for dimension type expressions, which allows representation of
dimensions as types in Isabelle. This will allow us to represent quantities that are parametrised
by a particular dimension type. We first must characterise the subclass of types that represent a
dimension.
The mechanism in Isabelle to characterize a certain subclass of Isabelle type expressions
are \<^emph>\<open>type classes\<close>. The following type class is used to link particular Isabelle types
to an instance of the type \<^typ>\<open>Dimension\<close>. It requires that any such type has the cardinality
\<^term>\<open>1\<close>, since a dimension type is used only to mark a quantity.
\<close>
class dim_type = finite +
fixes dim_ty_sem :: "'a itself \<Rightarrow> Dimension"
assumes unitary_unit_pres: "card (UNIV::'a set) = 1"
syntax
"_QD" :: "type \<Rightarrow> logic" ("QD'(_')")
translations
"QD('a)" == "CONST dim_ty_sem TYPE('a)"
text \<open> The notation \<^term>\<open>QD('a::dim_type)\<close> allows to obtain the dimension of a dimension type
\<^typ>\<open>'a\<close>.
The subset of basic dimension types can be characterized by the following type class: \<close>
2020-03-13 16:10:51 +00:00
class basedim_type = dim_type +
2020-03-12 17:23:47 +00:00
assumes is_BaseDim: "is_BaseDim QD('a)"
subsubsection \<open> Base Dimension Type Expressions \<close>
text \<open> The definition of the basic dimension type constructors is straightforward via a
one-elementary set, \<^typ>\<open>unit set\<close>. The latter is adequate since we need just an abstract syntax
for type expressions, so just one value for the \<^verbatim>\<open>dimension\<close>-type symbols. We define types for
each of the seven base dimensions, and also for dimensionless quantities. \<close>
2020-02-10 12:03:51 +00:00
2020-02-18 17:46:13 +00:00
typedef Length = "UNIV :: unit set" .. setup_lifting type_definition_Length
typedef Mass = "UNIV :: unit set" .. setup_lifting type_definition_Mass
typedef Time = "UNIV :: unit set" .. setup_lifting type_definition_Time
typedef Current = "UNIV :: unit set" .. setup_lifting type_definition_Current
typedef Temperature = "UNIV :: unit set" .. setup_lifting type_definition_Temperature
typedef Amount = "UNIV :: unit set" .. setup_lifting type_definition_Amount
typedef Intensity = "UNIV :: unit set" .. setup_lifting type_definition_Intensity
typedef NoDimension = "UNIV :: unit set" .. setup_lifting type_definition_NoDimension
type_synonym M = Mass
type_synonym L = Length
type_synonym T = Time
type_synonym I = Current
type_synonym \<Theta> = Temperature
type_synonym N = Amount
type_synonym J = Intensity
type_notation NoDimension ("\<one>")
translations
(type) "M" <= (type) "Mass"
(type) "L" <= (type) "Length"
(type) "T" <= (type) "Time"
(type) "I" <= (type) "Current"
(type) "\<Theta>" <= (type) "Temperature"
(type) "N" <= (type) "Amount"
(type) "J" <= (type) "Intensity"
2020-02-10 12:03:51 +00:00
2020-03-12 17:23:47 +00:00
text\<open> Next, we embed the base dimensions into the dimension type expressions by instantiating the
2020-03-13 16:10:51 +00:00
class \<^class>\<open>basedim_type\<close> with each of the base dimension types. \<close>
2020-02-10 12:03:51 +00:00
2020-03-13 16:10:51 +00:00
instantiation Length :: basedim_type
2020-02-10 12:03:51 +00:00
begin
2020-03-12 17:23:47 +00:00
definition [si_def]: "dim_ty_sem_Length (_::Length itself) = \<^bold>L"
2020-02-23 18:11:11 +00:00
instance by (intro_classes, auto simp add: dim_ty_sem_Length_def is_BaseDim_def, (transfer, simp)+)
2020-02-10 12:03:51 +00:00
end
2020-03-13 16:10:51 +00:00
instantiation Mass :: basedim_type
2020-02-10 12:03:51 +00:00
begin
2020-03-12 17:23:47 +00:00
definition [si_def]: "dim_ty_sem_Mass (_::Mass itself) = \<^bold>M"
2020-02-23 18:11:11 +00:00
instance by (intro_classes, auto simp add: dim_ty_sem_Mass_def is_BaseDim_def, (transfer, simp)+)
2020-02-10 12:03:51 +00:00
end
2020-03-13 16:10:51 +00:00
instantiation Time :: basedim_type
2020-02-10 12:03:51 +00:00
begin
2020-03-12 17:23:47 +00:00
definition [si_def]: "dim_ty_sem_Time (_::Time itself) = \<^bold>T"
2020-02-23 18:11:11 +00:00
instance by (intro_classes, auto simp add: dim_ty_sem_Time_def is_BaseDim_def, (transfer, simp)+)
2020-02-10 12:03:51 +00:00
end
2020-03-13 16:10:51 +00:00
instantiation Current :: basedim_type
2020-02-10 12:03:51 +00:00
begin
2020-03-12 17:23:47 +00:00
definition [si_def]: "dim_ty_sem_Current (_::Current itself) = \<^bold>I"
2020-02-23 18:11:11 +00:00
instance by (intro_classes, auto simp add: dim_ty_sem_Current_def is_BaseDim_def, (transfer, simp)+)
2020-02-10 12:03:51 +00:00
end
2020-03-13 16:10:51 +00:00
instantiation Temperature :: basedim_type
2020-02-10 12:03:51 +00:00
begin
2020-03-12 17:23:47 +00:00
definition [si_def]: "dim_ty_sem_Temperature (_::Temperature itself) = \<^bold>\<Theta>"
2020-02-23 18:11:11 +00:00
instance by (intro_classes, auto simp add: dim_ty_sem_Temperature_def is_BaseDim_def, (transfer, simp)+)
2020-02-10 12:03:51 +00:00
end
2020-03-13 16:10:51 +00:00
instantiation Amount :: basedim_type
2020-02-10 12:03:51 +00:00
begin
2020-03-12 17:23:47 +00:00
definition [si_def]: "dim_ty_sem_Amount (_::Amount itself) = \<^bold>N"
2020-02-23 18:11:11 +00:00
instance by (intro_classes, auto simp add: dim_ty_sem_Amount_def is_BaseDim_def, (transfer, simp)+)
2020-02-10 12:03:51 +00:00
end
2020-03-13 16:10:51 +00:00
instantiation Intensity :: basedim_type
2020-02-10 12:03:51 +00:00
begin
2020-03-12 17:23:47 +00:00
definition [si_def]: "dim_ty_sem_Intensity (_::Intensity itself) = \<^bold>J"
2020-02-23 18:11:11 +00:00
instance by (intro_classes, auto simp add: dim_ty_sem_Intensity_def is_BaseDim_def, (transfer, simp)+)
2020-02-10 12:03:51 +00:00
end
2020-02-23 18:06:32 +00:00
instantiation NoDimension :: dim_type
2020-02-18 17:46:13 +00:00
begin
2020-03-12 17:23:47 +00:00
definition [si_def]: "dim_ty_sem_NoDimension (_::NoDimension itself) = (1::Dimension)"
2020-02-23 18:11:11 +00:00
instance by (intro_classes, auto simp add: dim_ty_sem_NoDimension_def is_BaseDim_def, (transfer, simp)+)
2020-02-18 17:46:13 +00:00
end
2020-03-12 11:11:30 +00:00
lemma base_dimension_types [simp]:
2020-03-12 17:23:47 +00:00
"is_BaseDim QD(Length)" "is_BaseDim QD(Mass)" "is_BaseDim QD(Time)" "is_BaseDim QD(Current)"
"is_BaseDim QD(Temperature)" "is_BaseDim QD(Amount)" "is_BaseDim QD(Intensity)"
by (simp_all add: is_BaseDim)
subsubsection \<open> Dimension Type Constructors: Inner Product and Inverse \<close>
2020-02-10 12:03:51 +00:00
2020-03-12 17:23:47 +00:00
text\<open> Dimension type expressions can be constructed by multiplication and division of the base
dimension types above. Consequently, we need to define multiplication and inverse operators
at the type level as well. On the class of dimension types (in which we have already inserted
the base dimension types), the definitions of the type constructors for inner product and inverse is
straightforward. \<close>
2020-02-10 12:03:51 +00:00
2020-02-23 18:06:32 +00:00
typedef ('a::dim_type, 'b::dim_type) DimTimes (infixl "\<cdot>" 69) = "UNIV :: unit set" ..
2020-02-20 17:41:28 +00:00
setup_lifting type_definition_DimTimes
2020-02-10 12:03:51 +00:00
2020-03-12 17:23:47 +00:00
text \<open> The type \<^typ>\<open>('a,'b) DimTimes\<close> is parameterised by two types, \<^typ>\<open>'a\<close> and \<^typ>\<open>'b\<close> that must
both be elements of the \<^class>\<open>dim_type\<close> class. As with the base dimensions, it is a unitary type
as its purpose is to represent dimension type expressions. We instantiate \<^class>\<open>dim_type\<close> with
this type, where the semantics of a product dimension expression is the product of the underlying
dimensions. This means that multiplication of two dimension types yields a dimension type. \<close>
2020-02-10 12:03:51 +00:00
2020-02-23 18:06:32 +00:00
instantiation DimTimes :: (dim_type, dim_type) dim_type
2020-02-10 12:03:51 +00:00
begin
2020-02-23 18:11:11 +00:00
definition dim_ty_sem_DimTimes :: "('a \<cdot> 'b) itself \<Rightarrow> Dimension" where
2020-03-12 11:11:30 +00:00
[si_eq]: "dim_ty_sem_DimTimes x = QD('a) * QD('b)"
2020-02-23 18:11:11 +00:00
instance by (intro_classes, simp_all add: dim_ty_sem_DimTimes_def, (transfer, simp)+)
2020-02-10 12:03:51 +00:00
end
2020-02-25 15:42:42 +00:00
text \<open> Similarly, we define inversion of dimension types and prove that dimension types are
closed under this. \<close>
2020-02-10 12:03:51 +00:00
2020-02-20 17:41:28 +00:00
typedef 'a DimInv ("(_\<^sup>-\<^sup>1)" [999] 999) = "UNIV :: unit set" ..
setup_lifting type_definition_DimInv
2020-02-23 18:06:32 +00:00
instantiation DimInv :: (dim_type) dim_type
2020-02-10 12:03:51 +00:00
begin
2020-02-23 18:11:11 +00:00
definition dim_ty_sem_DimInv :: "('a\<^sup>-\<^sup>1) itself \<Rightarrow> Dimension" where
2020-03-12 11:11:30 +00:00
[si_eq]: "dim_ty_sem_DimInv x = inverse QD('a)"
2020-02-23 18:11:11 +00:00
instance by (intro_classes, simp_all add: dim_ty_sem_DimInv_def, (transfer, simp)+)
2020-02-10 12:03:51 +00:00
end
2020-03-12 17:23:47 +00:00
subsubsection \<open> Dimension Type Syntax \<close>
2020-02-10 12:03:51 +00:00
2020-02-25 15:42:42 +00:00
text \<open> A division is expressed, as usual, by multiplication with an inverted dimension. \<close>
2020-02-20 17:41:28 +00:00
type_synonym ('a, 'b) DimDiv = "'a \<cdot> ('b\<^sup>-\<^sup>1)" (infixl "'/" 69)
2020-02-10 12:03:51 +00:00
2020-03-12 17:23:47 +00:00
text \<open> A number of further type synonyms allow for more compact notation: \<close>
2020-02-25 15:42:42 +00:00
2020-02-20 17:41:28 +00:00
type_synonym 'a DimSquare = "'a \<cdot> 'a" ("(_)\<^sup>2" [999] 999)
type_synonym 'a DimCube = "'a \<cdot> 'a \<cdot> 'a" ("(_)\<^sup>3" [999] 999)
type_synonym 'a DimQuart = "'a \<cdot> 'a \<cdot> 'a \<cdot> 'a" ("(_)\<^sup>4" [999] 999)
type_synonym 'a DimInvSquare = "('a\<^sup>2)\<^sup>-\<^sup>1" ("(_)\<^sup>-\<^sup>2" [999] 999)
type_synonym 'a DimInvCube = "('a\<^sup>3)\<^sup>-\<^sup>1" ("(_)\<^sup>-\<^sup>3" [999] 999)
type_synonym 'a DimInvQuart = "('a\<^sup>4)\<^sup>-\<^sup>1" ("(_)\<^sup>-\<^sup>4" [999] 999)
2020-02-10 12:03:51 +00:00
translations (type) "'a\<^sup>-\<^sup>2" <= (type) "('a\<^sup>2)\<^sup>-\<^sup>1"
translations (type) "'a\<^sup>-\<^sup>3" <= (type) "('a\<^sup>3)\<^sup>-\<^sup>1"
2020-02-17 15:36:26 +00:00
translations (type) "'a\<^sup>-\<^sup>4" <= (type) "('a\<^sup>4)\<^sup>-\<^sup>1"
2020-02-10 12:03:51 +00:00
print_translation \<open>
2020-02-20 17:41:28 +00:00
[(@{type_syntax DimTimes},
2020-02-10 12:03:51 +00:00
fn ctx => fn [a, b] =>
if (a = b)
2020-02-20 17:41:28 +00:00
then Const (@{type_syntax DimSquare}, dummyT) $ a
2020-02-10 12:03:51 +00:00
else case a of
2020-02-20 17:41:28 +00:00
Const (@{type_syntax DimTimes}, _) $ a1 $ a2 =>
2020-02-10 12:03:51 +00:00
if (a1 = a2 andalso a2 = b)
2020-02-20 17:41:28 +00:00
then Const (@{type_syntax DimCube}, dummyT) $ a1
2020-02-19 17:02:24 +00:00
else case a1 of
2020-02-20 17:41:28 +00:00
Const (@{type_syntax DimTimes}, _) $ a11 $ a12 =>
2020-02-19 17:02:24 +00:00
if (a11 = a12 andalso a12 = a2 andalso a2 = b)
2020-02-20 17:41:28 +00:00
then Const (@{type_syntax DimQuart}, dummyT) $ a11
2020-02-19 17:02:24 +00:00
else raise Match |
2020-02-10 12:03:51 +00:00
_ => raise Match)]
\<close>
2020-03-12 17:23:47 +00:00
subsubsection \<open> Derived Dimension Types \<close>
2020-02-17 15:36:26 +00:00
type_synonym Area = "L\<^sup>2"
type_synonym Volume = "L\<^sup>3"
type_synonym Acceleration = "L\<cdot>T\<^sup>-\<^sup>1"
type_synonym Frequency = "T\<^sup>-\<^sup>1"
type_synonym Energy = "L\<^sup>2\<cdot>M\<cdot>T\<^sup>-\<^sup>2"
type_synonym Power = "L\<^sup>2\<cdot>M\<cdot>T\<^sup>-\<^sup>3"
type_synonym Force = "L\<cdot>M\<cdot>T\<^sup>-\<^sup>2"
2020-02-18 17:46:13 +00:00
type_synonym Pressure = "L\<^sup>-\<^sup>1\<cdot>M\<cdot>T\<^sup>-\<^sup>2"
type_synonym Charge = "I\<cdot>T"
type_synonym PotentialDifference = "L\<^sup>2\<cdot>M\<cdot>T\<^sup>-\<^sup>3\<cdot>I\<^sup>-\<^sup>1"
type_synonym Capacitance = "L\<^sup>-\<^sup>2\<cdot>M\<^sup>-\<^sup>1\<cdot>T\<^sup>4\<cdot>I\<^sup>2"
2020-02-10 12:03:51 +00:00
end