text
stringlengths 0
3.34M
|
|---|
State Before: M : Type ?u.368159
N : Type ?u.368162
G : Type ?u.368165
R : Type u_1
S : Type ?u.368171
F : Type ?u.368174
inst✝³ : CommMonoid M
inst✝² : CommMonoid N
inst✝¹ : DivisionCommMonoid G
k l : ℕ+
inst✝ : CommMonoid R
ζ : { x // x ∈ rootsOfUnity k R }
m : ℕ
⊢ ↑↑(ζ ^ m) = ↑↑ζ ^ m State After: no goals Tactic: rw [Subgroup.coe_pow, Units.val_pow_eq_pow_val] |
import sys
import numpy as np
import pandas as pd
import matplotlib
import matplotlib.pyplot as plt
import matplotlib.patches as mpatch
import seaborn
sys.path.append("../analysis")
from fffit.utils import values_real_to_scaled
from utils.ap import APConstants
from matplotlib import ticker
AP = APConstants()
matplotlib.rc("font", family="sans-serif")
matplotlib.rc("font", serif="Arial")
NM_TO_ANGSTROM = 10
K_B = 0.008314 # J/MOL K
KJMOL_TO_K = 1.0 / K_B
def main():
df = pd.read_csv("../analysis/csv/uc-lattice-final-params.csv", index_col=0)
df = df[df.temperature == 10]
dff = pd.read_csv("../analysis/csv/ap-final-2.csv", index_col=0)
seaborn.set_palette('bright', n_colors=len(df))
#data = values_real_to_scaled(df[list(AP.param_names)].values, AP.param_bounds)
#data_f = values_real_to_scaled(dff[list(AP.param_names)].values, AP.param_bounds)
data = df[list(AP.param_names)].values
data_f = dff[list(AP.param_names)].values
result_bounds = np.array([[0, 0.5], [0, 5]])
results = values_real_to_scaled(df[["uc_mean_distance", "lattice_ape"]].values, result_bounds)
results_f = values_real_to_scaled(dff[["uc_mean_distance", "lattice_ape"]].values, result_bounds)
param_bounds = AP.param_bounds
param_bounds[:4] = param_bounds[:4] #* NM_TO_ANGSTROM
param_bounds[4:] = param_bounds[4:] #* KJMOL_TO_K
data = np.hstack((data, results))
data_f = np.hstack((data_f, results_f))
bounds = np.vstack((param_bounds, result_bounds))
print(data.shape)
col_names = [
r"$\sigma_{Cl}$",
r"$\sigma_H$",
r"$\sigma_N$",
r"$\sigma_O$",
r"$\epsilon_{Cl}$",
r"$\epsilon_H$",
r"$\epsilon_N$",
r"$\epsilon_O$",
r"UCMD",
"Lattice\nMAPE",
]
n_axis = len(col_names)
assert data.shape[1] == n_axis
x_vals = [i for i in range(n_axis)]
# Create (N-1) subplots along x axis
fig, axes = plt.subplots(1, n_axis-1, sharey=False, figsize=(12,5))
# Plot each row
for i, ax in enumerate(axes):
for line in data:
ax.plot(x_vals, line, alpha=0.35)
ax.set_xlim([x_vals[i], x_vals[i+1]])
for line in data_f:
ax.plot(x_vals, line, alpha=1.0, linewidth=3)
for dim, ax in enumerate(axes):
ax.xaxis.set_major_locator(ticker.FixedLocator([dim]))
set_ticks_for_axis(ax, bounds[dim], nticks=6)
ax.set_xticklabels([col_names[dim]], fontsize=30)
ax.tick_params(axis="x", pad=10)
ax.set_ylim(-0.05,1.05)
# Add white background behind labels
for label in ax.get_yticklabels():
label.set_bbox(
dict(
facecolor='white',
edgecolor='none',
alpha=0.45,
boxstyle=mpatch.BoxStyle("round4")
)
)
ax.spines['top'].set_visible(False)
ax.spines['bottom'].set_visible(False)
ax.spines['left'].set_linewidth(2.0)
ax = axes[-1]
ax.xaxis.set_major_locator(ticker.FixedLocator([n_axis-2, n_axis-1]))
ax.set_xticklabels([col_names[-2], col_names[-1]], fontsize=24)
ax.tick_params(axis="x", pad=14)
# Add class II data
#ax.plot(x_vals[-2], 0.3485/bounds[-2][1], markersize=15, color="red", marker="*", clip_on=False, zorder=200)
ax = plt.twinx(axes[-1])
ax.set_ylim(-0.05, 1.05)
set_ticks_for_axis(ax, bounds[-1], nticks=6)
ax.spines['top'].set_visible(False)
ax.spines['bottom'].set_visible(False)
ax.spines['right'].set_linewidth(2.0)
# Add class I data
ax.plot(x_vals[-1], 1.42/bounds[-1][1], markersize=15, color="tab:purple", marker="o", clip_on=False, zorder=200)
ax.plot(x_vals[-2], 0.156/bounds[-2][1], markersize=15, color="tab:purple", marker="o", clip_on=False, zorder=200)
# Add class II data
ax.plot(x_vals[-1], 3.55/bounds[-1][1], markersize=20, color="tab:red", marker="*", clip_on=False, zorder=200)
ax.plot(x_vals[-2], 0.3485/bounds[-2][1], markersize=20, color="tab:red", marker="*", clip_on=False, zorder=200)
# Remove space between subplots
plt.subplots_adjust(wspace=0, bottom=0.2, left=0.05, right=0.95)
fig.savefig("pdfs/fig4-ap-parallel.pdf")
def set_ticks_for_axis(ax, bounds, nticks):
"""Set the tick positions and labels on y axis for each plot
Tick positions based on normalised data
Tick labels are based on original data
"""
min_val, max_val = bounds
step = (max_val - min_val) / float(nticks-1)
tick_labels = [round(min_val + step * i, 3) for i in range(nticks)]
ticks = np.linspace(0, 1.0, nticks)
ax.yaxis.set_ticks(ticks)
ax.set_yticklabels(tick_labels, fontsize=18)
ax.yaxis.set_minor_locator(ticker.AutoMinorLocator(2))
ax.tick_params("y", direction="inout", which="both", length=6)
ax.tick_params("y", which="major", length=12)
ax.tick_params("x", pad=15)
if __name__ == "__main__":
main()
|
\section{Adding Type Parameter to Actor Library}
This section examines actor programming in the Akka library and how type parameters are added to actor-related classes to improve type safety. We show that supervision trees in TAkka are constructed in the same way as in Akka. This section concludes with a brief discussion about alternative designs used by Akka and other actor libraries.
\mycomment{Explain Actor Programming. Compare Akka and TAkka side by side.}
\subsection{The Actor Class}
An Actor has four important fields given in Figure-\ref{actor_api}:
(i) a receive function that defines its reaction to incoming messages, (ii)
an actor reference pointing to itself, (iii) the actor context representing
the outside world of the actor, and (iv) the supervisor strategy for its
children.
An TAkka {\bf Actor} has Akka equivalent fields as shown in
Table \ref{actor_api}. Different from other actor libraries, every TAkka
actor class takes a type parameter {\bf M} which specifies the type of messages
it expects to receive. The same type parameter is used as the input type of the
receive function, the type parameter of actor context and the type parameter of
the actor reference pointing to itself. We introduce a new field $mt$ to inform the compiler that the type parameter of the {\bf Actor} class should be recorded.
\begin{table}[h]
\label{actor_api}
\caption{Akka and TAkka Actor}
% \begin{adjustwidth}{-1.8cm}{}
\begin{tabular}{ l l }
\begin{lstlisting}[language=scala]
package akka.actor
trait Actor {
def typedReceive:Any=>Unit
val typedSelf:ActorRef
val typedContext:ActorContext
var supervisorStrategy:
SupervisorStrategy
}
\end{lstlisting} &
\begin{lstlisting}[language=scala]
package takka.actor
trait Actor[M] {
implicit val mt : TypeTag[M]
def typedReceive:M=>Unit
val typedSelf:ActorRef[M]
val typedContext:ActorContext[M]
var supervisorStrategy:
SupervisorStrategy
}
\end{lstlisting}
\end{tabular}
% \end{adjustwidth}
\end{table}
The three immutable fields of TAkka {\bf Actor}: {\it mt}, {\it typedContext} and {\it
typedSelf}, will be initialised automatically when the actor is created.
Application developers may override the default supervisor strategy in the way
explained in \S\ref{supervision}. The implementation of the {\it typedReceive}
method, on the other hand, is left to developers.
\subsection{Actor Reference}
\label{actor_ref}
A reference pointing to an Actor of type {\bf Actor[M]} has type {\bf ActorRef[M]}. It provides a {\it !} method, through which users could send a message of type {\bf M} to the referenced actor. Sending an actor reference a message whose type is not the
expected type will raise a compile error. By using type-parametrized actor
references, the receiver does not need to worry about unexpected messages while
senders can ensure that messages will be understood and processed, as long as
the message is delivered.
In a type system which supports polymorphism, {\bf ActorRef} should be
contravariant. We further provide a {\it publishAs} method which type-safely
casts an actor reference to a version of its supertype. In another word, the
output actor reference accepts partial forms of messages that are accepted by
the input actor reference. The ability of publishing partial services makes
TAkka a good tool for solving security problems such as the type pollution
problem described at \S\ref{type_pollution}.
\begin{table}[h]
\label{ActorRef}
\begin{tabular}{ l l }
\begin{lstlisting}[language=scala]
abstract class ActorRef {
def !(message: Any):Unit
}
\end{lstlisting}
&
\begin{lstlisting}[language=scala]
abstract class ActorRef[-M]
(implicit mt:TypeTag[M]) {
def !(message: M):Unit
def publishAs[SubM<:M]
(implicit mt:TypeTag[SubM]):ActorRef[SubM]
}
\end{lstlisting}
\end{tabular}
\caption{Actor Reference}
\end{table}
The code below defines and uses a string processing actor in Akka and TAkka. The receive
function of Akka Actor has type {\bf Any$\Rightarrow$Unit} but the defined actor
only intends to process strings. Both examples create an actor inside an actor system
and returns a reference pointing to that actor. The same string message is sent to actor in both examples
and processed in the way defined in the receive function. Sending an integer message, which is not expected
by both actors; However, is permitted in the Akka version but rejected by the TAkka version.
\begin{table}[h]
\label{ActorRef}
\begin{adjustwidth}{-0.8cm}{}
\begin{tabular}{ l l }
\begin{lstlisting}[language=scala]
class MyActor extends Actor {
def receive:Any => Unit = {
case m:String =>
println("Received message: " + m)
}
}
val system = ActorSystem("MySystem")
val actorRef:ActorRef =
system.actorOf(Props[MyActor])
actorRef ! "Hello World!"
actorRef ! 3
/*
Terminal output:
Received message: Hello World!
*/
\end{lstlisting}
&
\begin{lstlisting}[language=scala]
class MyActor extends Actor[String] {
def typedReceive:String=>Unit = {
case m:String =>
println("received message: "+m)
}
}
val system = ActorSystem("MySystem")
val actorRef:ActorRef[String] =
system.actorOf(Props[String, MyActor])
actorRef ! "Hello World!"
// actorRef ! 3
// compile error: type mismatch; found : Int(3)
// required: String
/*
Terminal output:
Received message: Hello World!
*/
\end{lstlisting}
\end{tabular}
\end{adjustwidth}
\caption{A Actor String Processor}
\end{table}
Undefined messages are treated differently in different actor libraries. In
Erlang, an actor keeps undefined messages in its mailbox, attempts to process
the message again when a new message handler is in use. In versions prior to
2.0, an Akka actor raises an exception when it processes an undefined message.
In recent Akka versions, undefined message is discarded by the actor and an {\bf
UnhandledMessage} event is pushed to the event stream of the actor system. The
event stream may be subscribed by other actors to which all events will be
published. In the example code no subscriber of the event stream is defined and
the integer message is simply discarded.
\subsection{Props and Actor Context}
\label{actor_context}
\mycomment{Explain Akka version and TAkka version at the same time}
A Props is the configuration of actor creation. A Props of type {\bf Prop[M]}
specifies how to create an actor of type {\bf Actor[M]} and returns an actor
reference of type {\bf ActorRef[M]}. A Prop should be created by one of
following APIs, where {\bf MyActor} should be a subtype of {\bf Actor[M]}:
\begin{table}[h]
\label{Props}
\begin{adjustwidth}{-1.2cm}{}
\begin{tabular}{ l l }
\begin{lstlisting}[language=scala]
val props:Props = Props[MyActor]
val props:Props = Props(new MyActor)
val props:Props = Props(myActor.getClass)
\end{lstlisting}
&
\begin{lstlisting}[language=scala]
val props:Props[M] = Props[M, MyActor]
val props:Props[M] = Props[M](new MyActor)
val props:Props[M] = Props[M](myActor.getClass)
\end{lstlisting}
\end{tabular}
\end{adjustwidth}
\caption{Props Creation API}
\end{table}
Contrary to actor reference, an actor context describes the outside world of the
actor. For security consideration, actor context is only available inside the
actor definition. By using APIs in Figure \ref{ActorContext}, an actor can (i)
retrieving an actor reference according to a given actor path, (ii) creating a
child actor with system generated or user specified name, (iii) set a timeout
during which period a new message shall be received, and (iv) update its
behaviours.
The {\it ActorFor} method in the {\bf ActorContext} classes returns an actor
reference of the desired type, if the actor located at the specified actor path
has a compatible type. To implement the {\it ActorFor} method, we would like to
have a more general mechanism that will return a value of the desired type
when the corresponding key is given. To this end, we designed and implemented a
typed name server which will be explained \S\ref{nameserver}.
The {\it become} method enables hot code swap on the behaviour of an actor. The
{\it become} method in TAkka is different from code swap in Akka in two aspects.
Firstly, the supervision strategy could be updated as well. Secondly, the new
receive function must be more general than the previous version. As a result,
no stack of receive functions is required. Interestingly, the implementation of
{\it become} involves a mix of static and dynamic type checks. Details of the
implementation will be discussed in \S\ref{code_evolution}.
\begin{table}[h]
\label{ActorContext}
\begin{adjustwidth}{-1.3cm}{}
\begin{tabular}{ l l }
\begin{lstlisting}[language=scala]
trait ActorContext {
def actorFor(actorPath:String):ActorRef
def actorOf(props: Props):ActorRef
def actorOf(props: Props,
name: String): ActorRef
def setReceiveTimeout
(timeout: Duration): Unit
def become(
newReceive: Any => Unit,
):ActorRef
}
\end{lstlisting}
&
\begin{lstlisting}[language=scala]
trait ActorContext[M] {
def actorFor [Msg] (actorPath: String)
(implicit mt: TypeTag[Msg]): ActorRef[Msg]
def actorOf[Msg](props: Props[Msg])
(implicit mt: TypeTag[Msg]): ActorRef[Msg]
def actorOf[Msg](props: Props[Msg], name: String)
(implicit mt: TypeTag[Msg]): ActorRef[Msg]
def setReceiveTimeout(timeout: Duration): Unit
def become[SupM >: M](
newTypedReceive: SupM => Unit,
newSystemMessageHandler:
SystemMessage => Unit,
newSupervisionStrategy:SupervisionStrategy
)(implicit smt:TypeTag[SupM]):ActorRef[SupM]
}
\end{lstlisting}
\end{tabular}
\end{adjustwidth}
\caption{Actor Context}
\end{table}
\subsection{Supervision Strategies}
\label{supervision}
There are three supervision strategies defined in Erlang/OTP: one-for-one,
one-for-all, and rest-for-one\cite{OTP}. If a supervisor adopts the one-for-one
supervision strategy, a child will be restarted when it fails. If a supervisor
adopts the one-for-all supervision strategy, all children will be restarted when
any of them fails. In Erlang/OTP, children are started in a user-specified
order. If a supervisor adopts the rest-for-one supervision strategy, all
children started after the failed child will be restarted. For each
supervision strategy, users can further specify the maximum restarts of any
child within a period.
The Akka library only considers the one-for-one strategy and the one-for-all
strategy. The rest-for-one strategy is not considered because children are not
created according to a user-specified order. The default supervision strategy
is a one-for-one strategy that permits unlimited restarts. Users can define
their own supervision strategy by using APIs given in Figure-\ref{super}. {\bf
OneForOne} corresponds to the one-for-one strategy in Erlang whereas {\bf
OneForAll} corresponds to the all-for-one strategy in Erlang. Both
strategies are constructed by providing required parameters. {\bf Directive} is
an enumerable type whose value is {\bf Escalate}, {\bf Restart}, {\bf Resume},
or {\bf Stop}. Notice that neither supervision strategies require any type-parametrized class. Therefore, both supervision strategies
are constructed in TAkka in the same way as in Akka.
\begin{figure}[h]
\label{super}
\begin{lstlisting}
abstract class SupervisorStrategy
case class OneForOne(restart:Int, time:Duration)
(decider: Throwable => Directive) extends SupervisorStrategy
case class OneForAll(restart:Int, time:Duration)
(decider: Throwable => Directive) extends SupervisorStrategy
\end{lstlisting}
\caption{Supervision Strategies}
\end{figure}
\subsection{Handling System Messages}
Actors are communicated with each other by sending messages. To maintain a
supervision tree, for example to monitor and control the liveness of actors, a
special category of messages should be addressed by all actors. We define a
trait {\bf SystemMessage} to be the supertype of all messages for system
maintenance purposes. Based on the design of Erlang and Akka, we consider
following messages should be included in system messages:
\begin{itemize}
\item {\bf ChildTerminated(child: ActorRef[M])}
a message sent from a child actor to its supervisor before it terminates.
\item {\bf Kill}
a message sent from a supervisor to its child.
\item {\bf Restart}
a message sent from a supervisor to its terminated child asking to restart the child.
\item {\bf ReceiveTimeout}
a message sent from an actor to itself when it did not receive any message after a timeout.
\end{itemize}
An open question is which system messages are allowed to be handled by users.
In Erlang and early Akka versions, all system messages could be explicitly
handled by users in the {\it receive} block. In recent Akka versions, there is
a consideration that some system messages should be handled in library
implementation but not be handled by library users.
Considering that there are only two supervision strategies to consider, both of
which have clearly defined operational behaviours, all messages related to the
liveness of actors are handled in the TAkka library implementation. General
library users may indirectly affect the system message handler via specifying
the supervision strategies. On the contrary, messages related to the behaviour
of an actor, e.g. ReceiveTimeout, are better to be handled by application
developers. In TAkka, {\bf ReceiveTimeout} is the only system message that can
be explicitly handled by users.
\subsection{Alternative Designs}
\label{alternative designs}
\paragraph{Akka Typed Actor}
In the Akka library, there is a special class called {\bf TypedActor}, which
contains an internal actor and could be supervised. Users of typed actor invoke
a service by calling a method instead of sending messages. The typed actor
prevents some type errors but has two limitations. For one thing, typed actor
does not permit code evolution. For the other, avoiding type pollution when
using typed actor would be as awkward as using a plain objected-oriented model.
\paragraph{Actors with or without Mutable States}
The actor model formalised by Hewitt et al. \cite{Hewitt:1973} does not specify
its implementation strategy. In Erlang, a functional programming language,
actor does not have mutable states. In Scala, an objected-oriented
programming language, actor may have mutable states. The TAkka library is
built on top of Akka and implemented in Scala as well. As a result, TAkka does
not prevent users from defining actors with mutable states. Nevertheless, the
library designers would like to encourage using actors in a functional
style because actors with mutable states is difficult to synchronize in a
cluster environment.
In a cluster, resources are replicated at different locations to provide
efficient fault-tolerant services. Known as the CAP theorem \cite{CAP}, it is
impossible to achieve consistency, availability, and partition tolerance in a
distributed system simultaneously. For actors without mutable state, system
providers do not need to worry about consistency. For actors that contain
mutable states, system providers have to either sacrifice availability or
partition tolerance, or modify the consistency model. For example, Akka actor
has mutable states and Akka cluster employs an eventual consistency
model \cite{Kuhn12}.
\paragraph{Linked Actors}
Alternative to forming supervision trees, reliability of actor-based programs
could be improved by linking related actors \cite{ErlangWeb}. Linked actors are
aware of the death of each other. Indeed, supervision tree is a special
structure for linking actors. For this reason, we consider actor linking is a
redundant design in a system where supervision is obligatory. After all, if
the computation of an actor relies on the liveness of another actor, those two
actors should be organised in the same logic supervision tree.
|
Require Import Coq.Program.Basics.
Require Import FunctionalExtensionality.
Require Import List.
Require Export functor.
Require Import monad monoid.
(** list is a covariant functor. *)
Instance Fmap_list : Fmap list := map.
Instance Functor_list : Functor list.
Proof.
constructor; unfold fmap, Fmap_list; intros; extensionality l;
induction l; auto; simpl; rewrite IHl; auto.
Qed.
(** list is a Jmonad. *)
Instance Return_list : Return list := fun _ x => x :: nil.
Instance Join_list : Join list := concat.
Instance Jmonad_list : Jmonad list.
Proof.
constructor.
- apply app_nil_r.
- unfold fmap, Fmap_list, join, Join_list.
intros ? l; induction l; auto; simpl; rewrite IHl; auto.
- intros A l. induction l; auto.
unfold join, Join_list in *. simpl.
unfold fmap, Fmap_list in *.
rewrite <- IHl.
apply concat_app.
- firstorder.
- intros A B f.
unfold fmap, Fmap_list, join, Join_list, compose; simpl.
extensionality l; induction l; simpl; auto.
rewrite <- IHl, map_app; auto.
Qed.
Instance Mappend_list A : Mappend (list A) := @app _.
Instance Semigroup_list A : Semigroup (list A).
Proof. constructor; apply app_assoc_reverse. Qed.
Instance Mempty_list A : Mempty (list A) := nil.
Instance Monoid_list A : Monoid (list A).
Proof. constructor; auto; apply app_nil_r. Qed.
|
#pragma once
#include <boost/container/small_vector.hpp>
namespace fc {
using boost::container::small_vector;
using boost::container::small_vector_base;
namespace raw {
template<typename Stream, typename T, std::size_t N>
inline void pack(Stream& s, const small_vector<T, N>& v);
template<typename Stream, typename T, std::size_t N>
inline void unpack(Stream& s, small_vector<T, N>& v);
} // namespace raw
} // namespace fc
|
Require Import Crypto.Specific.Framework.RawCurveParameters.
Require Import Crypto.Util.LetIn.
(***
Modulus : 2^137 - 13
Base: 64
***)
Definition curve : CurveParameters :=
{|
sz := 3%nat;
base := 64;
bitwidth := 64;
s := 2^137;
c := [(1, 13)];
carry_chains := None;
a24 := None;
coef_div_modulus := None;
goldilocks := None;
karatsuba := None;
montgomery := true;
freeze := Some false;
ladderstep := false;
mul_code := None;
square_code := None;
upper_bound_of_exponent_loose := None;
upper_bound_of_exponent_tight := None;
allowable_bit_widths := None;
freeze_extra_allowable_bit_widths := None;
modinv_fuel := None
|}.
Ltac extra_prove_mul_eq _ := idtac.
Ltac extra_prove_square_eq _ := idtac.
|
/-
Copyright (c) 2022 Rémi Bottinelli. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Rémi Bottinelli
-/
import category_theory.groupoid
import category_theory.path_category
import algebra.group.defs
import algebra.hom.group
import algebra.hom.equiv.basic
import combinatorics.quiver.path
/-!
# Vertex group
> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
> Any changes to this file require a corresponding PR to mathlib4.
This file defines the vertex group (*aka* isotropy group) of a groupoid at a vertex.
## Implementation notes
* The instance is defined "manually", instead of relying on `category_theory.Aut.group` or
using `category_theory.inv`.
* The multiplication order therefore matches the categorical one : `x * y = x ≫ y`.
* The inverse is directly defined in terms of the groupoidal inverse : `x ⁻¹ = groupoid.inv x`.
## Tags
isotropy, vertex group, groupoid
-/
namespace category_theory
namespace groupoid
universes u v
variables {C : Type u} [groupoid C]
/-- The vertex group at `c`. -/
@[simps] instance vertex_group (c : C): group (c ⟶ c) :=
{ mul := λ (x y : c ⟶ c), x ≫ y,
mul_assoc := category.assoc,
one := 𝟙 c,
one_mul := category.id_comp,
mul_one := category.comp_id,
inv := groupoid.inv,
mul_left_inv := inv_comp }
/-- The inverse in the group is equal to the inverse given by `category_theory.inv`. -/
lemma vertex_group.inv_eq_inv (c : C) (γ : c ⟶ c) :
γ ⁻¹ = category_theory.inv γ := groupoid.inv_eq_inv γ
/--
An arrow in the groupoid defines, by conjugation, an isomorphism of groups between
its endpoints.
-/
@[simps] def vertex_group_isom_of_map {c d : C} (f : c ⟶ d) : (c ⟶ c) ≃* (d ⟶ d) :=
{ to_fun := λ γ, inv f ≫ γ ≫ f,
inv_fun := λ δ, f ≫ δ ≫ inv f,
left_inv := λ γ, by simp_rw [category.assoc, comp_inv, category.comp_id,
←category.assoc, comp_inv, category.id_comp],
right_inv := λ δ, by simp_rw [category.assoc, inv_comp, ←category.assoc,
inv_comp, category.id_comp, category.comp_id],
map_mul' := λ γ₁ γ₂, by simp only [vertex_group_mul, inv_eq_inv,
category.assoc, is_iso.hom_inv_id_assoc] }
/--
A path in the groupoid defines an isomorphism between its endpoints.
-/
def vertex_group_isom_of_path {c d : C} (p : quiver.path c d) : (c ⟶ c) ≃* (d ⟶ d) :=
vertex_group_isom_of_map (compose_path p)
/-- A functor defines a morphism of vertex group. -/
@[simps] def _root_.category_theory.functor.map_vertex_group {D : Type v} [groupoid D]
(φ : C ⥤ D) (c : C) : (c ⟶ c) →* (φ.obj c ⟶ φ.obj c) :=
{ to_fun := φ.map,
map_one' := φ.map_id c,
map_mul' := φ.map_comp }
end groupoid
end category_theory
|
using HydrogenDimerMRCC
using Test
@testset "HydrogenDimerMRCC" begin
@testset "Invalid Inputs" begin
# negative bond length
@test_throws ErrorException p = PolarCoords(-1.0, pi/2, pi/2)
# zero bond length
@test_throws ErrorException p = PolarCoords(0.0, pi/2, pi/4)
# polar angle below bounds
@test_throws ErrorException p = PolarCoords(1.0, -0.5*pi, pi/2)
# polar angle above bounds
@test_throws ErrorException p = PolarCoords(1.0, 1.5*pi, pi/2)
# azimuthal angle below bounds
@test_throws ErrorException p = PolarCoords(1.0, pi/2, -0.5*pi)
# azimuthal angle above bounds
@test_throws ErrorException p = PolarCoords(1.0, pi/2, 2.5*pi)
# invalid distance directly into DimerParameters
@test_throws ErrorException d = DimerParameters(-5.0, 1.0, pi/2, pi/2, 1.0, pi/2, pi/2)
@test_throws ErrorException d = DimerParameters(0.0, 1.0, pi/2, pi/2, 1.0, pi/2, pi/2)
end
@testset "Ideal Case 1" begin
import HydrogenDimerMRCC: atom_positions, Cartesian3D, distance
# rotate dimer (at origin) of length 2 onto x-y plane
# one atom should be at ( 1, 0, 0)
# the other should be at (-1, 0, 0)
polar = PolarCoords(2.0, pi/2, 0.0)
com = Cartesian3D(0.0, 0.0, 0.0)
atom1, atom2 = atom_positions(polar, com)
ideal1 = Cartesian3D( 1.0, 0.0, 0.0)
ideal2 = Cartesian3D(-1.0, 0.0, 0.0)
tolerance = 1.0e-15
@test distance(atom1, ideal1) < tolerance
@test distance(atom2, ideal2) < tolerance
end
@testset "Ideal Case 2" begin
import HydrogenDimerMRCC: atom_positions, Cartesian3D, distance
# rotate dimer (at origin) of length 2 onto x-y plane
# then rotate 45 degrees in x-y place
# one atom should be at ( 1/sqrt(2), 1/sqrt(2), 0)
# the other should be at (-1/sqrt(2), -1/sqrt(2), 0)
polar = PolarCoords(2.0, pi/2, pi/4)
com = Cartesian3D(0.0, 0.0, 0.0)
atom1, atom2 = atom_positions(polar, com)
ideal1 = Cartesian3D( 1.0/sqrt(2.0), 1.0/sqrt(2.0), 0.0)
ideal2 = Cartesian3D(-1.0/sqrt(2.0), -1.0/sqrt(2.0), 0.0)
tolerance = 1.0e-15
@test distance(atom1, ideal1) < tolerance
@test distance(atom2, ideal2) < tolerance
end
end
|
lemma Cauchy_derivative_integral_circlepath: assumes contf: "continuous_on (cball z r) f" and holf: "f holomorphic_on ball z r" and w: "w \<in> ball z r" shows "(\<lambda>u. f u/(u - w)^2) contour_integrable_on (circlepath z r)" (is "?thes1") and "(f has_field_derivative (1 / (2 * of_real pi * \<i>) * contour_integral(circlepath z r) (\<lambda>u. f u / (u - w)^2))) (at w)" (is "?thes2") |
Many homes built in the Scottsdale area today have custom shutters as an exterior architectural accent. They can add a touch of old world grace, a pop of color, some extra architectural interest, and increase your home’s value and curb appeal.
We are Scottsdale real estate experts who love to share home improvement ideas. Bookmark this site and check back frequently for additional tips to improve the value of your home.
You’d be surprised at how many different variations of shutters are available to modern-day consumers. Here’s a breakdown of shutter styles according to architecturaldepot.com, the “do-it-yourselfer superstore”.
In terms of shutter composition, most styles come in wood, vinyl, fiberglass, composite wood or aluminum (or a mix). While vinyl tends to be the most popular choice, fiberglass is known for its durability and wood for its classic authenticity.
Of course, the style of shutter that you choose needs to match the style of your home. Feel free to contact us if we can help you find a designer or architect who can help you choose the right look.
And, if you live in a neighborhood with an HOA make sure you check the architectural guidelines for your community to see what materials and styles are allowed before you make any exterior changes to your home.
Reach out to us for more ideas on how to increase the value of your home or if you’re looking for homes for sale in Scottsdale. All you have to do is fill out the form below; its’s that easy! |
Formal statement is: lemma connected_component_mono: "S \<subseteq> T \<Longrightarrow> connected_component_set S x \<subseteq> connected_component_set T x" Informal statement is: If $S \subseteq T$, then the connected component of $x$ in $S$ is a subset of the connected component of $x$ in $T$. |
(* Title: HOL/Auth/n_flash_nodata_cub_lemma_on_inv__145.thy
Author: Yongjian Li and Kaiqiang Duan, State Key Lab of Computer Science, Institute of Software, Chinese Academy of Sciences
Copyright 2016 State Key Lab of Computer Science, Institute of Software, Chinese Academy of Sciences
*)
header{*The n_flash_nodata_cub Protocol Case Study*}
theory n_flash_nodata_cub_lemma_on_inv__145 imports n_flash_nodata_cub_base
begin
section{*All lemmas on causal relation between inv__145 and some rule r*}
lemma n_PI_Remote_GetVsinv__145:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_PI_Remote_Get src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_PI_Remote_Get src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__145 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_PI_Remote_GetXVsinv__145:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_PI_Remote_GetX src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_PI_Remote_GetX src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__145 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_NakVsinv__145:
assumes a1: "(\<exists> dst. dst\<le>N\<and>r=n_NI_Nak dst)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain dst where a1:"dst\<le>N\<and>r=n_NI_Nak dst" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__145 p__Inv4" apply fastforce done
have "(dst=p__Inv4)\<or>(dst~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(dst=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(dst~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_Get_Nak__part__0Vsinv__145:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_Get_Nak__part__0 src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_Get_Nak__part__0 src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__145 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_Get_Nak__part__1Vsinv__145:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_Get_Nak__part__1 src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_Get_Nak__part__1 src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__145 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_Get_Nak__part__2Vsinv__145:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_Get_Nak__part__2 src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_Get_Nak__part__2 src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__145 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_Get_Get__part__0Vsinv__145:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_Get_Get__part__0 src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_Get_Get__part__0 src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__145 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_Get_Get__part__1Vsinv__145:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_Get_Get__part__1 src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_Get_Get__part__1 src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__145 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_Get_Put_HeadVsinv__145:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_Get_Put_Head N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_Get_Put_Head N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__145 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_Get_PutVsinv__145:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_Get_Put src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_Get_Put src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__145 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_Get_Put_DirtyVsinv__145:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_Get_Put_Dirty src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_Get_Put_Dirty src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__145 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Remote_Get_NakVsinv__145:
assumes a1: "(\<exists> src dst. src\<le>N\<and>dst\<le>N\<and>src~=dst\<and>r=n_NI_Remote_Get_Nak src dst)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src dst where a1:"src\<le>N\<and>dst\<le>N\<and>src~=dst\<and>r=n_NI_Remote_Get_Nak src dst" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__145 p__Inv4" apply fastforce done
have "(src=p__Inv4\<and>dst~=p__Inv4)\<or>(src~=p__Inv4\<and>dst=p__Inv4)\<or>(src~=p__Inv4\<and>dst~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4\<and>dst~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>dst=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>dst~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Remote_Get_PutVsinv__145:
assumes a1: "(\<exists> src dst. src\<le>N\<and>dst\<le>N\<and>src~=dst\<and>r=n_NI_Remote_Get_Put src dst)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src dst where a1:"src\<le>N\<and>dst\<le>N\<and>src~=dst\<and>r=n_NI_Remote_Get_Put src dst" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__145 p__Inv4" apply fastforce done
have "(src=p__Inv4\<and>dst~=p__Inv4)\<or>(src~=p__Inv4\<and>dst=p__Inv4)\<or>(src~=p__Inv4\<and>dst~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4\<and>dst~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>dst=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>dst~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_Nak__part__0Vsinv__145:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_Nak__part__0 src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_Nak__part__0 src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__145 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_Nak__part__1Vsinv__145:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_Nak__part__1 src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_Nak__part__1 src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__145 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_Nak__part__2Vsinv__145:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_Nak__part__2 src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_Nak__part__2 src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__145 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_GetX__part__0Vsinv__145:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_GetX__part__0 src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_GetX__part__0 src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__145 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_GetX__part__1Vsinv__145:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_GetX__part__1 src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_GetX__part__1 src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__145 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_1Vsinv__145:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_1 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_1 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__145 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_2Vsinv__145:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_2 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_2 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__145 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_3Vsinv__145:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_3 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_3 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__145 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_4Vsinv__145:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_4 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_4 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__145 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_5Vsinv__145:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_5 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_5 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__145 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_6Vsinv__145:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_6 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_6 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__145 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_7__part__0Vsinv__145:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_7__part__0 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_7__part__0 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__145 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_7__part__1Vsinv__145:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_7__part__1 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_7__part__1 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__145 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_7_NODE_Get__part__0Vsinv__145:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_7_NODE_Get__part__0 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_7_NODE_Get__part__0 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__145 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_7_NODE_Get__part__1Vsinv__145:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_7_NODE_Get__part__1 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_7_NODE_Get__part__1 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__145 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_8_HomeVsinv__145:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_8_Home N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_8_Home N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__145 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_8_Home_NODE_GetVsinv__145:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_8_Home_NODE_Get N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_8_Home_NODE_Get N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__145 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_8Vsinv__145:
assumes a1: "(\<exists> src pp. src\<le>N\<and>pp\<le>N\<and>src~=pp\<and>r=n_NI_Local_GetX_PutX_8 N src pp)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src pp where a1:"src\<le>N\<and>pp\<le>N\<and>src~=pp\<and>r=n_NI_Local_GetX_PutX_8 N src pp" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__145 p__Inv4" apply fastforce done
have "(src=p__Inv4\<and>pp~=p__Inv4)\<or>(src~=p__Inv4\<and>pp=p__Inv4)\<or>(src~=p__Inv4\<and>pp~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4\<and>pp~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>pp=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>pp~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_8_NODE_GetVsinv__145:
assumes a1: "(\<exists> src pp. src\<le>N\<and>pp\<le>N\<and>src~=pp\<and>r=n_NI_Local_GetX_PutX_8_NODE_Get N src pp)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src pp where a1:"src\<le>N\<and>pp\<le>N\<and>src~=pp\<and>r=n_NI_Local_GetX_PutX_8_NODE_Get N src pp" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__145 p__Inv4" apply fastforce done
have "(src=p__Inv4\<and>pp~=p__Inv4)\<or>(src~=p__Inv4\<and>pp=p__Inv4)\<or>(src~=p__Inv4\<and>pp~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4\<and>pp~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>pp=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>pp~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_9__part__0Vsinv__145:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_9__part__0 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_9__part__0 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__145 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_9__part__1Vsinv__145:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_9__part__1 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_9__part__1 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__145 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_10_HomeVsinv__145:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_10_Home N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_10_Home N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__145 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_10Vsinv__145:
assumes a1: "(\<exists> src pp. src\<le>N\<and>pp\<le>N\<and>src~=pp\<and>r=n_NI_Local_GetX_PutX_10 N src pp)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src pp where a1:"src\<le>N\<and>pp\<le>N\<and>src~=pp\<and>r=n_NI_Local_GetX_PutX_10 N src pp" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__145 p__Inv4" apply fastforce done
have "(src=p__Inv4\<and>pp~=p__Inv4)\<or>(src~=p__Inv4\<and>pp=p__Inv4)\<or>(src~=p__Inv4\<and>pp~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4\<and>pp~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>pp=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>pp~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_11Vsinv__145:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_11 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_11 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__145 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Remote_GetX_NakVsinv__145:
assumes a1: "(\<exists> src dst. src\<le>N\<and>dst\<le>N\<and>src~=dst\<and>r=n_NI_Remote_GetX_Nak src dst)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src dst where a1:"src\<le>N\<and>dst\<le>N\<and>src~=dst\<and>r=n_NI_Remote_GetX_Nak src dst" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__145 p__Inv4" apply fastforce done
have "(src=p__Inv4\<and>dst~=p__Inv4)\<or>(src~=p__Inv4\<and>dst=p__Inv4)\<or>(src~=p__Inv4\<and>dst~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4\<and>dst~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>dst=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>dst~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Remote_GetX_PutXVsinv__145:
assumes a1: "(\<exists> src dst. src\<le>N\<and>dst\<le>N\<and>src~=dst\<and>r=n_NI_Remote_GetX_PutX src dst)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src dst where a1:"src\<le>N\<and>dst\<le>N\<and>src~=dst\<and>r=n_NI_Remote_GetX_PutX src dst" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__145 p__Inv4" apply fastforce done
have "(src=p__Inv4\<and>dst~=p__Inv4)\<or>(src~=p__Inv4\<and>dst=p__Inv4)\<or>(src~=p__Inv4\<and>dst~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4\<and>dst~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>dst=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>dst~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Remote_PutVsinv__145:
assumes a1: "(\<exists> dst. dst\<le>N\<and>r=n_NI_Remote_Put dst)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain dst where a1:"dst\<le>N\<and>r=n_NI_Remote_Put dst" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__145 p__Inv4" apply fastforce done
have "(dst=p__Inv4)\<or>(dst~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(dst=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(dst~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Remote_PutXVsinv__145:
assumes a1: "(\<exists> dst. dst\<le>N\<and>r=n_NI_Remote_PutX dst)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain dst where a1:"dst\<le>N\<and>r=n_NI_Remote_PutX dst" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__145 p__Inv4" apply fastforce done
have "(dst=p__Inv4)\<or>(dst~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(dst=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(dst~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_FAckVsinv__145:
assumes a1: "(r=n_NI_FAck )" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__145 p__Inv4" apply fastforce done
have "((formEval (eqn (IVar (Field (Field (Ident ''Sta'') ''Dir'') ''Dirty'')) (Const true)) s))\<or>((formEval (neg (eqn (IVar (Field (Field (Ident ''Sta'') ''Dir'') ''Dirty'')) (Const true))) s))" by auto
moreover {
assume c1: "((formEval (eqn (IVar (Field (Field (Ident ''Sta'') ''Dir'') ''Dirty'')) (Const true)) s))"
have "?P3 s"
apply (cut_tac a1 a2 c1, simp, rule_tac x="(neg (andForm (andForm (eqn (IVar (Field (Para (Field (Ident ''Sta'') ''UniMsg'') p__Inv4) ''Cmd'')) (Const UNI_GetX)) (eqn (IVar (Field (Para (Field (Ident ''Sta'') ''UniMsg'') p__Inv4) ''HomeProc'')) (Const false))) (eqn (IVar (Field (Field (Ident ''Sta'') ''ShWbMsg'') ''Cmd'')) (Const SHWB_FAck))))" in exI, auto) done
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume c1: "((formEval (neg (eqn (IVar (Field (Field (Ident ''Sta'') ''Dir'') ''Dirty'')) (Const true))) s))"
have "?P2 s"
proof(cut_tac a1 a2 c1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Remote_GetX_PutX_HomeVsinv__145:
assumes a1: "\<exists> dst. dst\<le>N\<and>r=n_NI_Remote_GetX_PutX_Home dst" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_PI_Local_GetX_PutX__part__0Vsinv__145:
assumes a1: "r=n_PI_Local_GetX_PutX__part__0 " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_WbVsinv__145:
assumes a1: "r=n_NI_Wb " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_InvAck_3Vsinv__145:
assumes a1: "\<exists> src. src\<le>N\<and>r=n_NI_InvAck_3 N src" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_InvAck_1Vsinv__145:
assumes a1: "\<exists> src. src\<le>N\<and>r=n_NI_InvAck_1 N src" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_PI_Local_GetX_GetX__part__1Vsinv__145:
assumes a1: "r=n_PI_Local_GetX_GetX__part__1 " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_PI_Local_GetX_GetX__part__0Vsinv__145:
assumes a1: "r=n_PI_Local_GetX_GetX__part__0 " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_PI_Remote_ReplaceVsinv__145:
assumes a1: "\<exists> src. src\<le>N\<and>r=n_PI_Remote_Replace src" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_PI_Local_ReplaceVsinv__145:
assumes a1: "r=n_PI_Local_Replace " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_InvAck_existsVsinv__145:
assumes a1: "\<exists> src pp. src\<le>N\<and>pp\<le>N\<and>src~=pp\<and>r=n_NI_InvAck_exists src pp" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_PI_Remote_PutXVsinv__145:
assumes a1: "\<exists> dst. dst\<le>N\<and>r=n_PI_Remote_PutX dst" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_Remote_Get_Put_HomeVsinv__145:
assumes a1: "\<exists> dst. dst\<le>N\<and>r=n_NI_Remote_Get_Put_Home dst" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_InvVsinv__145:
assumes a1: "\<exists> dst. dst\<le>N\<and>r=n_NI_Inv dst" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_PI_Local_PutXVsinv__145:
assumes a1: "r=n_PI_Local_PutX " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_PI_Local_Get_PutVsinv__145:
assumes a1: "r=n_PI_Local_Get_Put " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_ShWbVsinv__145:
assumes a1: "r=n_NI_ShWb N " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_PI_Local_GetX_PutX_HeadVld__part__0Vsinv__145:
assumes a1: "r=n_PI_Local_GetX_PutX_HeadVld__part__0 N " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_ReplaceVsinv__145:
assumes a1: "\<exists> src. src\<le>N\<and>r=n_NI_Replace src" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_Remote_GetX_Nak_HomeVsinv__145:
assumes a1: "\<exists> dst. dst\<le>N\<and>r=n_NI_Remote_GetX_Nak_Home dst" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_Local_PutXAcksDoneVsinv__145:
assumes a1: "r=n_NI_Local_PutXAcksDone " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_PI_Local_GetX_PutX__part__1Vsinv__145:
assumes a1: "r=n_PI_Local_GetX_PutX__part__1 " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_Remote_Get_Nak_HomeVsinv__145:
assumes a1: "\<exists> dst. dst\<le>N\<and>r=n_NI_Remote_Get_Nak_Home dst" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_InvAck_exists_HomeVsinv__145:
assumes a1: "\<exists> src. src\<le>N\<and>r=n_NI_InvAck_exists_Home src" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_Replace_HomeVsinv__145:
assumes a1: "r=n_NI_Replace_Home " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_Local_PutVsinv__145:
assumes a1: "r=n_NI_Local_Put " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_Nak_ClearVsinv__145:
assumes a1: "r=n_NI_Nak_Clear " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_PI_Local_Get_GetVsinv__145:
assumes a1: "r=n_PI_Local_Get_Get " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_Nak_HomeVsinv__145:
assumes a1: "r=n_NI_Nak_Home " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_InvAck_2Vsinv__145:
assumes a1: "\<exists> src. src\<le>N\<and>r=n_NI_InvAck_2 N src" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_PI_Local_GetX_PutX_HeadVld__part__1Vsinv__145:
assumes a1: "r=n_PI_Local_GetX_PutX_HeadVld__part__1 N " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__145 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
end
|
import numpy as np
shape = []
i = 0
while i < 10:
shape.append(i*3+2)
i += 1
newarray = np.ndarray(shape)
# show_store()
|
from codonPython.tolerance import check_tolerance
import numpy as np
import pandas as pd
import pandas.util.testing as pdt
import pytest
## TODO migrate from numpy arrays to pandas series/dataframes
testdata = [
pd.Series([1234, 1235, 1236, 1237, 1238, 1239, 1240, 1241, 1242]),
pd.Series([1, 2, 3, 4, 5, 5.5, 6, 6.5, 7]),
]
@pytest.mark.parametrize("t, y, to_exclude, poly_features, alpha, parse_dates, expected", [
(
*testdata,
2,
[1, 2],
0.05,
False,
pd.DataFrame({
"t" : [1241, 1242, 1241, 1242],
'yhat_u': [
8.11380197739608,
9.051653693670929,
7.127135023632205,
7.735627110021585,
],
'yobs': [6.5, 7.0, 6.5, 7.0],
'yhat': [
7.214285714285714,
8.071428571428573,
6.500000000000002,
6.821428571428574,
],
'yhat_l': [
6.31476945117535,
7.091203449186216,
5.872864976367799,
5.907230032835563,
],
'polynomial': [1, 1, 2, 2]
}),
),
(
*testdata,
2,
[3],
0.05,
False,
pd.DataFrame({
"t" : [1241, 1242],
'yhat_u': [
6.753927165005773,
7.214574732953706,
],
'yobs': [6.5, 7.0],
'yhat': [
6.0000000000000036,
5.571428571428576,
],
'yhat_l': [
5.2460728349942345,
3.928282409903445,
],
'polynomial': [3, 3]
}),
),
(
pd.Series([ # Check dates
"2012-05-16",
"2012-05-17",
"2012-05-18",
"2012-05-19",
"2012-05-20",
"2012-05-21",
"2012-05-22",
"2012-05-23",
"2012-05-24",
]),
pd.Series([1, 2, 3, 4, 5, 5.5, 6, 6.5, 7]),
2,
[3],
0.05,
True,
pd.DataFrame({
"t" : ["2012-05-23", "2012-05-24"],
'yhat_u': [
6.753927165005773,
7.214574732953706,
],
'yobs': [6.5, 7.0],
'yhat': [
6.0000000000000036,
5.571428571428576,
],
'yhat_l': [
5.2460728349942345,
3.928282409903445,
],
'polynomial': [3, 3]
}),
),
])
def test_tolerance_checking_BAU(t, y, to_exclude, poly_features, alpha, parse_dates, expected):
obtained = check_tolerance(
t,
y,
to_exclude=to_exclude,
poly_features=poly_features,
alpha=alpha,
parse_dates=parse_dates,
)
pdt.assert_frame_equal(expected, obtained)
@pytest.mark.parametrize("t, y, to_exclude, poly_features, alpha", [
(
*testdata,
2,
"flamingo", # This should be a list
0.05,
),
(
*testdata,
2,
[2],
"flamingo", # Needs to be int
),
(
*testdata,
2,
[2],
42, # Needs to be between 0 and 1
),
(
*testdata,
"flamingo", # Needs to be int
[2],
0.05,
),
])
def test_ValueErrors(t, y, to_exclude, poly_features, alpha):
with pytest.raises(ValueError):
check_tolerance(t, y, to_exclude=to_exclude,
poly_features=poly_features, alpha=alpha)
@pytest.mark.parametrize("t, y, to_exclude, poly_features, alpha", [
(
*testdata,
2,
[42], # Elements in the list should be between 0 and 4
0.05,
),
(
*testdata,
42, # Can't have to_exclude making your sample size smaller than 4
[2],
0.05,
),
(
pd.Series([1234, 1235, 1236, 1237, 1238, 1239,
1240, 1241, np.nan]), # Missing t value
pd.Series([1, 2, 3, 4, 5, 5.5, 6, 6.5, 7]),
2,
[2],
0.05,
),
(
pd.Series([1234, 1235, 1236, 1237, 1238, 1239, 1240, 1241, 1242]),
pd.Series([1, 2, 3, 4, 5, 5.5, 6, 6.5, np.nan]), # Missing y value
2,
[2],
0.05,
)
])
def test_AssertionErrors(t, y, to_exclude, poly_features, alpha):
with pytest.raises(AssertionError):
check_tolerance(t, y, to_exclude=to_exclude,
poly_features=poly_features, alpha=alpha)
|
Formal statement is: lemma (in subset_class) sets_into_space: "x \<in> M \<Longrightarrow> x \<subseteq> \<Omega>" Informal statement is: If $x$ is an element of $M$, then $x$ is a subset of $\Omega$. |
[STATEMENT]
lemma (in jozsa) prob0_jozsa_algo_of_const_1:
assumes "const 1"
shows "prob0_fst_qubits n jozsa_algo = 1"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. prob0_fst_qubits n jozsa_algo = 1
[PROOF STEP]
proof-
[PROOF STATE]
proof (state)
goal (1 subgoal):
1. prob0_fst_qubits n jozsa_algo = 1
[PROOF STEP]
have "prob0_fst_qubits n jozsa_algo = (\<Sum>j\<in>{0,1}. (cmod(jozsa_algo $$ (j,0)))\<^sup>2)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. prob0_fst_qubits n jozsa_algo = (\<Sum>j\<in>{0, 1}. (cmod (jozsa_algo $$ (j, 0)))\<^sup>2)
[PROOF STEP]
using prob0_fst_qubits_of_jozsa_algo
[PROOF STATE]
proof (prove)
using this:
prob0_fst_qubits n jozsa_algo = (\<Sum>j\<in>{0, 1}. (cmod (jozsa_algo $$ (j, 0)))\<^sup>2)
goal (1 subgoal):
1. prob0_fst_qubits n jozsa_algo = (\<Sum>j\<in>{0, 1}. (cmod (jozsa_algo $$ (j, 0)))\<^sup>2)
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
prob0_fst_qubits n jozsa_algo = (\<Sum>j\<in>{0, 1}. (cmod (jozsa_algo $$ (j, 0)))\<^sup>2)
goal (1 subgoal):
1. prob0_fst_qubits n jozsa_algo = 1
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
prob0_fst_qubits n jozsa_algo = (\<Sum>j\<in>{0, 1}. (cmod (jozsa_algo $$ (j, 0)))\<^sup>2)
goal (1 subgoal):
1. prob0_fst_qubits n jozsa_algo = 1
[PROOF STEP]
have "(cmod(jozsa_algo $$ (0,0)))\<^sup>2 = 1/2"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. (cmod (jozsa_algo $$ (0, 0)))\<^sup>2 = 1 / 2
[PROOF STEP]
proof-
[PROOF STATE]
proof (state)
goal (1 subgoal):
1. (cmod (jozsa_algo $$ (0, 0)))\<^sup>2 = 1 / 2
[PROOF STEP]
have "k<2^n \<longrightarrow> ((0 div 2) \<cdot>\<^bsub>n\<^esub> k) = 0" for k::nat
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. k < 2 ^ n \<longrightarrow> 0 div 2 \<cdot>\<^bsub>n\<^esub> k = 0
[PROOF STEP]
using bitwise_inner_prod_with_zero
[PROOF STATE]
proof (prove)
using this:
?m < 2 ^ ?n \<Longrightarrow> 0 \<cdot>\<^bsub>?n\<^esub> ?m = 0
goal (1 subgoal):
1. k < 2 ^ n \<longrightarrow> 0 div 2 \<cdot>\<^bsub>n\<^esub> k = 0
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
?k < 2 ^ n \<longrightarrow> 0 div 2 \<cdot>\<^bsub>n\<^esub> ?k = 0
goal (1 subgoal):
1. (cmod (jozsa_algo $$ (0, 0)))\<^sup>2 = 1 / 2
[PROOF STEP]
then
[PROOF STATE]
proof (chain)
picking this:
?k < 2 ^ n \<longrightarrow> 0 div 2 \<cdot>\<^bsub>n\<^esub> ?k = 0
[PROOF STEP]
have "(cmod(jozsa_algo $$ (0,0)))\<^sup>2 = (cmod(\<Sum>k::nat<2^n. 1/(sqrt(2)^n * sqrt(2)^(n+1))))\<^sup>2"
[PROOF STATE]
proof (prove)
using this:
?k < 2 ^ n \<longrightarrow> 0 div 2 \<cdot>\<^bsub>n\<^esub> ?k = 0
goal (1 subgoal):
1. (cmod (jozsa_algo $$ (0, 0)))\<^sup>2 = (cmod (complex_of_real (\<Sum>k<2 ^ n. 1 / (sqrt 2 ^ n * sqrt 2 ^ (n + 1)))))\<^sup>2
[PROOF STEP]
using jozsa_algo_result const_def assms
[PROOF STATE]
proof (prove)
using this:
?k < 2 ^ n \<longrightarrow> 0 div 2 \<cdot>\<^bsub>n\<^esub> ?k = 0
jozsa_algo = Matrix.mat (2 ^ (n + 1)) 1 (\<lambda>x. complex_of_real (case x of (i, j) \<Rightarrow> if even i then \<Sum>k<2 ^ n. (- 1) ^ (f k + i div 2 \<cdot>\<^bsub>n\<^esub> k) / (sqrt 2 ^ n * sqrt 2 ^ (n + 1)) else \<Sum>k<2 ^ n. (- 1) ^ (f k + 1 + i div 2 \<cdot>\<^bsub>n\<^esub> k) / (sqrt 2 ^ n * sqrt 2 ^ (n + 1))))
const ?c = (\<forall>x\<in>{i. i < 2 ^ n}. f x = ?c)
const 1
goal (1 subgoal):
1. (cmod (jozsa_algo $$ (0, 0)))\<^sup>2 = (cmod (complex_of_real (\<Sum>k<2 ^ n. 1 / (sqrt 2 ^ n * sqrt 2 ^ (n + 1)))))\<^sup>2
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
(cmod (jozsa_algo $$ (0, 0)))\<^sup>2 = (cmod (complex_of_real (\<Sum>k<2 ^ n. 1 / (sqrt 2 ^ n * sqrt 2 ^ (n + 1)))))\<^sup>2
goal (1 subgoal):
1. (cmod (jozsa_algo $$ (0, 0)))\<^sup>2 = 1 / 2
[PROOF STEP]
also
[PROOF STATE]
proof (state)
this:
(cmod (jozsa_algo $$ (0, 0)))\<^sup>2 = (cmod (complex_of_real (\<Sum>k<2 ^ n. 1 / (sqrt 2 ^ n * sqrt 2 ^ (n + 1)))))\<^sup>2
goal (1 subgoal):
1. (cmod (jozsa_algo $$ (0, 0)))\<^sup>2 = 1 / 2
[PROOF STEP]
have "... = (cmod((-1)/(sqrt(2))))\<^sup>2 "
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. (cmod (complex_of_real (\<Sum>k<2 ^ n. 1 / (sqrt 2 ^ n * sqrt 2 ^ (n + 1)))))\<^sup>2 = (cmod (complex_of_real (- 1 / sqrt 2)))\<^sup>2
[PROOF STEP]
using aux_comp_with_sqrt2_bis
[PROOF STATE]
proof (prove)
using this:
2 ^ ?n / (sqrt 2 ^ ?n * sqrt 2 ^ (?n + 1)) = 1 / sqrt 2
goal (1 subgoal):
1. (cmod (complex_of_real (\<Sum>k<2 ^ n. 1 / (sqrt 2 ^ n * sqrt 2 ^ (n + 1)))))\<^sup>2 = (cmod (complex_of_real (- 1 / sqrt 2)))\<^sup>2
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
(cmod (complex_of_real (\<Sum>k<2 ^ n. 1 / (sqrt 2 ^ n * sqrt 2 ^ (n + 1)))))\<^sup>2 = (cmod (complex_of_real (- 1 / sqrt 2)))\<^sup>2
goal (1 subgoal):
1. (cmod (jozsa_algo $$ (0, 0)))\<^sup>2 = 1 / 2
[PROOF STEP]
also
[PROOF STATE]
proof (state)
this:
(cmod (complex_of_real (\<Sum>k<2 ^ n. 1 / (sqrt 2 ^ n * sqrt 2 ^ (n + 1)))))\<^sup>2 = (cmod (complex_of_real (- 1 / sqrt 2)))\<^sup>2
goal (1 subgoal):
1. (cmod (jozsa_algo $$ (0, 0)))\<^sup>2 = 1 / 2
[PROOF STEP]
have "... = 1/2"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. (cmod (complex_of_real (- 1 / sqrt 2)))\<^sup>2 = 1 / 2
[PROOF STEP]
by (simp add: norm_divide power2_eq_square)
[PROOF STATE]
proof (state)
this:
(cmod (complex_of_real (- 1 / sqrt 2)))\<^sup>2 = 1 / 2
goal (1 subgoal):
1. (cmod (jozsa_algo $$ (0, 0)))\<^sup>2 = 1 / 2
[PROOF STEP]
finally
[PROOF STATE]
proof (chain)
picking this:
(cmod (jozsa_algo $$ (0, 0)))\<^sup>2 = 1 / 2
[PROOF STEP]
show "?thesis"
[PROOF STATE]
proof (prove)
using this:
(cmod (jozsa_algo $$ (0, 0)))\<^sup>2 = 1 / 2
goal (1 subgoal):
1. (cmod (jozsa_algo $$ (0, 0)))\<^sup>2 = 1 / 2
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
(cmod (jozsa_algo $$ (0, 0)))\<^sup>2 = 1 / 2
goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
(cmod (jozsa_algo $$ (0, 0)))\<^sup>2 = 1 / 2
goal (1 subgoal):
1. prob0_fst_qubits n jozsa_algo = 1
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
(cmod (jozsa_algo $$ (0, 0)))\<^sup>2 = 1 / 2
goal (1 subgoal):
1. prob0_fst_qubits n jozsa_algo = 1
[PROOF STEP]
have "(cmod(jozsa_algo $$ (1,0)))\<^sup>2 = 1/2"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. (cmod (jozsa_algo $$ (1, 0)))\<^sup>2 = 1 / 2
[PROOF STEP]
proof-
[PROOF STATE]
proof (state)
goal (1 subgoal):
1. (cmod (jozsa_algo $$ (1, 0)))\<^sup>2 = 1 / 2
[PROOF STEP]
have "k<2^n \<longrightarrow> ((1 div 2) \<cdot>\<^bsub>n\<^esub> k) = 0" for k::nat
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. k < 2 ^ n \<longrightarrow> 1 div 2 \<cdot>\<^bsub>n\<^esub> k = 0
[PROOF STEP]
using bitwise_inner_prod_with_zero
[PROOF STATE]
proof (prove)
using this:
?m < 2 ^ ?n \<Longrightarrow> 0 \<cdot>\<^bsub>?n\<^esub> ?m = 0
goal (1 subgoal):
1. k < 2 ^ n \<longrightarrow> 1 div 2 \<cdot>\<^bsub>n\<^esub> k = 0
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
?k < 2 ^ n \<longrightarrow> 1 div 2 \<cdot>\<^bsub>n\<^esub> ?k = 0
goal (1 subgoal):
1. (cmod (jozsa_algo $$ (1, 0)))\<^sup>2 = 1 / 2
[PROOF STEP]
then
[PROOF STATE]
proof (chain)
picking this:
?k < 2 ^ n \<longrightarrow> 1 div 2 \<cdot>\<^bsub>n\<^esub> ?k = 0
[PROOF STEP]
have "(\<Sum>k::nat<2^n. (-1)^(f k +1 + ((1 div 2) \<cdot>\<^bsub>n\<^esub> k))/(sqrt(2)^n * sqrt(2)^(n+1)))
= (\<Sum>k::nat<2^n. 1/(sqrt(2)^n * sqrt(2)^(n+1)))"
[PROOF STATE]
proof (prove)
using this:
?k < 2 ^ n \<longrightarrow> 1 div 2 \<cdot>\<^bsub>n\<^esub> ?k = 0
goal (1 subgoal):
1. (\<Sum>k<2 ^ n. (- 1) ^ (f k + 1 + 1 div 2 \<cdot>\<^bsub>n\<^esub> k) / (sqrt 2 ^ n * sqrt 2 ^ (n + 1))) = (\<Sum>k<2 ^ n. 1 / (sqrt 2 ^ n * sqrt 2 ^ (n + 1)))
[PROOF STEP]
using const_def assms
[PROOF STATE]
proof (prove)
using this:
?k < 2 ^ n \<longrightarrow> 1 div 2 \<cdot>\<^bsub>n\<^esub> ?k = 0
const ?c = (\<forall>x\<in>{i. i < 2 ^ n}. f x = ?c)
const 1
goal (1 subgoal):
1. (\<Sum>k<2 ^ n. (- 1) ^ (f k + 1 + 1 div 2 \<cdot>\<^bsub>n\<^esub> k) / (sqrt 2 ^ n * sqrt 2 ^ (n + 1))) = (\<Sum>k<2 ^ n. 1 / (sqrt 2 ^ n * sqrt 2 ^ (n + 1)))
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
(\<Sum>k<2 ^ n. (- 1) ^ (f k + 1 + 1 div 2 \<cdot>\<^bsub>n\<^esub> k) / (sqrt 2 ^ n * sqrt 2 ^ (n + 1))) = (\<Sum>k<2 ^ n. 1 / (sqrt 2 ^ n * sqrt 2 ^ (n + 1)))
goal (1 subgoal):
1. (cmod (jozsa_algo $$ (1, 0)))\<^sup>2 = 1 / 2
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
(\<Sum>k<2 ^ n. (- 1) ^ (f k + 1 + 1 div 2 \<cdot>\<^bsub>n\<^esub> k) / (sqrt 2 ^ n * sqrt 2 ^ (n + 1))) = (\<Sum>k<2 ^ n. 1 / (sqrt 2 ^ n * sqrt 2 ^ (n + 1)))
goal (1 subgoal):
1. (cmod (jozsa_algo $$ (1, 0)))\<^sup>2 = 1 / 2
[PROOF STEP]
have "(cmod(jozsa_algo $$ (1,0)))\<^sup>2
= (cmod (\<Sum>k::nat<2^n. (-1)^(f k + 1 + ((1 div 2) \<cdot>\<^bsub>n\<^esub> k))/(sqrt(2)^n * sqrt(2)^(n+1))))\<^sup>2"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. (cmod (jozsa_algo $$ (1, 0)))\<^sup>2 = (cmod (complex_of_real (\<Sum>k<2 ^ n. (- 1) ^ (f k + 1 + 1 div 2 \<cdot>\<^bsub>n\<^esub> k) / (sqrt 2 ^ n * sqrt 2 ^ (n + 1)))))\<^sup>2
[PROOF STEP]
using \<psi>\<^sub>3_dim
[PROOF STATE]
proof (prove)
using this:
1 < dim_row (Matrix.mat (2 ^ (n + 1)) 1 (\<lambda>x. complex_of_real (case x of (i, j) \<Rightarrow> if even i then \<Sum>k<2 ^ n. (- 1) ^ (f k + i div 2 \<cdot>\<^bsub>n\<^esub> k) / (sqrt 2 ^ n * sqrt 2 ^ (n + 1)) else \<Sum>k<2 ^ n. (- 1) ^ (f k + 1 + i div 2 \<cdot>\<^bsub>n\<^esub> k) / (sqrt 2 ^ n * sqrt 2 ^ (n + 1)))))
goal (1 subgoal):
1. (cmod (jozsa_algo $$ (1, 0)))\<^sup>2 = (cmod (complex_of_real (\<Sum>k<2 ^ n. (- 1) ^ (f k + 1 + 1 div 2 \<cdot>\<^bsub>n\<^esub> k) / (sqrt 2 ^ n * sqrt 2 ^ (n + 1)))))\<^sup>2
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
(cmod (jozsa_algo $$ (1, 0)))\<^sup>2 = (cmod (complex_of_real (\<Sum>k<2 ^ n. (- 1) ^ (f k + 1 + 1 div 2 \<cdot>\<^bsub>n\<^esub> k) / (sqrt 2 ^ n * sqrt 2 ^ (n + 1)))))\<^sup>2
goal (1 subgoal):
1. (cmod (jozsa_algo $$ (1, 0)))\<^sup>2 = 1 / 2
[PROOF STEP]
ultimately
[PROOF STATE]
proof (chain)
picking this:
(\<Sum>k<2 ^ n. (- 1) ^ (f k + 1 + 1 div 2 \<cdot>\<^bsub>n\<^esub> k) / (sqrt 2 ^ n * sqrt 2 ^ (n + 1))) = (\<Sum>k<2 ^ n. 1 / (sqrt 2 ^ n * sqrt 2 ^ (n + 1)))
(cmod (jozsa_algo $$ (1, 0)))\<^sup>2 = (cmod (complex_of_real (\<Sum>k<2 ^ n. (- 1) ^ (f k + 1 + 1 div 2 \<cdot>\<^bsub>n\<^esub> k) / (sqrt 2 ^ n * sqrt 2 ^ (n + 1)))))\<^sup>2
[PROOF STEP]
have "(cmod(jozsa_algo $$ (1,0)))\<^sup>2 = (cmod(\<Sum>k::nat<2^n. 1/(sqrt(2)^n * sqrt(2)^(n+1))))\<^sup>2"
[PROOF STATE]
proof (prove)
using this:
(\<Sum>k<2 ^ n. (- 1) ^ (f k + 1 + 1 div 2 \<cdot>\<^bsub>n\<^esub> k) / (sqrt 2 ^ n * sqrt 2 ^ (n + 1))) = (\<Sum>k<2 ^ n. 1 / (sqrt 2 ^ n * sqrt 2 ^ (n + 1)))
(cmod (jozsa_algo $$ (1, 0)))\<^sup>2 = (cmod (complex_of_real (\<Sum>k<2 ^ n. (- 1) ^ (f k + 1 + 1 div 2 \<cdot>\<^bsub>n\<^esub> k) / (sqrt 2 ^ n * sqrt 2 ^ (n + 1)))))\<^sup>2
goal (1 subgoal):
1. (cmod (jozsa_algo $$ (1, 0)))\<^sup>2 = (cmod (complex_of_real (\<Sum>k<2 ^ n. 1 / (sqrt 2 ^ n * sqrt 2 ^ (n + 1)))))\<^sup>2
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
(cmod (jozsa_algo $$ (1, 0)))\<^sup>2 = (cmod (complex_of_real (\<Sum>k<2 ^ n. 1 / (sqrt 2 ^ n * sqrt 2 ^ (n + 1)))))\<^sup>2
goal (1 subgoal):
1. (cmod (jozsa_algo $$ (1, 0)))\<^sup>2 = 1 / 2
[PROOF STEP]
also
[PROOF STATE]
proof (state)
this:
(cmod (jozsa_algo $$ (1, 0)))\<^sup>2 = (cmod (complex_of_real (\<Sum>k<2 ^ n. 1 / (sqrt 2 ^ n * sqrt 2 ^ (n + 1)))))\<^sup>2
goal (1 subgoal):
1. (cmod (jozsa_algo $$ (1, 0)))\<^sup>2 = 1 / 2
[PROOF STEP]
have "... = (cmod(1/(sqrt(2))))\<^sup>2 "
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. (cmod (complex_of_real (\<Sum>k<2 ^ n. 1 / (sqrt 2 ^ n * sqrt 2 ^ (n + 1)))))\<^sup>2 = (cmod (complex_of_real (1 / sqrt 2)))\<^sup>2
[PROOF STEP]
using aux_comp_with_sqrt2_bis
[PROOF STATE]
proof (prove)
using this:
2 ^ ?n / (sqrt 2 ^ ?n * sqrt 2 ^ (?n + 1)) = 1 / sqrt 2
goal (1 subgoal):
1. (cmod (complex_of_real (\<Sum>k<2 ^ n. 1 / (sqrt 2 ^ n * sqrt 2 ^ (n + 1)))))\<^sup>2 = (cmod (complex_of_real (1 / sqrt 2)))\<^sup>2
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
(cmod (complex_of_real (\<Sum>k<2 ^ n. 1 / (sqrt 2 ^ n * sqrt 2 ^ (n + 1)))))\<^sup>2 = (cmod (complex_of_real (1 / sqrt 2)))\<^sup>2
goal (1 subgoal):
1. (cmod (jozsa_algo $$ (1, 0)))\<^sup>2 = 1 / 2
[PROOF STEP]
also
[PROOF STATE]
proof (state)
this:
(cmod (complex_of_real (\<Sum>k<2 ^ n. 1 / (sqrt 2 ^ n * sqrt 2 ^ (n + 1)))))\<^sup>2 = (cmod (complex_of_real (1 / sqrt 2)))\<^sup>2
goal (1 subgoal):
1. (cmod (jozsa_algo $$ (1, 0)))\<^sup>2 = 1 / 2
[PROOF STEP]
have "... = 1/2"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. (cmod (complex_of_real (1 / sqrt 2)))\<^sup>2 = 1 / 2
[PROOF STEP]
by (simp add: norm_divide power2_eq_square)
[PROOF STATE]
proof (state)
this:
(cmod (complex_of_real (1 / sqrt 2)))\<^sup>2 = 1 / 2
goal (1 subgoal):
1. (cmod (jozsa_algo $$ (1, 0)))\<^sup>2 = 1 / 2
[PROOF STEP]
finally
[PROOF STATE]
proof (chain)
picking this:
(cmod (jozsa_algo $$ (1, 0)))\<^sup>2 = 1 / 2
[PROOF STEP]
show "?thesis"
[PROOF STATE]
proof (prove)
using this:
(cmod (jozsa_algo $$ (1, 0)))\<^sup>2 = 1 / 2
goal (1 subgoal):
1. (cmod (jozsa_algo $$ (1, 0)))\<^sup>2 = 1 / 2
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
(cmod (jozsa_algo $$ (1, 0)))\<^sup>2 = 1 / 2
goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
(cmod (jozsa_algo $$ (1, 0)))\<^sup>2 = 1 / 2
goal (1 subgoal):
1. prob0_fst_qubits n jozsa_algo = 1
[PROOF STEP]
ultimately
[PROOF STATE]
proof (chain)
picking this:
prob0_fst_qubits n jozsa_algo = (\<Sum>j\<in>{0, 1}. (cmod (jozsa_algo $$ (j, 0)))\<^sup>2)
(cmod (jozsa_algo $$ (0, 0)))\<^sup>2 = 1 / 2
(cmod (jozsa_algo $$ (1, 0)))\<^sup>2 = 1 / 2
[PROOF STEP]
have "prob0_fst_qubits n jozsa_algo = 1/2 + 1/2"
[PROOF STATE]
proof (prove)
using this:
prob0_fst_qubits n jozsa_algo = (\<Sum>j\<in>{0, 1}. (cmod (jozsa_algo $$ (j, 0)))\<^sup>2)
(cmod (jozsa_algo $$ (0, 0)))\<^sup>2 = 1 / 2
(cmod (jozsa_algo $$ (1, 0)))\<^sup>2 = 1 / 2
goal (1 subgoal):
1. prob0_fst_qubits n jozsa_algo = 1 / 2 + 1 / 2
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
prob0_fst_qubits n jozsa_algo = 1 / 2 + 1 / 2
goal (1 subgoal):
1. prob0_fst_qubits n jozsa_algo = 1
[PROOF STEP]
then
[PROOF STATE]
proof (chain)
picking this:
prob0_fst_qubits n jozsa_algo = 1 / 2 + 1 / 2
[PROOF STEP]
show "?thesis"
[PROOF STATE]
proof (prove)
using this:
prob0_fst_qubits n jozsa_algo = 1 / 2 + 1 / 2
goal (1 subgoal):
1. prob0_fst_qubits n jozsa_algo = 1
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
prob0_fst_qubits n jozsa_algo = 1
goal:
No subgoals!
[PROOF STEP]
qed |
Lemma nat_id_ok : forall n, id n = n.
Proof.
Print bool.
|
In 1941 , German policy evolved further , calling for the complete destruction of the Polish people , whom the Nazis regarded as " subhumans " ( Untermenschen ) . Within ten to twenty years , the Polish territories under German occupation were to be entirely cleared of ethnic Poles and settled by German colonists . The policy was relaxed somewhat in the final years of occupation ( 1943 – 44 ) , in view of German military defeats and the approaching Eastern Front . The Germans hoped that a more lenient cultural policy would lessen unrest and weaken the Polish Resistance . Poles were allowed back into those museums that now supported German propaganda and indoctrination , such as the newly created Chopin museum , which emphasized the composer 's invented German roots . Restrictions on education , theater and music performances were eased .
|
# Copyright (c) 2021 Dai HBG
"""
selectors定义了多个用于特征选择的具体方法
日志
2021-12-18
- init
"""
import numpy as np
from sklearn import linear_model
from sklearn.ensemble import RandomForestRegressor
import lightgbm as lgb
from DataSetConstructor import DataSetConstructor
import sys
sys.path.append('C:/Users/HBG/Desktop/Repositories/Daily-Frequency-Quant/QBG')
from DataLoader.DataLoader import Data
class CorrSelector: # 选出相互之间相关系数不超过阈值的特征集，该方法适用于线性因子
"""
基于相关系数的特征选择流程：
1. 计算候选特征和y的相关系数，低于阈值的剔除；
2. 依次计算候选特征和已有特征的相关系数，全部低于阈值的进入特征池；
3. 若和某一个已有特征相关系数高于阈值，则比较它们预测力的比例和相关系数的比例，具体计算
added_value := abs(sqrt((predict_corr_1**2 + predict_corr_2**2 - 2 * corr_12 * predict_corr_1
* predict_corr_2) / (1 - corr_12**2)) / predict_corr_1 - 1
4. 当added_value超过阈值时继续检查，否则剔除
"""
def __init__(self):
pass
@staticmethod
def select(data: Data, x: dict, y: np.array, start_date: str, end_date: str,
corr_threshold: float = 0.8, predict_corr_threshold: float = 0.01, added_value_threshold: float = 0.2,
memory_save: bool = True, shift: int = 1) -> list:
"""
:param data: Data类
:param x: 信号字典
:param y: 预测收益率，默认时data.ret
:param start_date: 开始日期
:param end_date: 结束日期
:param corr_threshold: 相互之间的相关系数阈值
:param predict_corr_threshold: 单个特征的预测力阈值
:param added_value_threshold: 高度相关的特征的附加值阈值
:param memory_save: 是否节约内存，选择False时将已加入的信号矩阵缓存以加快速度
:param shift: 平移
:return:
"""
start, end = data.get_real_date(start_date, end_date)
select_list = []
predict_corr_record = [] # 记录已经进入特征池的特征的线性预测力
new_y = y.copy()
for i in range(start, end - start + 1):
new_y[i, data.top[i]] -= np.nanmean(new_y[i, data.top[i]]) # demean
if not memory_save:
signals_cache = {}
else:
signals_cache = None
for i in range(len(x)):
# 计算线性预测力
tmp_x = x[i].copy()
predict_corr = np.zeros(end - start + 1)
for k in range(start, end + 1):
if np.sum(~np.isnan(tmp_x[k, data.top[k]])) <= 1:
tmp_x[k, data.top[k]] = 0 # 将有效信号值个数少于2的交易日信号全部置为0
tmp_x[k, data.top[k]] -= np.nanmean(tmp_x[k, data.top[k]]) # demean
mean = np.nanmean(tmp_x[k, data.top[k]] * new_y[k + shift, data.top[k]]) # mean
std = np.nanstd(tmp_x[k, data.top[k]]) * np.nanstd(new_y[k + shift, data.top[k]]) # std
if std == 0:
predict_corr[k - start] = 0
else:
predict_corr[k - start] = mean / std
predict_corr = np.mean(predict_corr)
if not select_list:
if np.abs(predict_corr) >= predict_corr_threshold:
select_list.append(i)
predict_corr_record.append(predict_corr) # 记录已有的信号的预测力
if not memory_save:
signals_cache[i] = tmp_x # 非节约内存时缓存处理过的信号
else: # 判断和已有特征相关性
if np.abs(predict_corr) < predict_corr_threshold:
continue
for idx in select_list:
corr = np.zeros(end - start + 1)
if not memory_save:
tmp_y = signals_cache[idx]
else:
tmp_y = x[idx].copy()
# 计算相关系数
for k in range(start, end + 1):
if memory_save:
if np.sum(~np.isnan(tmp_y[k, data.top[k]])) <= 1:
tmp_y[k, data.top[k]] = 0 # 将有效信号值个数少于2的交易日信号全部置为0
tmp_y[k, data.top[k]] -= np.nanmean(tmp_y[k, data.top[k]]) # demean
mean = np.nanmean(tmp_x[k, data.top[k]] * tmp_y[k + shift, data.top[k]]) # mean
std = np.nanstd(tmp_x[k, data.top[k]]) * np.nanstd(tmp_y[k + shift, data.top[k]]) # std
if std == 0:
corr[k - start] = 0
else:
corr[k - start] = mean / std
corr = np.mean(corr)
if np.abs(corr) >= corr_threshold: # 相关系数高于阈值时检查added_value
added_value = abs(np.sqrt((predict_corr_record[idx] ** 2 + predict_corr ** 2 - 2 * corr *
predict_corr_record[idx] * predict_corr) / (1 - corr ** 2))
/ predict_corr_record[idx]) - 1
if added_value < added_value_threshold:
break
else:
select_list.append(i)
predict_corr_record.append(predict_corr) # 记录已有的信号的预测力
if not memory_save:
signals_cache[i] = tmp_x # 非节约内存时缓存处理过的信号
return select_list
class BoostingSelector: # boosting进行选择
def __init__(self):
pass
@staticmethod
def select(data: Data, x: dict, y: np.array, start_date: str, end_date: str,
corr_threshold: float = None, predict_corr_threshold: float = 0.01,
res_corr_threshold: float = 0.005,
memory_save: bool = True, shift: int = 1) -> list:
"""
:param data: Data类
:param x: 信号字典
:param y: 预测收益率，默认时data.ret
:param start_date: 开始日期
:param end_date: 结束日期
:param corr_threshold: 相互之间的相关系数阈值，默认不需要
:param predict_corr_threshold: 单个特征的预测力阈值
:param res_corr_threshold: 对残差的预测力的阈值
:param memory_save: 是否节约内存，选择False时将已加入的信号矩阵缓存以加快速度
:param shift: 平移
:return:
"""
ds = DataSetConstructor(data, shift=shift)
x_train, y_train = ds.construct(signals_dic=x, start_date=start_date, end_date=end_date)
start, end = data.get_real_date(start_date, end_date)
select_list = []
# predict_corr_record = [] # 记录已经进入特征池的特征的线性预测力
# opt_IC = 0 # 记录当前回归值的IC
res = y.copy() # 预测残差
if not memory_save:
signals_cache = {}
else:
signals_cache = None
lr = linear_model.LinearRegression()
for i in range(len(x)):
# 计算残差
new_res = res.copy()
for k in range(start, end - start + 1):
new_res[k, data.top[k]] -= np.nanmean(new_res[k, data.top[k]]) # demean
# 计算残差预测力
tmp_x = x[i].copy()
res_corr = np.zeros(end - start + 1)
for k in range(start, end + 1):
if np.sum(~np.isnan(tmp_x[k, data.top[k]])) <= 1:
tmp_x[k, data.top[k]] = 0 # 将有效信号值个数少于2的交易日信号全部置为0
tmp_x[k, data.top[k]] -= np.nanmean(tmp_x[k, data.top[k]]) # demean
mean = np.nanmean(tmp_x[k, data.top[k]] * res[k + shift, data.top[k]]) # mean
std = np.nanstd(tmp_x[k, data.top[k]]) * np.nanstd(res[k + shift, data.top[k]]) # std
if std == 0:
res_corr[k - start] = 0
else:
res_corr[k - start] = mean / std
res_corr = np.mean(res_corr)
if not select_list:
if np.abs(res_corr) < predict_corr_threshold: # 第一次添加的信号要具有一定的预测力
continue
else:
if np.abs(res_corr) < res_corr_threshold: # 此后只需考虑残差预测力
continue
select_list.append(i)
# predict_corr_record.append(predict_corr) # 记录已有的信号的预测力
# opt_IC = abs(res_corr)
if not memory_save:
signals_cache[i] = tmp_x # 非节约内存时缓存处理过的信号
# 更新res
lr.fit(x_train[select_list], y_train)
for k in range(start, end + 1):
tmp_x = []
for se in select_list:
tmp = x[se][k].copy()
tmp = tmp.astype(float)
tmp[np.isnan(tmp)] = np.nanmean(tmp[data.top[k]])
tmp[np.isinf(tmp)] = np.nanmean(tmp[data.top[k]])
tmp[data.top[k]] -= np.nanmean(tmp[data.top[k]])
if np.sum(tmp[data.top[k]] != 0) >= 2:
tmp[data.top[k]] /= np.nanstd(tmp[data.top[k]])
tmp_x.append(tmp)
tmp_x = np.vstack(tmp_x).T
res[k, data.top[k]] = y[k, data.top[k]] - lr.predict(tmp_x[data.top[k]])
return select_list
class LassoSelector:
def __init__(self):
pass
@staticmethod
def select(data: Data, x: dict, y: np.array, start_date: str, end_date: str,
alpha: float = 1e-3, shift: int = 1) -> list:
"""
:param data: Data类
:param x: 信号字典
:param y: 预测收益率，默认为data.ret
:param start_date: 开始日期
:param end_date: 结束日期
:param alpha: 模型参数
:param shift: 平移
:return:
"""
ds = DataSetConstructor(data, shift=shift)
x_train, y_train = ds.construct(signals_dic=x, start_date=start_date, end_date=end_date)
lasso = linear_model.Lasso(alpha=alpha)
lasso.fit(x_train, y_train)
select_list = []
for i in range(len(lasso.coef_)):
if np.abs(lasso.coef_[i]) > 0:
select_list.append(i)
return select_list
class TreeSelector:
def __init__(self):
pass
@staticmethod
def select(data: Data, x: dict, y: np.array, start_date: str, end_date: str,
method: str = 'lgbm', params: dict = None, proportion: float = 0.5,
feature_num: int = 0,
shift: int = 1) -> list:
"""
:param data: Data类
:param x: 信号字典
:param y: 预测收益率，默认为data.ret
:param start_date: 开始日期
:param end_date: 结束日期
:param method: 使用的树模型
:param params: 树模型参数
:param proportion: 选取特征的比例
:param feature_num: 选取特征的数量
:param shift: 平移
:return:
"""
ds = DataSetConstructor(data, shift=shift)
x_train, y_train = ds.construct(signals_dic=x, start_date=start_date, end_date=end_date)
if method == 'lgbm':
if params is None:
params = {'num_leaves': 20, 'min_data_in_leaf': 200, 'objective': 'regression', 'max_depth': 6,
'learning_rate': 0.05, "min_sum_hessian_in_leaf": 6,
"boosting": "gbdt", "feature_fraction": 0.5, "bagging_freq": 1, "bagging_fraction": 0.7,
"bagging_seed": 11, "lambda_l1": 2, "verbosity": 0, "nthread": -1,
'metric': 'mse', "random_state": 2021} # 'device': 'gpu'}
num_round = 100
trn_data = lgb.Dataset(x_train[:-1000], label=y_train[:-1000])
val_data = lgb.Dataset(x_train[-1000:], label=y_train[-1000:])
lgbm = lgb.train(params, trn_data, num_round, valid_sets=[trn_data, val_data], verbose_eval=20)
feature_importance = np.argsort(lgbm.feature_importance()) # 特征重要性排序
if feature_num == 0:
feature_num = int(len(feature_importance) * proportion)
if feature_num == 0:
feature_num = 1
return list(feature_importance[-feature_num:])
elif method == 'rf': # 随机森林
if params is None:
params = {'num_leaves': 20, 'min_data_in_leaf': 200, 'objective': 'regression', 'max_depth': 6,
'learning_rate': 0.05, "min_sum_hessian_in_leaf": 6,
"boosting": "gbdt", "feature_fraction": 0.5, "bagging_freq": 1, "bagging_fraction": 0.7,
"bagging_seed": 11, "lambda_l1": 2, "verbosity": 0, "nthread": -1,
'metric': 'mse', "random_state": 2021} # 'device': 'gpu'}
rf = RandomForestRegressor(n_estimators=100, max_depth=3)
rf.fit(x_train, y_train)
feature_importance = np.argsort(rf.feature_importances_) # 特征重要性排序
if feature_num == 0:
feature_num = int(len(feature_importance) * proportion)
if feature_num == 0:
feature_num = 1
return list(feature_importance[-feature_num:])
|
{-# OPTIONS --cubical #-}
module Multidimensional.Data.NNat.Base where
open import Cubical.Foundations.Prelude
open import Cubical.Data.Unit
open import Cubical.Data.Nat
open import Cubical.Data.Prod
open import Cubical.Data.Bool
open import Cubical.Relation.Nullary
open import Multidimensional.Data.Extra.Nat
open import Multidimensional.Data.Dir
open import Multidimensional.Data.DirNum
data N (r : ℕ) : Type₀ where
bn : DirNum r → N r
xr : DirNum r → N r → N r
-- should define induction principle for N r
-- we have 2ⁿ "unary" constructors, analogous to BNat with 2¹ (b0 and b1)
-- rename n to r
-- this likely introduces inefficiencies compared
-- to BinNat, with the max? check etc.
sucN : ∀ {n} → N n → N n
sucN {zero} (bn tt) = xr tt (bn tt)
sucN {zero} (xr tt x) = xr tt (sucN x)
sucN {suc n} (bn (↓ , ds)) = (bn (↑ , ds))
sucN {suc n} (bn (↑ , ds)) with max? ds
... | no _ = (bn (↓ , next ds))
... | yes _ = xr (zero-n (suc n)) (bn (one-n (suc n)))
sucN {suc n} (xr d x) with max? d
... | no _ = xr (next d) x
... | yes _ = xr (zero-n (suc n)) (sucN x)
sucnN : {r : ℕ} → (n : ℕ) → (N r → N r)
sucnN n = iter n sucN
doubleN : (r : ℕ) → N r → N r
doubleN zero (bn tt) = bn tt
doubleN zero (xr d x) = sucN (sucN (doubleN zero x))
doubleN (suc r) (bn x) with zero-n? x
... | yes _ = bn x
-- bad:
... | no _ = caseBool (bn (doubleDirNum (suc r) x)) (xr (zero-n (suc r)) (bn x)) (doubleable-n? x)
-- ... | no _ | doubleable = {!bn (doubleDirNum x)!}
-- ... | no _ | notdoubleable = xr (zero-n (suc r)) (bn x)
doubleN (suc r) (xr x x₁) = sucN (sucN (doubleN (suc r) x₁))
doublesN : (r : ℕ) → ℕ → N r → N r
doublesN r zero m = m
doublesN r (suc n) m = doublesN r n (doubleN r m)
N→ℕ : (r : ℕ) (x : N r) → ℕ
N→ℕ zero (bn tt) = zero
N→ℕ zero (xr tt x) = suc (N→ℕ zero x)
N→ℕ (suc r) (bn x) = DirNum→ℕ x
N→ℕ (suc r) (xr d x) = sucn (DirNum→ℕ d) (doublesℕ (suc r) (N→ℕ (suc r) x))
ℕ→N : (r : ℕ) → (n : ℕ) → N r
ℕ→N r zero = bn (zero-n r)
ℕ→N zero (suc n) = xr tt (ℕ→N zero n)
ℕ→N (suc r) (suc n) = sucN (ℕ→N (suc r) n)
|
\section{Sparse Coding}
\subsection*{Orthogonal Basis}
Pros: fast inverse; preserves energy.
For $\mathbf{x}$ and orthog. mat. $\mathbf{U}$ compute $\mathbf{z} = \mathbf{U}^\top \mathbf{x} $. Approx $ \mathbf{\hat{x}} = \mathbf{U\hat{z}}$, $\hat{z}_i = z_i$ if $ \lvert z_i \rvert > \epsilon$ else 0.
Reconstruction Error $\|\mathbf{x}-\mathbf{\hat{x}}\|^2 = \sum_{d\notin\sigma}\langle\mathbf{x},\mathbf{u}_d\rangle ^2$.
Choice of base depends on signal. Fourier for global, wavelet for local support. PCA basis optimal for given $\Sigma$. Stripes \& check patterns: hi-freq in Fourier.
\subsection*{Haar Wavelets (form orthogonal basis)}
scaling fcn $\phi(x)=[1,1,1,1]$, mother $W(x)=[1,1,-1,-1]$, dilated $W(2x)=[1,-1,0,0]$, translated $W(2x-1)=[0,0,1,-1]$
\subsection*{Overcomplete Basis}
$\mathbf{U} \in \mathbb{R}^{D \times L}$ for \# atoms $ = L > D = \mathsf{dim}\text{(data)}$. Decoding involved $\rightarrow$ add constraint $\mathbf{z}^\star \in \argmin_\mathbf{z} \lVert \mathbf{z} \rVert_0$ s.t. $\mathbf{x} = \mathbf{Uz}$. NP-hard $\rightarrow$ approximate with 1-norm (convex) or with MP.
\textbf{Coherence}
\begin{inparaitem}[\color{red}\textbullet]
\item $m(\mathbf{U}) = \max_{i,j:\, i \neq j} | \mathbf{u}_i^\top \mathbf{u}_j |$
\item $m(\mathbf{B}) = 0$ if $\mathbf{B}$ orthogonal matrix
\item $m([\mathbf{B}, \mathbf{u}]) \geq \frac{1}{\sqrt{D}}$ if atom $\mathbf{u}$ is added to orthogonal basis $\mathbf{B}$ (o.n.b. = orthonormal base)
\end{inparaitem}
\textbf{Matching Pursuit (MP)}
approximation of $\mathbf{x}$ onto $\mathbf{U}$, using $K$ entries.
Objective: $\mathbf{z}^\star \in \argmin_{\mathbf{z}} \|\mathbf{x} - \mathbf{Uz} \|_2$, s.t. $\|\mathbf{z}\|_0 \leq K$
\begin{inparaenum}[\color{red}1.]
\item init: $z \leftarrow 0, r \leftarrow x$
\item while $\|\mathbf{z}\|_0 < K$ do
\item select atom with smallest angle $i^\star = \argmax_i |\langle \mathbf{u}_i, \mathbf{r} \rangle|$
\item update coefficients: $z_{i^\star} \leftarrow z_{i^\star} + \langle \mathbf{u}_{i^\star}, \mathbf{r} \rangle$
\item update residual: $\mathbf{r} \leftarrow \mathbf{r} - \langle \mathbf{u}_{i^\star}, \mathbf{r} \rangle \mathbf{u}_{i^\star}$.
\end{inparaenum}
\\\textbf{Exact recovery} when: $K<1/2( 1+1/m(\mathbf{U}))$
\textbf{Compressive Sensing}: Compress data while gathering:
\begin{inparaitem}[\color{red}\textbullet]
\item $\mathbf{x} \in \mathbb{R}^D$, $K$-sparse in o.n.b. $\mathbf{U}$. $\mathbf{y} \in \mathbb{R}^M$ with $y_i = \langle \mathbf{w}_i, \mathbf{x}\rangle $: $M$ lin. combinations of signal; $\mathbf{y} = \mathbf{Wx} = \mathbf{WUz} = \mathbf{\Theta z}$, $\Theta \in \mathbb{R}^{M \times D}$
\item Reconstruct $\mathbf{x} \in \mathbb{R}^D$ from $\mathbf{y}$; find $\mathbf{z}^\star \in \argmin_{\mathbf{z}}\|\mathbf{z}\|_0$, s.t. $\mathbf{y} = \mathbf{\Theta z}$ (e.g. with MP, or convex it with 1-norm: canbe eq!). Given $\mathbf{z}$, reconstruct $\mathbf{x} = \mathbf{Uz}$
\end{inparaitem}
\\Any orthogonal $\mathbf{U}$ sufficient if:
\begin{inparaitem}[\color{red}\textbullet]
\item $\mathbf{W} = $ Gaussian random projection, i.e. $w_{ij}\sim\mathcal{N}(0, \frac{1}{D})$
\item M $\geq cK log(\frac{D}{K})$, where $c$ is some constant
\end{inparaitem}
|
Formal statement is: lemma continuous_map_real_mult_left: "continuous_map X euclideanreal f \<Longrightarrow> continuous_map X euclideanreal (\<lambda>x. c * f x)" Informal statement is: If $f$ is a continuous real-valued function, then so is $c \cdot f$. |
#pragma once
#ifdef __CUDA_ARCH__
// Dummy class to eliminate warnings about usage of BigFloat when using __both__
struct BigFloat {
__both__ BigFloat() {}
template<typename T> __both__ BigFloat(const T&) {}
template<typename T> __both__ BigFloat(const T&, int prec) {}
__both__ operator double() const { return 0; }
template<typename T> __both__ BigFloat operator+(const T&) const { return {}; }
template<typename T> __both__ BigFloat operator-(const T&) const { return {}; }
template<typename T> __both__ BigFloat operator*(const T&) const { return {}; }
template<typename T> __both__ BigFloat operator/(const T&) const { return {}; }
template<typename T> __both__ BigFloat& operator+=(const T&) { return *this; }
template<typename T> __both__ BigFloat& operator-=(const T&) { return *this; }
template<typename T> __both__ BigFloat& operator*=(const T&) { return *this; }
template<typename T> __both__ BigFloat& operator/=(const T&) { return *this; }
__both__ static unsigned default_precision() { return 0; }
__both__ static void default_precision(unsigned) {}
};
BigFloat operator+(double, const BigFloat&) { return {}; }
BigFloat operator-(double, const BigFloat&) { return {}; }
BigFloat operator*(double, const BigFloat&) { return {}; }
BigFloat operator/(double, const BigFloat&) { return {}; }
BigFloat frexp(const BigFloat&, int*) { return {}; }
#else
#include <boost/multiprecision/mpfr.hpp>
using namespace boost::multiprecision;
using BigFloat = mpfr_float;
#endif
|
lemma lipschitz_on_cmult_real_upper [lipschitz_intros]: fixes f::"'a::metric_space \<Rightarrow> real" assumes "C-lipschitz_on U f" "abs(a) \<le> D" shows "(D * C)-lipschitz_on U (\<lambda>x. a * f x)" |
[STATEMENT]
lemma coclop_lsl_lsu: "coclop (\<nu> \<circ> \<nu>\<^sup>\<natural>)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. coclop (\<nu> \<circ> \<nu>\<^sup>\<natural>)
[PROOF STEP]
by (simp add: coclop_adj ls_galois) |
/-
Copyright (c) 2017 Robert Y. Lewis. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Author: Robert Y. Lewis
More about finite numbers.
-/
import data.nat.basic
open fin nat
/-- `fin 0` is empty -/
def fin_zero_elim {C : Sort*} : fin 0 → C :=
λ x, false.elim $ nat.not_lt_zero x.1 x.2
namespace fin
variables {n m : ℕ} {a b : fin n}
@[simp] protected lemma eta (a : fin n) (h : a.1 < n) : (⟨a.1, h⟩ : fin n) = a :=
by cases a; refl
protected lemma ext_iff (a b : fin n) : a = b ↔ a.val = b.val :=
iff.intro (congr_arg _) fin.eq_of_veq
lemma eq_iff_veq (a b : fin n) : a = b ↔ a.1 = b.1 :=
⟨veq_of_eq, eq_of_veq⟩
instance fin_to_nat (n : ℕ) : has_coe (fin n) nat := ⟨fin.val⟩
@[simp] def mk_val {m n : ℕ} (h : m < n) : (⟨m, h⟩ : fin n).val = m := rfl
instance {n : ℕ} : decidable_linear_order (fin n) :=
decidable_linear_order.lift fin.val (@fin.eq_of_veq _)
lemma zero_le (a : fin (n + 1)) : 0 ≤ a := zero_le a.1
lemma lt_iff_val_lt_val : a < b ↔ a.val < b.val := iff.refl _
lemma le_iff_val_le_val : a ≤ b ↔ a.val ≤ b.val := iff.refl _
@[simp] lemma succ_val (j : fin n) : j.succ.val = j.val.succ :=
by cases j; simp [fin.succ]
protected theorem succ.inj (p : fin.succ a = fin.succ b) : a = b :=
by cases a; cases b; exact eq_of_veq (nat.succ.inj (veq_of_eq p))
@[simp] lemma pred_val (j : fin (n+1)) (h : j ≠ 0) : (j.pred h).val = j.val.pred :=
by cases j; simp [fin.pred]
@[simp] lemma succ_pred : ∀(i : fin (n+1)) (h : i ≠ 0), (i.pred h).succ = i
| ⟨0, h⟩ hi := by contradiction
| ⟨n + 1, h⟩ hi := rfl
@[simp] lemma pred_succ (i : fin n) {h : i.succ ≠ 0} : i.succ.pred h = i :=
by cases i; refl
@[simp] lemma pred_inj :
∀ {a b : fin (n + 1)} {ha : a ≠ 0} {hb : b ≠ 0}, a.pred ha = b.pred hb ↔ a = b
| ⟨0, _⟩ b ha hb := by contradiction
| ⟨i+1, _⟩ ⟨0, _⟩ ha hb := by contradiction
| ⟨i+1, hi⟩ ⟨j+1, hj⟩ ha hb := by simp [fin.eq_iff_veq]
/-- The greatest value of `fin (n+1)` -/
def last (n : ℕ) : fin (n+1) := ⟨_, n.lt_succ_self⟩
/-- `cast_lt i h` embeds `i` into a `fin` where `h` proves it belongs into. -/
def cast_lt (i : fin m) (h : i.1 < n) : fin n := ⟨i.1, h⟩
/-- `cast_le h i` embeds `i` into a larger `fin` type. -/
def cast_le (h : n ≤ m) (a : fin n) : fin m := cast_lt a (lt_of_lt_of_le a.2 h)
/-- `cast eq i` embeds `i` into a equal `fin` type. -/
def cast (eq : n = m): fin n → fin m := cast_le $ le_of_eq eq
/-- `cast_add m i` embedds `i` in `fin (n+m)`. -/
def cast_add (m) : fin n → fin (n + m) := cast_le $ le_add_right n m
/-- `cast_succ i` embedds `i` in `fin (n+1)`. -/
def cast_succ : fin n → fin (n + 1) := cast_add 1
/-- `succ_above p i` embeds into `fin (n + 1)` with a hole around `p`. -/
def succ_above (p : fin (n+1)) (i : fin n) : fin (n+1) :=
if i.1 < p.1 then i.cast_succ else i.succ
/-- `pred_above p i h` embeds `i` into `fin n` by ignoring `p`. -/
def pred_above (p : fin (n+1)) (i : fin (n+1)) (hi : i ≠ p) : fin n :=
if h : i < p
then i.cast_lt (lt_of_lt_of_le h $ nat.le_of_lt_succ p.2)
else i.pred $
have p < i, from lt_of_le_of_ne (le_of_not_gt h) hi.symm,
ne_of_gt (lt_of_le_of_lt (zero_le p) this)
/-- `sub_nat i h` subtracts `m` from `i`, generalizes `fin.pred`. -/
def sub_nat (m) (i : fin (n + m)) (h : i.val ≥ m) : fin n :=
⟨i.val - m, by simp [nat.sub_lt_right_iff_lt_add h, i.is_lt]⟩
/-- `add_nat i h` adds `m` on `i`, generalizes `fin.succ`. -/
def add_nat (m) (i : fin n) : fin (n + m) :=
⟨i.1 + m, add_lt_add_right i.2 _⟩
/-- `nat_add i h` adds `n` on `i` -/
def nat_add (n) {m} (i : fin m) : fin (n + m) :=
⟨n + i.1, add_lt_add_left i.2 _⟩
theorem le_last (i : fin (n+1)) : i ≤ last n :=
le_of_lt_succ i.is_lt
@[simp] lemma cast_succ_val (k : fin n) : k.cast_succ.val = k.val := rfl
@[simp] lemma cast_lt_val (k : fin m) (h : k.1 < n) : (k.cast_lt h).val = k.val := rfl
@[simp] lemma cast_succ_cast_lt (i : fin (n + 1)) (h : i.val < n): cast_succ (cast_lt i h) = i :=
fin.eq_of_veq rfl
@[simp] lemma sub_nat_val (i : fin (n + m)) (h : i.val ≥ m) : (i.sub_nat m h).val = i.val - m :=
rfl
@[simp] lemma add_nat_val (i : fin (n + m)) (h : i.val ≥ m) : (i.add_nat m).val = i.val + m :=
rfl
@[simp] lemma cast_succ_inj {a b : fin n} : a.cast_succ = b.cast_succ ↔ a = b :=
by simp [eq_iff_veq]
lemma injective_cast_le {n₁ n₂ : ℕ} (h : n₁ ≤ n₂) : function.injective (fin.cast_le h)
| ⟨i₁, h₁⟩ ⟨i₂, h₂⟩ eq := fin.eq_of_veq $ show i₁ = i₂, from fin.veq_of_eq eq
theorem succ_above_ne (p : fin (n+1)) (i : fin n) : p.succ_above i ≠ p :=
begin
assume eq,
unfold fin.succ_above at eq,
split_ifs at eq with h;
simpa [lt_irrefl, nat.lt_succ_self, eq.symm] using h
end
@[simp] lemma succ_above_descend : ∀(p i : fin (n+1)) (h : i ≠ p), p.succ_above (p.pred_above i h) = i
| ⟨p, hp⟩ ⟨0, hi⟩ h := fin.eq_of_veq $ by simp [succ_above, pred_above]; split_ifs; simp * at *
| ⟨p, hp⟩ ⟨i+1, hi⟩ h := fin.eq_of_veq
begin
have : i + 1 ≠ p, by rwa [(≠), fin.ext_iff] at h,
unfold succ_above pred_above,
split_ifs with h1 h2; simp at *,
exact (this (le_antisymm h2 (le_of_not_gt h1))).elim
end
@[simp] lemma pred_above_succ_above (p : fin (n+1)) (i : fin n) (h : p.succ_above i ≠ p) :
p.pred_above (p.succ_above i) h = i :=
begin
unfold fin.succ_above,
apply eq_of_veq,
split_ifs with h₀,
{ simp [pred_above, h₀, lt_iff_val_lt_val], },
{ unfold pred_above,
split_ifs with h₁,
{ exfalso,
rw [lt_iff_val_lt_val, succ_val] at h₁,
exact h₀ (lt_trans (nat.lt_succ_self _) h₁) },
{ rw [pred_succ] } }
end
section rec
@[elab_as_eliminator] def succ_rec
{C : ∀ n, fin n → Sort*}
(H0 : ∀ n, C (succ n) 0)
(Hs : ∀ n i, C n i → C (succ n) i.succ) : ∀ {n : ℕ} (i : fin n), C n i
| 0 i := i.elim0
| (succ n) ⟨0, _⟩ := H0 _
| (succ n) ⟨succ i, h⟩ := Hs _ _ (succ_rec ⟨i, lt_of_succ_lt_succ h⟩)
@[elab_as_eliminator] def succ_rec_on {n : ℕ} (i : fin n)
{C : ∀ n, fin n → Sort*}
(H0 : ∀ n, C (succ n) 0)
(Hs : ∀ n i, C n i → C (succ n) i.succ) : C n i :=
i.succ_rec H0 Hs
@[simp] theorem succ_rec_on_zero {C : ∀ n, fin n → Sort*} {H0 Hs} (n) :
@fin.succ_rec_on (succ n) 0 C H0 Hs = H0 n :=
rfl
@[simp] theorem succ_rec_on_succ {C : ∀ n, fin n → Sort*} {H0 Hs} {n} (i : fin n) :
@fin.succ_rec_on (succ n) i.succ C H0 Hs = Hs n i (fin.succ_rec_on i H0 Hs) :=
by cases i; refl
@[elab_as_eliminator] def cases
{C : fin (succ n) → Sort*} (H0 : C 0) (Hs : ∀ i : fin n, C (i.succ)) :
∀ (i : fin (succ n)), C i
| ⟨0, h⟩ := H0
| ⟨succ i, h⟩ := Hs ⟨i, lt_of_succ_lt_succ h⟩
@[simp] theorem cases_zero {n} {C : fin (succ n) → Sort*} {H0 Hs} : @fin.cases n C H0 Hs 0 = H0 :=
rfl
@[simp] theorem cases_succ {n} {C : fin (succ n) → Sort*} {H0 Hs} (i : fin n) :
@fin.cases n C H0 Hs i.succ = Hs i :=
by cases i; refl
end rec
end fin
|
using DistCtrl4DistMan
using LinearAlgebra
using Test
# @testset "DistCtrl4DistMan.jl" begin
# end
@testset "ObjectAgentModule.jl" begin
include("test_data.jl")
@testset "Test - MAG" begin# Used types
F = Float64;
U = UInt64;
# Load test data
Gxy_ref, MAG_test_currents, MAG_fi_ref, MAG_F_ref = test_data_MAG();
n = U(8);
dx = F(25e-3);
aa = DistCtrl4DistMan.ActuatorArray(n, n, dx, dx, :coil);
ball_pos = ( (n-1)*dx/2 - dx/2, (n-1)*dx/2 + 1.3*dx );
# calcMAGForce() and fi() test values
fi_test = DistCtrl4DistMan.ObjectAgentModule.mag_fi(MAG_test_currents);
F_MAG = DistCtrl4DistMan.calcMAGForce(aa, ball_pos, fi_test);
aL, a_used = DistCtrl4DistMan.genActList(aa, (ball_pos[1], ball_pos[2], F(0)), F(2.5*dx), F(3.5*dx));
oa_mag = DistCtrl4DistMan.ObjectAgent_MAG("Agent_MAG", ball_pos, F_MAG, aa, aL, a_used, F(1));
@testset "Test the function generating the Gxy matrix" begin
@test DistCtrl4DistMan.ObjectAgentModule.genGxy(aa, ball_pos) ≈ Gxy_ref
end
@testset "Test the function fi()" begin
@test fi_test ≈ MAG_fi_ref
end
@testset "Test the function calcMagForce()" begin
@test all(F_MAG .≈ MAG_F_ref)
end
end
@testset "Test - DEP" begin
# Used types
F = Float64;
U = UInt64;
# Load test data
Gamma_ref, Lambda_x, Lambda_y, Lambda_z, DEP_test_phases, DEP_F_ref = test_data_DEP();
n = U(5);
dx = F(100e-6);
aa = DistCtrl4DistMan.ActuatorArray(n, n, dx, dx/2, :square);
center_pos = ( (n-1)*dx/2, (n-1)*dx/2, F(100e-6));
F_DEP = DistCtrl4DistMan.calcDEPForce(aa, center_pos, DEP_test_phases);
aL, a_used = DistCtrl4DistMan.genActList(aa, center_pos, F(350e-6), F(350e-6));
oa_dep = DistCtrl4DistMan.ObjectAgent_DEP("Agent1", center_pos, F_DEP, aa, aL, a_used);
@testset "Test the function generating the Gamma and Lambda_a marices" begin
Gamma_test, Lambda_a = DistCtrl4DistMan.ObjectAgentModule.genC_DEP(aa, center_pos);
@test Gamma_ref ≈ Gamma_test
@test Lambda_a[1] ≈ Lambda_x
@test Lambda_a[2] ≈ Lambda_y
@test Lambda_a[3] ≈ Lambda_z
end
@testset "Test the function calculating the DEP force" begin
@test all(F_DEP .≈ DEP_F_ref)
end
@testset "Test the cost function" begin # The cost function (oa_dep,fvk) should be zero since we set oa_dep.vk_r and oa_dep.vk_i to values which should result in the desired force
# Calculate the cost function (oa_dep.fvk)
oa_dep.vk_r = cos.(DEP_test_phases'[:]);
oa_dep.vk_i = sin.(DEP_test_phases'[:]);
DistCtrl4DistMan.costFun!(oa_dep);
@test all( abs.(oa_dep.fvk) .< [1,1,1].*1e-6 )
end
end
@testset "Test - ACU" begin
# Used types
F = Float64;
U = UInt64;
# Load test data
C1ref, C2ref, th1, th2, objVal1_ref, objVal2_ref, D1ref, D2ref, phases_test, p1_ref, p2_ref = test_data_ACU();
n = U(8);
dx = F(10.0e-3);
aa = DistCtrl4DistMan.ActuatorArray(n, n, dx);
# two agents at positions close to the center
z0 = F(-50e-3);
maxDist1 = 3*dx; #2
maxDist2 = 3*dx; #3
oa1_pos = ((n-1)*aa.dx/2-dx, (n-1)*aa.dx/2, z0);
oa2_pos = ((n-1)*aa.dx/2+dx, (n-1)*aa.dx/2+1.6f0*dx, z0);
Pdes = F(1000); # desired presure (same for both agents)
# Generate list of used actuators for each object agent
aL1, a_used1 = DistCtrl4DistMan.genActList(aa, oa1_pos, maxDist1, maxDist2);
aL2, a_used2 = DistCtrl4DistMan.genActList(aa, oa2_pos, maxDist1, maxDist2);
oa1 = DistCtrl4DistMan.ObjectAgent_ACU("Agent1", oa1_pos, Pdes, aa, aL1, a_used1);
oa2 = DistCtrl4DistMan.ObjectAgent_ACU("Agent2", oa2_pos, Pdes, aa, aL2, a_used2);
@testset "Test the function generating the C matrix" begin
@test isapprox(oa1.zvec*oa1.zvec' + 1im*oa1.zvec*[0 1; -1 0]*oa1.zvec', C1ref, atol=1e-6)
@test isapprox(oa2.zvec*oa2.zvec' + 1im*oa2.zvec*[0 1; -1 0]*oa2.zvec', C2ref, atol=1e-6)
end
@testset "Test the cost function" begin
oa1.vk_r = cos.(th1);
oa1.vk_i = sin.(th1);
oa2.vk_r = cos.(th2);
oa2.vk_i = sin.(th2);
# Compute the values of the cost function (oa.fvk)
DistCtrl4DistMan.costFun!(oa1)
DistCtrl4DistMan.costFun!(oa2)
@test isapprox(oa1.fvk[1], objVal1_ref, atol=1e-5)
@test isapprox(oa2.fvk[1], objVal2_ref, atol=1e-5)
end
@testset "Test the cost function calculating the jacobian" begin
# Compute the jacobians
DistCtrl4DistMan.ObjectAgentModule.jac!(oa1);
DistCtrl4DistMan.ObjectAgentModule.jac!(oa2);
@test isapprox(oa1.J, D1ref', atol=1e-6)
@test isapprox(oa2.J, D2ref', atol=1e-6)
end
@testset "Test the function calculating the pressure" begin
@test isapprox(DistCtrl4DistMan.calcPressure(aa, oa1_pos, convert.(F, phases_test)), F(p1_ref), atol=1e-4)
@test isapprox(DistCtrl4DistMan.calcPressure(aa, oa2_pos, convert.(F, phases_test)), F(p2_ref), atol=1e-4)
end
@testset "Test the function finding the shared actuators among agents (function from ActuatorArray module)" begin
DistCtrl4DistMan.resolveNeighbrRelations!([oa1, oa2])
@test oa1.actList[oa1.neighbors[1][2]] == oa2.actList[oa1.neighbors[1][3]]
@test oa2.actList[oa2.neighbors[1][2]] == oa1.actList[oa2.neighbors[1][3]]
end
end
end
@testset "ActuatorArray tests" begin
# Used types
F = Float64;
U = UInt64;
# Load test data
aL1_ref = Array{Tuple{UInt8,UInt8},1}([(1, 3), (1, 4), (1, 5), (1, 6), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2,7), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 2), (5, 3),(5, 4), (5, 5), (5, 6), (5, 7), (6, 3), (6, 4), (6, 5), (6, 6)]);
aL2_ref = Array{Tuple{UInt8,UInt8},1}([(3, 5), (3, 6), (3, 7), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (8, 5), (8, 6), (8, 7)]);
n = U(8);
dx = F(10.0e-3);
aa = DistCtrl4DistMan.ActuatorArray(n, n, dx);
# two agents at positions close to the center
z0 = F(-50e-3);
maxDist1 = 3*dx; #2
maxDist2 = 3*dx; #3
oa1_pos = ((n-1)*aa.dx/2-dx, (n-1)*aa.dx/2, z0);
oa2_pos = ((n-1)*aa.dx/2+dx, (n-1)*aa.dx/2+1.6f0*dx, z0);
# Generate list of used actuators for each object agent
aL1, a_used1 = DistCtrl4DistMan.genActList(aa, oa1_pos, maxDist1, maxDist2);
aL2, a_used2 = DistCtrl4DistMan.genActList(aa, oa2_pos, maxDist1, maxDist2);
@testset "Test the function generating the actuator list" begin
@test aL1 == aL1_ref
@test aL2 == aL2_ref
end
end
@testset "LinSolvers.jl package tests" begin
n = 100;
m = 5;
@testset "Test backward and forward substitution for solution of R^T*Rx=b" begin
for i=1:20
R = Matrix(UpperTriangular(rand(n,n) + I));
A = R'*R;
x_test = rand(n);
b_test = A*x_test;
b = copy(b_test)
DistCtrl4DistMan.LinSolvers.forward_substitution!(R, b)
DistCtrl4DistMan.LinSolvers.backward_substitution!(R, b)
x_sol = b;
@test A*x_sol ≈ b_test
end
end
@testset "Test solving of (D^T*D + 1/λ*I)x=D^T*b by kernel_solve!()" begin
x_sol = zeros(n);
lsd = DistCtrl4DistMan.LinSystemData(n, m, x_sol);
λ = 1.0e3;
for i in 1:20
Dt = rand(n,m);
b = rand(m);
DistCtrl4DistMan.kernel_solve!(lsd, Dt, λ, b);
@test (Dt*Dt' + 1/λ*I)*x_sol ≈ Dt*b
end
end
@testset "Test solving of (D^T*D + 1/λ*I)x=D^T*b by kernel_solve()" begin
λ = 1.0e3;
for i in 1:20
Dt = rand(n,m);
b = rand(m);
x_sol = DistCtrl4DistMan.kernel_solve(Dt, λ, b);
@test (Dt*Dt' + 1/λ*I)*x_sol ≈ Dt*b
end
end
@testset "Test solving of (D^T*D + 1/λ*I)x=D^T*b by kernel_solve_prealloc!()" begin
λ = 1.0e3;
x_sol = zeros(n);
A_prealloc = zeros(m+n,m);
b_prealloc = zeros(m);
R_prealloc = zeros(m,m);
for i in 1:20
Dt = rand(n,m);
b = rand(m);
DistCtrl4DistMan.LinSolvers.kernel_solve_prealloc!(Dt, λ, b, x_sol, A_prealloc, b_prealloc, R_prealloc);
@test (Dt*Dt' + 1/λ*I)*x_sol ≈ Dt*b
end
end
@testset "Test qr_r!() function" begin
for i in 1:20
A = rand(n,m);
R = zeros(m,m);
# Compute the upper triangular R matrix from QR factorization by qr_r!()
# Matrix A is modified in qr_r!(), that is why we use copy of it as an argument
DistCtrl4DistMan.LinSolvers.qr_r!(copy(A), R);
# Compute the cholesky factor of AᵀA which has to match to R
C = cholesky(A'*A);
@test C.U ≈ R
end
end
end
@testset "Test - ADMM" begin
F = Float64;
U = UInt64;
n = U(8);
dx = F(25e-3);
aa = DistCtrl4DistMan.ActuatorArray(n, n, dx, dx, :coil);
# Set the maximum distance so that both agents use all the coils
maxdist = n*dx;
for i in 1:20
# Generate random positions of the agents
ball_pos1 = ( dx*(n-1)*rand(), dx*(n-1)*rand());
ball_pos2 = ( dx*(n-1)*rand(), dx*(n-1)*rand());
# Generate the desired forces so that one can actually generate them
random_ctrls = rand(F, n, n);
F_des1 = DistCtrl4DistMan.calcMAGForce(aa, ball_pos1, random_ctrls)
F_des2 = DistCtrl4DistMan.calcMAGForce(aa, ball_pos2, random_ctrls)
# Initialize the agents
aL1, a_used1 = DistCtrl4DistMan.genActList(aa, (ball_pos1[1], ball_pos1[2], F(0)), maxdist, maxdist);
aL2, a_used2 = DistCtrl4DistMan.genActList(aa, (ball_pos2[1], ball_pos2[2], F(0)), maxdist, maxdist);
oa1 = DistCtrl4DistMan.ObjectAgent_MAG("Agent 1", ball_pos1, F_des1, aa, aL1, a_used1, F(1));
oa2 = DistCtrl4DistMan.ObjectAgent_MAG("Agent 2", ball_pos2, F_des2, aa, aL2, a_used2, F(1));
agents = [oa1, oa2];
DistCtrl4DistMan.admm(agents,
λ = 1.0, ρ = 1.0,
log = false,
maxiter = 1000,
method = :freedir);
F_dev1 = tuple((oa1.Gxy'*oa1.zk*oa1.Fdes_sc)...)
F_dev2 = tuple((oa2.Gxy'*oa2.zk*oa2.Fdes_sc)...)
@test all(isapprox.(F_dev1, F_des1, atol=1e-4))
@test all(isapprox.(F_dev2, F_des2, atol=1e-4))
end
end
|
!-------------------------------------------------------------------
! class-hpc-smoke-ring: A simple sample field solver.
!
! by Akira Kageyama, Kobe University, Japan.
! email: [email protected]
!
! Copyright 2018 Akira Kageyama
!
! This software is released under the MIT License.
!
!-------------------------------------------------------------------
! src/job.f90
!-------------------------------------------------------------------
module job_m
use constants_m
use ut_m
implicit none
private
public :: & !<variable>
job__karte
public :: & !<routines>
job__finalize
type, public :: job__karte_t
character(len=20) :: state = "fine"
contains
procedure :: set => job__karte_set
end type job__karte_t
type(job__karte_t) :: job__karte
contains
subroutine job__finalize(nloop)
integer(DI), intent(in) :: nloop
select case (trim(job__karte%state))
case ("fine", "loop_max")
call ut__message('#',"Successfully finished.")
case ("time_out")
call ut__message('-',"Time out at nloop = ", nloop)
case ("over_flow")
call ut__message('%',"Overflow at nloop = ", nloop)
case ("negative_anormaly")
call ut__message('%',"Underflow at nloop = ",nloop)
case default
call ut__message('?',"Stopped at nloop = ", nloop)
end select
end subroutine job__finalize
subroutine job__karte_set(self, state_)
class(job__karte_t), intent(out) :: self
character(len=*), intent(in) :: state_
select case (trim(state_))
case ("fine")
self%state = "fine"
case ("time_out")
self%state = "time_out"
case ("loop_max")
self%state = "loop_max"
case ("over_flow")
self%state = "over_flow"
case ("negative_anormaly")
self%state = "negative_anormaly"
case default
call ut__fatal("<job__karte_set> case error.")
end select
end subroutine job__karte_set
end module job_m
|
The DEBUT of the greatest super-band since the Traveling Wilburys, Crosby, Stills, Nash & Young, or The Highwaymen.
These trad jazz superstars abandon their roots to play some pop and rock ‘n roll.
We think we know what we’re doing; PWYC to be sure. |
center = 5
sigma = 2
mf = GaussianMF(center, sigma)
# Evaluation tests
@assert mf.eval(center + sigma) == exp(-0.5)
@assert mf.eval(center) == 1
@assert mf.eval(center + sigma) == mf.eval(center - sigma)
# Mean finding tests
@assert mf.mean_at(1) == mf.mean_at(0.6) == mf.mean_at(0.3) == mf.mean_at(0) == center
|
\documentclass{article}
\usepackage{amsmath,amsthm,amssymb}
\title{Uniform estimates for fourier restriction to complex polynomial curves in $\mathbb{R^d}$}
\author{Jaume de Dios Pont}
\newtheorem{thm}{Theorem}
\newtheorem{defi}{Definition}
\begin{document}
\maketitle
\abstract{
This is the first instance of a uniform optimal estimate (not including the endpoint) for families of surfaces of dimension>1. On the other hand, they are still on the specific $d|cod$, which seems to be easier.
}
\section{Introduction}
\begin{thm}
For each $N,d$ and $(p,q)$ satisfying:
\begin{equation}
p' = \frac{d(d+1)}{2} q, \;\; q> \frac{d^2+d+2}{d^2+d}
\end{equation}
there is a constant $C_{N,d,p}$ such that for all polynomials $\gamma: \mathbb C \to \mathbb C^d$ of degree up to $N$ we have:
\begin{equation}
\|\hat f\|_{L^q(d\lambda_\gamma)} \le C_{N,d,p} \|f\|_{L^q(dx)}
\end{equation}
for all Schwartz functions $f$.
\end{thm}
We will instead prove the dual problem, showing boundedness of the adjoint (extension) operator $\mathcal E_\gamma$.
\section{Uniform Local restriction}
\begin{defi}
For a polynomial $\gamma: \mathbb C \to \mathbb C^d$ we define $$L_\gamma(z) := \det(\gamma'(z), \gamma^{(2)}(z), \dots,\gamma^{d}(z))$$ $$J_\gamma(z_1, \dots , z_d) = \det(\gamma'(z_1), \dots, \gamma'(z_d))$$
\end{defi}
In this section we will prove the following result:
\begin{thm}
Fix $d>2$, $N$, and a feasible $(p,q)$ pair. For every triangular set $S\subset \mathbb C^d$ and every degree $N$ polynomial $\gamma: \mathbb C \to \mathbb C^d$ satisfying:
\begin{equation}
0 < C_1 \le \Re \, L_\gamma(z)
\end{equation}
\begin{equation}
|L_\gamma(z)| \le C_2 < \infty
\end{equation}
in S we have the extension estimate:
\begin{equation}
\|\mathcal E_\gamma \|_{L^q} \le C_{d,N, \frac {C_1}{C_2}}\|f\|_{L^p(d\lambda_\gamma)}
\end{equation}
\end{thm}
Without loss of generality, we can split in a controlled number of triangles, and assume $C_1 = \frac 1 2$, $C_2=2$.
\section{$\epsilon-$aligned sets, $\epsilon-$aligned functions} % (fold)
\label{sec:section_name}
The main idea of the paper is to uniformly partition
\begin{defi}[$\epsilon-$aligned set] We say that a list $S = (z_1, .. z_n)$ is $\epsilon-$aligned in a direction $s \in C\setminus 0$ if $\arg{(s^{-1}(z_i-z_j))} \in [-\pi +\epsilon,\pi -\epsilon]$ whenever\footnote{we use the convention $\arg(0) = 0$} $i<j$. (or, equivalently, whenever $j=i+1$). Given a list $s$ let $A_\epsilon(S)$ be the set of $s$ such that $S$ is $\epsilon$-aligned with respect to $s$
\end{defi}
\begin{defi} ()
Given two lists $S = (z_1, \dots z_n)$, $T=(w_1, \dots w_{n+1})$ we say $T> S$ if $w_i$ is a real convex combination of $z_i,z_i+1$. We extend the relationship by transitivity to arbitrary tuples.
\end{defi}
Now, it is an easy to see that that $S>T$ implies that $A_\epsilon(S) \subseteq A_\epsilon(T)$.\\
\textbf{Decomposition procedure D1'}
There exists a decomposition of a rational function $m(z)$onto $O_{\epsilon, N}(1)$ convex sets $C_i$, such that there exists $w_i, c_i \in \mathbb C$, $n_i \in \mathbb N$, such that on each $c_i$:
\begin{equation}
\frac{p(z)}{w_i(z-c_i)^n} \in B(1,\epsilon)
\end{equation}
Using this lemma, \\
\textbf{Partition for injectivity:}
Let $P(x) = (x-x_i)^k_i$. Do $\epsilon$ partitions for the jacobian and all the involved polynomials and their derivatives. Assume you are in one of the $\epsilon-$regions where the Jacobian does not vanish first. You can write
\section{Uncoordinated polynomials} % (fold)
\label{sec:uncoordinated_polynomials}
In this section we will study functions that $\epsilon-$look like polynomials (in the sense above), and whose derivatives also $\epsilon-$look like polynomials.
Note that $P =_\epsilon Q$ in $D$ does not imply $P'=_\epsilon Q$ in $D$
Want to solve: $\sigma_M(\vec x) = \sum M(x_i) = 0$
$$d\Sigma_M = \frac 1 {K!} V(x_i)$$
$p(z) = z^p$
$z' = - p z^{p-1} p(z) = -p z$
% section uncoordinated_polynomials (end)
% section section_name (end)
\end{document}
|
#include "cyk_file_tools.h"
#include <iterator>
#include <algorithm>
#include <boost/filesystem.hpp>
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/xml_parser.hpp>
using namespace std;
using namespace boost::filesystem;
//cyk_file_tools::cyk_file_tools()
//{
//}
//
//cyk_file_tools::~cyk_file_tools()
//{
//}
int cyk_file_tools::get_file_contents(const std::string& path_, vector<std::string>& contents_str, std::string name_extension, bool if_show)
{
int count_files;
vector<path> pathes;
//vector<string> paths_str;
path p(path_); // p reads clearer than argv[1] in the following code
try
{
if (exists(p)) // does p actually exist?
{
if (is_regular_file(p)) // is p a regular file?
cout << p << " size is " << file_size(p) << '\n';
else if (is_directory(p)) // is p a directory?
{
if (if_show)
cout << p << " is a directory containing:\n";
copy(directory_iterator(p), directory_iterator(), back_inserter(pathes));
for (auto iter = pathes.begin(); iter != pathes.end(); iter++){
if (name_extension == "*" || name_extension == iter->extension().generic_string())
{
contents_str.push_back(iter->generic_string());
if (if_show)
cout << contents_str.back() << endl;
}
}
}
else
cout << p << " exists, but is neither a regular file nor a directory\n";
}
else
cout << p << " does not exist\n";
return contents_str.size();
}
catch (const filesystem_error& ex)
{
cout << ex.what() << '\n';
return -1;
}
}
bool cyk_file_tools::filename_compare(string a, string b, string prefix)
{
int length_prefix = prefix.length();
a = a.substr(length_prefix, a.length() - length_prefix);
b = b.substr(length_prefix, b.length() - length_prefix);
if (a.substr(0, 1)=="/")
a = a.substr(1, a.length()-1);
if (b.substr(0, 1)=="/")
b = b.substr(1, b.length()-1);
int num_a = stoi(a);
int num_b = stoi(b);
return num_a < num_b;
}
int cyk_file_tools::sort_filename(std::vector<string>& filenames, string prefix)
{
if (filenames.empty())
{
return 0;
}
sort(filenames.begin(), filenames.end(), [prefix](string a, string b)->bool{return filename_compare(a, b, prefix);});
string tmp_str = filenames[filenames.size()-1];
tmp_str = tmp_str.substr(prefix.length(), tmp_str.length()-prefix.length());
if (tmp_str.substr(0, 1)=="/")
tmp_str = tmp_str.substr(1, tmp_str.length()-1);
// std::cout << tmp_str << std::endl;
return stoi(tmp_str);
}
|
Jack and Jill went up the hill
|
If $d$ and $e$ are positive real numbers, then the spheres of radius $d$ and $e$ centered at $a$ and $b$ are homeomorphic. |
lemma Bseq_eq_bounded: "range f \<subseteq> {a..b} \<Longrightarrow> Bseq f" for a b :: real |
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
#pragma once
#include <codecvt>
#include <string>
#include <locale>
#include <gsl/gsl>
namespace mira
{
inline std::string utf16_to_utf8(const wchar_t* input)
{
std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
return converter.to_bytes(input);
}
inline std::wstring utf8_to_utf16(const char* input)
{
std::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
return converter.from_bytes(input);
}
inline std::string utf16_to_utf8(const std::wstring& input)
{
return utf16_to_utf8(input.data());
}
inline std::wstring utf8_to_utf16(const std::string& input)
{
return utf8_to_utf16(input.data());
}
struct string_compare
{
using is_transparent = std::true_type;
bool operator()(gsl::cstring_span<> a, gsl::cstring_span<> b) const
{
return std::lexicographical_compare(a.begin(), a.end(), b.begin(), b.end());
}
bool operator()(gsl::czstring_span<> a, gsl::czstring_span<> b) const
{
return (*this)(a.as_string_span(), b.as_string_span());
}
bool operator()(const char* a, const char* b) const
{
return strcmp(a, b) < 0;
}
};
}
|
------------------------------------------------------------------------------
-- Properties related with lists of natural numbers
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS --without-K #-}
module FOTC.Data.Nat.List.PropertiesATP where
open import FOTC.Base
open import FOTC.Base.List
open import FOTC.Data.Nat.List
open import FOTC.Data.List
------------------------------------------------------------------------------
++-ListN : ∀ {ms ns} → ListN ms → ListN ns → ListN (ms ++ ns)
++-ListN {ns = ns} lnnil nsL = prf
where postulate prf : ListN ([] ++ ns)
{-# ATP prove prf #-}
++-ListN {ns = ns} (lncons {m} {ms} Nd LNms) LNns = prf (++-ListN LNms LNns)
where postulate prf : ListN (ms ++ ns) → ListN ((m ∷ ms) ++ ns)
{-# ATP prove prf #-}
|
Image Title: Kenroy Home Hatteras Outdoor Floor Lamp Chocolate Within Lamps Ideas 9. Post Title: Outdoor Floor Lamps. Filename: kenroy-home-hatteras-outdoor-floor-lamp-chocolate-within-lamps-ideas-9.jpg. Image Dimension: 747 x 1000 pixels. Images Format: jpg/jpeg. Publisher/Author: Ahmed Schuster. Uploaded Date: Thursday - October 18th. 2018 11:39:23 AM. Category: Architecture. Image Source: housetohome.co.uk. Miami F3 Outdoor Floor Lamp By Anton Angeli Interior Deluxe Within Lamps Ideas 0. Outdoor Floor Lamps To Use In A Deck Or Patio Regarding Plan 14. Outdoor Decorative Floor Lamps Exterior Portable Patio Lights With Remodel 4. Great Deals On Crate Barrel Prism Outdoor Floor Lamp Lamps Regarding Plan 17. Sasha Outdoor Floor Carpyen For Lamps Prepare 11. Outdoor Floor Lamps YLighting With Decor 12. Kenroy Home Hatteras Outdoor Floor Lamp Chocolate Within Lamps Ideas 9. Outdoor Floor Lamps To Use In A Deck Or Patio Decor Regarding 2. Orleon Outdoor Floor Lamp Lights Co Uk Within Lamps Remodel 7. Original 1227 Giant Outdoor Floor Lamp I Shop Now At The Longest Stay Inside Lamps Ideas 16. |
(* Title: HOL/Auth/n_mutualExDeadFree_lemma_inv__5_on_rules.thy
Author: Yongjian Li and Kaiqiang Duan, State Key Lab of Computer Science, Institute of Software, Chinese Academy of Sciences
Copyright 2016 State Key Lab of Computer Science, Institute of Software, Chinese Academy of Sciences
*)
header{*The n_mutualExDeadFree Protocol Case Study*}
theory n_mutualExDeadFree_lemma_inv__5_on_rules imports n_mutualExDeadFree_lemma_on_inv__5
begin
section{*All lemmas on causal relation between inv__5*}
lemma lemma_inv__5_on_rules:
assumes b1: "r \<in> rules N" and b2: "(\<exists> p__Inv0 p__Inv1. p__Inv0\<le>N\<and>p__Inv1\<le>N\<and>p__Inv0~=p__Inv1\<and>f=inv__5 p__Inv0 p__Inv1)"
shows "invHoldForRule s f r (invariants N)"
proof -
have c1: "(\<exists> i. i\<le>N\<and>r=n_Try i)\<or>
(\<exists> i. i\<le>N\<and>r=n_Crit i)\<or>
(\<exists> i. i\<le>N\<and>r=n_Exit i)\<or>
(\<exists> i. i\<le>N\<and>r=n_Idle i)"
apply (cut_tac b1, auto) done
moreover {
assume d1: "(\<exists> i. i\<le>N\<and>r=n_Try i)"
have "invHoldForRule s f r (invariants N)"
apply (cut_tac b2 d1, metis n_TryVsinv__5) done
}
moreover {
assume d1: "(\<exists> i. i\<le>N\<and>r=n_Crit i)"
have "invHoldForRule s f r (invariants N)"
apply (cut_tac b2 d1, metis n_CritVsinv__5) done
}
moreover {
assume d1: "(\<exists> i. i\<le>N\<and>r=n_Exit i)"
have "invHoldForRule s f r (invariants N)"
apply (cut_tac b2 d1, metis n_ExitVsinv__5) done
}
moreover {
assume d1: "(\<exists> i. i\<le>N\<and>r=n_Idle i)"
have "invHoldForRule s f r (invariants N)"
apply (cut_tac b2 d1, metis n_IdleVsinv__5) done
}
ultimately show "invHoldForRule s f r (invariants N)"
by satx
qed
end
|
She was referred to as a " young activist in the Maryhill Branch of the ILP " , before she joined the WSPU in 1909 , aged 16 . She was the youngest member of the WSPU Glasgow delegation to the Chancellor of the Exchequer David Lloyd George in 1912 . As a member of the WSPU and organiser of the Domestic Workers ' Union , she led the first of the " Scottish Outrages " ( involving attacks on pillar boxes ) in Glasgow in February 1913 .
|
lemma LIMSEQ_inverse_real_of_nat_add: "(\<lambda>n. r + inverse (real (Suc n))) \<longlonglongrightarrow> r" |
#ABRS_behavior_analysis
import numpy as np
import scipy
from scipy import ndimage
from scipy import misc
import pickle
import pandas as pd
import time
import matplotlib.pyplot as plt
import cv2
import os
from ABRS_modules import discrete_radon_transform
from ABRS_modules import etho2ethoAP
from ABRS_modules import smooth_1d
from ABRS_modules import create_LDA_training_dataset
from ABRS_modules import removeZeroLabelsFromTrainingData
from ABRS_modules import computeSpeedFromPosXY
from ABRS_data_vis import create_colorMat
from ABRS_data_vis import cmapG
def remove_empty_ethograms (ethoMat,minBeh = 10000):
shEthoMat = np.shape(ethoMat)
ethoMatBin = np.zeros((shEthoMat[0],shEthoMat[1]))
ethoMatBin[ethoMat != 7] = 1
sumCol = np.sum(ethoMatBin,1)
sumInd = np.where(sumCol<minBeh)
ethoMatFull = np.zeros((shEthoMat[0]-np.shape(sumInd)[1],shEthoMat[1]))
ind=0;
for i in range(0,shEthoMat[0]):
if sumCol[i]>minBeh:
ethoMatFull[ind,:] = ethoMat[i,:]
ind = ind+1
return ethoMatFull
def get_behavior_probability(idx):
shIdx = np.shape(idx)
idxBin = np.zeros((1,shIdx[1]))
probVect = np.zeros((int(np.max(idx)+1),1))
for b in range(1,int(np.max(idx))+1):
idxBin = np.zeros((1,shIdx[1]))
idxBin[idx == b] = 1
probVect[b-1,0] = np.sum(idxBin)
return probVect
def get_probability_progression(ethoMat):
shEthoMat = np.shape(ethoMat)
ethoMatBin = np.zeros((shEthoMat[0],shEthoMat[1]))
windSize = 1000
stepWin = 1
probMat = np.zeros((int(np.max(ethoMat)+1),shEthoMat[1]-windSize))
for b in range(1,int(np.max(ethoMat))+1):
ethoMatBin = np.zeros((shEthoMat[0],shEthoMat[1]))
ethoMatBin[ethoMat == b] = 1
#print(b)
for i in range(0,np.shape(ethoMatBin)[1]-windSize,stepWin):
probMat[b-1,i] = np.sum(ethoMatBin[:,i:i+windSize])
return probMat
def get_durations (idx):
shIdx = np.shape(idx)
ind_d=0
ind=1
durCol=np.zeros((3,1))
durRec=np.zeros((3,1))
for i in range(1,shIdx[1]):
if idx[0,i]!= idx[0,i-1] or i==0 or i==shIdx[1]:
ident=idx[0,i-1]
#print(ident)
dur=ind_d
durCol[0,0]=ident
durCol[1,0]=dur
durCol[2,0]=i
if i == 1:
durRec = durCol
if i > 1:
durRec = np.hstack((durRec,durCol))
ind_d=0
ind=ind+1
ind_d=ind_d+1
return durRec
def get_syntax (idx):
idx1 = idx
idx2=np.zeros((1,np.shape(idx1)[1]))
idx2[0,0:np.shape(idx1)[1]-1] = idx1[0,1:np.shape(idx1)[1]]
TFmat = np.zeros((7,7))
for i in range(0,np.shape(idx1)[1]):
TFmat[int(idx1[0,i])-1,int(idx2[0,i])-1] = TFmat[int(idx1[0,i])-1,int(idx2[0,i])-1]+1
TPmat=TFmat/np.shape(idx1)[1]
TPmatNorm = np.zeros((7,7))
for i in range(0,7):
TPmatNorm[:,i]=TPmat[:,i]/np.sum(TPmat[:,i])
TPnoSelf = TPmat
for i in range(0,7):
TPnoSelf[i,i] = 0
sc = np.sum(TPnoSelf[i,:])
if sc > 0:
TPnoSelf[i,:] = TPnoSelf[i,:]/sc
return TFmat, TPmat, TPmatNorm, TPnoSelf
def etho2ethoAP (idx):
sh = np.shape(idx);
idxAP = np.zeros((1,sh[1]))
idxAP[0,idx[0,:]==1]=1
idxAP[0,idx[0,:]==2]=1
idxAP[0,idx[0,:]==3]=2
idxAP[0,idx[0,:]==4]=2
idxAP[0,idx[0,:]==5]=2
idxAP[0,idx[0,:]==6]=3
return idxAP
def remove_zeros_from_etho (idx):
shIdx = np.shape(idx)
idxNew = np.zeros((shIdx[0],shIdx[1]))
for i in range(0,shIdx[1]):
idxNew[0,i]=idx[0,i]
if idx[0,i] == 0:
idxNew[0,i]=idxNew[0,i-1]
return idxNew
def post_process_etho (idx):
shIdx = np.shape(idx)
idxAP = etho2ethoAP (idx)
#durRecG = get_durations (idx);#np.mean(durRec[1,:])
durRecAP = get_durations (idxAP);
idxNew = np.zeros((1,shIdx[1]))
idxNew[0,0:shIdx[1]] = idx[0,0:shIdx[1]]
idxS = idx
minDurWalk=5;
minDurSilence=5;
minDurAPW=10;
minDurAPA=30;
durRecAP = get_durations (idxAP)
shDurRecAP = np.shape(durRecAP)
for d in range(1,shDurRecAP[1]-1):
if durRecAP[0,d] == 3 and durRecAP[1,d] < minDurWalk:
#print(durRecAP[1,d])
idxNew[0,int(durRecAP[2,d-1]): int(durRecAP[2,d]-1)] = idxS[0,int(durRecAP[2,d-1]-1)]
if durRecAP[0,d] == 1 and durRecAP[0,d-1] == 2 and durRecAP[0,d+1] == 2 and durRecAP[1,d] < minDurAPA and \
durRecAP[1,d] < durRecAP[1,d-1] and durRecAP[0,d] < durRecAP[1,d+1]:
idxNew[0,int(durRecAP[2,d-1]): int(durRecAP[2,d]-1)] = idxS[0,int(durRecAP[2,d-1]-1)]
if durRecAP[0,d] == 2 and durRecAP[0,d-1] == 1 and durRecAP[0,d+1] == 1 and durRecAP[1,d] < minDurAPA and \
durRecAP[1,d] < durRecAP[1,d-1] and durRecAP[1,d] < durRecAP[1,d+1]:
idxNew[0,int(durRecAP[2,d-1]): int(durRecAP[2,d]-1)] = idxS[0,int(durRecAP[2,d-1]-1)];
if durRecAP[1,d] < minDurAPW:
idxNew[0,int(durRecAP[2,d-1]): int(durRecAP[2,d]-1)] = idxS[0,int(durRecAP[2,d-1]-1)]
return idxNew
def post_process_etho3 (idx,minDurWalk,minDurSilence,minDurAPW,minDurAPA):
shIdx = np.shape(idx)
idxAP = etho2ethoAP (idx)
durRecG = get_durations (idx);#np.mean(durRec[1,:])
durRecAP = get_durations (idxAP);
idxNew = np.zeros((1,shIdx[1]))
idxNew[0,0:shIdx[1]] = idx[0,0:shIdx[1]]
idxS = idx
idxOriginal = idx
idxOriginalAP = idxAP
#minDurWalk=5;
#minDurSilence=5;
#minDurAPW=10;
#minDurAPA=30;
durRecAP = get_durations (idxAP)
shDurRecAP = np.shape(durRecAP)
for d in range(1,shDurRecAP[1]-1):
if durRecAP[0,d] == 3 and durRecAP[1,d] < minDurWalk:
idxNew[0,int(durRecAP[2,d-1]): int(durRecAP[2,d]-0)] = idxS[0,int(durRecAP[2,d-1]-1)]
idxS = idxNew
idxAP = etho2ethoAP (idxNew)
durRecAP = get_durations (idxAP)
shDurRecAP = np.shape(durRecAP)
for d in range(1,shDurRecAP[1]-1):
if durRecAP[0,d] == 1 and durRecAP[0,d-1] == 2 and durRecAP[0,d+1] == 2 and durRecAP[1,d] < minDurAPA and \
durRecAP[1,d] < durRecAP[1,d-1] and durRecAP[0,d] < durRecAP[1,d+1]:
idxNew[0,int(durRecAP[2,d-1]): int(durRecAP[2,d]-0)] = idxS[0,int(durRecAP[2,d-1]-1)]
idxS = idxNew
idxAP = etho2ethoAP (idxNew)
durRecAP = get_durations (idxAP)
shDurRecAP = np.shape(durRecAP)
for d in range(1,shDurRecAP[1]-1):
if durRecAP[0,d] == 2 and durRecAP[0,d-1] == 1 and durRecAP[0,d+1] == 1 and durRecAP[1,d] < minDurAPA and \
durRecAP[1,d] < durRecAP[1,d-1] and durRecAP[1,d] < durRecAP[1,d+1]:
idxNew[0,int(durRecAP[2,d-1]): int(durRecAP[2,d]-0)] = idxS[0,int(durRecAP[2,d-1]-1)]
idxS = idxNew
idxAP = etho2ethoAP (idxNew)
durRecAP = get_durations (idxAP)
shDurRecAP = np.shape(durRecAP)
for d in range(1,shDurRecAP[1]-1):
if durRecAP[1,d] < minDurAPW:
idxNew[0,int(durRecAP[2,d-1]): int(durRecAP[2,d]-0)] = idxS[0,int(durRecAP[2,d-1]-1)]
#idxS = idxNew;
idxNewAP = etho2ethoAP (idxNew)
return idxNew
def get_behavior_freq(idx):
behFreqCol = np.zeros((int(np.max(idx))+1,1))
for b in range(0,int(np.max(idx))+1):
idxBehBin = np.zeros((1,np.shape(idx)[1]))
idxBehBin[idx==b] = 1
behFreqCol[b] = np.sum(idxBehBin)
return behFreqCol
def get_comulative_freq(idx):
shIdx = np.shape(idx)
commFreq = np.zeros((int(np.max(idx)),shIdx[1]));
sumMat = np.zeros((int(np.max(idx)),1));
for i in range(1,shIdx[1]):
sumMat[int(idx[0,i])-1,0] = sumMat[int(idx[0,i])-1,0] + 1
commFreq[int(idx[0,i])-1,i] = sumMat[int(idx[0,i])-1,0]
return commFreq, sumMat
def get_half_time (ethoMat):
shEthoMat = np.shape(ethoMat)
halfTimeRec = np.zeros((shEthoMat[0],1));
for i in range(0,shEthoMat[0]):
idx = ethoMat[[i]]
idxAP = etho2ethoAP(idx)
commFreq, sumMat = get_comulative_freq(idxAP)
halfTime = np.where(commFreq[0,:]==np.round(sumMat[0]/2))[0][0]
halfTimeRec[i,0]=halfTime
return halfTimeRec
def count_cycles(idx):
idxAP = etho2ethoAP (idx)
TFmat, TPmat, TPmatNorm, TPnoSelf = get_syntax (idx)
behFreqCol = get_behavior_freq(idxAP)
fhTF = int(np.round((TFmat[1][0]+TFmat[0][1])/1))
numCycFH = behFreqCol[1]/fhTF
abwTF = int(np.round((TFmat[2][3]+TFmat[3][2]+TFmat[4][2]+TFmat[2][4])/1))
numCycABW = behFreqCol[2]/fhTF
return numCycFH, numCycABW
|
lemma eval_fps_tan: fixes c :: complex assumes "norm z < pi / (2 * norm c)" shows "eval_fps (fps_tan c) z = tan (c * z)" |
(* Title: HOL/Auth/n_flash_nodata_cub_lemma_on_inv__82.thy
Author: Yongjian Li and Kaiqiang Duan, State Key Lab of Computer Science, Institute of Software, Chinese Academy of Sciences
Copyright 2016 State Key Lab of Computer Science, Institute of Software, Chinese Academy of Sciences
*)
header{*The n_flash_nodata_cub Protocol Case Study*}
theory n_flash_nodata_cub_lemma_on_inv__82 imports n_flash_nodata_cub_base
begin
section{*All lemmas on causal relation between inv__82 and some rule r*}
lemma n_PI_Remote_GetVsinv__82:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_PI_Remote_Get src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_PI_Remote_Get src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__82 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_PI_Remote_GetXVsinv__82:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_PI_Remote_GetX src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_PI_Remote_GetX src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__82 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_NakVsinv__82:
assumes a1: "(\<exists> dst. dst\<le>N\<and>r=n_NI_Nak dst)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain dst where a1:"dst\<le>N\<and>r=n_NI_Nak dst" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__82 p__Inv4" apply fastforce done
have "(dst=p__Inv4)\<or>(dst~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(dst=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(dst~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_Get_Nak__part__0Vsinv__82:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_Get_Nak__part__0 src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_Get_Nak__part__0 src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__82 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_Get_Nak__part__1Vsinv__82:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_Get_Nak__part__1 src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_Get_Nak__part__1 src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__82 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_Get_Nak__part__2Vsinv__82:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_Get_Nak__part__2 src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_Get_Nak__part__2 src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__82 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_Get_Get__part__0Vsinv__82:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_Get_Get__part__0 src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_Get_Get__part__0 src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__82 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_Get_Get__part__1Vsinv__82:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_Get_Get__part__1 src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_Get_Get__part__1 src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__82 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P3 s"
apply (cut_tac a1 a2 b1, simp, rule_tac x="(neg (andForm (eqn (IVar (Field (Field (Ident ''Sta'') ''ShWbMsg'') ''Cmd'')) (Const SHWB_FAck)) (eqn (IVar (Field (Field (Ident ''Sta'') ''Dir'') ''Pending'')) (Const false))))" in exI, auto) done
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_Get_Put_HeadVsinv__82:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_Get_Put_Head N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_Get_Put_Head N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__82 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_Get_PutVsinv__82:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_Get_Put src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_Get_Put src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__82 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_Get_Put_DirtyVsinv__82:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_Get_Put_Dirty src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_Get_Put_Dirty src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__82 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Remote_Get_NakVsinv__82:
assumes a1: "(\<exists> src dst. src\<le>N\<and>dst\<le>N\<and>src~=dst\<and>r=n_NI_Remote_Get_Nak src dst)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src dst where a1:"src\<le>N\<and>dst\<le>N\<and>src~=dst\<and>r=n_NI_Remote_Get_Nak src dst" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__82 p__Inv4" apply fastforce done
have "(src=p__Inv4\<and>dst~=p__Inv4)\<or>(src~=p__Inv4\<and>dst=p__Inv4)\<or>(src~=p__Inv4\<and>dst~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4\<and>dst~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>dst=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>dst~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Remote_Get_PutVsinv__82:
assumes a1: "(\<exists> src dst. src\<le>N\<and>dst\<le>N\<and>src~=dst\<and>r=n_NI_Remote_Get_Put src dst)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src dst where a1:"src\<le>N\<and>dst\<le>N\<and>src~=dst\<and>r=n_NI_Remote_Get_Put src dst" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__82 p__Inv4" apply fastforce done
have "(src=p__Inv4\<and>dst~=p__Inv4)\<or>(src~=p__Inv4\<and>dst=p__Inv4)\<or>(src~=p__Inv4\<and>dst~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4\<and>dst~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>dst=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>dst~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_Nak__part__0Vsinv__82:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_Nak__part__0 src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_Nak__part__0 src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__82 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_Nak__part__1Vsinv__82:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_Nak__part__1 src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_Nak__part__1 src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__82 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_Nak__part__2Vsinv__82:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_Nak__part__2 src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_Nak__part__2 src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__82 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_GetX__part__0Vsinv__82:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_GetX__part__0 src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_GetX__part__0 src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__82 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_GetX__part__1Vsinv__82:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_GetX__part__1 src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_GetX__part__1 src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__82 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_1Vsinv__82:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_1 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_1 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__82 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_2Vsinv__82:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_2 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_2 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__82 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_3Vsinv__82:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_3 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_3 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__82 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_4Vsinv__82:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_4 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_4 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__82 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_5Vsinv__82:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_5 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_5 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__82 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_6Vsinv__82:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_6 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_6 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__82 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_7__part__0Vsinv__82:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_7__part__0 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_7__part__0 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__82 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_7__part__1Vsinv__82:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_7__part__1 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_7__part__1 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__82 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_7_NODE_Get__part__0Vsinv__82:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_7_NODE_Get__part__0 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_7_NODE_Get__part__0 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__82 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_7_NODE_Get__part__1Vsinv__82:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_7_NODE_Get__part__1 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_7_NODE_Get__part__1 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__82 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_8_HomeVsinv__82:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_8_Home N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_8_Home N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__82 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_8_Home_NODE_GetVsinv__82:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_8_Home_NODE_Get N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_8_Home_NODE_Get N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__82 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_8Vsinv__82:
assumes a1: "(\<exists> src pp. src\<le>N\<and>pp\<le>N\<and>src~=pp\<and>r=n_NI_Local_GetX_PutX_8 N src pp)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src pp where a1:"src\<le>N\<and>pp\<le>N\<and>src~=pp\<and>r=n_NI_Local_GetX_PutX_8 N src pp" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__82 p__Inv4" apply fastforce done
have "(src=p__Inv4\<and>pp~=p__Inv4)\<or>(src~=p__Inv4\<and>pp=p__Inv4)\<or>(src~=p__Inv4\<and>pp~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4\<and>pp~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>pp=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>pp~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_8_NODE_GetVsinv__82:
assumes a1: "(\<exists> src pp. src\<le>N\<and>pp\<le>N\<and>src~=pp\<and>r=n_NI_Local_GetX_PutX_8_NODE_Get N src pp)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src pp where a1:"src\<le>N\<and>pp\<le>N\<and>src~=pp\<and>r=n_NI_Local_GetX_PutX_8_NODE_Get N src pp" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__82 p__Inv4" apply fastforce done
have "(src=p__Inv4\<and>pp~=p__Inv4)\<or>(src~=p__Inv4\<and>pp=p__Inv4)\<or>(src~=p__Inv4\<and>pp~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4\<and>pp~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>pp=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>pp~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_9__part__0Vsinv__82:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_9__part__0 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_9__part__0 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__82 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_9__part__1Vsinv__82:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_9__part__1 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_9__part__1 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__82 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_10_HomeVsinv__82:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_10_Home N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_10_Home N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__82 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_10Vsinv__82:
assumes a1: "(\<exists> src pp. src\<le>N\<and>pp\<le>N\<and>src~=pp\<and>r=n_NI_Local_GetX_PutX_10 N src pp)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src pp where a1:"src\<le>N\<and>pp\<le>N\<and>src~=pp\<and>r=n_NI_Local_GetX_PutX_10 N src pp" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__82 p__Inv4" apply fastforce done
have "(src=p__Inv4\<and>pp~=p__Inv4)\<or>(src~=p__Inv4\<and>pp=p__Inv4)\<or>(src~=p__Inv4\<and>pp~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4\<and>pp~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>pp=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>pp~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_11Vsinv__82:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_11 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_11 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__82 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Remote_GetX_NakVsinv__82:
assumes a1: "(\<exists> src dst. src\<le>N\<and>dst\<le>N\<and>src~=dst\<and>r=n_NI_Remote_GetX_Nak src dst)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src dst where a1:"src\<le>N\<and>dst\<le>N\<and>src~=dst\<and>r=n_NI_Remote_GetX_Nak src dst" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__82 p__Inv4" apply fastforce done
have "(src=p__Inv4\<and>dst~=p__Inv4)\<or>(src~=p__Inv4\<and>dst=p__Inv4)\<or>(src~=p__Inv4\<and>dst~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4\<and>dst~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>dst=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>dst~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Remote_GetX_PutXVsinv__82:
assumes a1: "(\<exists> src dst. src\<le>N\<and>dst\<le>N\<and>src~=dst\<and>r=n_NI_Remote_GetX_PutX src dst)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src dst where a1:"src\<le>N\<and>dst\<le>N\<and>src~=dst\<and>r=n_NI_Remote_GetX_PutX src dst" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__82 p__Inv4" apply fastforce done
have "(src=p__Inv4\<and>dst~=p__Inv4)\<or>(src~=p__Inv4\<and>dst=p__Inv4)\<or>(src~=p__Inv4\<and>dst~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4\<and>dst~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>dst=p__Inv4)"
have "?P3 s"
apply (cut_tac a1 a2 b1, simp, rule_tac x="(neg (andForm (eqn (IVar (Field (Para (Field (Ident ''Sta'') ''UniMsg'') p__Inv4) ''Cmd'')) (Const UNI_Get)) (eqn (IVar (Field (Para (Field (Ident ''Sta'') ''Proc'') p__Inv4) ''CacheState'')) (Const CACHE_E))))" in exI, auto) done
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>dst~=p__Inv4)"
have "?P3 s"
apply (cut_tac a1 a2 b1, simp, rule_tac x="(neg (andForm (andForm (andForm (eqn (IVar (Field (Para (Field (Ident ''Sta'') ''UniMsg'') p__Inv4) ''Cmd'')) (Const UNI_Get)) (eqn (IVar (Field (Para (Field (Ident ''Sta'') ''UniMsg'') p__Inv4) ''HomeProc'')) (Const false))) (eqn (IVar (Field (Para (Field (Ident ''Sta'') ''UniMsg'') src) ''Cmd'')) (Const UNI_GetX))) (eqn (IVar (Field (Para (Field (Ident ''Sta'') ''UniMsg'') src) ''HomeProc'')) (Const false))))" in exI, auto) done
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Remote_PutVsinv__82:
assumes a1: "(\<exists> dst. dst\<le>N\<and>r=n_NI_Remote_Put dst)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain dst where a1:"dst\<le>N\<and>r=n_NI_Remote_Put dst" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__82 p__Inv4" apply fastforce done
have "(dst=p__Inv4)\<or>(dst~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(dst=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(dst~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Remote_PutXVsinv__82:
assumes a1: "(\<exists> dst. dst\<le>N\<and>r=n_NI_Remote_PutX dst)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain dst where a1:"dst\<le>N\<and>r=n_NI_Remote_PutX dst" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__82 p__Inv4" apply fastforce done
have "(dst=p__Inv4)\<or>(dst~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(dst=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(dst~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_FAckVsinv__82:
assumes a1: "(r=n_NI_FAck )" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__82 p__Inv4" apply fastforce done
have "?P1 s"
proof(cut_tac a1 a2 , auto) qed
then show "invHoldForRule s f r (invariants N)" by auto
qed
lemma n_NI_ShWbVsinv__82:
assumes a1: "(r=n_NI_ShWb N )" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__82 p__Inv4" apply fastforce done
have "?P1 s"
proof(cut_tac a1 a2 , auto) qed
then show "invHoldForRule s f r (invariants N)" by auto
qed
lemma n_NI_Remote_GetX_PutX_HomeVsinv__82:
assumes a1: "\<exists> dst. dst\<le>N\<and>r=n_NI_Remote_GetX_PutX_Home dst" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_PI_Local_GetX_PutX__part__0Vsinv__82:
assumes a1: "r=n_PI_Local_GetX_PutX__part__0 " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_WbVsinv__82:
assumes a1: "r=n_NI_Wb " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_InvAck_3Vsinv__82:
assumes a1: "\<exists> src. src\<le>N\<and>r=n_NI_InvAck_3 N src" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_InvAck_1Vsinv__82:
assumes a1: "\<exists> src. src\<le>N\<and>r=n_NI_InvAck_1 N src" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_PI_Local_GetX_GetX__part__1Vsinv__82:
assumes a1: "r=n_PI_Local_GetX_GetX__part__1 " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_PI_Local_GetX_GetX__part__0Vsinv__82:
assumes a1: "r=n_PI_Local_GetX_GetX__part__0 " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_PI_Remote_ReplaceVsinv__82:
assumes a1: "\<exists> src. src\<le>N\<and>r=n_PI_Remote_Replace src" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_PI_Local_ReplaceVsinv__82:
assumes a1: "r=n_PI_Local_Replace " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_InvAck_existsVsinv__82:
assumes a1: "\<exists> src pp. src\<le>N\<and>pp\<le>N\<and>src~=pp\<and>r=n_NI_InvAck_exists src pp" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_PI_Remote_PutXVsinv__82:
assumes a1: "\<exists> dst. dst\<le>N\<and>r=n_PI_Remote_PutX dst" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_Remote_Get_Put_HomeVsinv__82:
assumes a1: "\<exists> dst. dst\<le>N\<and>r=n_NI_Remote_Get_Put_Home dst" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_InvVsinv__82:
assumes a1: "\<exists> dst. dst\<le>N\<and>r=n_NI_Inv dst" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_PI_Local_PutXVsinv__82:
assumes a1: "r=n_PI_Local_PutX " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_PI_Local_Get_PutVsinv__82:
assumes a1: "r=n_PI_Local_Get_Put " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_PI_Local_GetX_PutX_HeadVld__part__0Vsinv__82:
assumes a1: "r=n_PI_Local_GetX_PutX_HeadVld__part__0 N " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_ReplaceVsinv__82:
assumes a1: "\<exists> src. src\<le>N\<and>r=n_NI_Replace src" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_Remote_GetX_Nak_HomeVsinv__82:
assumes a1: "\<exists> dst. dst\<le>N\<and>r=n_NI_Remote_GetX_Nak_Home dst" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_Local_PutXAcksDoneVsinv__82:
assumes a1: "r=n_NI_Local_PutXAcksDone " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_PI_Local_GetX_PutX__part__1Vsinv__82:
assumes a1: "r=n_PI_Local_GetX_PutX__part__1 " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_Remote_Get_Nak_HomeVsinv__82:
assumes a1: "\<exists> dst. dst\<le>N\<and>r=n_NI_Remote_Get_Nak_Home dst" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_InvAck_exists_HomeVsinv__82:
assumes a1: "\<exists> src. src\<le>N\<and>r=n_NI_InvAck_exists_Home src" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_Replace_HomeVsinv__82:
assumes a1: "r=n_NI_Replace_Home " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_Local_PutVsinv__82:
assumes a1: "r=n_NI_Local_Put " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_Nak_ClearVsinv__82:
assumes a1: "r=n_NI_Nak_Clear " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_PI_Local_Get_GetVsinv__82:
assumes a1: "r=n_PI_Local_Get_Get " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_Nak_HomeVsinv__82:
assumes a1: "r=n_NI_Nak_Home " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_InvAck_2Vsinv__82:
assumes a1: "\<exists> src. src\<le>N\<and>r=n_NI_InvAck_2 N src" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_PI_Local_GetX_PutX_HeadVld__part__1Vsinv__82:
assumes a1: "r=n_PI_Local_GetX_PutX_HeadVld__part__1 N " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__82 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
end
|
/*
Copyright (C) 2016 Quaternion Risk Management Ltd
All rights reserved.
This file is part of ORE, a free-software/open-source library
for transparent pricing and risk analysis - http://opensourcerisk.org
ORE is free software: you can redistribute it and/or modify it
under the terms of the Modified BSD License. You should have received a
copy of the license along with this program.
The license is also available online at <http://opensourcerisk.org>
This program is distributed on the basis that it will form a useful
contribution to risk analytics and model standardisation, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the license for more details.
*/
/*! \file ored/marketdata/todaysmarket.cpp
\brief An concerte implementation of the Market class that loads todays market and builds the required curves
\ingroup
*/
#include <boost/range/adaptor/map.hpp>
#include <ored/marketdata/basecorrelationcurve.hpp>
#include <ored/marketdata/capfloorvolcurve.hpp>
#include <ored/marketdata/cdsvolcurve.hpp>
#include <ored/marketdata/commoditycurve.hpp>
#include <ored/marketdata/commodityvolcurve.hpp>
#include <ored/marketdata/correlationcurve.hpp>
#include <ored/marketdata/curveloader.hpp>
#include <ored/marketdata/curvespecparser.hpp>
#include <ored/marketdata/defaultcurve.hpp>
#include <ored/marketdata/equitycurve.hpp>
#include <ored/marketdata/equityvolcurve.hpp>
#include <ored/marketdata/fxspot.hpp>
#include <ored/marketdata/fxvolcurve.hpp>
#include <ored/marketdata/inflationcapfloorvolcurve.hpp>
#include <ored/marketdata/inflationcurve.hpp>
#include <ored/marketdata/security.hpp>
#include <ored/marketdata/structuredcurveerror.hpp>
#include <ored/marketdata/swaptionvolcurve.hpp>
#include <ored/marketdata/todaysmarket.hpp>
#include <ored/marketdata/yieldcurve.hpp>
#include <ored/marketdata/yieldvolcurve.hpp>
#include <ored/utilities/indexparser.hpp>
#include <ored/utilities/log.hpp>
#include <qle/indexes/equityindex.hpp>
#include <qle/indexes/inflationindexwrapper.hpp>
#include <qle/termstructures/blackvolsurfacewithatm.hpp>
#include <qle/termstructures/pricetermstructureadapter.hpp>
using namespace std;
using namespace QuantLib;
using QuantExt::EquityIndex;
using QuantExt::PriceTermStructure;
using QuantExt::PriceTermStructureAdapter;
namespace ore {
namespace data {
TodaysMarket::TodaysMarket(const Date& asof, const TodaysMarketParameters& params, const Loader& loader,
const CurveConfigurations& curveConfigs, const Conventions& conventions,
const bool continueOnError, bool loadFixings,
const boost::shared_ptr<ReferenceDataManager>& referenceData)
: MarketImpl(conventions) {
// Fixings
if (loadFixings) {
// Apply them now in case a curve builder needs them
LOG("Todays Market Loading Fixings");
applyFixings(loader.loadFixings(), conventions);
LOG("Todays Market Loading Fixing done.");
}
// Dividends
// Apply them now in case a curve builder needs them
LOG("Todays Market Loading Dividends");
applyDividends(loader.loadDividends());
LOG("Todays Market Loading Dividends done.");
// store all curves built, since they might appear in several configurations
// and might therefore be reused
map<string, boost::shared_ptr<YieldCurve>> requiredYieldCurves;
map<string, boost::shared_ptr<SwapIndex>> requiredSwapIndices;
map<string, boost::shared_ptr<FXSpot>> requiredFxSpots;
map<string, boost::shared_ptr<FXVolCurve>> requiredFxVolCurves;
map<string, boost::shared_ptr<SwaptionVolCurve>> requiredSwaptionVolCurves;
map<string, boost::shared_ptr<YieldVolCurve>> requiredYieldVolCurves;
map<string, boost::shared_ptr<CapFloorVolCurve>> requiredCapFloorVolCurves;
map<string, boost::shared_ptr<DefaultCurve>> requiredDefaultCurves;
map<string, boost::shared_ptr<CDSVolCurve>> requiredCDSVolCurves;
map<string, boost::shared_ptr<BaseCorrelationCurve>> requiredBaseCorrelationCurves;
map<string, boost::shared_ptr<InflationCurve>> requiredInflationCurves;
// map<string, boost::shared_ptr<InflationCapFloorPriceSurface>> requiredInflationCapFloorPriceSurfaces;
map<string, boost::shared_ptr<InflationCapFloorVolCurve>> requiredInflationCapFloorVolCurves;
map<string, boost::shared_ptr<EquityCurve>> requiredEquityCurves;
map<string, boost::shared_ptr<EquityVolCurve>> requiredEquityVolCurves;
map<string, boost::shared_ptr<Security>> requiredSecurities;
map<string, boost::shared_ptr<CommodityCurve>> requiredCommodityCurves;
map<string, boost::shared_ptr<CommodityVolCurve>> requiredCommodityVolCurves;
map<string, boost::shared_ptr<CorrelationCurve>> requiredCorrelationCurves;
// store all curve build errors
map<string, string> buildErrors;
// fx triangulation
FXTriangulation fxT;
// Add all FX quotes from the loader to Triangulation
for (auto& md : loader.loadQuotes(asof)) {
if (md->asofDate() == asof && md->instrumentType() == MarketDatum::InstrumentType::FX_SPOT) {
boost::shared_ptr<FXSpotQuote> q = boost::dynamic_pointer_cast<FXSpotQuote>(md);
QL_REQUIRE(q, "Failed to cast " << md->name() << " to FXSpotQuote");
fxT.addQuote(q->unitCcy() + q->ccy(), q->quote());
}
}
for (const auto& configuration : params.configurations()) {
LOG("Build objects in TodaysMarket configuration " << configuration.first);
asof_ = asof;
Size count = 0;
// Build the curve specs
vector<boost::shared_ptr<CurveSpec>> specs;
for (const auto& it : params.curveSpecs(configuration.first)) {
specs.push_back(parseCurveSpec(it));
DLOG("CurveSpec: " << specs.back()->name());
}
// order them
order(specs, curveConfigs, buildErrors, continueOnError);
bool swapIndicesBuilt = false;
// Loop over each spec, build the curve and add it to the MarketImpl container.
for (Size count = 0; count < specs.size(); ++count) {
auto spec = specs[count];
LOG("Loading spec " << *spec);
try {
switch (spec->baseType()) {
case CurveSpec::CurveType::Yield: {
boost::shared_ptr<YieldCurveSpec> ycspec = boost::dynamic_pointer_cast<YieldCurveSpec>(spec);
QL_REQUIRE(ycspec, "Failed to convert spec " << *spec << " to yield curve spec");
// have we built the curve already ?
auto itr = requiredYieldCurves.find(ycspec->name());
if (itr == requiredYieldCurves.end()) {
// build
LOG("Building YieldCurve for asof " << asof);
boost::shared_ptr<YieldCurve> yieldCurve = boost::make_shared<YieldCurve>(
asof, *ycspec, curveConfigs, loader, conventions, requiredYieldCurves, fxT, referenceData);
itr = requiredYieldCurves.insert(make_pair(ycspec->name(), yieldCurve)).first;
}
DLOG("Added YieldCurve \"" << ycspec->name() << "\" to requiredYieldCurves map");
if (itr->second->currency().code() != ycspec->ccy()) {
WLOG("Warning: YieldCurve has ccy " << itr->second->currency() << " but spec has ccy "
<< ycspec->ccy());
}
// We may have to add this spec multiple times (for discounting, yield and forwarding curves)
vector<YieldCurveType> yieldCurveTypes = {YieldCurveType::Discount, YieldCurveType::Yield};
for (auto& y : yieldCurveTypes) {
MarketObject o = static_cast<MarketObject>(y);
if (params.hasMarketObject(o)) {
for (auto& it : params.mapping(o, configuration.first)) {
if (it.second == spec->name()) {
LOG("Adding YieldCurve(" << it.first << ") with spec " << *ycspec
<< " to configuration " << configuration.first);
yieldCurves_[make_tuple(configuration.first, y, it.first)] = itr->second->handle();
}
}
}
}
if (params.hasMarketObject(MarketObject::IndexCurve)) {
for (const auto& it : params.mapping(MarketObject::IndexCurve, configuration.first)) {
if (it.second == spec->name()) {
LOG("Adding Index(" << it.first << ") with spec " << *ycspec << " to configuration "
<< configuration.first);
iborIndices_[make_pair(configuration.first, it.first)] = Handle<IborIndex>(
parseIborIndex(it.first, itr->second->handle(),
conventions.has(it.first, Convention::Type::IborIndex) ||
conventions.has(it.first, Convention::Type::OvernightIndex)
? conventions.get(it.first)
: nullptr));
}
}
}
break;
}
case CurveSpec::CurveType::FX: {
boost::shared_ptr<FXSpotSpec> fxspec = boost::dynamic_pointer_cast<FXSpotSpec>(spec);
QL_REQUIRE(fxspec, "Failed to convert spec " << *spec << " to fx spot spec");
// have we built the curve already ?
auto itr = requiredFxSpots.find(fxspec->name());
if (itr == requiredFxSpots.end()) {
// build the curve
LOG("Building FXSpot for asof " << asof);
boost::shared_ptr<FXSpot> fxSpot = boost::make_shared<FXSpot>(asof, *fxspec, fxT);
itr = requiredFxSpots.insert(make_pair(fxspec->name(), fxSpot)).first;
fxT.addQuote(fxspec->subName().substr(0, 3) + fxspec->subName().substr(4, 3),
itr->second->handle());
}
// add the handle to the Market Map (possible lots of times for proxies)
for (const auto& it : params.mapping(MarketObject::FXSpot, configuration.first)) {
if (it.second == spec->name()) {
LOG("Adding FXSpot (" << it.first << ") with spec " << *fxspec << " to configuration "
<< configuration.first);
fxSpots_[configuration.first].addQuote(it.first, itr->second->handle());
}
}
break;
}
case CurveSpec::CurveType::FXVolatility: {
// convert to fxspec
boost::shared_ptr<FXVolatilityCurveSpec> fxvolspec =
boost::dynamic_pointer_cast<FXVolatilityCurveSpec>(spec);
QL_REQUIRE(fxvolspec, "Failed to convert spec " << *spec);
// have we built the curve already ?
auto itr = requiredFxVolCurves.find(fxvolspec->name());
if (itr == requiredFxVolCurves.end()) {
// build the curve
LOG("Building FXVolatility for asof " << asof);
boost::shared_ptr<FXVolCurve> fxVolCurve = boost::make_shared<FXVolCurve>(
asof, *fxvolspec, loader, curveConfigs, fxT, requiredYieldCurves, conventions);
itr = requiredFxVolCurves.insert(make_pair(fxvolspec->name(), fxVolCurve)).first;
}
// add the handle to the Market Map (possible lots of times for proxies)
for (const auto& it : params.mapping(MarketObject::FXVol, configuration.first)) {
if (it.second == spec->name()) {
LOG("Adding FXVol (" << it.first << ") with spec " << *fxvolspec << " to configuration "
<< configuration.first);
fxVols_[make_pair(configuration.first, it.first)] =
Handle<BlackVolTermStructure>(itr->second->volTermStructure());
}
}
break;
}
case CurveSpec::CurveType::SwaptionVolatility: {
// convert to volspec
boost::shared_ptr<SwaptionVolatilityCurveSpec> swvolspec =
boost::dynamic_pointer_cast<SwaptionVolatilityCurveSpec>(spec);
QL_REQUIRE(swvolspec, "Failed to convert spec " << *spec);
// have we built the curve already ?
auto itr = requiredSwaptionVolCurves.find(swvolspec->name());
if (itr == requiredSwaptionVolCurves.end()) {
// build the curve
LOG("Building Swaption Volatility for asof " << asof);
boost::shared_ptr<SwaptionVolCurve> swaptionVolCurve = boost::make_shared<SwaptionVolCurve>(
asof, *swvolspec, loader, curveConfigs, requiredSwapIndices);
itr = requiredSwaptionVolCurves.insert(make_pair(swvolspec->name(), swaptionVolCurve)).first;
}
boost::shared_ptr<SwaptionVolatilityCurveConfig> cfg =
curveConfigs.swaptionVolCurveConfig(swvolspec->curveConfigID());
// add the handle to the Market Map (possible lots of times for proxies)
for (const auto& it : params.mapping(MarketObject::SwaptionVol, configuration.first)) {
if (it.second == spec->name()) {
LOG("Adding SwaptionVol (" << it.first << ") with spec " << *swvolspec
<< " to configuration " << configuration.first);
swaptionCurves_[make_pair(configuration.first, it.first)] =
Handle<SwaptionVolatilityStructure>(itr->second->volTermStructure());
swaptionIndexBases_[make_pair(configuration.first, it.first)] =
make_pair(cfg->shortSwapIndexBase(), cfg->swapIndexBase());
}
}
break;
}
case CurveSpec::CurveType::YieldVolatility: {
// convert to volspec
boost::shared_ptr<YieldVolatilityCurveSpec> ydvolspec =
boost::dynamic_pointer_cast<YieldVolatilityCurveSpec>(spec);
QL_REQUIRE(ydvolspec, "Failed to convert spec " << *spec);
// have we built the curve already ?
auto itr = requiredYieldVolCurves.find(ydvolspec->name());
if (itr == requiredYieldVolCurves.end()) {
// build the curve
LOG("Building Yield Volatility for asof " << asof);
boost::shared_ptr<YieldVolCurve> yieldVolCurve =
boost::make_shared<YieldVolCurve>(asof, *ydvolspec, loader, curveConfigs);
itr = requiredYieldVolCurves.insert(make_pair(ydvolspec->name(), yieldVolCurve)).first;
}
boost::shared_ptr<YieldVolatilityCurveConfig> cfg =
curveConfigs.yieldVolCurveConfig(ydvolspec->curveConfigID());
// add the handle to the Market Map (possible lots of times for proxies)
for (const auto& it : params.mapping(MarketObject::YieldVol, configuration.first)) {
if (it.second == spec->name()) {
LOG("Adding YieldVol (" << it.first << ") with spec " << *ydvolspec << " to configuration "
<< configuration.first);
yieldVolCurves_[make_pair(configuration.first, it.first)] =
Handle<SwaptionVolatilityStructure>(itr->second->volTermStructure());
}
}
break;
}
case CurveSpec::CurveType::CapFloorVolatility: {
// attempt to convert to cap/floor curve spec
boost::shared_ptr<CapFloorVolatilityCurveSpec> cfVolSpec =
boost::dynamic_pointer_cast<CapFloorVolatilityCurveSpec>(spec);
QL_REQUIRE(cfVolSpec, "Failed to convert spec " << *spec);
// Get the cap/floor volatility "curve" config
boost::shared_ptr<CapFloorVolatilityCurveConfig> cfg =
curveConfigs.capFloorVolCurveConfig(cfVolSpec->curveConfigID());
// Build the market data object if we have not built it already
auto itr = requiredCapFloorVolCurves.find(cfVolSpec->name());
if (itr == requiredCapFloorVolCurves.end()) {
LOG("Building cap/floor volatility for asof " << asof);
// Firstly, need to retrieve ibor index and discount curve
// Ibor index
Handle<IborIndex> iborIndex = MarketImpl::iborIndex(cfg->iborIndex(), configuration.first);
// Discount curve
auto it = requiredYieldCurves.find(cfg->discountCurve());
QL_REQUIRE(it != requiredYieldCurves.end(), "Discount curve with spec, "
<< cfg->discountCurve()
<< ", not found in loaded yield curves");
Handle<YieldTermStructure> discountCurve = it->second->handle();
// Now create cap/floor vol curve
boost::shared_ptr<CapFloorVolCurve> capFloorVolCurve = boost::make_shared<CapFloorVolCurve>(
asof, *cfVolSpec, loader, curveConfigs, iborIndex.currentLink(), discountCurve);
itr = requiredCapFloorVolCurves.insert(make_pair(cfVolSpec->name(), capFloorVolCurve)).first;
}
// add the handle to the Market Map (possible lots of times for proxies)
for (const auto& it : params.mapping(MarketObject::CapFloorVol, configuration.first)) {
if (it.second == spec->name()) {
LOG("Adding CapFloorVol (" << it.first << ") with spec " << *cfVolSpec
<< " to configuration " << configuration.first);
capFloorCurves_[make_pair(configuration.first, it.first)] =
Handle<OptionletVolatilityStructure>(itr->second->capletVolStructure());
}
}
break;
}
case CurveSpec::CurveType::Default: {
boost::shared_ptr<DefaultCurveSpec> defaultspec =
boost::dynamic_pointer_cast<DefaultCurveSpec>(spec);
QL_REQUIRE(defaultspec, "Failed to convert spec " << *spec);
// have we built the curve already ?
auto itr = requiredDefaultCurves.find(defaultspec->name());
if (itr == requiredDefaultCurves.end()) {
// build the curve
LOG("Building DefaultCurve for asof " << asof);
boost::shared_ptr<DefaultCurve> defaultCurve = boost::make_shared<DefaultCurve>(
asof, *defaultspec, loader, curveConfigs, conventions, requiredYieldCurves);
itr = requiredDefaultCurves.insert(make_pair(defaultspec->name(), defaultCurve)).first;
}
for (const auto& it : params.mapping(MarketObject::DefaultCurve, configuration.first)) {
if (it.second == spec->name()) {
LOG("Adding DefaultCurve (" << it.first << ") with spec " << *defaultspec
<< " to configuration " << configuration.first);
defaultCurves_[make_pair(configuration.first, it.first)] =
Handle<DefaultProbabilityTermStructure>(itr->second->defaultTermStructure());
recoveryRates_[make_pair(configuration.first, it.first)] =
Handle<Quote>(boost::make_shared<SimpleQuote>(itr->second->recoveryRate()));
}
}
break;
}
case CurveSpec::CurveType::CDSVolatility: {
// convert to cds vol spec
boost::shared_ptr<CDSVolatilityCurveSpec> cdsvolspec =
boost::dynamic_pointer_cast<CDSVolatilityCurveSpec>(spec);
QL_REQUIRE(cdsvolspec, "Failed to convert spec " << *spec);
// have we built the curve already ?
auto itr = requiredCDSVolCurves.find(cdsvolspec->name());
if (itr == requiredCDSVolCurves.end()) {
// build the curve
LOG("Building CDSVol for asof " << asof);
boost::shared_ptr<CDSVolCurve> cdsVolCurve =
boost::make_shared<CDSVolCurve>(asof, *cdsvolspec, loader, curveConfigs);
itr = requiredCDSVolCurves.insert(make_pair(cdsvolspec->name(), cdsVolCurve)).first;
}
// add the handle to the Market Map (possible lots of times for proxies)
for (const auto& it : params.mapping(MarketObject::CDSVol, configuration.first)) {
if (it.second == spec->name()) {
LOG("Adding CDSVol (" << it.first << ") with spec " << *cdsvolspec << " to configuration "
<< configuration.first);
cdsVols_[make_pair(configuration.first, it.first)] =
Handle<BlackVolTermStructure>(itr->second->volTermStructure());
}
}
break;
}
case CurveSpec::CurveType::BaseCorrelation: {
// convert to base correlation spec
boost::shared_ptr<BaseCorrelationCurveSpec> baseCorrelationSpec =
boost::dynamic_pointer_cast<BaseCorrelationCurveSpec>(spec);
QL_REQUIRE(baseCorrelationSpec, "Failed to convert spec " << *spec);
// have we built the curve already ?
auto itr = requiredBaseCorrelationCurves.find(baseCorrelationSpec->name());
if (itr == requiredBaseCorrelationCurves.end()) {
// build the curve
LOG("Building BaseCorrelation for asof " << asof);
boost::shared_ptr<BaseCorrelationCurve> baseCorrelationCurve =
boost::make_shared<BaseCorrelationCurve>(asof, *baseCorrelationSpec, loader, curveConfigs);
itr = requiredBaseCorrelationCurves
.insert(make_pair(baseCorrelationSpec->name(), baseCorrelationCurve))
.first;
}
// add the handle to the Market Map (possible lots of times for proxies)
for (const auto& it : params.mapping(MarketObject::BaseCorrelation, configuration.first)) {
if (it.second == spec->name()) {
LOG("Adding Base Correlation (" << it.first << ") with spec " << *baseCorrelationSpec
<< " to configuration " << configuration.first);
baseCorrelations_[make_pair(configuration.first, it.first)] =
Handle<BaseCorrelationTermStructure<BilinearInterpolation>>(
itr->second->baseCorrelationTermStructure());
}
}
break;
}
case CurveSpec::CurveType::Inflation: {
boost::shared_ptr<InflationCurveSpec> inflationspec =
boost::dynamic_pointer_cast<InflationCurveSpec>(spec);
QL_REQUIRE(inflationspec, "Failed to convert spec " << *spec << " to inflation curve spec");
// have we built the curve already ?
auto itr = requiredInflationCurves.find(inflationspec->name());
if (itr == requiredInflationCurves.end()) {
LOG("Building InflationCurve " << inflationspec->name() << " for asof " << asof);
boost::shared_ptr<InflationCurve> inflationCurve = boost::make_shared<InflationCurve>(
asof, *inflationspec, loader, curveConfigs, conventions, requiredYieldCurves);
itr = requiredInflationCurves.insert(make_pair(inflationspec->name(), inflationCurve)).first;
}
// this try-catch is necessary to handle cases where no ZC inflation index curves exist in scope
map<string, string> zcInfMap;
try {
zcInfMap = params.mapping(MarketObject::ZeroInflationCurve, configuration.first);
} catch (QuantLib::Error& e) {
LOG(e.what());
}
for (const auto& it : zcInfMap) {
if (it.second == spec->name()) {
LOG("Adding ZeroInflationIndex (" << it.first << ") with spec " << *inflationspec
<< " to configuration " << configuration.first);
boost::shared_ptr<ZeroInflationTermStructure> ts =
boost::dynamic_pointer_cast<ZeroInflationTermStructure>(
itr->second->inflationTermStructure());
QL_REQUIRE(ts, "expected zero inflation term structure for index "
<< it.first << ", but could not cast");
// index is not interpolated
auto tmp = parseZeroInflationIndex(it.first, false, Handle<ZeroInflationTermStructure>(ts));
zeroInflationIndices_[make_pair(configuration.first, it.first)] =
Handle<ZeroInflationIndex>(tmp);
}
}
// this try-catch is necessary to handle cases where no YoY inflation index curves exist in scope
map<string, string> yyInfMap;
try {
yyInfMap = params.mapping(MarketObject::YoYInflationCurve, configuration.first);
} catch (QuantLib::Error& e) {
LOG(e.what());
}
for (const auto& it : yyInfMap) {
if (it.second == spec->name()) {
LOG("Adding YoYInflationIndex (" << it.first << ") with spec " << *inflationspec
<< " to configuration " << configuration.first);
boost::shared_ptr<YoYInflationTermStructure> ts =
boost::dynamic_pointer_cast<YoYInflationTermStructure>(
itr->second->inflationTermStructure());
QL_REQUIRE(ts, "expected yoy inflation term structure for index "
<< it.first << ", but could not cast");
yoyInflationIndices_[make_pair(configuration.first, it.first)] =
Handle<YoYInflationIndex>(boost::make_shared<QuantExt::YoYInflationIndexWrapper>(
parseZeroInflationIndex(it.first, false), false,
Handle<YoYInflationTermStructure>(ts)));
}
}
break;
}
case CurveSpec::CurveType::InflationCapFloorVolatility: {
boost::shared_ptr<InflationCapFloorVolatilityCurveSpec> infcapfloorspec =
boost::dynamic_pointer_cast<InflationCapFloorVolatilityCurveSpec>(spec);
QL_REQUIRE(infcapfloorspec, "Failed to convert spec " << *spec << " to inf cap floor spec");
// have we built the curve already ?
auto itr = requiredInflationCapFloorVolCurves.find(infcapfloorspec->name());
if (itr == requiredInflationCapFloorVolCurves.end()) {
LOG("Building InflationCapFloorVolatilitySurface for asof " << asof);
boost::shared_ptr<InflationCapFloorVolCurve> inflationCapFloorVolCurve =
boost::make_shared<InflationCapFloorVolCurve>(asof, *infcapfloorspec, loader, curveConfigs,
requiredYieldCurves, requiredInflationCurves);
itr = requiredInflationCapFloorVolCurves
.insert(make_pair(infcapfloorspec->name(), inflationCapFloorVolCurve))
.first;
}
map<string, string> zcInfMap;
try {
zcInfMap = params.mapping(MarketObject::ZeroInflationCapFloorVol, configuration.first);
} catch (QuantLib::Error& e) {
LOG(e.what());
}
for (const auto& it : zcInfMap) {
if (it.second == spec->name()) {
LOG("Adding InflationCapFloorVol (" << it.first << ") with spec " << *infcapfloorspec
<< " to configuration " << configuration.first);
cpiInflationCapFloorVolatilitySurfaces_[make_pair(configuration.first, it.first)] =
Handle<CPIVolatilitySurface>(itr->second->cpiInflationCapFloorVolSurface());
}
}
map<string, string> yyInfMap;
try {
yyInfMap = params.mapping(MarketObject::YoYInflationCapFloorVol, configuration.first);
} catch (QuantLib::Error& e) {
LOG(e.what());
}
for (const auto& it : yyInfMap) {
if (it.second == spec->name()) {
LOG("Adding YoYOptionletVolatilitySurface (" << it.first << ") with spec "
<< *infcapfloorspec << " to configuration "
<< configuration.first);
yoyCapFloorVolSurfaces_[make_pair(configuration.first, it.first)] =
Handle<QuantExt::YoYOptionletVolatilitySurface>(
itr->second->yoyInflationCapFloorVolSurface());
}
}
break;
}
case CurveSpec::CurveType::Equity: {
boost::shared_ptr<EquityCurveSpec> equityspec = boost::dynamic_pointer_cast<EquityCurveSpec>(spec);
QL_REQUIRE(equityspec, "Failed to convert spec " << *spec);
// have we built the curve already ?
auto itr = requiredEquityCurves.find(equityspec->name());
if (itr == requiredEquityCurves.end()) {
// build the curve
LOG("Building EquityCurve for asof " << asof);
boost::shared_ptr<EquityCurve> equityCurve = boost::make_shared<EquityCurve>(
asof, *equityspec, loader, curveConfigs, conventions, requiredYieldCurves);
itr = requiredEquityCurves.insert(make_pair(equityspec->name(), equityCurve)).first;
}
for (const auto& it : params.mapping(MarketObject::EquityCurve, configuration.first)) {
if (it.second == spec->name()) {
LOG("Adding EquityCurve (" << it.first << ") with spec " << *equityspec
<< " to configuration " << configuration.first);
yieldCurves_[make_tuple(configuration.first, YieldCurveType::EquityDividend, it.first)] =
itr->second->equityIndex()->equityDividendCurve();
equitySpots_[make_pair(configuration.first, it.first)] =
itr->second->equityIndex()->equitySpot();
equityCurves_[make_pair(configuration.first, it.first)] =
Handle<EquityIndex>(itr->second->equityIndex());
}
}
break;
}
case CurveSpec::CurveType::EquityVolatility: {
// convert to eqvolspec
boost::shared_ptr<EquityVolatilityCurveSpec> eqvolspec =
boost::dynamic_pointer_cast<EquityVolatilityCurveSpec>(spec);
QL_REQUIRE(eqvolspec, "Failed to convert spec " << *spec);
// have we built the curve already ?
auto itr = requiredEquityVolCurves.find(eqvolspec->name());
if (itr == requiredEquityVolCurves.end()) {
// build the curve
LOG("Building EquityVol for asof " << asof);
// First we need the Equity Index, this should already be built
Handle<EquityIndex> eqIndex =
MarketImpl::equityCurve(eqvolspec->curveConfigID(), configuration.first);
boost::shared_ptr<EquityVolCurve> eqVolCurve =
boost::make_shared<EquityVolCurve>(asof, *eqvolspec, loader, curveConfigs, eqIndex,
requiredEquityCurves, requiredEquityVolCurves);
itr = requiredEquityVolCurves.insert(make_pair(eqvolspec->name(), eqVolCurve)).first;
}
// add the handle to the Market Map (possible lots of times for proxies)
for (const auto& it : params.mapping(MarketObject::EquityVol, configuration.first)) {
if (it.second == spec->name()) {
string eqName = it.first;
LOG("Adding EquityVol (" << eqName << ") with spec " << *eqvolspec << " to configuration "
<< configuration.first);
boost::shared_ptr<BlackVolTermStructure> bvts(itr->second->volTermStructure());
// Wrap it in QuantExt::BlackVolatilityWithATM as TodaysMarket might be used
// for model calibration. This is not the ideal place to put this logic but
// it can't be in EquityVolCurve as there are implicit, configuration dependent,
// choices made already (e.g. what discount curve to use).
// We do this even if it is an ATM curve, it does no harm.
Handle<Quote> spot = equitySpot(eqName, configuration.first);
Handle<YieldTermStructure> yts = discountCurve(eqvolspec->ccy(), configuration.first);
Handle<YieldTermStructure> divYts = equityDividendCurve(eqName, configuration.first);
bvts = boost::make_shared<QuantExt::BlackVolatilityWithATM>(bvts, spot, yts, divYts);
equityVols_[make_pair(configuration.first, it.first)] = Handle<BlackVolTermStructure>(bvts);
}
}
break;
}
case CurveSpec::CurveType::Security: {
boost::shared_ptr<SecuritySpec> securityspec = boost::dynamic_pointer_cast<SecuritySpec>(spec);
QL_REQUIRE(securityspec, "Failed to convert spec " << *spec << " to security spec");
auto check = requiredDefaultCurves.find(securityspec->securityID());
if (check != requiredDefaultCurves.end())
QL_FAIL("securities cannot have the same name as a default curve");
// have we built the security spread already?
auto itr = requiredSecurities.find(securityspec->securityID());
if (itr == requiredSecurities.end()) {
// build the curve
LOG("Building Securities for asof " << asof);
boost::shared_ptr<Security> security =
boost::make_shared<Security>(asof, *securityspec, loader, curveConfigs);
itr = requiredSecurities.insert(make_pair(securityspec->securityID(), security)).first;
}
// add the handle to the Market Map (possible lots of times for proxies)
for (const auto& it : params.mapping(MarketObject::Security, configuration.first)) {
if (it.second == spec->name()) {
LOG("Adding Security (" << it.first << ") with spec " << *securityspec
<< " to configuration " << configuration.first);
if (!itr->second->spread().empty())
securitySpreads_[make_pair(configuration.first, it.first)] = itr->second->spread();
if (!itr->second->recoveryRate().empty())
recoveryRates_[make_pair(configuration.first, it.first)] = itr->second->recoveryRate();
if (!itr->second->cpr().empty())
cprs_[make_pair(configuration.first, it.first)] = itr->second->cpr();
}
}
break;
}
case CurveSpec::CurveType::Commodity: {
boost::shared_ptr<CommodityCurveSpec> commodityCurveSpec =
boost::dynamic_pointer_cast<CommodityCurveSpec>(spec);
QL_REQUIRE(commodityCurveSpec, "Failed to convert spec, " << *spec << ", to CommodityCurveSpec");
// Have we built the curve already?
auto itr = requiredCommodityCurves.find(commodityCurveSpec->name());
if (itr == requiredCommodityCurves.end()) {
// build the curve
LOG("Building CommodityCurve for asof " << asof);
boost::shared_ptr<CommodityCurve> commodityCurve = boost::make_shared<CommodityCurve>(
asof, *commodityCurveSpec, loader, curveConfigs, conventions, fxT, requiredYieldCurves,
requiredCommodityCurves);
itr =
requiredCommodityCurves.insert(make_pair(commodityCurveSpec->name(), commodityCurve)).first;
}
for (const auto& it : params.mapping(MarketObject::CommodityCurve, configuration.first)) {
if (it.second == commodityCurveSpec->name()) {
LOG("Adding CommodityCurve, " << it.first << ", with spec " << *commodityCurveSpec
<< " to configuration " << configuration.first);
commodityCurves_[make_pair(configuration.first, it.first)] =
Handle<PriceTermStructure>(itr->second->commodityPriceCurve());
}
}
break;
}
case CurveSpec::CurveType::CommodityVolatility: {
boost::shared_ptr<CommodityVolatilityCurveSpec> commodityVolSpec =
boost::dynamic_pointer_cast<CommodityVolatilityCurveSpec>(spec);
QL_REQUIRE(commodityVolSpec, "Failed to convert spec " << *spec << " to commodity volatility spec");
// Build the volatility structure if we have not built it before
auto itr = requiredCommodityVolCurves.find(commodityVolSpec->name());
if (itr == requiredCommodityVolCurves.end()) {
LOG("Building commodity volatility for asof " << asof);
boost::shared_ptr<CommodityVolCurve> commodityVolCurve = boost::make_shared<CommodityVolCurve>(
asof, *commodityVolSpec, loader, curveConfigs, conventions, requiredYieldCurves,
requiredCommodityCurves, requiredCommodityVolCurves);
itr = requiredCommodityVolCurves.insert(make_pair(commodityVolSpec->name(), commodityVolCurve))
.first;
}
// add the handle to the Market Map (possible lots of times for proxies)
for (const auto& it : params.mapping(MarketObject::CommodityVolatility, configuration.first)) {
if (it.second == spec->name()) {
string commodityName = it.first;
LOG("Adding commodity volatility (" << commodityName << ") with spec " << *commodityVolSpec
<< " to configuration " << configuration.first);
// Logic copied from Equity vol section of TodaysMarket for now
boost::shared_ptr<BlackVolTermStructure> bvts(itr->second->volatility());
Handle<YieldTermStructure> discount =
discountCurve(commodityVolSpec->currency(), configuration.first);
Handle<PriceTermStructure> priceCurve =
commodityPriceCurve(commodityName, configuration.first);
Handle<YieldTermStructure> yield = Handle<YieldTermStructure>(
boost::make_shared<PriceTermStructureAdapter>(*priceCurve, *discount));
Handle<Quote> spot(boost::make_shared<SimpleQuote>(priceCurve->price(0, true)));
bvts = boost::make_shared<QuantExt::BlackVolatilityWithATM>(bvts, spot, discount, yield);
commodityVols_[make_pair(configuration.first, it.first)] =
Handle<BlackVolTermStructure>(bvts);
}
}
break;
}
case CurveSpec::CurveType::Correlation: {
boost::shared_ptr<CorrelationCurveSpec> corrspec =
boost::dynamic_pointer_cast<CorrelationCurveSpec>(spec);
QL_REQUIRE(corrspec, "Failed to convert spec " << *spec);
// have we built the curve already ?
auto itr = requiredCorrelationCurves.find(corrspec->name());
if (itr == requiredCorrelationCurves.end()) {
// build the curve
LOG("Building CorrelationCurve for asof " << asof);
boost::shared_ptr<CorrelationCurve> corrCurve = boost::make_shared<CorrelationCurve>(
asof, *corrspec, loader, curveConfigs, conventions, requiredSwapIndices,
requiredYieldCurves, requiredSwaptionVolCurves);
itr = requiredCorrelationCurves.insert(make_pair(corrspec->name(), corrCurve)).first;
}
for (const auto& it : params.mapping(MarketObject::Correlation, configuration.first)) {
if (it.second == spec->name()) {
LOG("Adding CorrelationCurve (" << it.first << ") with spec " << *corrspec
<< " to configuration " << configuration.first);
// Look for & first as it avoids collisions with : which can be used in an index name
// if it is not there we fall back on the old behaviour
string delim;
if (it.first.find('&') != std::string::npos)
delim = "&";
else
delim = "/:";
vector<string> tokens;
boost::split(tokens, it.first, boost::is_any_of(delim));
QL_REQUIRE(tokens.size() == 2, "Invalid correlation spec " << it.first);
correlationCurves_[make_tuple(configuration.first, tokens[0], tokens[1])] =
Handle<QuantExt::CorrelationTermStructure>(itr->second->corrTermStructure());
}
}
break;
}
default: {
// maybe we just log and continue? need to update count then
QL_FAIL("Unhandled spec " << *spec);
}
}
// Swap Indices
// Assumes we build all yield curves before anything else (which order() does)
// Once we have a non-Yield curve spec, we make sure to build all swap indices
// add add them to requiredSwapIndices for later.
if (swapIndicesBuilt == false && params.hasMarketObject(MarketObject::SwapIndexCurve) &&
(count == specs.size() - 1 || specs[count + 1]->baseType() != CurveSpec::CurveType::Yield)) {
LOG("building swap indices...");
for (const auto& it : params.mapping(MarketObject::SwapIndexCurve, configuration.first)) {
const string& swapIndexName = it.first;
const string& discountIndex = it.second;
try {
addSwapIndex(swapIndexName, discountIndex, configuration.first);
LOG("Added SwapIndex " << swapIndexName << " with DiscountingIndex " << discountIndex);
requiredSwapIndices[swapIndexName] =
swapIndex(swapIndexName, configuration.first).currentLink();
} catch (const std::exception& e) {
WLOG("Failed to build swap index " << it.first << ": " << e.what());
}
}
swapIndicesBuilt = true;
}
LOG("Loading spec " << *spec << " done.");
} catch (const std::exception& e) {
ALOG(StructuredCurveErrorMessage(spec->name(), "Failed to Build Curve", e.what()));
buildErrors[spec->name()] = e.what();
}
}
LOG("Loading " << count << " CurveSpecs done.");
} // loop over configurations
if (buildErrors.size() > 0 && !continueOnError) {
string errStr;
for (auto error : buildErrors)
errStr += "(" + error.first + ": " + error.second + "); ";
QL_FAIL("Cannot build all required curves! Building failed for: " << errStr);
}
} // CTOR
} // namespace data
} // namespace ore
|
module GRL.Test.Sif
import GRL.Lang.GLang
import GRL.Eval
import GRL.Test.Utils
%default total
g1 : GOAL
g1 = mkGoal "[Goal Requirement: Suitable Security Level Nothing ]"
g2 : TASK
g2 = mkGoal "[Goal Requirement: Data Confidentiality Nothing ]"
g3 : TASK
g3 = mkTask "[Goal Requirement: Recipient Confidentiality Nothing ]"
g4 : TASK
g4 = mkTask "[Goal Requirement: Suitable performance Nothing ]"
g5 : TASK
g5 = mkTask "[Goal Requirement: Minimal Workflow Disruption Nothing ]"
g6 : TASK
g6 = mkTask "[Goal Requirement: Secure Implementation Nothing ]"
g7 : TASK
g7 = mkTask "[Goal Requirement: Comprehensible by Non-Experts Nothing ]"
model : GModel
model = insertMany [g1,g2,g3,g4,g5,g6,g7] emptyModel
t1 : TASK
t1 = mkTask "Task Solution: Public Key Cryptography Nothing"
t2 : TASK
t2 = mkTask "[Task Property: Maths Algorithm Nothing ]"
t3 : TASK
t3 = mkTask "[Task Property: Implementation in Code Nothing ]"
t4 : TASK
t4 = mkTask "[Task Property: Key Pairs Nothing ]"
t5 : TASK
t5 = mkTask "[Task Property: Variable Security Parameters Nothing ]"
t6 : TASK
t6 = mkSatTask "t6" SATISFIED
t7 : TASK
t7 = mkSatTask "[Task Trait Disadvantage: Computationally Expensive Just WEAKDEN ]" WEAKDEN
t12 : TASK
t12 = mkSatTask "[Task Trait Disadvantage: Implementation InSecure Just WEAKDEN ]" WEAKDEN
t13 : TASK
t13 = mkSatTask "[Task Trait Disadvantage: Implementation obfuscates understanding Just WEAKSATIS ]" WEAKSATIS
t16 : TASK
t16 = mkSatTask "[Task Trait Advantage: PublicEnc/PrivateDec Keys Just SATISFIED ]" SATISFIED
t17 : TASK
t17 = mkSatTask "[Task Trait Disadvantage: Key Distribution Just DENIED ]" DENIED
t18 : TASK
t18 = mkSatTask "[Task Trait Disadvantage: Key Management Just DENIED ]" DENIED
t19 : TASK
t19 = mkSatTask "[Task Trait Advantage: Greater Security Just SATISFIED ]" SATISFIED
t20 : TASK
t20 = mkSatTask "[Task Trait Disadvantage: Parameter Selection Just DENIED ]" DENIED
t21 : TASK
t21 = mkSatTask "[Task Trait Disadvantage: Parameter Computation Just DENIED ]" DENIED
decls : (ds ** DList GTy GLang ds)
decls = (_ **
[ t1,
mkAnd t1 [ t2, t3 , t4 , t5],
t2 , t6 , t7 ,
mkImpacts HELPS t6 g2 ,
mkImpacts HELPS t6 g3 ,
mkImpacts HURTS t7 g4 ,
mkImpacts HURTS t7 g5 ,
mkAnd t2 [t6 , t7],
t3 , t12 , t13 ,
mkImpacts SOMENEG t12 g3 ,
mkImpacts SOMENEG t12 g2 ,
mkImpacts UNKNOWN t12 g5 ,
mkImpacts SOMENEG t12 g6 ,
mkImpacts HURTS t13 g7 ,
mkImpacts HURTS t13 g5 ,
mkAnd t3 [t12 , t13],
t4 , t16 , t17 , t18 ,
mkImpacts MAKES t16 g3 ,
mkImpacts SOMENEG t17 g3 ,
mkImpacts SOMENEG t17 g5 ,
mkImpacts SOMENEG t18 g2 ,
mkAnd t4 [t16 , t17 , t18] ,
t5 , t19 , t20 , t21 ,
mkImpacts HELPS t19 g1 ,
mkImpacts SOMENEG t20 g1 ,
mkImpacts SOMENEG t20 g6 ,
mkImpacts HURTS t21 g4 ,
mkImpacts HURTS t21 g5 ,
mkAnd t5 [t19 , t20 , t21]
])
export
partial
runTest : IO ()
runTest = do
let (_ ** ds) = groupDecls (snd decls)
putStrLn "Strategy 1:"
let m = (insertMany' ds model)
runEval m Nothing
|
!******************************************************
! This example program is part of HiggsSignals-2 (TS 29/03/2017).
!******************************************************
program HShadr
! This example program uses the hadronic cross section input format
! to scan over the two scale factors:
! scale_ggf scales the SM single Higgs and ttH production cross section
! scale_VH scales the SM VBF, HZ and HW production cross section
!
! The output is written into /results/HShadr.dat, which can be plotted with the
! python script plot_HShadr.py in the results folder.
!******************************************************
implicit none
integer :: nHzero,nHplus,ndf, i, j, k, ii, jj, CP_value
double precision :: Pvalue,Chisq,Chisq_mu,Chisq_mh,scale_ggf,scale_VH
double precision :: SMGammaTotal, SMGamma_h
double precision :: SMBR_Htoptop,SMBR_Hss, SMBR_Hcc, SMBR_Hbb, SMBR_Htt, &
& SMBR_Hmumu, SMBR_Htautau, SMBR_HWW, SMBR_HZZ, SMBR_HZgam, SMBR_Hgamgam, SMBR_Hgg
! Entries of CS arrays: TEV, LHC7, LHC8, LHC13
double precision :: Mh,GammaTotal,CS_hj_ratio(4), &
& CS_gg_hj_ratio(4),CS_bb_hj_ratio(4), &
& CS_hjW_ratio(4),CS_hjZ_ratio(4), &
& CS_vbf_ratio(4),CS_tthj_ratio(4), &
& CS_hjhi(4),CS_thj_schan_ratio(4), &
& CS_thj_tchan_ratio(4), &
& BR_hjss,BR_hjcc, &
& BR_hjbb,BR_hjtt, &
& BR_hjmumu, &
& BR_hjtautau, &
& BR_hjWW,BR_hjZZ,BR_hjZga,BR_hjgaga, &
& BR_hjgg
character(len=100)::filename
double precision :: dm
integer :: collider,collider_s
nHzero=1
nHplus=0
dm = 0.0D0
!---- Initialize HiggsSignals and pass the name of the experimental analysis folder ----!
call initialize_HiggsSignals(nHzero,nHplus,"LHC13_CMS_H-gaga")
!---- Set the output level (0: silent, 1: screen output, 2: even more output,...) ----!
call setup_output_level(0)
!---- Set the Higgs mass parametrization (1: box, 2:gaussian, 3:box+gaussian) ----!
call setup_pdf(2)
!---- Set the assignment range for the peak-centered method (optional) ----!
call setup_assignmentrange_massobservables(4.0D0)
!---- Pass the Higgs mass uncertainty to HiggsSignals ----!
call HiggsSignals_neutral_input_MassUncertainty(dm)
!---- Set number of free model parameters ----!
call setup_Nparam(2)
!---- Open output text file ----!
filename='results/HShadr.dat'
open(21,file=filename)
write(21,*) '# Mh scale_ggf scale_VH Chisq_mu Chisq_mh Chisq ndf Pvalue'
write(21,*) '#--------------------------------------------------------------------------'
do i=1,81
do j=1,81
scale_ggf = 0.0D0 +(i-1)*0.025D0
scale_VH = 0.0D0 +(j-1)*0.05D0
! do i=1,21
! do j=1,21
! scale_ggf = 0.5D0 +(i-1)*0.05D0
! scale_VH = 0.5D0 +(j-1)*0.05D0
Mh=125.09D0
SMGammaTotal=SMGamma_h(Mh)
if(.not. (SMGammaTotal .lt. 0)) then
GammaTotal=SMGammaTotal
! CP even
CP_value=1
! This applies to all 4 elements:
CS_hj_ratio=1.0D0*scale_ggf
CS_gg_hj_ratio=1.0D0*scale_ggf
CS_bb_hj_ratio=1.0D0*scale_ggf
CS_hjW_ratio=1.0D0*scale_VH
CS_hjZ_ratio=1.0D0*scale_VH
CS_vbf_ratio=1.0D0*scale_VH
CS_tthj_ratio=1.0D0*scale_ggf
CS_hjhi=0.0D0
CS_thj_tchan_ratio=1.0D0*scale_ggf
CS_thj_schan_ratio=1.0D0*scale_ggf
BR_hjss=SMBR_Hss(Mh)
BR_hjcc=SMBR_Hcc(Mh)
BR_hjbb=SMBR_Hbb(Mh)
BR_hjmumu=SMBR_Hmumu(Mh)
BR_hjtautau=SMBR_Htautau(Mh)
BR_hjWW=SMBR_HWW(Mh)
BR_hjZZ=SMBR_HZZ(Mh)
BR_hjZga=SMBR_HZgam(Mh)
BR_hjgaga=SMBR_Hgamgam(Mh)
BR_hjgg=SMBR_Hgg(Mh)
call HiggsBounds_neutral_input_properties(Mh,GammaTotal,CP_value)
do collider=1,4
select case(collider)
case(1)
collider_s = 2
case(2)
collider_s = 7
case(3)
collider_s = 8
case(4)
collider_s = 13
end select
call HiggsBounds_neutral_input_hadr(collider_s,CS_hj_ratio(collider), &
& CS_gg_hj_ratio(collider),CS_bb_hj_ratio(collider), &
& CS_hjW_ratio(collider),CS_hjZ_ratio(collider), &
& CS_vbf_ratio(collider),CS_tthj_ratio(collider), &
& CS_thj_tchan_ratio(collider),CS_thj_schan_ratio(collider), &
& CS_hjhi(collider))
enddo
call HiggsBounds_neutral_input_SMBR(BR_hjss,BR_hjcc,BR_hjbb,BR_hjtt, &
& BR_hjmumu,BR_hjtautau,BR_hjWW,BR_hjZZ, &
& BR_hjZga,BR_hjgaga,BR_hjgg)
call run_HiggsSignals(1, Chisq_mu, Chisq_mh, Chisq, ndf, Pvalue)
write(21,*) Mh,scale_ggf,scale_VH,Chisq_mu,Chisq_mh,Chisq,ndf,Pvalue
endif
enddo
enddo
close(21)
call finish_HiggsSignals
end program HShadr
|
#' Sample wave data by NOAA
#'
#' @description
#' This sample dataset contains the wave height and wave period time series provided by
#' NOAA's WaveWatch III project for location 30.5N, 240E. Two variations of the dataset are
#' included:
#'
#' 1) the hourly time series (\code{ww3_ts}), interpolated down from 3-hourly data before
#' March 2010, and
#'
#' 2) the extracted wave peak data (\code{ww3_pk}), where the peaks are extracted base
#' on the peak Hs and/or peak Tp.
#'
#' @docType data
#'
#' @name ww3_data
#' @aliases ww3_pk ww3_ts
#'
#' @format An object of class \code{data.table} with columns \code{time}, \code{hs} and \code{tp};
#' see \code{\link{data.table}}.
#'
#' @references The WAVEWATCH III Development Group., 2016:
#' User manual and system documentation of WAVEWATCH III version 5.16.
#' NOAA / NWS / NCEP / MMAB Technical Note 329, 326 pp. + Appendices.
#'
#' @source \href{https://polar.ncep.noaa.gov/waves/}{NOAA WAVEWATCH III Model}
#'
#' @examples
#' data(ww3_ts)
#' data(ww3_pk)
NULL |
[STATEMENT]
lemma option_while'_inj:
assumes "(s,s') \<in> option_while' C B" "(s, s'') \<in> option_while' C B"
shows "s' = s''"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. s' = s''
[PROOF STEP]
using assms
[PROOF STATE]
proof (prove)
using this:
(s, s') \<in> option_while' C B
(s, s'') \<in> option_while' C B
goal (1 subgoal):
1. s' = s''
[PROOF STEP]
by (induct rule: option_while'.induct) (auto elim: option_while'.cases) |
= BRIX11 host build command
== Collection
common
== Usage
brix11 host build [options]
=== options
-c, --clean Clean only.
-r, --rebuild Clean and than build.
-G, --generate Always (re-)generate project files
Default: only generate if project files do not exist.
-N, --no-redirect Do not redirect output from child process..
Default: redirect and filter output.
-f, --force Force all tasks to run even if their dependencies do not require them to.
Default: off
-v, --verbose Run with increased verbosity level. Repeat to increase more.
Default: 0
-h, --help Show this help message.
== Description
Build the local, minimal, crossbuild host tools.
The _brix11_ _configure_ command sets up a local, minimalized crossbuild host environment in
the $X11_BASE_ROOT/HOST folder when a crossbuild is configured without specifying an explicit
external host environment. This command allows to generate the project files and (re-)build the
minimum required host tool binaries for building the crossbuild itself.
== Example
$ brix11 host build
Build the host tools.
$ brix11 host build -r
Rebuild the host tools (clean first and than make again).
$ brix11 host build -G
Force (re-)generation of project files before making the host tools.
|
{-# OPTIONS --without-K --safe #-}
module Cats.Displayed where
open import Data.Product using (Σ ; Σ-syntax ; _,_)
open import Level using (_⊔_ ; suc)
open import Relation.Binary using
(Setoid ; IsEquivalence ; Rel ; REL ; _Preserves₂_⟶_⟶_)
open import Cats.Category
record DisplayedCategory {lo la l≈} (C : Category lo la l≈) lo′ la′ l≈′
: Set (lo ⊔ la ⊔ l≈ ⊔ suc (lo′ ⊔ la′ ⊔ l≈′)) where
infixr 9 _∘_
infix 4 _≈[_]_
infixr -1 _⇒[_]_
Base = C
module Base = Category Base
private
module C = Category C
field
Obj : (c : C.Obj) → Set lo′
_⇒[_]_ : ∀ {a b} (a⁺ : Obj a) (f : a C.⇒ b) (b⁺ : Obj b) → Set la′
_≈[_]_ : ∀ {a b} {f g : a C.⇒ b} {a⁺ : Obj a} {b⁺ : Obj b}
→ a⁺ ⇒[ f ] b⁺
→ f C.≈ g
→ a⁺ ⇒[ g ] b⁺
→ Set l≈′
id : ∀ {a} {a⁺ : Obj a} → a⁺ ⇒[ C.id ] a⁺
_∘_ : ∀ {a b c} {a⁺ : Obj a} {b⁺ : Obj b} {c⁺ : Obj c}
→ {f : b C.⇒ c} {g : a C.⇒ b}
→ (f⁺ : b⁺ ⇒[ f ] c⁺) (g⁺ : a⁺ ⇒[ g ] b⁺)
→ a⁺ ⇒[ f C.∘ g ] c⁺
≈-refl : ∀ {a b} {f : a C.⇒ b} {a⁺ : Obj a} {b⁺ : Obj b} {f⁺ : a⁺ ⇒[ f ] b⁺}
→ f⁺ ≈[ C.≈.refl ] f⁺
≈-sym : ∀ {a b} {f g : a C.⇒ b} {f≈g : f C.≈ g} {a⁺ : Obj a} {b⁺ : Obj b}
→ {f⁺ : a⁺ ⇒[ f ] b⁺} {g⁺ : a⁺ ⇒[ g ] b⁺}
→ f⁺ ≈[ f≈g ] g⁺
→ g⁺ ≈[ C.≈.sym f≈g ] f⁺
≈-trans : ∀ {a b}
→ {f g h : a C.⇒ b} {f≈g : f C.≈ g} {g≈h : g C.≈ h}
→ {a⁺ : Obj a} {b⁺ : Obj b}
→ {f⁺ : a⁺ ⇒[ f ] b⁺} {g⁺ : a⁺ ⇒[ g ] b⁺} {h⁺ : a⁺ ⇒[ h ] b⁺}
→ f⁺ ≈[ f≈g ] g⁺ → g⁺ ≈[ g≈h ] h⁺
→ f⁺ ≈[ C.≈.trans f≈g g≈h ] h⁺
∘-resp : ∀ {a b c} {f g : b C.⇒ c} {h i : a C.⇒ b}
→ {f≈g : f C.≈ g} {h≈i : h C.≈ i}
→ {a⁺ : Obj a} {b⁺ : Obj b} {c⁺ : Obj c}
→ {f⁺ : b⁺ ⇒[ f ] c⁺} {g⁺ : b⁺ ⇒[ g ] c⁺}
→ {h⁺ : a⁺ ⇒[ h ] b⁺} {i⁺ : a⁺ ⇒[ i ] b⁺}
→ f⁺ ≈[ f≈g ] g⁺
→ h⁺ ≈[ h≈i ] i⁺
→ f⁺ ∘ h⁺ ≈[ C.∘-resp f≈g h≈i ] g⁺ ∘ i⁺
id-r : ∀ {a b} {f : a C.⇒ b} {a⁺ : Obj a} {b⁺ : Obj b} {f⁺ : a⁺ ⇒[ f ] b⁺}
→ f⁺ ∘ id ≈[ C.id-r ] f⁺
id-l : ∀ {a b} {f : a C.⇒ b} {a⁺ : Obj a} {b⁺ : Obj b} {f⁺ : a⁺ ⇒[ f ] b⁺}
→ id ∘ f⁺ ≈[ C.id-l ] f⁺
assoc : ∀ {a b c d} {f : c C.⇒ d} {g : b C.⇒ c} {h : a C.⇒ b}
→ {a⁺ : Obj a} {b⁺ : Obj b} {c⁺ : Obj c} {d⁺ : Obj d}
→ {f⁺ : c⁺ ⇒[ f ] d⁺} {g⁺ : b⁺ ⇒[ g ] c⁺} {h⁺ : a⁺ ⇒[ h ] b⁺}
→ (f⁺ ∘ g⁺) ∘ h⁺ ≈[ C.assoc ] f⁺ ∘ (g⁺ ∘ h⁺)
module BuildTotal
{lo la l≈} {C : Category lo la l≈} {lo′ la′ l≈′}
(D : DisplayedCategory C lo′ la′ l≈′)
where
infixr 9 _∘_
infix 4 _≈_
infixr -1 _⇒_
private
module C = Category C
module D = DisplayedCategory D
Obj : Set (lo ⊔ lo′)
Obj = Σ[ c ∈ C.Obj ] D.Obj c
_⇒_ : (a b : Obj) → Set (la ⊔ la′)
(a , a⁺) ⇒ (b , b⁺) = Σ[ f ∈ a C.⇒ b ] (a⁺ D.⇒[ f ] b⁺)
_≈_ : ∀ {a b} → Rel (a ⇒ b) (l≈ ⊔ l≈′)
(f , f⁺) ≈ (g , g⁺) = Σ[ f≈g ∈ f C.≈ g ] f⁺ D.≈[ f≈g ] g⁺
id : ∀ {a} → a ⇒ a
id = C.id , D.id
_∘_ : ∀ {a b c} → b ⇒ c → a ⇒ b → a ⇒ c
(f , f⁺) ∘ (g , g⁺) = (f C.∘ g) , (f⁺ D.∘ g⁺)
equiv : ∀ {a b} → IsEquivalence (_≈_ {a} {b})
equiv = record
{ refl = C.≈.refl , D.≈-refl
; sym = λ where
(f≈g , f⁺≈g⁺) → C.≈.sym f≈g , D.≈-sym f⁺≈g⁺
; trans = λ where
(f≈g , f⁺≈g⁺) (g≈h , g⁺≈h⁺) → C.≈.trans f≈g g≈h , D.≈-trans f⁺≈g⁺ g⁺≈h⁺
}
∘-resp : ∀ {a b c} → (_∘_ {a} {b} {c} Preserves₂ _≈_ ⟶ _≈_ ⟶ _≈_)
∘-resp (f≈g , f⁺≈g⁺) (h≈i , h⁺≈i⁺) = C.∘-resp f≈g h≈i , D.∘-resp f⁺≈g⁺ h⁺≈i⁺
id-r : ∀ {a b} {f : a ⇒ b} → f ∘ id ≈ f
id-r = C.id-r , D.id-r
id-l : ∀ {a b} {f : a ⇒ b} → id ∘ f ≈ f
id-l = C.id-l , D.id-l
assoc : ∀ {a b c d} {f : c ⇒ d} {g : b ⇒ c} {h : a ⇒ b}
→ (f ∘ g) ∘ h ≈ f ∘ (g ∘ h)
assoc = C.assoc , D.assoc
Total : Category (lo ⊔ lo′) (la ⊔ la′) (l≈ ⊔ l≈′)
Total = record
{ Obj = Obj
; _⇒_ = _⇒_
; _≈_ = _≈_
; id = id
; _∘_ = _∘_
; equiv = equiv
; ∘-resp = ∘-resp
; id-r = id-r
; id-l = id-l
; assoc = assoc
}
open BuildTotal public using (Total)
|
#Blank file
Checkin updates
|
module GTLC
import Data.Fin
import Data.Vect
import Data.So
%default total
-- The Representation of types
mutual
data Ty = TyDyn | TyInt | TyBool | TyFun Ty Ty
mutual
-- The representation of Dyn values
data Dyn : Type where
inj : (t : Ty) -> (x : interpTy t) -> Dyn
-- Convert Ty to Type in proof land
data Ty2T : Ty -> Type -> Type where
d2d : Ty2T TyDyn Dyn
i2i : Ty2T TyInt Int
b2b : Ty2T TyBool Bool
f2f : Ty2T a b -> Ty2T c d -> Ty2T (TyFun a c) (b -> Maybe d)
-- Compute the real type of interpreted Ty values
total
interpTy : Ty -> Type
interpTy TyDyn = Dyn
interpTy TyInt = Int
interpTy TyBool = Bool
interpTy (TyFun A T) = (interpTy A) -> Maybe (interpTy T)
-- Proof that two Types are consistent
data consistTy : Ty -> Ty -> Type where
refl : consistTy a a
dynR : consistTy a TyDyn
dynL : consistTy TyDyn a
funC : consistTy a b -> consistTy c d -> consistTy (TyFun a c) (TyFun b d)
data joinTy : Ty -> Ty -> Ty -> Type where
const : joinTy a a a
right : joinTy TyDyn a a
left : joinTy a TyDyn a
under : joinTy a b c -> joinTy d e f ->
joinTy (TyFun a d) (TyFun b e) (TyFun c f)
-- I am Interested in how this is implemented but it represents a type index
-- that allows variables types to be computed computed while typechecking.
using (G : Vect n Ty)
-- An index for variable types
data HasType : (i : Fin n) -> Vect n Ty -> Ty -> Type where
Stop : HasType FZ (t :: G) t
Pop : HasType k G t -> HasType (FS k) (u :: G) t
-- The Explicitly Typed Cast Calculus
data Expr : Vect n Ty -> Ty -> Type where
Var : HasType i G t -> Expr G t
ValI : (v : Int) -> Expr G TyInt
ValB : (v : Bool) -> Expr G TyBool
ILam : Expr (a :: G) t -> Expr G (TyFun a t)
IApp : Expr G (TyFun a t) -> Expr G a -> Expr G t
IOp : (interpTy a -> interpTy b -> interpTy c) ->
Expr G a -> Expr G b -> Expr G c
IIf : Expr G TyBool -> Lazy (Expr G a) -> Lazy (Expr G a) -> Expr G a
ICast : Expr G t -> (t : Ty) -> (g : Ty) -> Expr G g
mkCast : Expr G t1 -> (t1 : Ty) -> (t2 : Ty) -> (p : consistTy t1 t2) -> Expr G t2
mkCast e s t p = (ICast e s t)
-- mkCast refl s t e = e -- mkCast is really dumb currently
-- Lam is an unannotated lambda
Lam : Expr (TyDyn :: G) t -> Expr G (TyFun TyDyn t)
Lam = ILam
-- LamT is a lambda that accecpts a non dynamic type annotation
LamT : (t : Ty) -> Expr (t :: G) g -> Expr G (TyFun t g)
LamT t = ILam
-- If is the "smart" constructor for if terms
If : Expr G tt -> Lazy (Expr G tc) -> Lazy (Expr G ta) ->
{auto ct : consistTy tt TyBool} ->
{auto cc : consistTy tc tr} ->
{auto ca : consistTy ta tr} ->
Expr G tr
If {ct=dynL}{cc}{ca} t c a = If {ct=refl}{cc}{ca} (ICast t TyDyn TyBool) c a
If {ct=refl}{cc=refl}{ca=refl} t c a = IIf t c a
If {ct=refl}{tc}{ta}{tr} t c a = IIf t (ICast c tc tr) (ICast a ta tr)
-- App is the smart constructor for Application terms
data AppRule : Ty -> Ty -> Ty -> Type where
fApp : AppRule (TyFun a b) a b
dApp : AppRule TyDyn TyDyn TyDyn
App : Expr G tf -> Expr G ta -> {auto ar : AppRule tf ra rr} ->
{auto cf : consistTy tf (TyFun ra rr)} -> {auto ca : consistTy ta ra} -> Expr G rr
App f a {cf} {ca} {tf} {ra} {rr} {ta} = IApp (mkCast f tf (TyFun ra rr) cf)
(mkCast a ta ra ca)
-- Op is the smart constructor for operators
Op : (interpTy oa -> interpTy ob -> interpTy c) -> Expr G aa -> Expr G ab ->
{auto pa : consistTy aa oa} ->
{auto pb : consistTy ab ob} -> Expr G c
Op p a b {pa} {aa} {oa} {pb} {ab} {ob} = IOp p (mkCast a aa oa pa) (mkCast b ab ob pb)
-- The lexical environment of the interpreter
data Env : Vect n Ty -> Type where
Nil : Env Nil
(::) : interpTy a -> Env G -> Env (a :: G)
-- Lookup of lexical values in the interpreter
lookup : HasType i G t -> Env G -> interpTy t
lookup Stop (x :: xs) = x
lookup (Pop k) (x :: xs) = lookup k xs
mutual
-- Cast between types computed in the smart constructors
rtCast : (t : Ty) -> (g : Ty) -> (x : interpTy t) -> Maybe (interpTy g)
rtCast TyDyn TyDyn x = return x
rtCast TyInt TyInt x = return x
rtCast TyBool TyBool x = return x
rtCast TyDyn g (inj t' x) = rtCast t' g x
rtCast t' TyDyn x = return (inj t' x)
rtCast (TyFun a b)(TyFun c d) f =
return (\x => rtCast b d !(f !(rtCast c a x)))
rtCast _ _ _ = Nothing
-- The GTLC interpreter
interp : Env G -> Expr G ty -> Maybe (interpTy ty)
interp env (Var i) = return (lookup i env)
interp env (ValI x) = return x
interp env (ValB x) = return x
interp env (ICast x r1 r2) = ?ICast --rtCast r1 r2 !(interp env x)
interp env (ILam b) = return (\x => interp (x :: env) b)
interp env (IOp op x y) = return (op !(interp env x) !(interp env y))
interp env (IApp f s) = (!(interp env f) !(interp env s))
interp env (IIf t c a) = return (if !(interp env t)
then !(interp env c)
else !(interp env a))
-- unit tests
-- unit tests for consist
a2 : consistTy TyInt TyInt
a2 = refl
a0 : consistTy TyDyn TyDyn
a0 = refl
a1 : consistTy TyDyn TyBool
a1 = dynL
a3 : consistTy TyInt TyDyn
a3 = dynR
a4 : consistTy (TyFun TyInt TyBool) (TyFun TyInt TyBool)
a4 = refl
a5 : consistTy (TyFun TyInt TyBool) (TyFun TyInt TyBool)
a5 = funC refl refl
a6 : consistTy (TyFun TyDyn TyBool) (TyFun TyInt TyDyn)
a6 = funC dynL dynR
-- unit tests of coersion calculus forms
c0 : Expr [] TyInt
c0 = ValI 1
c1 : Expr [] TyBool
c1 = ValB True
-- unit tests of gradually typed forms
t0 : Expr [] TyInt
t0 = ValI 1
t0' : Expr [] TyBool
t0' = ValB True
t1 : Expr [] (TyFun TyDyn TyDyn)
t1 = Lam (Var Stop)
t2 : Expr [] (TyFun TyInt TyInt)
t2 = LamT TyInt (Var Stop)
-- unit test on the gradual If smart constructor
t3 : Expr [] TyInt
t3 = (If (ValB True) (ValI 0) (ValI 1))
t4 : Expr [TyDyn] TyInt
t4 = (If (Var Stop) (ValI 0) (ValI 1))
t5 : Expr [TyDyn] TyInt
t5 = (If (Var Stop) (Var Stop) (ValI 1))
t6 : Expr [TyDyn] TyInt
t6 = (If (Var Stop) (Var Stop) (Var Stop))
t7 : Expr [TyDyn] TyDyn
t7 = (If (Var Stop) (ValI 0) (ValB True))
-- unit tests for the gradual App smart constructor
t8 : Expr [] TyInt
t8 = App (LamT TyInt (Var Stop)) (ValI 1)
t9 : Expr [] TyDyn
t9 = App (Lam (Var Stop)) (ValI 1)
t10 : Expr [] TyDyn
t10 = App (Lam (If (Var Stop) (ValI 0) (Var Stop))) (ValI 1)
sub1 : Expr [] (TyFun TyInt TyInt)
sub1 = LamT TyInt (Op (-) (Var Stop) (ValI 1))
zerop : Expr [] (TyFun TyInt TyBool)
zerop = LamT TyInt (Op (==) (ValI 0) (Var Stop))
--zerod : Expr [] (TyFun TyDyn TyBool)
--zerod = Lam (Op (==) (ValI 0) (Var Stop))
{-
fact : Expr [] (TyFun TyDyn TyInt)
fact = (Lam (If (App zerop (Var Stop))
(ValI 1)
(Op (*) (Var Stop) (App fact (App sub1 (Var Stop))))))
-}
-- unit tests for the interpreter
i0 : Maybe Int
i0 = (interp [] (ValI 0))
i0p : i0 = Just 0
i0p = Refl
i1 : Maybe Bool
i1 = (interp [] (ValB True))
i1p : i1 = Just True
i1p = Refl
--main : IO ()
--main = putStrLn (show i0)
|
Load LFindLoad.
From lfind Require Import LFind.
From QuickChick Require Import QuickChick.
From adtind Require Import goal33.
Derive Show for natural.
Derive Arbitrary for natural.
Instance Dec_Eq_natural : Dec_Eq natural.
Proof. dec_eq. Qed.
Lemma conj6synthconj2 : forall (lv0 : natural) (lv1 : natural), (@eq natural (mult Zero lv0) (mult lv0 lv1)).
Admitted.
QuickChick conj6synthconj2.
|
a := [ 8, 2, 5, 9, 1, 3, 6, 7, 4 ];
# Make a copy (with "b := a;", b and a would point to the same list)
b := ShallowCopy(a);
# Sort in place
Sort(a);
a;
# [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]
# Sort without changing the argument
SortedList(b);
# [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]
b;
# [ 8, 2, 5, 9, 1, 3, 6, 7, 4 ]
|
[STATEMENT]
lemma cr_cr_vfsequence_bi_unqie[transfer_rule]: "bi_unique cr_cr_vfsequence"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. bi_unique cr_cr_vfsequence
[PROOF STEP]
unfolding cr_cr_vfsequence_def bi_unique_def
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. (\<forall>x y z. x = vfsequence_of_vlist (map vfsequence_of_vlist y) \<longrightarrow> x = vfsequence_of_vlist (map vfsequence_of_vlist z) \<longrightarrow> y = z) \<and> (\<forall>x y z. x = vfsequence_of_vlist (map vfsequence_of_vlist z) \<longrightarrow> y = vfsequence_of_vlist (map vfsequence_of_vlist z) \<longrightarrow> x = y)
[PROOF STEP]
by (simp add: inj_eq inj_vfsequence_of_vlist) |
State Before: α : Type u_1
β : Type ?u.319127
γ : Type ?u.319130
δ : Type ?u.319133
ι : Type ?u.319136
R : Type ?u.319139
R' : Type ?u.319142
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
hs : ↑↑μ s ≠ 0
p : α → Prop
hp : ∀ᵐ (x : α) ∂restrict μ s, p x
⊢ ∃ x, x ∈ s ∧ p x State After: α : Type u_1
β : Type ?u.319127
γ : Type ?u.319130
δ : Type ?u.319133
ι : Type ?u.319136
R : Type ?u.319139
R' : Type ?u.319142
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
hs : ∃ᵐ (a : α) ∂restrict μ s, a ∈ s
p : α → Prop
hp : ∀ᵐ (x : α) ∂restrict μ s, p x
⊢ ∃ x, x ∈ s ∧ p x Tactic: rw [← μ.restrict_apply_self, ← frequently_ae_mem_iff] at hs State Before: α : Type u_1
β : Type ?u.319127
γ : Type ?u.319130
δ : Type ?u.319133
ι : Type ?u.319136
R : Type ?u.319139
R' : Type ?u.319142
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
hs : ∃ᵐ (a : α) ∂restrict μ s, a ∈ s
p : α → Prop
hp : ∀ᵐ (x : α) ∂restrict μ s, p x
⊢ ∃ x, x ∈ s ∧ p x State After: no goals Tactic: exact (hs.and_eventually hp).exists |
function model = mvuOptimise(model, display, iters)
% MVUOPTIMISE Optimise an MVU model.
% FORMAT
% DESC optimises a maximum variance unfolding model.
% ARG model : the model to be optimised.
% RETURN model : the optimised model.
%
% SEEALSO : mvuCreate, modelOptimise
%
% COPYRIGHT : Neil D. Lawrence, 2009
% MLTOOLS
if(any(any(isnan(model.Y))))
error('Cannot run MVU when missing data is present.');
end
[X, details] = mvu(distance(model.Y'), model.k, 'solver', model.solver);
model.X = X(1:1:model.q,:)';
model.lambda = details.D/sum(details.D);
function D = distance(Y)
D = sqrt(dist2(Y', Y'));
return
|
Require Import Essentials.Notations.
Require Import Essentials.Types.
Require Import Essentials.Facts_Tactics.
Require Import Category.Main.
Require Import Basic_Cons.Equalizer.
Require Import Coq_Cats.Type_Cat.Type_Cat.
Local Obligation Tactic := idtac.
(** Just like in category of sets, in category of types, the equalizer is the type
that reperesents the subset of the cartesian profuct of the domain of the two functions
that is mapped to equal values by both functions. *)
Section Equalizer.
Context {A B : Type} (f g : A → B).
Program Definition Type_Cat_Eq : Equalizer Type_Cat f g :=
{|
equalizer := {x : A | f x = g x};
equalizer_morph := @proj1_sig _ _;
equalizer_morph_ex :=
fun T eqm H x =>
exist _ (eqm x) _
|}.
Next Obligation.
Proof.
extensionality x; destruct x as [x Px]; trivial.
Qed.
Next Obligation.
Proof.
intros T eqm H x.
apply (fun w => equal_f w x) in H; trivial.
Qed.
Next Obligation.
Proof.
trivial.
Qed.
Next Obligation.
Proof.
intros T eqm H1 u u' H2 H3.
extensionality x.
apply (fun w => equal_f w x) in H2; cbn in H2.
apply (fun w => equal_f w x) in H3; cbn in H3.
destruct (u x) as [ux e]; destruct (u' x) as [ux' e']; cbn in *.
destruct H2; destruct H3.
PIR.
trivial.
Qed.
End Equalizer.
(** Similar to the category set, in category of types, the coequalizer of two functions
f,g : A -> B is quotient of B with respect to the equivalence relation ~. Here, ~
is the equivalence closure of the relation for which we have
x ~ y if and only if ∃z. (f(z) = x) ∧ (g(z) = y)
*)
Program Instance Type_Cat_Has_Equalizers : Has_Equalizers Type_Cat := fun _ _ => Type_Cat_Eq.
Require Import Coq.Relations.Relations Coq.Relations.Relation_Definitions.
Require Import Coq.Logic.ClassicalChoice Coq.Logic.ChoiceFacts.
Require Coq.Logic.ClassicalFacts.
Section CoEqualizer.
Context {A B : Type} (f g : A → B).
Local Obligation Tactic := idtac.
Definition CoEq_rel_base : relation B := fun x y => exists z, f z = x ∧ g z = y.
Definition CoEq_rel : relation B := clos_refl_sym_trans _ CoEq_rel_base.
Definition CoEq_rel_refl := equiv_refl _ _ (clos_rst_is_equiv _ CoEq_rel_base).
Definition CoEq_rel_sym := equiv_sym _ _ (clos_rst_is_equiv _ CoEq_rel_base).
Definition CoEq_rel_trans := equiv_trans _ _ (clos_rst_is_equiv _ CoEq_rel_base).
Definition CoEq_Type := {P : B → Prop | exists z : B, P z ∧ (∀ (y : B), (P y ↔ CoEq_rel z y))}.
Local Axiom ConstructiveIndefiniteDescription_B : ConstructiveIndefiniteDescription_on B.
Definition CoEq_Choice (ct : CoEq_Type) : {x : B | (proj1_sig ct) x}.
Proof.
apply ConstructiveIndefiniteDescription_B.
destruct ct as [P [z [H1 H2]]].
exists z; trivial.
Defined.
Local Axiom PropExt : ClassicalFacts.prop_extensionality.
Theorem CoEq_rel_Ext : ∀ (x : A) (y : B), CoEq_rel (f x) y = CoEq_rel (g x) y.
Proof.
intros x y.
assert (Hx : CoEq_rel (f x) (g x)).
{
constructor 1.
exists x; split; trivial.
}
apply PropExt; split; intros H.
{
apply CoEq_rel_sym in Hx.
apply (CoEq_rel_trans _ _ _ Hx H).
}
{
apply (CoEq_rel_trans _ _ _ Hx H).
}
Qed.
Program Definition Type_Cat_CoEq : CoEqualizer Type_Cat f g :=
{|
equalizer := CoEq_Type
|}.
Next Obligation.
Proof.
cbn in *.
intros x.
exists (fun y => CoEq_rel x y).
exists x; split.
apply CoEq_rel_refl.
intros z; split; intros; trivial.
Defined.
Next Obligation.
Proof.
extensionality x.
apply sig_proof_irrelevance.
extensionality y.
apply CoEq_rel_Ext.
Qed.
Next Obligation.
Proof.
intros T F H x.
exact (F (proj1_sig (CoEq_Choice x))).
Defined.
Next Obligation.
Proof.
intros T eqm H.
unfold Type_Cat_CoEq_obligation_1, Type_Cat_CoEq_obligation_3.
extensionality x.
cbn in *.
match goal with
[|- eqm (proj1_sig ?A) = _] =>
destruct A as [z Hz]
end.
cbn in *.
induction Hz as [? ? [w [[] []]]| | |]; auto.
{
eapply equal_f in H; eauto.
}
Qed.
Next Obligation.
Proof.
intros T eqm H1 u u' H2 H3.
destruct H3.
extensionality x.
destruct x as [P [z [Hz1 Hz2]]].
unfold Type_Cat_CoEq_obligation_1 in H2; cbn in *.
apply equal_f with (x := z) in H2.
match goal with
[|- ?A = ?B] =>
match type of H2 with
?C = ?D => cutrewrite (A = C); [cutrewrite (B = D)|]; trivial
end
end.
{
apply f_equal.
apply sig_proof_irrelevance; cbn.
extensionality y; apply PropExt; trivial.
}
{
apply f_equal.
apply sig_proof_irrelevance; cbn.
extensionality y; apply PropExt; trivial.
}
Qed.
End CoEqualizer.
Program Instance Type_Cat_Has_CoEqualizers : Has_CoEqualizers Type_Cat := fun _ _ => Type_Cat_CoEq. |
-- @@stderr --
dtrace: failed to compile script test/unittest/lexer/err.D_SYNTAX.brace2.d: [D_SYNTAX] line 17: syntax error near end of input
|
module subst where
open import lib
open import cedille-types
open import ctxt-types
open import is-free
open import rename
open import general-util
open import syntax-util
substh-ret-t : Set → Set
substh-ret-t T = ∀ {ed} → ctxt → renamectxt → trie ⟦ ed ⟧ → T → T
substh : ∀ {ed} → substh-ret-t ⟦ ed ⟧
substh-term : substh-ret-t term
substh-type : substh-ret-t type
substh-kind : substh-ret-t kind
substh-tk : substh-ret-t tk
substh-optClass : substh-ret-t optClass
substh-optGuide : substh-ret-t optGuide
substh-optTerm : substh-ret-t optTerm
substh-optType : substh-ret-t optType
substh-liftingType : substh-ret-t liftingType
substh-arg : substh-ret-t arg
substh-args : substh-ret-t args
substh-params : substh-ret-t params
substh-cases : substh-ret-t cases
substh-varargs : {ed : exprd} → ctxt → renamectxt → trie ⟦ ed ⟧ → varargs → varargs × renamectxt
substh{TERM} = substh-term
substh{TYPE} = substh-type
substh{KIND} = substh-kind
substh{LIFTINGTYPE} = substh-liftingType
substh{TK} = substh-tk
substh{ARG} = substh-arg
substh{QUALIF} = λ Γ ρ σ q → q
subst-rename-var-if : {ed : exprd} → ctxt → renamectxt → var → trie ⟦ ed ⟧ → var
subst-rename-var-if Γ ρ "_" σ = "_"
subst-rename-var-if Γ ρ x σ =
{- rename bound variable x iff it is one of the vars being substituted for,
or if x occurs free in one of the terms we are substituting for vars,
or if it is the renamed version of any variable -}
if trie-contains σ x || trie-any (is-free-in check-erased x) σ || renamectxt-in-range ρ x || ctxt-binds-var Γ x then
rename-away-from x (λ s → ctxt-binds-var Γ s || trie-contains σ s) ρ
else
x
substh-term Γ ρ σ (App t m t') = App (substh-term Γ ρ σ t) m (substh-term Γ ρ σ t')
substh-term Γ ρ σ (AppTp t tp) = AppTp (substh-term Γ ρ σ t) (substh-type Γ ρ σ tp)
substh-term Γ ρ σ (Hole x₁) = Hole x₁
substh-term Γ ρ σ (Lam _ b _ x oc t) =
let x' = subst-rename-var-if Γ ρ x σ in
Lam posinfo-gen b posinfo-gen x' (substh-optClass Γ ρ σ oc)
(substh-term (ctxt-var-decl x' Γ) (renamectxt-insert ρ x x') σ t)
substh-term Γ ρ σ (Let _ (DefTerm _ x m t) t') =
let x' = subst-rename-var-if Γ ρ x σ in
(Let posinfo-gen (DefTerm posinfo-gen x' (substh-optType Γ ρ σ m) (substh-term Γ ρ σ t))
(substh-term (ctxt-var-decl x' Γ) (renamectxt-insert ρ x x') σ t'))
substh-term Γ ρ σ (Let _ (DefType _ x k t) t') =
let x' = subst-rename-var-if Γ ρ x σ in
(Let posinfo-gen (DefType posinfo-gen x' (substh-kind Γ ρ σ k) (substh-type Γ ρ σ t))
(substh-term (ctxt-var-decl x' Γ) (renamectxt-insert ρ x x') σ t'))
substh-term Γ ρ σ (Open _ x t) = Open posinfo-gen x (substh-term Γ ρ σ t)
substh-term Γ ρ σ (Parens _ t _) = substh-term Γ ρ σ t
substh-term{TERM} Γ ρ σ (Var _ x) =
let x' = renamectxt-rep ρ x in
trie-lookup-else (Var posinfo-gen x') σ x'
substh-term{ARG} Γ ρ σ (Var _ x) =
let x' = renamectxt-rep ρ x in
inst-lookup-term σ x'
substh-term{QUALIF} Γ ρ σ (Var _ x) =
let x' = renamectxt-rep ρ x in
qualif-lookup-term σ x'
substh-term Γ ρ σ (Var _ x) = Var posinfo-gen (renamectxt-rep ρ x)
substh-term Γ ρ σ (Beta _ ot ot') = Beta posinfo-gen (substh-optTerm Γ ρ σ ot) (substh-optTerm Γ ρ σ ot')
substh-term Γ ρ σ (IotaPair _ t1 t2 og pi') = IotaPair posinfo-gen (substh-term Γ ρ σ t1) (substh-term Γ ρ σ t2) (substh-optGuide Γ ρ σ og) pi'
substh-term Γ ρ σ (IotaProj t n _) = IotaProj (substh-term Γ ρ σ t) n posinfo-gen
substh-term Γ ρ σ (Epsilon _ lr m t) = Epsilon posinfo-gen lr m (substh-term Γ ρ σ t)
substh-term Γ ρ σ (Sigma _ t) = Sigma posinfo-gen (substh-term Γ ρ σ t)
substh-term Γ ρ σ (Phi _ t t₁ t₂ _) = Phi posinfo-gen (substh-term Γ ρ σ t) (substh-term Γ ρ σ t₁) (substh-term Γ ρ σ t₂) posinfo-gen
substh-term Γ ρ σ (Rho _ op on t og t') = Rho posinfo-gen op on (substh-term Γ ρ σ t) (substh-optGuide Γ ρ σ og) (substh-term Γ ρ σ t')
substh-term Γ ρ σ (Chi _ T t') = Chi posinfo-gen (substh-optType Γ ρ σ T) (substh-term Γ ρ σ t')
substh-term Γ ρ σ (Delta _ T t') = Delta posinfo-gen (substh-optType Γ ρ σ T) (substh-term Γ ρ σ t')
substh-term Γ ρ σ (Theta _ θ t ls) = Theta posinfo-gen (substh-theta θ) (substh-term Γ ρ σ t) (substh-lterms ls)
where substh-lterms : lterms → lterms
substh-lterms (LtermsNil pi) = LtermsNil pi
substh-lterms (LtermsCons m t ls) = LtermsCons m (substh-term Γ ρ σ t) (substh-lterms ls)
substh-vars : vars → vars
substh-vars (VarsStart x) = VarsStart (renamectxt-rep ρ x)
substh-vars (VarsNext x xs) = VarsNext (renamectxt-rep ρ x) (substh-vars xs)
substh-theta : theta → theta
substh-theta (AbstractVars xs) = AbstractVars (substh-vars xs)
substh-theta θ = θ
substh-term Γ ρ σ (Mu _ x t ot _ cs _) =
let x' = subst-rename-var-if Γ ρ x σ in
let ρ' = renamectxt-insert ρ x x' in
Mu posinfo-gen x' (substh-term (ctxt-var-decl x' Γ) ρ' σ t) (substh-optType Γ ρ σ ot) posinfo-gen (substh-cases Γ ρ' σ cs) posinfo-gen
substh-term Γ ρ σ (Mu' _ t ot _ cs _) = Mu' posinfo-gen (substh-term Γ ρ σ t) (substh-optType Γ ρ σ ot) posinfo-gen (substh-cases Γ ρ σ cs) posinfo-gen
substh-cases Γ ρ σ NoCase = NoCase
substh-cases Γ ρ σ (SomeCase _ x varargs t cs) =
let res = substh-varargs Γ ρ σ varargs in
SomeCase posinfo-gen x (fst res) (substh-term Γ (snd res) σ t) (substh-cases Γ ρ σ cs)
substh-varargs Γ ρ σ NoVarargs = NoVarargs , ρ
substh-varargs Γ ρ σ (NormalVararg x varargs) =
let x' = subst-rename-var-if Γ ρ x σ in
let ρ' = renamectxt-insert ρ x x' in
let res = substh-varargs Γ ρ' σ varargs in
NormalVararg x' (fst res) , snd res
substh-varargs Γ ρ σ (ErasedVararg x varargs) =
let x' = subst-rename-var-if Γ ρ x σ in
let ρ' = renamectxt-insert ρ x x' in
let res = substh-varargs Γ ρ' σ varargs in
ErasedVararg x' (fst res) , snd res
substh-varargs Γ ρ σ (TypeVararg x varargs) =
let x' = subst-rename-var-if Γ ρ x σ in
let ρ' = renamectxt-insert ρ x x' in
let res = substh-varargs Γ ρ' σ varargs in
TypeVararg x' (fst res) , snd res
substh-type Γ ρ σ (Abs _ b _ x atk t) =
let x' = subst-rename-var-if Γ ρ x σ in
Abs posinfo-gen b posinfo-gen x' (substh-tk Γ ρ σ atk)
(substh-type (ctxt-var-decl x' Γ) (renamectxt-insert ρ x x') σ t)
substh-type Γ ρ σ (TpLambda _ _ x atk t) =
let x' = subst-rename-var-if Γ ρ x σ in
TpLambda posinfo-gen posinfo-gen x' (substh-tk Γ ρ σ atk)
(substh-type (ctxt-var-decl x' Γ) (renamectxt-insert ρ x x') σ t)
substh-type Γ ρ σ (Iota _ _ x m t) =
let x' = subst-rename-var-if Γ ρ x σ in
Iota posinfo-gen posinfo-gen x' (substh-type Γ ρ σ m)
(substh-type (ctxt-var-decl x' Γ) (renamectxt-insert ρ x x') σ t)
substh-type Γ ρ σ (Lft _ _ x t l) =
let x' = subst-rename-var-if Γ ρ x σ in
Lft posinfo-gen posinfo-gen x' (substh-term (ctxt-var-decl x' Γ) (renamectxt-insert ρ x x') σ t)
(substh-liftingType Γ ρ σ l)
substh-type Γ ρ σ (TpApp tp tp₁) = TpApp (substh-type Γ ρ σ tp) (substh-type Γ ρ σ tp₁)
substh-type Γ ρ σ (TpAppt tp t) = TpAppt (substh-type Γ ρ σ tp) (substh-term Γ ρ σ t)
substh-type Γ ρ σ (TpArrow tp arrowtype tp₁) = TpArrow (substh-type Γ ρ σ tp) arrowtype (substh-type Γ ρ σ tp₁)
substh-type Γ ρ σ (TpEq _ x₁ x₂ _) = TpEq posinfo-gen (substh-term Γ ρ σ x₁) (substh-term Γ ρ σ x₂) posinfo-gen
substh-type Γ ρ σ (TpParens _ tp _) = substh-type Γ ρ σ tp
substh-type Γ ρ σ (NoSpans tp _) = substh-type Γ ρ σ tp
substh-type{TYPE} Γ ρ σ (TpVar _ x) =
let x' = renamectxt-rep ρ x in
trie-lookup-else (TpVar posinfo-gen x') σ x'
substh-type{ARG} Γ ρ σ (TpVar _ x) =
let x' = renamectxt-rep ρ x in
inst-lookup-type σ x'
substh-type{QUALIF} Γ ρ σ (TpVar _ x) =
let x' = renamectxt-rep ρ x in
qualif-lookup-type σ x'
substh-type Γ ρ σ (TpVar _ x) = TpVar posinfo-gen (renamectxt-rep ρ x)
substh-type Γ ρ σ (TpHole _) = TpHole posinfo-gen --ACG
substh-type Γ ρ σ (TpLet _ (DefTerm _ x m t) t') =
let x' = subst-rename-var-if Γ ρ x σ in
(TpLet posinfo-gen (DefTerm posinfo-gen x' (substh-optType Γ ρ σ m) (substh-term Γ ρ σ t))
(substh-type (ctxt-var-decl x' Γ) (renamectxt-insert ρ x x') σ t'))
substh-type Γ ρ σ (TpLet _ (DefType _ x k t) t') =
let x' = subst-rename-var-if Γ ρ x σ in
(TpLet posinfo-gen (DefType posinfo-gen x' (substh-kind Γ ρ σ k) (substh-type Γ ρ σ t))
(substh-type (ctxt-var-decl x' Γ) (renamectxt-insert ρ x x') σ t'))
substh-kind Γ ρ σ (KndArrow k k₁) = KndArrow (substh-kind Γ ρ σ k) (substh-kind Γ ρ σ k₁)
substh-kind Γ ρ σ (KndParens x₁ k x₂) = substh-kind Γ ρ σ k
substh-kind Γ ρ σ (KndPi _ _ x atk k) =
let x' = subst-rename-var-if Γ ρ x σ in
KndPi posinfo-gen posinfo-gen x' (substh-tk Γ ρ σ atk)
(substh-kind (ctxt-var-decl x' Γ) (renamectxt-insert ρ x x') σ k)
substh-kind Γ ρ σ (KndTpArrow t k) = KndTpArrow (substh-type Γ ρ σ t) (substh-kind Γ ρ σ k)
substh-kind{QUALIF} Γ ρ σ (KndVar _ x xs) =
qualif-lookup-kind (substh-args Γ ρ σ xs) σ x
substh-kind Γ ρ σ (KndVar _ x xs) = KndVar posinfo-gen x (substh-args Γ ρ σ xs)
substh-kind Γ ρ σ (Star _) = Star posinfo-gen
substh-arg Γ ρ σ (TermArg me t) = TermArg me (substh-term Γ ρ σ t)
substh-arg Γ ρ σ (TypeArg T) = TypeArg (substh-type Γ ρ σ T)
substh-args Γ ρ σ (ArgsCons a as) = ArgsCons (substh-arg Γ ρ σ a) (substh-args Γ ρ σ as)
substh-args Γ ρ σ ArgsNil = ArgsNil
substh-params{QUALIF} Γ ρ σ (ParamsCons (Decl _ pi me x atk _) ps) =
ParamsCons (Decl posinfo-gen posinfo-gen me (pi % x) (substh-tk Γ ρ σ atk) posinfo-gen)
(substh-params Γ (renamectxt-insert ρ x (pi % x)) (trie-remove σ (pi % x)) ps)
substh-params Γ ρ σ (ParamsCons (Decl _ _ me x atk _) ps) =
ParamsCons (Decl posinfo-gen posinfo-gen me x (substh-tk Γ ρ σ atk) posinfo-gen)
(substh-params Γ (renamectxt-insert ρ x x) (trie-remove σ x) ps)
substh-params Γ ρ σ ParamsNil = ParamsNil
substh-tk Γ ρ σ (Tkk k) = Tkk (substh-kind Γ ρ σ k)
substh-tk Γ ρ σ (Tkt t) = Tkt (substh-type Γ ρ σ t)
substh-optClass Γ ρ σ NoClass = NoClass
substh-optClass Γ ρ σ (SomeClass atk) = SomeClass (substh-tk Γ ρ σ atk)
substh-liftingType Γ ρ σ (LiftArrow l l₁) = LiftArrow (substh-liftingType Γ ρ σ l) (substh-liftingType Γ ρ σ l₁)
substh-liftingType Γ ρ σ (LiftParens _ l _) = substh-liftingType Γ ρ σ l
substh-liftingType Γ ρ σ (LiftPi _ x tp l) =
let x' = subst-rename-var-if Γ ρ x σ in
LiftPi posinfo-gen x' (substh-type Γ ρ σ tp)
(substh-liftingType (ctxt-var-decl x' Γ) (renamectxt-insert ρ x x') σ l)
substh-liftingType Γ ρ σ (LiftStar _) = LiftStar posinfo-gen
substh-liftingType Γ ρ σ (LiftTpArrow tp l) =
LiftTpArrow (substh-type Γ ρ σ tp) (substh-liftingType Γ ρ σ l)
substh-optType Γ ρ σ NoType = NoType
substh-optType Γ ρ σ (SomeType T) = SomeType (substh-type Γ ρ σ T)
substh-optTerm Γ ρ σ NoTerm = NoTerm
substh-optTerm Γ ρ σ (SomeTerm t _) = (SomeTerm (substh-term Γ ρ σ t) posinfo-gen)
substh-optGuide Γ ρ σ NoGuide = NoGuide
substh-optGuide Γ ρ σ (Guide _ x T) =
let x' = subst-rename-var-if Γ ρ x σ in
Guide posinfo-gen x' (substh-type (ctxt-var-decl x' Γ) (renamectxt-insert ρ x x') σ T)
subst-ret-t : Set → Set
subst-ret-t T = {ed : exprd} → ctxt → ⟦ ed ⟧ → var → T → T
subst : ∀ {ed} → subst-ret-t ⟦ ed ⟧
subst Γ t x = substh Γ empty-renamectxt (trie-single x t)
subst-term = subst {TERM}
subst-type = subst {TYPE}
subst-kind = subst {KIND}
subst-liftingType = subst {LIFTINGTYPE}
subst-tk = subst {TK}
subst-renamectxt : ∀ {ed : exprd} → ctxt → renamectxt → ⟦ ed ⟧ → ⟦ ed ⟧
subst-renamectxt {ed} Γ ρ = substh {ed} {ed} Γ ρ empty-trie
rename-var : ∀ {ed} → ctxt → var → var → ⟦ ed ⟧ → ⟦ ed ⟧
rename-var Γ x x' = subst-renamectxt Γ (renamectxt-single x x')
substs-ret-t : Set → Set
substs-ret-t T = ∀ {ed} → ctxt → trie ⟦ ed ⟧ → T → T
substs : ∀ {ed} → substs-ret-t ⟦ ed ⟧
substs Γ = substh Γ empty-renamectxt
substs-term = substs {TERM}
substs-type = substs {TYPE}
substs-kind = substs {KIND}
substs-liftingType = substs {LIFTINGTYPE}
substs-tk = substs {TK}
substs-args : substs-ret-t args
substs-args Γ = substh-args Γ empty-renamectxt
substs-params : substs-ret-t params
substs-params Γ = substh-params Γ empty-renamectxt
subst-params-args : ∀ {ed} → ctxt → params → args → ⟦ ed ⟧ → ⟦ ed ⟧ × params × args
subst-params-args Γ (ParamsCons (Decl _ _ me x atk _) ps) (ArgsCons a as) t =
subst-params-args Γ (substs-params Γ (trie-single x a) ps) as (subst Γ a x t)
subst-params-args Γ ps as t = t , ps , as
|
#include <boost/type_erasure/typeid_of.hpp>
|
-- @@stderr --
dtrace: failed to compile script test/unittest/inline/err.D_OP_INCOMPAT.baddef2.d: [D_OP_INCOMPAT] line 20: inline i definition uses incompatible types: "int" = "string"
|
# -*-rd-*-
= Getting RubyCocoa
== Binary Distribution
=== for Mac OS X 10.3
RubyCocoa's binary distribution has been built for the Ruby 1.6.8 distributed
with Mac OS X 10.3.
Download
((<RubyCocoa-0.4.2-panther.dmg|URL:http://prdownloads.sourceforge.net/rubycocoa/RubyCocoa-0.4.2-panther.dmg?download>))
from ((<file list|URL:http://sourceforge.net/project/showfiles.php?group_id=44114>)).
It includes library, samples, templates for Project Builder, etc. for both
RubyCocoa and RubyAEOSA. Everything necessary for execution and development is
included in an easy-to-install '.pkg' package file.
A successful installation of the binary package will add the following items:
: /Library/Frameworks/RubyCocoa.framework
RubyCocoa framework (core)
: inside of /usr/lib/ruby/site_ruby/1.6/osx/
RubyCocoa library (stub)
: /usr/lib/ruby/site_ruby/1.6/powerpc-darwin7.0/rubycocoa.bundle
RubyCocoa extended library (stub)
: inside of '/Library/Application Support/Apple/Developer Tools'
Some templates for Xcode
: inside of '/Developer/ProjectBuilder Extras/'
Some templates for ProjectBuilder
: /Developer/Documentation/RubyCocoa
HTML documentation
: /Developer/Examples/RubyCocoa
Sample programs
After installation, try the samples that are written in Ruby. Refer
to ((<'Try RubyCocoa Samples'|URL:trysamples.en.html>)).
=== for Mac OS X 10.4
RubyCocoa's binary distribution has been built for the Ruby 1.8.2 distributed
with Mac OS X 10.4.
Download
((<RubyCocoa-0.4.2-tiger.dmg|URL:http://prdownloads.sourceforge.net/rubycocoa/RubyCocoa-0.4.2-tiger.dmg?download>))
from ((<file list|URL:http://sourceforge.net/project/showfiles.php?group_id=44114>)).
=== for Mac OS X 10.2
RubyCocoa's binary distribution has been built for the Ruby 1.6.7 distributed
with Mac OS X 10.2.
Download
((<RubyCocoa-0.4.2-jaguar.dmg|URL:http://prdownloads.sourceforge.net/rubycocoa/RubyCocoa-0.4.2-jaguar.dmg?download>))
from ((<file list|URL:http://sourceforge.net/project/showfiles.php?group_id=44114>)).
== Source Distribution
Download
((<rubycocoa-0.4.2.tgz|URL:http://prdownloads.sourceforge.net/rubycocoa/rubycocoa-0.4.2.tgz?download>))
from ((<file list|URL:http://sourceforge.net/project/showfiles.php?group_id=44114>)).
To build and install RubyCocoa, refer to
((<"Build and Install RubyCocoa from Source"|URL:build.en.html>)).
== Getting Development Source from CVS Server
The latest (or the oldest) development source is available from the
((<CVS Server|URL:http://sourceforge.net/cvs/?group_id=44114>)).
You can
((<view the CVS Repository|URL:http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/rubycocoa/>))
for RubyCocoa. On the shell command line, type this:
$ cvs -d:pserver:[email protected]:/cvsroot/rubycocoa login
$ cvs -z3 -d:pserver:[email protected]:/cvsroot/rubycocoa co \
-P -d rubycocoa src
$ cd rubycocoa
$ cvs update -d -P
All of the source for RubyCocoa is downloaded into a directory named 'rubycocoa'.
Building may fail because of the nature of CVS. Some cvs commands such as
'cvs update' or 'cvs status -v' will be helpful. Use these commands
with appropriate options.
== DarwinPorts
((<DarwinPorts|URL:http://darwinports.opendarwin.org/>)) has a port
"rb-cocoa" for RubyCocoa(0.4.1).
The port requires DarwinPorts version 1.1. You can update your DarwinPorts
with following command:
$ sudo port -d selfupdate
== PINEAPPLE RPM Package
RPM format binary (0.2.x) exist on
((<Project PINEAPPLE (Japanese)|URL:http://sacral.c.u-tokyo.ac.jp/~hasimoto/Pineapple/>)).
$Date: 2005-11-06 20:24:54 +0900 (日, 06 11 2005) $
|
{-# OPTIONS --cubical --safe --guardedness #-}
module Container.Fixpoint where
open import Container
open import Prelude
data μ {s p} (C : Container s p) : Type (s ℓ⊔ p) where
sup : ⟦ C ⟧ (μ C) → μ C
record ν {s p} (C : Container s p) : Type (s ℓ⊔ p) where
coinductive
field inf : ⟦ C ⟧ (ν C)
open ν public
|
using StatsBase, Turing
using Gadfly
# include("ASCIIPlot.jl")
import Gadfly.ElementOrFunction
# First add a method to the basic Gadfly.plot function for QQPair types (generated by Distributions.qqbuild())
Gadfly.plot(qq::QQPair, elements::ElementOrFunction...) = Gadfly.plot(x=qq.qx, y=qq.qy, Geom.point, Theme(highlight_width=0px), elements...)
# Now some shorthand functions
qqplot(x, y, elements::ElementOrFunction...) = Gadfly.plot(qqbuild(x, y), elements...)
qqnorm(x, elements::ElementOrFunction...) = qqplot(Normal(), x, Guide.xlabel("Theoretical Normal quantiles"), Guide.ylabel("Observed quantiles"), elements...)
NSamples = 5000
@model gdemo_fw() = begin
s ~ InverseGamma(2,3)
m ~ Normal(0, sqrt(s))
y ~ MvNormal([m; m; m], [sqrt(s) 0 0; 0 sqrt(s) 0; 0 0 sqrt(s)])
end
@model gdemo_bk(x) = begin
# Backward Step 1: theta ~ theta | x
s ~ InverseGamma(2,3)
m ~ Normal(0,sqrt(s))
x ~ MvNormal([m; m; m], [sqrt(s) 0 0; 0 sqrt(s) 0; 0 0 sqrt(s)])
# Backward Step 2: x ~ x | theta
y ~ MvNormal([m; m; m], [sqrt(s) 0 0; 0 sqrt(s) 0; 0 0 sqrt(s)])
end
fw = HMCDA(NSamples, 0.9, 0.1)
# bk = Gibbs(10, PG(10,10, :s, :y), HMC(1, 0.25, 5, :m));
bk = HMCDA(50, 0.9, 0.1);
s = sample(gdemo_fw(), fw);
# describe(s)
N = div(NSamples, 50)
x = [s[:y][1]...]
s_bk = Array{Turing.Chain}(undef, N)
simple_logger = Base.CoreLogging.SimpleLogger(stderr, Base.CoreLogging.Debug)
with_logger(simple_logger) do
i = 1
while i <= N
try
s_bk[i] = sample(gdemo_bk(x), bk);
x = [s_bk[i][:y][end]...];
i += 1
catch
end
end
do
s2 = vcat(s_bk...);
# describe(s2)
qqplot(s[:m], s2[:m])
qqplot(s[:s], s2[:s])
using Test
qqm = qqbuild(s[:m], s2[:m])
X = qqm.qx
y = qqm.qy
slope = (1 / (transpose(X) * X)[1] * transpose(X) * y)[1]
@test slope ≈ 1.0 atol=0.1
# NOTE: test for s is not stable
# probably due to the transformation
# qqs = qqbuild(s[:s], s2[:s])
# X = qqs.qx
# y = qqs.qy
# slope = (1 / (transpose(X) * X)[1] * transpose(X) * y)[1]
# @test slope ≈ 1.0 atol=0.1
|
/-
Copyright (c) 2019 Floris van Doorn. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Floris van Doorn, Yury Kudryashov, Sébastien Gouëzel, Chris Hughes
-/
import data.fin.basic
import order.pilex
/-!
# Operation on tuples
We interpret maps `Π i : fin n, α i` as `n`-tuples of elements of possibly varying type `α i`,
`(α 0, …, α (n-1))`. A particular case is `fin n → α` of elements with all the same type.
In this case when `α i` is a constant map, then tuples are isomorphic (but not definitionally equal)
to `vector`s.
We define the following operations:
* `fin.tail` : the tail of an `n+1` tuple, i.e., its last `n` entries;
* `fin.cons` : adding an element at the beginning of an `n`-tuple, to get an `n+1`-tuple;
* `fin.init` : the beginning of an `n+1` tuple, i.e., its first `n` entries;
* `fin.snoc` : adding an element at the end of an `n`-tuple, to get an `n+1`-tuple. The name `snoc`
comes from `cons` (i.e., adding an element to the left of a tuple) read in reverse order.
* `fin.insert_nth` : insert an element to a tuple at a given position.
* `fin.find p` : returns the first index `n` where `p n` is satisfied, and `none` if it is never
satisfied.
-/
universes u v
namespace fin
variables {m n : ℕ}
open function
section tuple
/-- There is exactly one tuple of size zero. -/
example (α : fin 0 → Sort u) : unique (Π i : fin 0, α i) :=
by apply_instance
@[simp] lemma tuple0_le {α : Π i : fin 0, Type*} [Π i, preorder (α i)] (f g : Π i, α i) : f ≤ g :=
fin_zero_elim
variables {α : fin (n+1) → Type u} (x : α 0) (q : Πi, α i) (p : Π(i : fin n), α (i.succ))
(i : fin n) (y : α i.succ) (z : α 0)
/-- The tail of an `n+1` tuple, i.e., its last `n` entries. -/
def tail (q : Πi, α i) : (Π(i : fin n), α (i.succ)) := λ i, q i.succ
lemma tail_def {n : ℕ} {α : fin (n+1) → Type*} {q : Π i, α i} :
tail (λ k : fin (n+1), q k) = (λ k : fin n, q k.succ) := rfl
/-- Adding an element at the beginning of an `n`-tuple, to get an `n+1`-tuple. -/
def cons (x : α 0) (p : Π(i : fin n), α (i.succ)) : Πi, α i :=
λ j, fin.cases x p j
@[simp] lemma tail_cons : tail (cons x p) = p :=
by simp [tail, cons]
@[simp] lemma cons_succ : cons x p i.succ = p i :=
by simp [cons]
@[simp] lemma cons_zero : cons x p 0 = x :=
by simp [cons]
/-- Updating a tuple and adding an element at the beginning commute. -/
@[simp] lemma cons_update : cons x (update p i y) = update (cons x p) i.succ y :=
begin
ext j,
by_cases h : j = 0,
{ rw h, simp [ne.symm (succ_ne_zero i)] },
{ let j' := pred j h,
have : j'.succ = j := succ_pred j h,
rw [← this, cons_succ],
by_cases h' : j' = i,
{ rw h', simp },
{ have : j'.succ ≠ i.succ, by rwa [ne.def, succ_inj],
rw [update_noteq h', update_noteq this, cons_succ] } }
end
/-- As a binary function, `fin.cons` is injective. -/
lemma cons_injective2 : function.injective2 (@cons n α) :=
λ x₀ y₀ x y h, ⟨congr_fun h 0, funext $ λ i, by simpa using congr_fun h (fin.succ i)⟩
@[simp] lemma cons_eq_cons {x₀ y₀ : α 0} {x y : Π i : fin n, α (i.succ)} :
cons x₀ x = cons y₀ y ↔ x₀ = y₀ ∧ x = y :=
cons_injective2.eq_iff
lemma cons_left_injective (x : Π i : fin n, α (i.succ)) : function.injective (λ x₀, cons x₀ x) :=
cons_injective2.left _
lemma cons_right_injective (x₀ : α 0) : function.injective (cons x₀) :=
cons_injective2.right _
/-- Adding an element at the beginning of a tuple and then updating it amounts to adding it
directly. -/
lemma update_cons_zero : update (cons x p) 0 z = cons z p :=
begin
ext j,
by_cases h : j = 0,
{ rw h, simp },
{ simp only [h, update_noteq, ne.def, not_false_iff],
let j' := pred j h,
have : j'.succ = j := succ_pred j h,
rw [← this, cons_succ, cons_succ] }
end
/-- Concatenating the first element of a tuple with its tail gives back the original tuple -/
@[simp] lemma cons_self_tail : cons (q 0) (tail q) = q :=
begin
ext j,
by_cases h : j = 0,
{ rw h, simp },
{ let j' := pred j h,
have : j'.succ = j := succ_pred j h,
rw [← this, tail, cons_succ] }
end
/-- Recurse on an `n+1`-tuple by splitting it into a single element and an `n`-tuple. -/
@[elab_as_eliminator]
def cons_induction {P : (Π i : fin n.succ, α i) → Sort v}
(h : ∀ x₀ x, P (fin.cons x₀ x)) (x : (Π i : fin n.succ, α i)) : P x :=
_root_.cast (by rw cons_self_tail) $ h (x 0) (tail x)
@[simp] lemma cons_induction_cons {P : (Π i : fin n.succ, α i) → Sort v}
(h : Π x₀ x, P (fin.cons x₀ x)) (x₀ : α 0) (x : Π i : fin n, α i.succ) :
@cons_induction _ _ _ h (cons x₀ x) = h x₀ x :=
begin
rw [cons_induction, cast_eq],
congr',
exact tail_cons _ _
end
/-- Updating the first element of a tuple does not change the tail. -/
@[simp] lemma tail_update_zero : tail (update q 0 z) = tail q :=
by { ext j, simp [tail, fin.succ_ne_zero] }
/-- Updating a nonzero element and taking the tail commute. -/
@[simp] lemma tail_update_succ :
tail (update q i.succ y) = update (tail q) i y :=
begin
ext j,
by_cases h : j = i,
{ rw h, simp [tail] },
{ simp [tail, (fin.succ_injective n).ne h, h] }
end
lemma comp_cons {α : Type*} {β : Type*} (g : α → β) (y : α) (q : fin n → α) :
g ∘ (cons y q) = cons (g y) (g ∘ q) :=
begin
ext j,
by_cases h : j = 0,
{ rw h, refl },
{ let j' := pred j h,
have : j'.succ = j := succ_pred j h,
rw [← this, cons_succ, comp_app, cons_succ] }
end
lemma comp_tail {α : Type*} {β : Type*} (g : α → β) (q : fin n.succ → α) :
g ∘ (tail q) = tail (g ∘ q) :=
by { ext j, simp [tail] }
lemma le_cons [Π i, preorder (α i)] {x : α 0} {q : Π i, α i} {p : Π i : fin n, α i.succ} :
q ≤ cons x p ↔ q 0 ≤ x ∧ tail q ≤ p :=
forall_fin_succ.trans $ and_congr iff.rfl $ forall_congr $ λ j, by simp [tail]
lemma cons_le [Π i, preorder (α i)] {x : α 0} {q : Π i, α i} {p : Π i : fin n, α i.succ} :
cons x p ≤ q ↔ x ≤ q 0 ∧ p ≤ tail q :=
@le_cons _ (λ i, order_dual (α i)) _ x q p
lemma cons_le_cons [Π i, preorder (α i)] {x₀ y₀ : α 0} {x y : Π i : fin n, α (i.succ)} :
cons x₀ x ≤ cons y₀ y ↔ x₀ ≤ y₀ ∧ x ≤ y :=
forall_fin_succ.trans $ and_congr_right' $ by simp only [cons_succ, pi.le_def]
lemma pi_lex_lt_cons_cons {x₀ y₀ : α 0} {x y : Π i : fin n, α (i.succ)}
(s : Π {i : fin n.succ}, α i → α i → Prop) :
pi.lex (<) @s (fin.cons x₀ x) (fin.cons y₀ y) ↔
s x₀ y₀ ∨ x₀ = y₀ ∧ pi.lex (<) (λ i : fin n, @s i.succ) x y :=
begin
simp_rw [pi.lex, fin.exists_fin_succ, fin.cons_succ, fin.cons_zero, fin.forall_fin_succ],
simp [and_assoc, exists_and_distrib_left],
end
@[simp]
lemma range_cons {α : Type*} {n : ℕ} (x : α) (b : fin n → α) :
set.range (fin.cons x b : fin n.succ → α) = insert x (set.range b) :=
begin
ext y,
simp only [set.mem_range, set.mem_insert_iff],
split,
{ rintros ⟨i, rfl⟩,
refine cases (or.inl (cons_zero _ _)) (λ i, or.inr ⟨i, _⟩) i,
rw cons_succ },
{ rintros (rfl | ⟨i, hi⟩),
{ exact ⟨0, fin.cons_zero _ _⟩ },
{ refine ⟨i.succ, _⟩,
rw [cons_succ, hi] } }
end
/-- `fin.append ho u v` appends two vectors of lengths `m` and `n` to produce
one of length `o = m + n`. `ho` provides control of definitional equality
for the vector length. -/
def append {α : Type*} {o : ℕ} (ho : o = m + n) (u : fin m → α) (v : fin n → α) : fin o → α :=
λ i, if h : (i : ℕ) < m
then u ⟨i, h⟩
else v ⟨(i : ℕ) - m, (tsub_lt_iff_left (le_of_not_lt h)).2 (ho ▸ i.property)⟩
@[simp] lemma fin_append_apply_zero {α : Type*} {o : ℕ} (ho : (o + 1) = (m + 1) + n)
(u : fin (m + 1) → α) (v : fin n → α) :
fin.append ho u v 0 = u 0 := rfl
end tuple
section tuple_right
/-! In the previous section, we have discussed inserting or removing elements on the left of a
tuple. In this section, we do the same on the right. A difference is that `fin (n+1)` is constructed
inductively from `fin n` starting from the left, not from the right. This implies that Lean needs
more help to realize that elements belong to the right types, i.e., we need to insert casts at
several places. -/
variables {α : fin (n+1) → Type u} (x : α (last n)) (q : Πi, α i) (p : Π(i : fin n), α i.cast_succ)
(i : fin n) (y : α i.cast_succ) (z : α (last n))
/-- The beginning of an `n+1` tuple, i.e., its first `n` entries -/
def init (q : Πi, α i) (i : fin n) : α i.cast_succ :=
q i.cast_succ
lemma init_def {n : ℕ} {α : fin (n+1) → Type*} {q : Π i, α i} :
init (λ k : fin (n+1), q k) = (λ k : fin n, q k.cast_succ) := rfl
/-- Adding an element at the end of an `n`-tuple, to get an `n+1`-tuple. The name `snoc` comes from
`cons` (i.e., adding an element to the left of a tuple) read in reverse order. -/
def snoc (p : Π(i : fin n), α i.cast_succ) (x : α (last n)) (i : fin (n+1)) : α i :=
if h : i.val < n
then _root_.cast (by rw fin.cast_succ_cast_lt i h) (p (cast_lt i h))
else _root_.cast (by rw eq_last_of_not_lt h) x
@[simp] lemma init_snoc : init (snoc p x) = p :=
begin
ext i,
have h' := fin.cast_lt_cast_succ i i.is_lt,
simp [init, snoc, i.is_lt, h'],
convert cast_eq rfl (p i)
end
@[simp] lemma snoc_cast_succ : snoc p x i.cast_succ = p i :=
begin
have : i.cast_succ.val < n := i.is_lt,
have h' := fin.cast_lt_cast_succ i i.is_lt,
simp [snoc, this, h'],
convert cast_eq rfl (p i)
end
@[simp] lemma snoc_comp_cast_succ {n : ℕ} {α : Sort*} {a : α} {f : fin n → α} :
(snoc f a : fin (n + 1) → α) ∘ cast_succ = f :=
funext (λ i, by rw [function.comp_app, snoc_cast_succ])
@[simp] lemma snoc_last : snoc p x (last n) = x :=
by { simp [snoc] }
/-- Updating a tuple and adding an element at the end commute. -/
@[simp] lemma snoc_update : snoc (update p i y) x = update (snoc p x) i.cast_succ y :=
begin
ext j,
by_cases h : j.val < n,
{ simp only [snoc, h, dif_pos],
by_cases h' : j = cast_succ i,
{ have C1 : α i.cast_succ = α j, by rw h',
have E1 : update (snoc p x) i.cast_succ y j = _root_.cast C1 y,
{ have : update (snoc p x) j (_root_.cast C1 y) j = _root_.cast C1 y, by simp,
convert this,
{ exact h'.symm },
{ exact heq_of_cast_eq (congr_arg α (eq.symm h')) rfl } },
have C2 : α i.cast_succ = α (cast_succ (cast_lt j h)),
by rw [cast_succ_cast_lt, h'],
have E2 : update p i y (cast_lt j h) = _root_.cast C2 y,
{ have : update p (cast_lt j h) (_root_.cast C2 y) (cast_lt j h) = _root_.cast C2 y,
by simp,
convert this,
{ simp [h, h'] },
{ exact heq_of_cast_eq C2 rfl } },
rw [E1, E2],
exact eq_rec_compose _ _ _ },
{ have : ¬(cast_lt j h = i),
by { assume E, apply h', rw [← E, cast_succ_cast_lt] },
simp [h', this, snoc, h] } },
{ rw eq_last_of_not_lt h,
simp [ne.symm (ne_of_lt (cast_succ_lt_last i))] }
end
/-- Adding an element at the beginning of a tuple and then updating it amounts to adding it
directly. -/
lemma update_snoc_last : update (snoc p x) (last n) z = snoc p z :=
begin
ext j,
by_cases h : j.val < n,
{ have : j ≠ last n := ne_of_lt h,
simp [h, update_noteq, this, snoc] },
{ rw eq_last_of_not_lt h,
simp }
end
/-- Concatenating the first element of a tuple with its tail gives back the original tuple -/
@[simp] lemma snoc_init_self : snoc (init q) (q (last n)) = q :=
begin
ext j,
by_cases h : j.val < n,
{ have : j ≠ last n := ne_of_lt h,
simp [h, update_noteq, this, snoc, init, cast_succ_cast_lt],
have A : cast_succ (cast_lt j h) = j := cast_succ_cast_lt _ _,
rw ← cast_eq rfl (q j),
congr' 1; rw A },
{ rw eq_last_of_not_lt h,
simp }
end
/-- Updating the last element of a tuple does not change the beginning. -/
@[simp] lemma init_update_last : init (update q (last n) z) = init q :=
by { ext j, simp [init, ne_of_lt, cast_succ_lt_last] }
/-- Updating an element and taking the beginning commute. -/
@[simp] lemma init_update_cast_succ :
init (update q i.cast_succ y) = update (init q) i y :=
begin
ext j,
by_cases h : j = i,
{ rw h, simp [init] },
{ simp [init, h] }
end
/-- `tail` and `init` commute. We state this lemma in a non-dependent setting, as otherwise it
would involve a cast to convince Lean that the two types are equal, making it harder to use. -/
lemma tail_init_eq_init_tail {β : Type*} (q : fin (n+2) → β) :
tail (init q) = init (tail q) :=
by { ext i, simp [tail, init, cast_succ_fin_succ] }
/-- `cons` and `snoc` commute. We state this lemma in a non-dependent setting, as otherwise it
would involve a cast to convince Lean that the two types are equal, making it harder to use. -/
lemma cons_snoc_eq_snoc_cons {β : Type*} (a : β) (q : fin n → β) (b : β) :
@cons n.succ (λ i, β) a (snoc q b) = snoc (cons a q) b :=
begin
ext i,
by_cases h : i = 0,
{ rw h, refl },
set j := pred i h with ji,
have : i = j.succ, by rw [ji, succ_pred],
rw [this, cons_succ],
by_cases h' : j.val < n,
{ set k := cast_lt j h' with jk,
have : j = k.cast_succ, by rw [jk, cast_succ_cast_lt],
rw [this, ← cast_succ_fin_succ],
simp },
rw [eq_last_of_not_lt h', succ_last],
simp
end
lemma comp_snoc {α : Type*} {β : Type*} (g : α → β) (q : fin n → α) (y : α) :
g ∘ (snoc q y) = snoc (g ∘ q) (g y) :=
begin
ext j,
by_cases h : j.val < n,
{ have : j ≠ last n := ne_of_lt h,
simp [h, this, snoc, cast_succ_cast_lt] },
{ rw eq_last_of_not_lt h,
simp }
end
lemma comp_init {α : Type*} {β : Type*} (g : α → β) (q : fin n.succ → α) :
g ∘ (init q) = init (g ∘ q) :=
by { ext j, simp [init] }
end tuple_right
section insert_nth
variables {α : fin (n+1) → Type u} {β : Type v}
/-- Define a function on `fin (n + 1)` from a value on `i : fin (n + 1)` and values on each
`fin.succ_above i j`, `j : fin n`. This version is elaborated as eliminator and works for
propositions, see also `fin.insert_nth` for a version without an `@[elab_as_eliminator]`
attribute. -/
@[elab_as_eliminator]
def succ_above_cases {α : fin (n + 1) → Sort u} (i : fin (n + 1)) (x : α i)
(p : Π j : fin n, α (i.succ_above j)) (j : fin (n + 1)) : α j :=
if hj : j = i then eq.rec x hj.symm
else if hlt : j < i then eq.rec_on (succ_above_cast_lt hlt) (p _)
else eq.rec_on (succ_above_pred $ (ne.lt_or_lt hj).resolve_left hlt) (p _)
lemma forall_iff_succ_above {p : fin (n + 1) → Prop} (i : fin (n + 1)) :
(∀ j, p j) ↔ p i ∧ ∀ j, p (i.succ_above j) :=
⟨λ h, ⟨h _, λ j, h _⟩, λ h, succ_above_cases i h.1 h.2⟩
/-- Insert an element into a tuple at a given position. For `i = 0` see `fin.cons`,
for `i = fin.last n` see `fin.snoc`. See also `fin.succ_above_cases` for a version elaborated
as an eliminator. -/
def insert_nth (i : fin (n + 1)) (x : α i) (p : Π j : fin n, α (i.succ_above j)) (j : fin (n + 1)) :
α j :=
succ_above_cases i x p j
@[simp] lemma insert_nth_apply_same (i : fin (n + 1)) (x : α i) (p : Π j, α (i.succ_above j)) :
insert_nth i x p i = x :=
by simp [insert_nth, succ_above_cases]
@[simp] lemma insert_nth_apply_succ_above (i : fin (n + 1)) (x : α i) (p : Π j, α (i.succ_above j))
(j : fin n) :
insert_nth i x p (i.succ_above j) = p j :=
begin
simp only [insert_nth, succ_above_cases, dif_neg (succ_above_ne _ _)],
by_cases hlt : j.cast_succ < i,
{ rw [dif_pos ((succ_above_lt_iff _ _).2 hlt)],
apply eq_of_heq ((eq_rec_heq _ _).trans _),
rw [cast_lt_succ_above hlt] },
{ rw [dif_neg (mt (succ_above_lt_iff _ _).1 hlt)],
apply eq_of_heq ((eq_rec_heq _ _).trans _),
rw [pred_succ_above (le_of_not_lt hlt)] }
end
@[simp] lemma succ_above_cases_eq_insert_nth :
@succ_above_cases.{u + 1} = @insert_nth.{u} := rfl
@[simp] lemma insert_nth_comp_succ_above (i : fin (n + 1)) (x : β) (p : fin n → β) :
insert_nth i x p ∘ i.succ_above = p :=
funext $ insert_nth_apply_succ_above i x p
lemma insert_nth_eq_iff {i : fin (n + 1)} {x : α i} {p : Π j, α (i.succ_above j)} {q : Π j, α j} :
i.insert_nth x p = q ↔ q i = x ∧ p = (λ j, q (i.succ_above j)) :=
by simp [funext_iff, forall_iff_succ_above i, eq_comm]
lemma eq_insert_nth_iff {i : fin (n + 1)} {x : α i} {p : Π j, α (i.succ_above j)} {q : Π j, α j} :
q = i.insert_nth x p ↔ q i = x ∧ p = (λ j, q (i.succ_above j)) :=
eq_comm.trans insert_nth_eq_iff
lemma insert_nth_apply_below {i j : fin (n + 1)} (h : j < i) (x : α i)
(p : Π k, α (i.succ_above k)) :
i.insert_nth x p j = eq.rec_on (succ_above_cast_lt h) (p $ j.cast_lt _) :=
by rw [insert_nth, succ_above_cases, dif_neg h.ne, dif_pos h]
lemma insert_nth_apply_above {i j : fin (n + 1)} (h : i < j) (x : α i)
(p : Π k, α (i.succ_above k)) :
i.insert_nth x p j = eq.rec_on (succ_above_pred h) (p $ j.pred _) :=
by rw [insert_nth, succ_above_cases, dif_neg h.ne', dif_neg h.not_lt]
lemma insert_nth_zero (x : α 0) (p : Π j : fin n, α (succ_above 0 j)) :
insert_nth 0 x p = cons x (λ j, _root_.cast (congr_arg α (congr_fun succ_above_zero j)) (p j)) :=
begin
refine insert_nth_eq_iff.2 ⟨by simp, _⟩,
ext j,
convert (cons_succ _ _ _).symm
end
@[simp] lemma insert_nth_zero' (x : β) (p : fin n → β) :
@insert_nth _ (λ _, β) 0 x p = cons x p :=
by simp [insert_nth_zero]
lemma insert_nth_last (x : α (last n)) (p : Π j : fin n, α ((last n).succ_above j)) :
insert_nth (last n) x p =
snoc (λ j, _root_.cast (congr_arg α (succ_above_last_apply j)) (p j)) x :=
begin
refine insert_nth_eq_iff.2 ⟨by simp, _⟩,
ext j,
apply eq_of_heq,
transitivity snoc (λ j, _root_.cast (congr_arg α (succ_above_last_apply j)) (p j)) x j.cast_succ,
{ rw [snoc_cast_succ], exact (cast_heq _ _).symm },
{ apply congr_arg_heq,
rw [succ_above_last] }
end
@[simp] lemma insert_nth_last' (x : β) (p : fin n → β) :
@insert_nth _ (λ _, β) (last n) x p = snoc p x :=
by simp [insert_nth_last]
@[simp] lemma insert_nth_zero_right [Π j, has_zero (α j)] (i : fin (n + 1)) (x : α i) :
i.insert_nth x 0 = pi.single i x :=
insert_nth_eq_iff.2 $ by simp [succ_above_ne, pi.zero_def]
lemma insert_nth_binop (op : Π j, α j → α j → α j) (i : fin (n + 1))
(x y : α i) (p q : Π j, α (i.succ_above j)) :
i.insert_nth (op i x y) (λ j, op _ (p j) (q j)) =
λ j, op j (i.insert_nth x p j) (i.insert_nth y q j) :=
insert_nth_eq_iff.2 $ by simp
@[simp] lemma insert_nth_mul [Π j, has_mul (α j)] (i : fin (n + 1))
(x y : α i) (p q : Π j, α (i.succ_above j)) :
i.insert_nth (x * y) (p * q) = i.insert_nth x p * i.insert_nth y q :=
insert_nth_binop (λ _, (*)) i x y p q
@[simp] lemma insert_nth_add [Π j, has_add (α j)] (i : fin (n + 1))
(x y : α i) (p q : Π j, α (i.succ_above j)) :
i.insert_nth (x + y) (p + q) = i.insert_nth x p + i.insert_nth y q :=
insert_nth_binop (λ _, (+)) i x y p q
@[simp] lemma insert_nth_div [Π j, has_div (α j)] (i : fin (n + 1))
(x y : α i) (p q : Π j, α (i.succ_above j)) :
i.insert_nth (x / y) (p / q) = i.insert_nth x p / i.insert_nth y q :=
insert_nth_binop (λ _, (/)) i x y p q
@[simp] lemma insert_nth_sub [Π j, has_sub (α j)] (i : fin (n + 1))
(x y : α i) (p q : Π j, α (i.succ_above j)) :
i.insert_nth (x - y) (p - q) = i.insert_nth x p - i.insert_nth y q :=
insert_nth_binop (λ _, has_sub.sub) i x y p q
@[simp] lemma insert_nth_sub_same [Π j, add_group (α j)] (i : fin (n + 1))
(x y : α i) (p : Π j, α (i.succ_above j)) :
i.insert_nth x p - i.insert_nth y p = pi.single i (x - y) :=
by simp_rw [← insert_nth_sub, ← insert_nth_zero_right, pi.sub_def, sub_self, pi.zero_def]
variables [Π i, preorder (α i)]
lemma insert_nth_le_iff {i : fin (n + 1)} {x : α i} {p : Π j, α (i.succ_above j)} {q : Π j, α j} :
i.insert_nth x p ≤ q ↔ x ≤ q i ∧ p ≤ (λ j, q (i.succ_above j)) :=
by simp [pi.le_def, forall_iff_succ_above i]
lemma le_insert_nth_iff {i : fin (n + 1)} {x : α i} {p : Π j, α (i.succ_above j)} {q : Π j, α j} :
q ≤ i.insert_nth x p ↔ q i ≤ x ∧ (λ j, q (i.succ_above j)) ≤ p :=
by simp [pi.le_def, forall_iff_succ_above i]
open set
lemma insert_nth_mem_Icc {i : fin (n + 1)} {x : α i} {p : Π j, α (i.succ_above j)}
{q₁ q₂ : Π j, α j} :
i.insert_nth x p ∈ Icc q₁ q₂ ↔
x ∈ Icc (q₁ i) (q₂ i) ∧ p ∈ Icc (λ j, q₁ (i.succ_above j)) (λ j, q₂ (i.succ_above j)) :=
by simp only [mem_Icc, insert_nth_le_iff, le_insert_nth_iff, and.assoc, and.left_comm]
lemma preimage_insert_nth_Icc_of_mem {i : fin (n + 1)} {x : α i} {q₁ q₂ : Π j, α j}
(hx : x ∈ Icc (q₁ i) (q₂ i)) :
i.insert_nth x ⁻¹' (Icc q₁ q₂) = Icc (λ j, q₁ (i.succ_above j)) (λ j, q₂ (i.succ_above j)) :=
set.ext $ λ p, by simp only [mem_preimage, insert_nth_mem_Icc, hx, true_and]
lemma preimage_insert_nth_Icc_of_not_mem {i : fin (n + 1)} {x : α i} {q₁ q₂ : Π j, α j}
(hx : x ∉ Icc (q₁ i) (q₂ i)) :
i.insert_nth x ⁻¹' (Icc q₁ q₂) = ∅ :=
set.ext $ λ p, by simp only [mem_preimage, insert_nth_mem_Icc, hx, false_and, mem_empty_eq]
end insert_nth
section find
/-- `find p` returns the first index `n` where `p n` is satisfied, and `none` if it is never
satisfied. -/
def find : Π {n : ℕ} (p : fin n → Prop) [decidable_pred p], option (fin n)
| 0 p _ := none
| (n+1) p _ := by resetI; exact option.cases_on
(@find n (λ i, p (i.cast_lt (nat.lt_succ_of_lt i.2))) _)
(if h : p (fin.last n) then some (fin.last n) else none)
(λ i, some (i.cast_lt (nat.lt_succ_of_lt i.2)))
/-- If `find p = some i`, then `p i` holds -/
/-- `find p` does not return `none` if and only if `p i` holds at some index `i`. -/
lemma is_some_find_iff : Π {n : ℕ} {p : fin n → Prop} [decidable_pred p],
by exactI (find p).is_some ↔ ∃ i, p i
| 0 p _ := iff_of_false (λ h, bool.no_confusion h) (λ ⟨i, _⟩, fin_zero_elim i)
| (n+1) p _ := ⟨λ h, begin
rw [option.is_some_iff_exists] at h,
cases h with i hi,
exactI ⟨i, find_spec _ hi⟩
end, λ ⟨⟨i, hin⟩, hi⟩,
begin
resetI,
dsimp [find],
cases h : find (λ i : fin n, (p (i.cast_lt (nat.lt_succ_of_lt i.2)))) with j,
{ split_ifs with hl hl,
{ exact option.is_some_some },
{ have := (@is_some_find_iff n (λ x, p (x.cast_lt (nat.lt_succ_of_lt x.2))) _).2
⟨⟨i, lt_of_le_of_ne (nat.le_of_lt_succ hin)
(λ h, by clear_aux_decl; cases h; exact hl hi)⟩, hi⟩,
rw h at this,
exact this } },
{ simp }
end⟩
/-- `find p` returns `none` if and only if `p i` never holds. -/
lemma find_eq_none_iff {n : ℕ} {p : fin n → Prop} [decidable_pred p] :
find p = none ↔ ∀ i, ¬ p i :=
by rw [← not_exists, ← is_some_find_iff]; cases (find p); simp
/-- If `find p` returns `some i`, then `p j` does not hold for `j < i`, i.e., `i` is minimal among
the indices where `p` holds. -/
lemma find_min : Π {n : ℕ} {p : fin n → Prop} [decidable_pred p] {i : fin n}
(hi : i ∈ by exactI fin.find p) {j : fin n} (hj : j < i), ¬ p j
| 0 p _ i hi j hj hpj := option.no_confusion hi
| (n+1) p _ i hi ⟨j, hjn⟩ hj hpj := begin
resetI,
dsimp [find] at hi,
cases h : find (λ i : fin n, (p (i.cast_lt (nat.lt_succ_of_lt i.2)))) with k,
{ rw [h] at hi,
split_ifs at hi with hl hl,
{ have := option.some_inj.1 hi,
subst this,
rw [find_eq_none_iff] at h,
exact h ⟨j, hj⟩ hpj },
{ exact option.no_confusion hi } },
{ rw h at hi,
dsimp at hi,
have := option.some_inj.1 hi,
subst this,
exact find_min h (show (⟨j, lt_trans hj k.2⟩ : fin n) < k, from hj) hpj }
end
lemma find_min' {p : fin n → Prop} [decidable_pred p] {i : fin n}
(h : i ∈ fin.find p) {j : fin n} (hj : p j) : i ≤ j :=
le_of_not_gt (λ hij, find_min h hij hj)
lemma nat_find_mem_find {p : fin n → Prop} [decidable_pred p]
(h : ∃ i, ∃ hin : i < n, p ⟨i, hin⟩) :
(⟨nat.find h, (nat.find_spec h).fst⟩ : fin n) ∈ find p :=
let ⟨i, hin, hi⟩ := h in
begin
cases hf : find p with f,
{ rw [find_eq_none_iff] at hf,
exact (hf ⟨i, hin⟩ hi).elim },
{ refine option.some_inj.2 (le_antisymm _ _),
{ exact find_min' hf (nat.find_spec h).snd },
{ exact nat.find_min' _ ⟨f.2, by convert find_spec p hf;
exact fin.eta _ _⟩ } }
end
lemma mem_find_iff {p : fin n → Prop} [decidable_pred p] {i : fin n} :
i ∈ fin.find p ↔ p i ∧ ∀ j, p j → i ≤ j :=
⟨λ hi, ⟨find_spec _ hi, λ _, find_min' hi⟩,
begin
rintros ⟨hpi, hj⟩,
cases hfp : fin.find p,
{ rw [find_eq_none_iff] at hfp,
exact (hfp _ hpi).elim },
{ exact option.some_inj.2 (le_antisymm (find_min' hfp hpi) (hj _ (find_spec _ hfp))) }
end⟩
lemma find_eq_some_iff {p : fin n → Prop} [decidable_pred p] {i : fin n} :
fin.find p = some i ↔ p i ∧ ∀ j, p j → i ≤ j :=
mem_find_iff
lemma mem_find_of_unique {p : fin n → Prop} [decidable_pred p]
(h : ∀ i j, p i → p j → i = j) {i : fin n} (hi : p i) : i ∈ fin.find p :=
mem_find_iff.2 ⟨hi, λ j hj, le_of_eq $ h i j hi hj⟩
end find
end fin
|
lemma degree_add_le_max: "degree (p + q) \<le> max (degree p) (degree q)" |
import cv2
import numpy as np
# Read the images to be aligned
im1 = cv2.imread("220.png");
im2 = cv2.imread("237.png");
# Convert images to grayscale
im1_gray = cv2.cvtColor(im1, cv2.COLOR_BGR2GRAY)
im2_gray = cv2.cvtColor(im2, cv2.COLOR_BGR2GRAY)
cv2.imshow("Image 1", im1)
cv2.imshow("Image 2", im2)
# Find size of image1
sz = im1.shape
print cv2.__version__
# Define the motion model
warp_mode = cv2.MOTION_EUCLIDEAN
# Define 2x3 or 3x3 matrices and initialize the matrix to identity
if warp_mode == cv2.MOTION_HOMOGRAPHY:
warp_matrix = np.eye(3, 3, dtype=np.float32)
else:
warp_matrix = np.eye(2, 3, dtype=np.float32)
# Specify the number of iterations.
number_of_iterations = 5000; #was 5000
# Specify the threshold of the increment
# in the correlation coefficient between two iterations
termination_eps = 1e-10;
# Define termination criteria
criteria = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, number_of_iterations, termination_eps)
# Run the ECC algorithm. The results are stored in warp_matrix.
(cc, warp_matrix) = cv2.findTransformECC(im1_gray, im2_gray, warp_matrix, warp_mode, criteria)
if warp_mode == cv2.MOTION_HOMOGRAPHY:
# Use warpPerspective for Homography
im2_aligned = cv2.warpPerspective(im2, warp_matrix, (sz[1], sz[0]), flags=cv2.INTER_LINEAR + cv2.WARP_INVERSE_MAP)
else:
# Use warpAffine for Translation, Euclidean and Affine
im2_aligned = cv2.warpAffine(im2, warp_matrix, (sz[1], sz[0]), flags=cv2.INTER_LINEAR + cv2.WARP_INVERSE_MAP);
# Show final results
cv2.imshow("Aligned Image 2", im2_aligned)
cv2.waitKey(0)
|
We stock and ship Same Day a large selection of Dryer Conversion Kits. Free Shipping is available on all orders over $50.00 (within the U.S.). Brands available include: Maytag, Frigidaire, Speed Queen, Whirlpool, GE, Jenn-Air, Kenmore, Magic Chef, Montgomery Wards.
This kit converts from natural gas to LP gas. It can be used on some models of Maytag Dryers and other brands.
Gas conversion kit can be used on some models of Maytag Dryers and other brands.
Gas conversion kit is for natural gas to LP. It can be used on some models of Frigidaire Dryers and other brands.
Conversion kit can be used on some models of Whirlpool Dryers including: Kenmore, KitchenAid, Roper and other brands.
This kit converts natural to LP gas. It can be used on some models of Maytag Dryers and other brands.
This kit converts natural gas to LP. It can be used on some models of Frigidaire Dryers and other brands.
Gas conversion kit for natural gas to LP. It can be used on some models of GE Dryers and other brands.
This kit converts LP to Natural Gas it can be used on some models of GE Washers and other brands.
LP conversion kit can be used on some models of GE Dryers and other brands.
Gas conversion kit can be used on some models of Whirlpool Dryers and other brands.
This kit converts natural to LP gas. It can be used on some models of Frigidaire Dryers and other brands.
Need more information on Dryer Conversion Kits? |
Require Import String.
Inductive EA : Type :=
|V: string -> EA
|N: nat -> EA
|Plus: EA -> EA -> EA
|Suc: EA -> EA.
Definition State := string -> nat.
Print EA_ind.
Print State.
Fixpoint eval (e:EA) (s:State) : nat :=
match e with
| V x => s x
| N n => n
| Plus e1 e2 => (eval e1 s)+(eval e2 s)
| Suc e => S (eval e s)
end.
Fixpoint cf (e:EA):EA :=
match e with
| V x => V x
| N n => N n
| Plus e1 e2 => match cf e1 with
|N n => match cf e2 with
|N k => N (n+k)
|_ => Plus (cf e1) (cf e2)
end
|_ => Plus (cf e1) (cf e2)
end
| Suc e => match cf e with
|N n => N(S n)
|_ => Suc (cf e)
end
end.
Lemma eq_suc_nat : forall (n:nat), S n = n + 1.
Proof.
induction n.
reflexivity.
simpl.
rewrite <- IHn.
trivial.
Qed.
(*a*)
Theorem eq_suc: forall (s:State) (e:EA), eval (Suc e) s = eval e s + 1.
Proof.
intro.
destruct e;simpl;apply eq_suc_nat.
Qed.
(*b*)
Theorem eval_cf: forall (s:State) (e:EA), eval e s = eval (cf e) s.
Proof.
intros.
induction e;simpl;trivial.
rewrite IHe1;rewrite IHe2;destruct (cf e1);destruct (cf e2);reflexivity.
rewrite (IHe);destruct (cf e); reflexivity.
Qed.
Fixpoint plus (e1 e2:EA) :EA :=
match e1, e2 with
| N n1, N n2 => N (n1 + n2)
| N 0, e => e
| e, N 0 => e
| a, b => Plus a b
end.
Fixpoint cfp (e:EA):EA :=
match e with
| V x => V x
| N n => N n
| Plus e1 e2 => plus (cfp e1) (cfp e2)
| Suc e1 => Suc (cfp e1)
end.
Lemma mas_cero: forall (n:nat), n + 0 = n.
Proof.
induction n.
reflexivity.
simpl.
rewrite IHn.
trivial.
Qed.
(*c*)
Theorem corr_cfp : forall (e:EA) (s:State), eval e s = eval (cfp e) s.
Proof.
intros.
induction e;simpl;trivial.
rewrite IHe1.
rewrite IHe2.
destruct (cfp e1);destruct (cfp e2);trivial;destruct n;simpl;trivial;rewrite mas_cero;trivial.
destruct (cfp e);rewrite IHe;trivial.
Qed. |
function env = mrvGetEvironment()
% function env = mrvGetEvironment()
%
% Copyright Stanford team, mrVista, 2011
%
% FP, 6/30/2011
%
% See also mrvValidate.m and mrvValidateAll.m
% save the matlab version being used
env.matlabVer = ver;
% save the architecture
env.computer = computer;
% vistasoft revision number
env.vistaDir = mrvRootPath;
tmp = gitInfo(vistaRootPath);
env.gitOrigin = tmp.origin;
env.gitchecksum = tmp.checksum;
return |
/**
* Simulate: Particles from Form+Code in Art, Design, and Architecture
* implemented in C++ by Patrick Tierney ([email protected] || http://ptierney.com)
*
* Requires Cinder 0.8.2 available at http://libcinder.org
*
* Project files are located at https://github.com/hlp/form-and-code
*
* For more information about Form+Code visit http://formandcode.com
*/
#include <boost/date_time.hpp>
#include "cinder/app/AppBasic.h"
#include "cinder/Rand.h"
#include "cinder/CinderMath.h"
class Particle;
class Simulate_Particles : public ci::app::AppBasic {
public:
void prepareSettings(Settings* settings);
void setup();
void draw();
private:
std::vector<Particle> particles;
bool saving;
};
class Particle {
public:
Particle(ci::Vec2f l) {
counter = 0;
float randmin = -M_PI / 2.0f;
float randmax = 0;
float r = ci::Rand::randFloat(0, M_PI * 2.0f);
float x = ci::math<float>::cos(r);
float y = ci::math<float>::sin(r);
acc = ci::Vec2f(x / 250.0f, y / 250.0f);
float q = ci::Rand::randFloat(0, 1);
r = ci::Rand::randFloat(randmin, randmax);
x = ci::math<float>::cos(r) * q;
y = ci::math<float>::sin(r) * q;
vel = ci::Vec2f(x, y);
loc = l;
counter = 0;
hist.resize(1000);
}
void update() {
vel += acc;
loc += vel;
// save location every 10 frames
if (ci::app::getElapsedFrames() % 10 == 0) {
hist[counter] = (loc);
counter++;
}
}
void drawArrowHead(ci::Vec2f v, ci::Vec2f loc, float scale) {
ci::gl::pushMatrices();
float arrowsize = 4;
// Translate to location to render vector
ci::gl::translate(ci::Vec2f(loc.x, loc.y));
// Rotate to the vector heading
ci::Quatf q(0.0f, 0.0f, ci::math<float>::atan2(v.normalized().y, v.normalized().x));
ci::gl::rotate(q);
// Calculate length of vector & scale it to be bigger or smaller if necessary
float len = v.length()*scale;
arrowsize = ci::lmap<float>(len, 0, 10, 0, 1) * arrowsize;
// Draw point
glColor4f(0.0f, 0.0f, 0.0f, 100.0f/255.0f);
ci::gl::drawLine(ci::Vec2f(0,0),ci::Vec2f(len-arrowsize,0));
glBegin(GL_TRIANGLES);
glVertex2f(len,0);
glVertex2f(len-arrowsize,+arrowsize/2);
glVertex2f(len-arrowsize,-arrowsize/2);
glEnd();
ci::gl::popMatrices();
}
void draw() {
float c = 100.0f/255.0f;
glColor4f(c, c, c, 50.0f/255.0f);
drawArrowHead(vel,loc,10);
// draw history path
glColor4f(0.0f, 0.0f, 0.0f, 100.0f/255.0f);
glBegin(GL_LINE_STRIP);
for (int i = 0; i < counter; i++) {
glVertex2f(hist[i].x, hist[i].y);
}
if (!hist.empty()) glVertex2f(loc.x, loc.y);
glEnd();
}
private:
ci::Vec2f loc;
ci::Vec2f vel;
ci::Vec2f acc;
std::vector<ci::Vec2f> hist;
int counter;
};
void Simulate_Particles::prepareSettings(Settings* settings) {
settings->setWindowSize(1024, 768);
}
void Simulate_Particles::setup() {
glEnable(GL_LINE_SMOOTH);
ci::gl::enableAlphaBlending();
for (int i = 0; i < 1000; i++) {
particles.push_back(Particle(ci::Vec2f(100, getWindowHeight()-100)));
}
}
void Simulate_Particles::draw() {
ci::gl::setMatricesWindow(getWindowSize());
ci::gl::clear(ci::Color::white());
for (std::vector<Particle>::iterator it = particles.begin();
it != particles.end(); ++it) {
it->update();
it->draw();
}
}
CINDER_APP_BASIC(Simulate_Particles, ci::app::RendererGl)
|
State Before: α✝ : Type ?u.72894
β✝ : Type ?u.72897
γ : Type ?u.72900
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
α β : Type u_1
r : α → α → Prop
s : β → β → Prop
inst✝¹ : IsWellOrder α r
inst✝ : IsWellOrder β s
f : r ≺i s
x✝ : ↑{b | s b f.top}
a : β
h : a ∈ {b | s b f.top}
⊢ ∃ a_1,
↑(RelEmbedding.codRestrict {b | s b f.top}
{ toRelEmbedding := f.toRelEmbedding,
init' :=
(_ :
∀ (x : α) (x_1 : β),
s x_1 (↑f.toRelEmbedding x) → ∃ a', ↑f.toRelEmbedding a' = x_1) }.toRelEmbedding
(_ : ∀ (a : α), s (↑f.toRelEmbedding a) f.top))
a_1 =
{ val := a, property := h } State After: case intro
α✝ : Type ?u.72894
β✝ : Type ?u.72897
γ : Type ?u.72900
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
α β : Type u_1
r : α → α → Prop
s : β → β → Prop
inst✝¹ : IsWellOrder α r
inst✝ : IsWellOrder β s
f : r ≺i s
x✝ : ↑{b | s b f.top}
b : α
h : ↑f.toRelEmbedding b ∈ {b | s b f.top}
⊢ ∃ a,
↑(RelEmbedding.codRestrict {b | s b f.top}
{ toRelEmbedding := f.toRelEmbedding,
init' :=
(_ :
∀ (x : α) (x_1 : β),
s x_1 (↑f.toRelEmbedding x) → ∃ a', ↑f.toRelEmbedding a' = x_1) }.toRelEmbedding
(_ : ∀ (a : α), s (↑f.toRelEmbedding a) f.top))
a =
{ val := ↑f.toRelEmbedding b, property := h } Tactic: rcases f.down.1 h with ⟨b, rfl⟩ State Before: case intro
α✝ : Type ?u.72894
β✝ : Type ?u.72897
γ : Type ?u.72900
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
α β : Type u_1
r : α → α → Prop
s : β → β → Prop
inst✝¹ : IsWellOrder α r
inst✝ : IsWellOrder β s
f : r ≺i s
x✝ : ↑{b | s b f.top}
b : α
h : ↑f.toRelEmbedding b ∈ {b | s b f.top}
⊢ ∃ a,
↑(RelEmbedding.codRestrict {b | s b f.top}
{ toRelEmbedding := f.toRelEmbedding,
init' :=
(_ :
∀ (x : α) (x_1 : β),
s x_1 (↑f.toRelEmbedding x) → ∃ a', ↑f.toRelEmbedding a' = x_1) }.toRelEmbedding
(_ : ∀ (a : α), s (↑f.toRelEmbedding a) f.top))
a =
{ val := ↑f.toRelEmbedding b, property := h } State After: no goals Tactic: exact ⟨b, rfl⟩ |
using Base.Iterators, PolygonOps
abstract type Edge end
struct EdgeX <: Edge
range :: Tuple{Number, Number} # [a, b]
y :: Function # y(x)
a :: Number # ∂y
end
struct EdgeY <: Edge
range :: Tuple{Number, Number} # [a, b]
x :: Function # x(y)
a :: Number # ∂x
end
function Edge(A, B)::Edge
xRange, yRange = minmax.(A, B)
(xa, ya), (xb, yb) = A, B
if xa != xb
a = (ya - yb) // (xa - xb)
b = ya - a * xa
EdgeX(xRange, x -> a * x + b, a)
else
a = (xa - xb) // (ya - yb)
b = xa - a * ya
EdgeY(yRange, y -> a * y + b, a)
end
end
wrap1(xs) = flatten((rest(xs, 2), [xs[1]]))
onEdge((x, y), edge :: EdgeX) = (edge.range[1] <= x <= edge.range[2]) && y ≈ edge.y(x)
onEdge((x, y), edge :: EdgeY) = (edge.range[1] <= y <= edge.range[2]) && x ≈ edge.x(y)
onEdge(point, edges :: Vector{Edge}) = any([onEdge(point, edge) for edge in edges])
function prepareEdge(shape, Γ) :: Tuple{Any, Vector{Edge}}
Γn, Γd = [], []
for (edge, f) ∈ zip(Edge.(shape, wrap1(shape)), Γ)
if f != 0 push!(Γn, (f, edge))
else push!(Γd, edge) end
end
Γn, Γd
end
|
Load LFindLoad.
From lfind Require Import LFind.
From QuickChick Require Import QuickChick.
From adtind Require Import goal33.
Derive Show for natural.
Derive Arbitrary for natural.
Instance Dec_Eq_natural : Dec_Eq natural.
Proof. dec_eq. Qed.
Lemma conj27eqsynthconj1 : forall (lv0 : natural), (@eq natural (lv0) (plus Zero (plus Zero lv0))).
Admitted.
QuickChick conj27eqsynthconj1.
|
module SqlDsl
import Data.Vect
--%access public export
data SqlType : Type where
SqlInt : SqlType
SqlBool : SqlType
SqlString : SqlType
data SqlExpr : SqlType -> Type where
IntC : Int -> SqlExpr SqlInt
BoolC : Bool -> SqlExpr SqlBool
StringC : String -> SqlExpr SqlString
PlusC : SqlExpr SqlInt -> SqlExpr SqlInt -> SqlExpr SqlInt
ConcatC : SqlExpr SqlString -> SqlExpr SqlString -> SqlExpr SqlString
EqualC : SqlExpr a -> SqlExpr a -> SqlExpr SqlBool
NotC : SqlExpr SqlBool -> SqlExpr SqlBool
Field : {t : SqlType} -> (alias : String) -> (name : String) -> SqlExpr t
int : Int -> SqlExpr SqlInt
int x = IntC x
bool : Bool -> SqlExpr SqlBool
bool x = BoolC x
str : String -> SqlExpr SqlString
str x = StringC x
(==) : SqlExpr a -> SqlExpr a -> SqlExpr SqlBool
(==) x y = EqualC x y
data Tuple : {a : Type} -> (f : a -> Type) -> Vect n a -> Type where
Nil : Tuple f []
(::) : f t -> Tuple f ts -> Tuple f (t :: ts)
Table : {n : Nat} -> Type
Table {n} = (String, Vect n (String, SqlType))
index : (i : Fin k) -> Tuple f ts -> f (index i ts)
index FZ (x::xs) = x
index (FS j) (x::xs) = index j xs
get : (t : (String, SqlType)) -> {ts : Vect n (String, SqlType)} -> Tuple (\t => SqlExpr (snd t)) ts -> {auto p : Elem t ts} -> SqlExpr (snd t)
get t (x :: xs) {p = Here} = x
get t (x :: xs) {p = There p'} = get t {p = p'} xs
data SqlQuery : Vect n (String, SqlType) -> Type where
From : (t : Table) -> SqlQuery (snd t)
Product : SqlQuery ts -> SqlQuery ts' -> (Tuple (\t => SqlExpr (snd t)) ts -> Tuple (\t => SqlExpr (snd t)) ts' -> Tuple (\t => SqlExpr (snd t)) ts'') -> SqlQuery ts''
Where : SqlQuery ts -> (Tuple (\t => SqlExpr (snd t)) ts -> SqlExpr SqlBool) -> SqlQuery ts
Select : SqlQuery ts -> (Tuple (\t => SqlExpr (snd t)) ts -> Tuple (\t => SqlExpr (snd t)) ts') -> SqlQuery ts'
from : (t : Table) -> SqlQuery (snd t)
from t = From t
product : (Tuple (\t => SqlExpr (snd t)) ts -> Tuple (\t => SqlExpr (snd t)) ts' -> Tuple (\t => SqlExpr (snd t)) ts'') -> SqlQuery ts -> SqlQuery ts' -> SqlQuery ts''
product proj q1 q2 = Product q1 q2 proj
where' : (Tuple (\t => SqlExpr (snd t)) ts -> SqlExpr SqlBool) -> SqlQuery ts -> SqlQuery ts
where' pred query = Where query pred
select : (Tuple (\t => SqlExpr (snd t)) ts -> Tuple (\t => SqlExpr (snd t)) ts') -> SqlQuery ts -> SqlQuery ts'
select f query = Select query f
compileExpr : SqlExpr t -> String
compileExpr (IntC x) = show x
compileExpr (BoolC x) = show x
compileExpr (StringC x) = "\"" ++ x ++ "\""
compileExpr (PlusC x y) = "(" ++ compileExpr x ++ " + " ++ compileExpr y ++ ")"
compileExpr (ConcatC x y) = "(" ++ compileExpr x ++ " ++ " ++ compileExpr y ++ ")"
compileExpr (EqualC x y) = "(" ++ compileExpr x ++ " = " ++ compileExpr y ++ ")"
compileExpr (NotC x) = "NOT" ++ compileExpr x
compileExpr (Field alias name) = alias ++ "." ++ name
mapToTuple : String -> (ts : Vect n (String, SqlType)) -> Tuple (\t => SqlExpr (snd t)) ts
mapToTuple alias [] = []
mapToTuple alias ((name, t) :: ts) = Field {t = t} alias name :: mapToTuple alias ts
tupleToString : {ts : Vect n (String, SqlType)} -> Tuple (\t => SqlExpr (snd t)) ts -> String
tupleToString {ts = []} [] = ""
tupleToString {ts = [t]} [e] = compileExpr e ++ " AS " ++ fst t
tupleToString {ts = t :: ts} (e :: es) = compileExpr e ++ " AS " ++ fst t ++ ", " ++ tupleToString es
compile' : {ts : Vect n (String, SqlType)} -> SqlQuery ts -> Int -> (Int -> String -> String) -> String
compile' (Select {ts} (From (tableName, _)) f) i k =
let alias = "c" ++ show i in
let tuple' = f $ mapToTuple alias ts in
let sql = "SELECT " ++ tupleToString tuple' ++ " FROM " ++ tableName ++ " AS " ++ alias in
k (i + 1) sql
compile' (Select {ts} (Where (From (tableName, _)) pred) f) i k =
let alias = "c" ++ show i in
let tuple' = f $ mapToTuple alias ts in
let sql = "SELECT " ++ tupleToString tuple' ++ " FROM " ++ tableName ++ " AS " ++ alias ++ " WHERE " ++ (compileExpr $ pred $ mapToTuple alias ts) in
k (i + 1) sql
compile' (From (tableName, ts)) i k =
let alias = "c" ++ show i in
let sql = "SELECT * FROM " ++ tableName ++ " AS " ++ alias in
k (i + 1) sql
compile' {ts} (Where query pred) i k =
compile' query i (\i, sql =>
let alias = "c" ++ show i in
let sql' = "SELECT * FROM (" ++ sql ++ ") AS " ++ alias ++ " WHERE " ++ (compileExpr $ pred $ mapToTuple alias ts) in
k (i + 1) sql')
compile' (Select {ts} query f) i k =
compile' query i (\i, sql =>
let alias = "c" ++ show i in
let tuple' = f $ mapToTuple alias ts in
let sql' = "SELECT " ++ tupleToString tuple' ++ " FROM (" ++ sql ++ ") AS " ++ alias in
k (i + 1) sql')
compile' (Product {ts} {ts'} q1 q2 f) i k =
compile' q1 i (\i, sql =>
compile' q2 i (\i, sql' =>
let alias = "c" ++ show i in
let i' = i + 1 in
let alias' = "c" ++ show i' in
let tuple' = f (mapToTuple alias ts) (mapToTuple alias' ts') in
let sql'' = "SELECT " ++ tupleToString tuple' ++ " FROM (" ++ sql ++ ") AS " ++ alias ++ ", (" ++ sql' ++ ") AS " ++ alias' in
k (i' + 1) sql''))
compile : SqlQuery ts -> String
compile query = compile' query 0 (\_, sql => sql)
customer : Table {n = 3}
customer = ("Customer", [("Id", SqlInt),
("Name", SqlString),
("Age", SqlInt)])
--
example0 : SqlQuery [("Id", SqlInt), ("Name", SqlString), ("Age", SqlInt)]
example0 = from customer
example1 : SqlQuery [("Name", SqlString)]
example1 = select (\ta => [get ("Name", SqlString) {ts = snd customer} ta]) $ from customer
example2 : SqlQuery [("Id", SqlInt)]
example2 = select (\ta => [index 0 ta]) $ from customer
example3 : SqlQuery [("Id", SqlInt), ("Age", SqlInt)]
example3 = select (\ta => [index 0 ta, index 2 ta]) $ where' (\ta => index 1 ta == str "Nick") $ from customer
|
module PGQueryTests
using AbstractTrees
using JSON
using PGQuery
using Test
const DEFAULT_SHOW_JSON = false
function try_query(qry; show_json::Bool=DEFAULT_SHOW_JSON)
println("query:")
println(qry)
if show_json
parse_query_json(qry) do parsed_qry_json_str
parsed_qry_json = JSON.parse(parsed_qry_json_str)
println("parsed_qry_json:")
JSON.print(parsed_qry_json, 2)
end
end
parse_query(qry) do parsed_qry
AbstractTrees.print_tree(parsed_qry, 999)
end
println("-----------------------------------------------")
end
function sql_files(dir)
[file for file in readdir(dir) if endswith(file, ".sql")]
end
@testset "simple SQL parsing" begin
try_query("SELECT 1")
try_query("SELECT 'abc'")
try_query("SELECT B'101010111'")
try_query("SELECT 3.14")
try_query("SELECT NULL")
try_query("SELECT a, t.b from tbl t")
for imdb_job_qry in sql_files(joinpath(@__DIR__, "imdb_job"))
println("query name: $imdb_job_qry")
try_query(read(joinpath(@__DIR__, "imdb_job", imdb_job_qry), String))
end
for tpch_qry in sql_files(joinpath(@__DIR__, "tpch"))
println("query name: $tpch_qry")
try_query(read(joinpath(@__DIR__, "tpch", tpch_qry), String))
end
@test_throws SQLParserException parse_query("INSERT FROM DOES NOT WORK")
end
end
|
[STATEMENT]
lemma homeomorphic_Euclidean_space_product_topology:
"Euclidean_space n homeomorphic_space product_topology (\<lambda>i. euclideanreal) {..<n}"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. Euclidean_space n homeomorphic_space powertop_real {..<n}
[PROOF STEP]
proof -
[PROOF STATE]
proof (state)
goal (1 subgoal):
1. Euclidean_space n homeomorphic_space powertop_real {..<n}
[PROOF STEP]
have cm: "continuous_map (product_topology (\<lambda>i. euclideanreal) {..<n})
euclideanreal (\<lambda>x. if k < n then x k else 0)" for k
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. continuous_map (powertop_real {..<n}) euclideanreal (\<lambda>x. if k < n then x k else 0)
[PROOF STEP]
by (auto intro: continuous_map_if continuous_map_product_projection)
[PROOF STATE]
proof (state)
this:
continuous_map (powertop_real {..<n}) euclideanreal (\<lambda>x. if ?k < n then x ?k else 0)
goal (1 subgoal):
1. Euclidean_space n homeomorphic_space powertop_real {..<n}
[PROOF STEP]
show ?thesis
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. Euclidean_space n homeomorphic_space powertop_real {..<n}
[PROOF STEP]
unfolding homeomorphic_space_def homeomorphic_maps_def
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. \<exists>f g. continuous_map (Euclidean_space n) (powertop_real {..<n}) f \<and> continuous_map (powertop_real {..<n}) (Euclidean_space n) g \<and> (\<forall>x\<in>topspace (Euclidean_space n). g (f x) = x) \<and> (\<forall>y\<in>topspace (powertop_real {..<n}). f (g y) = y)
[PROOF STEP]
apply (rule_tac x="\<lambda>f. restrict f {..<n}" in exI)
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. \<exists>g. continuous_map (Euclidean_space n) (powertop_real {..<n}) (\<lambda>f. restrict f {..<n}) \<and> continuous_map (powertop_real {..<n}) (Euclidean_space n) g \<and> (\<forall>x\<in>topspace (Euclidean_space n). g (restrict x {..<n}) = x) \<and> (\<forall>y\<in>topspace (powertop_real {..<n}). restrict (g y) {..<n} = y)
[PROOF STEP]
apply (rule_tac x="\<lambda>f i. if i < n then f i else 0" in exI)
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. continuous_map (Euclidean_space n) (powertop_real {..<n}) (\<lambda>f. restrict f {..<n}) \<and> continuous_map (powertop_real {..<n}) (Euclidean_space n) (\<lambda>f i. if i < n then f i else 0) \<and> (\<forall>x\<in>topspace (Euclidean_space n). (\<lambda>i. if i < n then restrict x {..<n} i else 0) = x) \<and> (\<forall>y\<in>topspace (powertop_real {..<n}). (\<lambda>i\<in>{..<n}. if i < n then y i else 0) = y)
[PROOF STEP]
apply (simp add: Euclidean_space_def continuous_map_in_subtopology)
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. continuous_map (subtopology (powertop_real UNIV) {x. \<forall>i\<ge>n. x i = 0}) (powertop_real {..<n}) (\<lambda>f. restrict f {..<n}) \<and> continuous_map (powertop_real {..<n}) (powertop_real UNIV) (\<lambda>f i. if i < n then f i else 0) \<and> (\<lambda>x i. if i < n then x i else 0) ` ({..<n} \<rightarrow>\<^sub>E UNIV) \<subseteq> {x. \<forall>i\<ge>n. x i = 0} \<and> (\<forall>x. (\<forall>i\<ge>n. x i = 0) \<longrightarrow> (\<lambda>i. if i < n then restrict x {..<n} i else 0) = x) \<and> (\<forall>y\<in>{..<n} \<rightarrow>\<^sub>E UNIV. (\<lambda>i\<in>{..<n}. if i < n then y i else 0) = y)
[PROOF STEP]
apply (intro conjI continuous_map_from_subtopology)
[PROOF STATE]
proof (prove)
goal (5 subgoals):
1. continuous_map (powertop_real UNIV) (powertop_real {..<n}) (\<lambda>f. restrict f {..<n})
2. continuous_map (powertop_real {..<n}) (powertop_real UNIV) (\<lambda>f i. if i < n then f i else 0)
3. (\<lambda>x i. if i < n then x i else 0) ` ({..<n} \<rightarrow>\<^sub>E UNIV) \<subseteq> {x. \<forall>i\<ge>n. x i = 0}
4. \<forall>x. (\<forall>i\<ge>n. x i = 0) \<longrightarrow> (\<lambda>i. if i < n then restrict x {..<n} i else 0) = x
5. \<forall>y\<in>{..<n} \<rightarrow>\<^sub>E UNIV. (\<lambda>i\<in>{..<n}. if i < n then y i else 0) = y
[PROOF STEP]
apply (force simp: continuous_map_componentwise cm intro: continuous_map_product_projection)+
[PROOF STATE]
proof (prove)
goal:
No subgoals!
[PROOF STEP]
done
[PROOF STATE]
proof (state)
this:
Euclidean_space n homeomorphic_space powertop_real {..<n}
goal:
No subgoals!
[PROOF STEP]
qed |
c
c comment section
c
c fs051
c
c fs051 is a subroutine subprogram which is called by the main
c program fm050. no arguments are specified therefore all
c parameters are passed via unlabeled common. the subroutine fs051
c increments the value of a real variable by 1 and returns control
c to the calling program fm050.
c
c references
c american national standard programming language fortran,
c x3.9-1978
c
c section 15.6, subroutines
c section 15.8, return statement
c
c test section
c
c subroutine subprogram - no arguments
c
subroutine fs051
common //rvcn01
rvcn01 = rvcn01 + 1.0
return
end
|
#*****************
# use haven for .sav to csv file conversion
# .sav is a proprietary format for IBM SPSS
# .csv is an open source standard that is usable on multiple platforms for both open source and proprietary end user tools including Excel, Libreoffice and is supported by all programming language
#*****************
library(haven)
load_savfile <- read_spss("~/projects/sav-to-csv/data/Innbyggerdel\ tidsserie.sav")
saveascsv <- write.csv(load_savfile, file = "~/projects/sav-to-csv/dataset.csv", row.names = FALSE)
load_csvfile <- read.csv("~/projects/sav-to-csv/dataset.csv")
|
Require Import SetoidCat SetoidUtils Algebra.Functor Algebra.Monoid PairUtils Algebra.Utils UnitUtils Algebra.Applicative Algebra.Functor.Utils.
Require Import SetoidClass.
Section Utils.
Context
{t: forall A, Setoid A -> Type}
{tS : forall A (AS : Setoid A), Setoid (t A AS)}
{func : @Functor t tS}
{app : @Applicative _ _ func}.
(* some general lemmas *)
Lemma idS_absorb : forall {A} {AS : Setoid A} (a : A), idS @ a == a.
Proof.
intros. simpl. reflexivity.
Qed.
Lemma fmap_pure : forall {A B} {AS : Setoid A} {BS : Setoid B} (f : AS ~> BS) (a : A),
f <$> pure @ a == pure @ (f @ a).
Proof.
intros. simpl. rewrite fmap_fmap.
evalproper. evalproper. simpl. arrequiv.
Qed.
Lemma uncurry_fmap_prod : forall {A B C} {AS : Setoid A} {BS : Setoid B} {CS : Setoid C} (f : AS ~> BS ~~> CS) (a : t A _) (b : t B _),
uncurryS @ f <$> (a ** b) == f <$> a <*> b.
Proof.
intros. unfold ap. unfold comp2S. normalize. rewrite <- (fmap_idS_absorb b) at 2. rewrite naturality_prod. rewrite fmap_fmap. evalproper. evalproper. simpl. arrequiv. destruct a0. simpl. reflexivity.
Qed.
Lemma evalS_idem : forall {A B} {AS : Setoid A} {BS : Setoid B},
@evalS _ _ AS BS ∘ @evalS _ _ AS BS == @evalS _ _ AS BS.
Proof.
intros. simpl_equiv. simpl_equiv. reflexivity.
Qed.
Lemma fmap_eval : forall {A B} {AS : Setoid A} {BS : Setoid B} (f : t (AS ~> BS) _) (a : t A _),
evalS <$> f <*> a == f <*> a.
Proof.
intros. unfold ap, comp2S. normalize. rewrite uncurry_fmap_prod . rewrite uncurry_fmap_prod. rewrite fmap_fmap. rewrite evalS_idem. reflexivity.
Qed.
Lemma ap_pure : forall {m mS}
{func}
{app : @Applicative m mS func}
{A B : Type}
{SA : Setoid A}
{SB : Setoid B} (f : SA ~> SB ) (a : m A _), pure @ f <*> a == f <$> a.
Proof.
intros. simpl. rewrite <- (fmap_idS_absorb a) at 1. rewrite naturality_prod. rewrite fmap_fmap. rewrite <- (left_unit_applicative a) at 2. rewrite fmap_fmap. evalproper. evalproper. simpl. arrequiv. destruct a0. reflexivity.
Qed.
Lemma applicative_id: forall {A} {AS : Setoid A} {a : t A _},
(pure @ @idS _ AS) <*> a == a.
Proof.
intros. unfold ap, comp2S. normalize. unfold pure, comp, flipS. normalize. rewrite <- (idS_absorb a) at 1. rewrite <- functoriality_id. rewrite naturality_prod. rewrite fmap_fmap.
rewrite <- (left_unit_applicative a) at 2. evalproper. evalproper. simpl. arrequiv. destruct a0. reflexivity.
Qed.
Lemma applicative_comp :
forall {A B C} {AS : Setoid A} {BS : Setoid B} {CS : Setoid C}
(f : t (AS ~> BS) _) (g : t (BS ~> CS) _) (a : t A _),
pure @ (flipS @ compS) <*> g <*> f <*> a ==
g <*> ( f <*> a).
Proof.
intros. simpl. arrequiv.
rewrite <- (fmap_idS_absorb g) at 1. rewrite naturality_prod at 1.
rewrite <- (fmap_idS_absorb f). rewrite fmap_fmap. rewrite naturality_prod at 1.
rewrite <- (fmap_idS_absorb a). rewrite fmap_fmap. rewrite naturality_prod at 1.
rewrite naturality_prod at 1.
rewrite <- (left_unit_applicative g) at 2. rewrite fmap_fmap. rewrite fmap_fmap. rewrite naturality_prod.
rewrite <- (associativity_applicative (unitA ** g) f a).
rewrite (fmap_fmap).
rewrite (fmap_fmap).
evalproper. evalproper. simpl.
arrequiv. destruct a0. destruct p. destruct p. simpl. reflexivity.
Qed.
Lemma applicative_homomorphism :
forall {A B} {AS : Setoid A} {BS : Setoid B}
(f : AS ~> BS) (a : A),
pure @ f <*> pure @ a == pure @ (f @ a).
Proof.
intros. simpl. rewrite naturality_prod. rewrite <- (left_unit_applicative unitA) at 3. rewrite fmap_fmap. rewrite (fmap_fmap). evalproper. evalproper. simpl. arrequiv. destruct a0. reflexivity.
Qed.
Lemma applicative_interchange:
forall {A B} {AS : Setoid A} {BS : Setoid B}
(f : t (AS ~> BS) _) (a : A),
f <*> (pure @ a) == pure @ (flipS @ evalS @ a) <*> f.
Proof.
intros. simpl.
rewrite <- (left_unit_applicative f) at 1.
rewrite <- (fmap_idS_absorb f) at 2.
rewrite naturality_prod.
rewrite naturality_prod.
rewrite <- (right_unit_applicative (unitA ** f)) at 2.
rewrite fmap_fmap.
rewrite (fmap_fmap).
rewrite (fmap_fmap).
evalproper. evalproper. simpl. arrequiv. destruct a0. simpl. destruct p. reflexivity.
Qed.
End Utils.
|
(* Title: HOL/Auth/n_flash_nodata_cub_lemma_on_inv__11.thy
Author: Yongjian Li and Kaiqiang Duan, State Key Lab of Computer Science, Institute of Software, Chinese Academy of Sciences
Copyright 2016 State Key Lab of Computer Science, Institute of Software, Chinese Academy of Sciences
*)
header{*The n_flash_nodata_cub Protocol Case Study*}
theory n_flash_nodata_cub_lemma_on_inv__11 imports n_flash_nodata_cub_base
begin
section{*All lemmas on causal relation between inv__11 and some rule r*}
lemma n_PI_Remote_GetVsinv__11:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_PI_Remote_Get src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_PI_Remote_Get src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_PI_Remote_GetXVsinv__11:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_PI_Remote_GetX src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_PI_Remote_GetX src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_NakVsinv__11:
assumes a1: "(\<exists> dst. dst\<le>N\<and>r=n_NI_Nak dst)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain dst where a1:"dst\<le>N\<and>r=n_NI_Nak dst" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "(dst=p__Inv4)\<or>(dst~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(dst=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(dst~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_Get_Nak__part__0Vsinv__11:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_Get_Nak__part__0 src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_Get_Nak__part__0 src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_Get_Nak__part__1Vsinv__11:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_Get_Nak__part__1 src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_Get_Nak__part__1 src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_Get_Nak__part__2Vsinv__11:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_Get_Nak__part__2 src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_Get_Nak__part__2 src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_Get_Get__part__0Vsinv__11:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_Get_Get__part__0 src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_Get_Get__part__0 src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_Get_Get__part__1Vsinv__11:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_Get_Get__part__1 src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_Get_Get__part__1 src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_Get_Put_HeadVsinv__11:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_Get_Put_Head N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_Get_Put_Head N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_Get_PutVsinv__11:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_Get_Put src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_Get_Put src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_Get_Put_DirtyVsinv__11:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_Get_Put_Dirty src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_Get_Put_Dirty src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P3 s"
apply (cut_tac a1 a2 b1, simp, rule_tac x="(neg (andForm (eqn (IVar (Field (Field (Ident ''Sta'') ''Dir'') ''Local'')) (Const true)) (eqn (IVar (Field (Para (Field (Ident ''Sta'') ''UniMsg'') p__Inv4) ''Cmd'')) (Const UNI_PutX))))" in exI, auto) done
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Remote_Get_NakVsinv__11:
assumes a1: "(\<exists> src dst. src\<le>N\<and>dst\<le>N\<and>src~=dst\<and>r=n_NI_Remote_Get_Nak src dst)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src dst where a1:"src\<le>N\<and>dst\<le>N\<and>src~=dst\<and>r=n_NI_Remote_Get_Nak src dst" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "(src=p__Inv4\<and>dst~=p__Inv4)\<or>(src~=p__Inv4\<and>dst=p__Inv4)\<or>(src~=p__Inv4\<and>dst~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4\<and>dst~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>dst=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>dst~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Remote_Get_PutVsinv__11:
assumes a1: "(\<exists> src dst. src\<le>N\<and>dst\<le>N\<and>src~=dst\<and>r=n_NI_Remote_Get_Put src dst)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src dst where a1:"src\<le>N\<and>dst\<le>N\<and>src~=dst\<and>r=n_NI_Remote_Get_Put src dst" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "(src=p__Inv4\<and>dst~=p__Inv4)\<or>(src~=p__Inv4\<and>dst=p__Inv4)\<or>(src~=p__Inv4\<and>dst~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4\<and>dst~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>dst=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>dst~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_Nak__part__0Vsinv__11:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_Nak__part__0 src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_Nak__part__0 src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_Nak__part__1Vsinv__11:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_Nak__part__1 src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_Nak__part__1 src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_Nak__part__2Vsinv__11:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_Nak__part__2 src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_Nak__part__2 src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_GetX__part__0Vsinv__11:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_GetX__part__0 src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_GetX__part__0 src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_GetX__part__1Vsinv__11:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_GetX__part__1 src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_GetX__part__1 src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_1Vsinv__11:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_1 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_1 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_2Vsinv__11:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_2 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_2 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_3Vsinv__11:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_3 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_3 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_4Vsinv__11:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_4 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_4 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_5Vsinv__11:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_5 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_5 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_6Vsinv__11:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_6 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_6 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_7__part__0Vsinv__11:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_7__part__0 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_7__part__0 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_7__part__1Vsinv__11:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_7__part__1 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_7__part__1 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_7_NODE_Get__part__0Vsinv__11:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_7_NODE_Get__part__0 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_7_NODE_Get__part__0 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_7_NODE_Get__part__1Vsinv__11:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_7_NODE_Get__part__1 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_7_NODE_Get__part__1 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_8_HomeVsinv__11:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_8_Home N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_8_Home N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_8_Home_NODE_GetVsinv__11:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_8_Home_NODE_Get N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_8_Home_NODE_Get N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_8Vsinv__11:
assumes a1: "(\<exists> src pp. src\<le>N\<and>pp\<le>N\<and>src~=pp\<and>r=n_NI_Local_GetX_PutX_8 N src pp)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src pp where a1:"src\<le>N\<and>pp\<le>N\<and>src~=pp\<and>r=n_NI_Local_GetX_PutX_8 N src pp" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "(src=p__Inv4\<and>pp~=p__Inv4)\<or>(src~=p__Inv4\<and>pp=p__Inv4)\<or>(src~=p__Inv4\<and>pp~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4\<and>pp~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>pp=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>pp~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_8_NODE_GetVsinv__11:
assumes a1: "(\<exists> src pp. src\<le>N\<and>pp\<le>N\<and>src~=pp\<and>r=n_NI_Local_GetX_PutX_8_NODE_Get N src pp)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src pp where a1:"src\<le>N\<and>pp\<le>N\<and>src~=pp\<and>r=n_NI_Local_GetX_PutX_8_NODE_Get N src pp" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "(src=p__Inv4\<and>pp~=p__Inv4)\<or>(src~=p__Inv4\<and>pp=p__Inv4)\<or>(src~=p__Inv4\<and>pp~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4\<and>pp~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>pp=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>pp~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_9__part__0Vsinv__11:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_9__part__0 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_9__part__0 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_9__part__1Vsinv__11:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_9__part__1 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_9__part__1 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_10_HomeVsinv__11:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_10_Home N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_10_Home N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_10Vsinv__11:
assumes a1: "(\<exists> src pp. src\<le>N\<and>pp\<le>N\<and>src~=pp\<and>r=n_NI_Local_GetX_PutX_10 N src pp)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src pp where a1:"src\<le>N\<and>pp\<le>N\<and>src~=pp\<and>r=n_NI_Local_GetX_PutX_10 N src pp" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "(src=p__Inv4\<and>pp~=p__Inv4)\<or>(src~=p__Inv4\<and>pp=p__Inv4)\<or>(src~=p__Inv4\<and>pp~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4\<and>pp~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>pp=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>pp~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_GetX_PutX_11Vsinv__11:
assumes a1: "(\<exists> src. src\<le>N\<and>r=n_NI_Local_GetX_PutX_11 N src)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src where a1:"src\<le>N\<and>r=n_NI_Local_GetX_PutX_11 N src" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "(src=p__Inv4)\<or>(src~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Remote_GetX_NakVsinv__11:
assumes a1: "(\<exists> src dst. src\<le>N\<and>dst\<le>N\<and>src~=dst\<and>r=n_NI_Remote_GetX_Nak src dst)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src dst where a1:"src\<le>N\<and>dst\<le>N\<and>src~=dst\<and>r=n_NI_Remote_GetX_Nak src dst" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "(src=p__Inv4\<and>dst~=p__Inv4)\<or>(src~=p__Inv4\<and>dst=p__Inv4)\<or>(src~=p__Inv4\<and>dst~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4\<and>dst~=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>dst=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>dst~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Remote_GetX_PutXVsinv__11:
assumes a1: "(\<exists> src dst. src\<le>N\<and>dst\<le>N\<and>src~=dst\<and>r=n_NI_Remote_GetX_PutX src dst)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain src dst where a1:"src\<le>N\<and>dst\<le>N\<and>src~=dst\<and>r=n_NI_Remote_GetX_PutX src dst" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "(src=p__Inv4\<and>dst~=p__Inv4)\<or>(src~=p__Inv4\<and>dst=p__Inv4)\<or>(src~=p__Inv4\<and>dst~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(src=p__Inv4\<and>dst~=p__Inv4)"
have "?P3 s"
apply (cut_tac a1 a2 b1, simp, rule_tac x="(neg (andForm (eqn (IVar (Field (Para (Field (Ident ''Sta'') ''Proc'') dst) ''CacheState'')) (Const CACHE_E)) (eqn (IVar (Field (Field (Ident ''Sta'') ''Dir'') ''Dirty'')) (Const false))))" in exI, auto) done
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>dst=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(src~=p__Inv4\<and>dst~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Remote_PutVsinv__11:
assumes a1: "(\<exists> dst. dst\<le>N\<and>r=n_NI_Remote_Put dst)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain dst where a1:"dst\<le>N\<and>r=n_NI_Remote_Put dst" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "(dst=p__Inv4)\<or>(dst~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(dst=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(dst~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Remote_PutXVsinv__11:
assumes a1: "(\<exists> dst. dst\<le>N\<and>r=n_NI_Remote_PutX dst)" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain dst where a1:"dst\<le>N\<and>r=n_NI_Remote_PutX dst" apply fastforce done
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "(dst=p__Inv4)\<or>(dst~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(dst=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(dst~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_PI_Local_GetX_PutX_HeadVld__part__0Vsinv__11:
assumes a1: "(r=n_PI_Local_GetX_PutX_HeadVld__part__0 N )" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "?P1 s"
proof(cut_tac a1 a2 , auto) qed
then show "invHoldForRule s f r (invariants N)" by auto
qed
lemma n_PI_Local_GetX_PutX_HeadVld__part__1Vsinv__11:
assumes a1: "(r=n_PI_Local_GetX_PutX_HeadVld__part__1 N )" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "?P1 s"
proof(cut_tac a1 a2 , auto) qed
then show "invHoldForRule s f r (invariants N)" by auto
qed
lemma n_PI_Local_GetX_PutX__part__0Vsinv__11:
assumes a1: "(r=n_PI_Local_GetX_PutX__part__0 )" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "?P1 s"
proof(cut_tac a1 a2 , auto) qed
then show "invHoldForRule s f r (invariants N)" by auto
qed
lemma n_PI_Local_GetX_PutX__part__1Vsinv__11:
assumes a1: "(r=n_PI_Local_GetX_PutX__part__1 )" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "?P1 s"
proof(cut_tac a1 a2 , auto) qed
then show "invHoldForRule s f r (invariants N)" by auto
qed
lemma n_PI_Local_PutXVsinv__11:
assumes a1: "(r=n_PI_Local_PutX )" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "((formEval (eqn (IVar (Field (Field (Ident ''Sta'') ''Dir'') ''Pending'')) (Const true)) s))\<or>((formEval (neg (eqn (IVar (Field (Field (Ident ''Sta'') ''Dir'') ''Pending'')) (Const true))) s))" by auto
moreover {
assume c1: "((formEval (eqn (IVar (Field (Field (Ident ''Sta'') ''Dir'') ''Pending'')) (Const true)) s))"
have "?P3 s"
apply (cut_tac a1 a2 c1, simp, rule_tac x="(neg (andForm (eqn (IVar (Field (Field (Ident ''Sta'') ''HomeProc'') ''CacheState'')) (Const CACHE_E)) (eqn (IVar (Field (Para (Field (Ident ''Sta'') ''UniMsg'') p__Inv4) ''Cmd'')) (Const UNI_PutX))))" in exI, auto) done
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume c1: "((formEval (neg (eqn (IVar (Field (Field (Ident ''Sta'') ''Dir'') ''Pending'')) (Const true))) s))"
have "?P3 s"
apply (cut_tac a1 a2 c1, simp, rule_tac x="(neg (andForm (eqn (IVar (Field (Field (Ident ''Sta'') ''HomeProc'') ''CacheState'')) (Const CACHE_E)) (eqn (IVar (Field (Para (Field (Ident ''Sta'') ''UniMsg'') p__Inv4) ''Cmd'')) (Const UNI_PutX))))" in exI, auto) done
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_NI_Local_PutVsinv__11:
assumes a1: "(r=n_NI_Local_Put )" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "?P3 s"
apply (cut_tac a1 a2 , simp, rule_tac x="(neg (andForm (eqn (IVar (Field (Para (Field (Ident ''Sta'') ''UniMsg'') p__Inv4) ''Cmd'')) (Const UNI_PutX)) (eqn (IVar (Field (Field (Ident ''Sta'') ''HomeUniMsg'') ''Cmd'')) (Const UNI_Put))))" in exI, auto) done
then show "invHoldForRule s f r (invariants N)" by auto
qed
lemma n_NI_WbVsinv__11:
assumes a1: "(r=n_NI_Wb )" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "?P3 s"
apply (cut_tac a1 a2 , simp, rule_tac x="(neg (andForm (eqn (IVar (Field (Para (Field (Ident ''Sta'') ''UniMsg'') p__Inv4) ''Cmd'')) (Const UNI_PutX)) (eqn (IVar (Field (Field (Ident ''Sta'') ''WbMsg'') ''Cmd'')) (Const WB_Wb))))" in exI, auto) done
then show "invHoldForRule s f r (invariants N)" by auto
qed
lemma n_NI_ShWbVsinv__11:
assumes a1: "(r=n_NI_ShWb N )" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a2 obtain p__Inv4 where a2:"p__Inv4\<le>N\<and>f=inv__11 p__Inv4" apply fastforce done
have "?P3 s"
apply (cut_tac a1 a2 , simp, rule_tac x="(neg (andForm (eqn (IVar (Field (Para (Field (Ident ''Sta'') ''UniMsg'') p__Inv4) ''Cmd'')) (Const UNI_PutX)) (eqn (IVar (Field (Field (Ident ''Sta'') ''ShWbMsg'') ''Cmd'')) (Const SHWB_ShWb))))" in exI, auto) done
then show "invHoldForRule s f r (invariants N)" by auto
qed
lemma n_NI_Remote_GetX_PutX_HomeVsinv__11:
assumes a1: "\<exists> dst. dst\<le>N\<and>r=n_NI_Remote_GetX_PutX_Home dst" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_InvAck_3Vsinv__11:
assumes a1: "\<exists> src. src\<le>N\<and>r=n_NI_InvAck_3 N src" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_InvAck_1Vsinv__11:
assumes a1: "\<exists> src. src\<le>N\<and>r=n_NI_InvAck_1 N src" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_PI_Local_GetX_GetX__part__1Vsinv__11:
assumes a1: "r=n_PI_Local_GetX_GetX__part__1 " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_PI_Local_GetX_GetX__part__0Vsinv__11:
assumes a1: "r=n_PI_Local_GetX_GetX__part__0 " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_PI_Remote_ReplaceVsinv__11:
assumes a1: "\<exists> src. src\<le>N\<and>r=n_PI_Remote_Replace src" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_PI_Local_ReplaceVsinv__11:
assumes a1: "r=n_PI_Local_Replace " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_InvAck_existsVsinv__11:
assumes a1: "\<exists> src pp. src\<le>N\<and>pp\<le>N\<and>src~=pp\<and>r=n_NI_InvAck_exists src pp" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_PI_Remote_PutXVsinv__11:
assumes a1: "\<exists> dst. dst\<le>N\<and>r=n_PI_Remote_PutX dst" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_Remote_Get_Put_HomeVsinv__11:
assumes a1: "\<exists> dst. dst\<le>N\<and>r=n_NI_Remote_Get_Put_Home dst" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_InvVsinv__11:
assumes a1: "\<exists> dst. dst\<le>N\<and>r=n_NI_Inv dst" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_PI_Local_Get_PutVsinv__11:
assumes a1: "r=n_PI_Local_Get_Put " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_ReplaceVsinv__11:
assumes a1: "\<exists> src. src\<le>N\<and>r=n_NI_Replace src" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_Remote_GetX_Nak_HomeVsinv__11:
assumes a1: "\<exists> dst. dst\<le>N\<and>r=n_NI_Remote_GetX_Nak_Home dst" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_Local_PutXAcksDoneVsinv__11:
assumes a1: "r=n_NI_Local_PutXAcksDone " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_Remote_Get_Nak_HomeVsinv__11:
assumes a1: "\<exists> dst. dst\<le>N\<and>r=n_NI_Remote_Get_Nak_Home dst" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_InvAck_exists_HomeVsinv__11:
assumes a1: "\<exists> src. src\<le>N\<and>r=n_NI_InvAck_exists_Home src" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_Replace_HomeVsinv__11:
assumes a1: "r=n_NI_Replace_Home " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_Nak_ClearVsinv__11:
assumes a1: "r=n_NI_Nak_Clear " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_PI_Local_Get_GetVsinv__11:
assumes a1: "r=n_PI_Local_Get_Get " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_Nak_HomeVsinv__11:
assumes a1: "r=n_NI_Nak_Home " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_InvAck_2Vsinv__11:
assumes a1: "\<exists> src. src\<le>N\<and>r=n_NI_InvAck_2 N src" and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_NI_FAckVsinv__11:
assumes a1: "r=n_NI_FAck " and
a2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__11 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
end
|
function [kJ] = Btu2kJ(Btu)
% Convert energy or work from British thermal units to kilojoules.
% Chad A. Greene 2012
kJ = Btu*1.0550559 ; |
C *********************************************************
C * *
C * TEST NUMBER: 06.01.01/01 *
C * TEST TITLE : Behavior of translations *
C * *
C * PHIGS Validation Tests, produced by NIST *
C * *
C *********************************************************
COMMON /GLOBNU/ CTLHND, ERRSIG, ERRFIL, IERRCT, UNERR,
1 TESTCT, IFLERR, PASSSW, ERRSW, MAXLIN,
2 CONID, MEMUN, WKID, WTYPE, GLBLUN, INDLUN,
3 DUMINT, DUMRL
INTEGER CTLHND, ERRSIG, ERRFIL, IERRCT, UNERR,
1 TESTCT, IFLERR, PASSSW, ERRSW, MAXLIN,
2 CONID, MEMUN, WKID, WTYPE, GLBLUN, INDLUN,
3 DUMINT(20), ERRIND
REAL DUMRL(20)
COMMON /GLOBCH/ PIDENT, GLBERR, TSTMSG, FUNCID,
1 DUMCH
CHARACTER PIDENT*40, GLBERR*60, TSTMSG*900, FUNCID*80,
1 DUMCH(20)*20
REAL ACT4X4(4,4), EXP4X4(4,4), DX,DY,DZ
REAL ACT3X3(3,3), EXP3X3(3,3)
LOGICAL TRNSEQ
CALL INITGL ('06.01.01/01')
C open PHIGS
CALL XPOPPH (ERRFIL, MEMUN)
CALL SETMSG ('1 2 3', '<Translate 3> should return a ' //
1 'correct representation for the transformation ' //
2 'to translate a 3D point, with non-zero ' //
3 'parameters.')
DX = -33.3
DY = 0.0076
DZ = 2.2
C <Translate 3> with dx,dy,dz returns act4x4 = actual array
CALL PTR3 (DX,DY,DZ, ERRIND, ACT4X4)
CALL CHKINQ ('ptr3', ERRIND)
C Compute exp4x4 = expected array
CALL ETR3 (DX,DY,DZ, EXP4X4)
C pass if matrices represent same transformation
CALL IFPF (TRNSEQ(4, ACT4X4, EXP4X4))
CALL SETMSG ('1 2 3', '<Translate 3> should return a ' //
1 'correct representation for the transformation ' //
2 'to translate a 3D point, with zero parameters.')
DX = 0.0
DY = 0.0076
DZ = 0.0
C <Translate 3> with dx,dy,dz returns act4x4 = actual array
CALL PTR3 (DX,DY,DZ, ERRIND, ACT4X4)
CALL CHKINQ ('ptr3', ERRIND)
C Compute exp4x4 = expected array
CALL ETR3 (DX,DY,DZ, EXP4X4)
C pass if matrices represent same transformation
CALL IFPF (TRNSEQ(4, ACT4X4, EXP4X4))
CALL SETMSG ('1 2 4', '<Translate> should return a ' //
1 'correct representation for the transformation ' //
2 'to translate a 2D point, with non-zero ' //
3 'parameters.')
DX = -33.3
DY = 0.0076
C <Translate> with dx,dy returns act3x3 = actual array
CALL PTR (DX,DY, ERRIND, ACT3X3)
CALL CHKINQ ('ptr', ERRIND)
C Compute exp3x3 = expected array
CALL ETR (DX,DY, EXP3X3)
C pass if matrices represent same transformation
CALL IFPF (TRNSEQ(3, ACT3X3, EXP3X3))
CALL SETMSG ('1 2 4', '<Translate> should return a ' //
1 'correct representation for the transformation ' //
2 'to translate a 2D point, with zero parameters.')
DX = 0.0
DY = 0.0
C <Translate> with dx,dy returns act3x3 = actual array
CALL PTR (DX,DY, ERRIND, ACT3X3)
CALL CHKINQ ('ptr', ERRIND)
C Compute exp3x3 = expected array
CALL ETR (DX,DY, EXP3X3)
C pass if matrices represent same transformation
CALL IFPF (TRNSEQ(3, ACT3X3, EXP3X3))
CALL ENDIT
END
|
The limit of $f(x)$ as $x$ approaches $a$ from the right is the same as the limit of $f(x + a)$ as $x$ approaches $0$ from the right. |
Various wuxia novels and folk legends have endowed Zhou with different kinds of martial and supernatural skills . These range from mastery of the bow , double broadswords , and Chinese spear to that of <unk> hard qigong and even x @-@ ray vision . Practitioners of Eagle Claw , Chuojiao and Xingyi commonly include him within their lineage history because of his association with Yue Fei , the supposed progenitor of these styles . He is also linked to Northern Praying Mantis boxing via Lin Chong and Yan Qing . Wang Shaotang 's folktale even represents him as a master of Drunken Eight Immortals boxing . However , the oldest historical record that mentions his name only says he taught archery to Yue Fei . Nothing is ever said about him knowing or teaching a specific style of Chinese martial arts .
|
The initial step of our work is the study of the existing MC TBR model and its
behaviour. Following the examination of its features (simulation parameters), we
present efficient means of evaluating this model on large sets of points in
high-performance computing (HPC) environment, preprocessing techniques designed
to adapt collected datasets for surrogate modelling, and our attempts at feature
space reduction to achieve the lowest possible number of dimensions.
\subsection{Expensive Model Description}
\label{sec:expensive-model-description}
The expensive MC TBR model is fundamentally a Monte Carlo simulation based on the
OpenMC framework~\cite{ROMANO201590}. As input the software expects 18~parameters, discrete and
continuous, that are fully listed in~\cref{tbl:params}. During evaluation, which
usually takes units of seconds, a fixed number of neutron events is generated, and the
results are given in terms of the mean and the standard deviation of the~TBR aggregated
over the simulated run. The former of these two we accept to be the output TBR
value that is subject to approximation.
\begin{table}[h]
\centering
{\footnotesize
\begin{tabular}{l|llll}
\toprule
{} & Parameter Name & Acronym & Type & Domain\\
\midrule
\parbox[t]{2mm}{\multirow{12}{*}{\rotatebox[origin=c]{90}{Blanket}}}
& Breeder fraction\textsuperscript{\textdagger} & BBF & Continuous & $[0,1]$\\
& Breeder \isotope[6]{Li} enrichment fraction & BBLEF & Continuous & $[0,1]$\\
& Breeder material & BBM & Discrete & $\{\ce{Li2TiO3}, \ce{Li4SiO4}\}$\\
& Breeder packing fraction & BBPF & Continuous & $[0,1]$\\
& Coolant fraction\textsuperscript{\textdagger} & BCF & Continuous & $[0,1]$\\
& Coolant material & BCM & Discrete & $\{\ce{D2O}, \ce{H2O}, \ce{He}\}$\\
& Multiplier fraction\textsuperscript{\textdagger} & BMF & Continuous & $[0,1]$\\
& Multiplier material & BMM & Discrete & $\{\ce{Be}, \ce{Be12Ti}\}$\\
& Multiplier packing fraction & BMPF & Continuous & $[0,1]$\\
& Structural fraction\textsuperscript{\textdagger} & BSF & Continuous & $[0,1]$\\
& Structural material & BSM & Discrete & $\{\ce{SiC}, \text{eurofer}\}$\\
& Thickness & BT & Continuous & $[0,500]$\\
\midrule
\parbox[t]{2mm}{\multirow{7}{*}{\rotatebox[origin=c]{90}{First wall}}}
& Armour fraction\textsuperscript{\textdaggerdbl} & FAF & Continuous & $[0,1]$\\
& Coolant fraction\textsuperscript{\textdaggerdbl} & FCF & Continuous & $[0,1]$\\
& Coolant material & FCM & Discrete & $\{\ce{D2O}, \ce{H2O}, \ce{He}\}$\\
& Structural fraction\textsuperscript{\textdaggerdbl} & FSF & Continuous & $[0,1]$\\
& Structural material & FSM & Discrete & $\{\ce{SiC}, \text{eurofer}\}$\\
& Thickness & FT & Continuous & $[0,20]$\\
\bottomrule
\end{tabular}
}
\caption{Input parameters supplied to the MC TBR simulation in alphabetical
order. Groups of fractions marked\textsuperscript{\textdagger
\textdaggerdbl} are independently required to sum to one.}
\label{tbl:params}
\end{table}
In the following sections, we often reference TBR points or samples. These are simply vectors
in the feature space generated by Cartesian product of domains of all
features---parameters from~\cref{tbl:params}.
Since most surrogate models
that we employ assume overall continuous numerical inputs, we take steps to unify our
feature interface in order to attain this property. In particular, we transform
discrete features by embedding each such feature using standard one-hot
encoding. This option is available to
us since discrete domains that generate our feature space are finite in
cardinality and relatively small in size. And while it helps us towards
unification, this step comes at the expense of increasing the dimensionality of the
feature space. This is further discussed in~\cref{sec:dimred}.
\subsection{Dataset Generation}
\label{sec:dataset-generation}
In our work, we deliberately make no assumptions about the internal properties of the
MC TBR simulation, effectively treating it as a black box model. This limits our
means of studying its behaviour to inspection of its outputs at various
points in the feature space. We therefore require
sufficiently large and representative quantities of samples to ensure that
surrogates can be trained to approximate the MC TBR model accurately.
With a grid search in such a high-dimensional domain clearly intractable, we
selected uniform pseudo-random sampling\footnote{Continuous and discrete
parameters are drawn from a corresponding uniform distribution over their
domain, as defined in~\cref{tbl:params}. For repeatability, each run uses a seed equal to its number.} to generate large amounts of feature
configurations that we consider to be independent and unbiased. For evaluation
of the expensive MC TBR model, we utilise parallelisation offered by
the HPC infrastructure available at UCL computing facilities. To this end, we
designed and implemented the Approximate TBR Evaluator---a Python software package capable of
sequential evaluation of the multi-threaded OpenMC simulation on batches of
previously generated points in the feature space.
Having deployed ATE at the UCL Hypatia cluster\footnote{The Hypatia RCIF
partition is comprised of 4~homogeneous nodes. Each node is installed with
376~GB RAM and 40~Intel\textsuperscript{\textregistered}
Xeon\textsuperscript{\textregistered} Gold 6148 CPUs of clock frequency
2.40~GHz.}, we completed three data
generation runs that are summarised in~\cref{tbl:sampling-runs}.
\begin{table}[h]
\sisetup{round-mode=places,round-precision=2}
\centering
{\footnotesize
\begin{tabular}{rlllll}
\toprule
\# & Samples & Batch division & $t_{\text{run}} $
& $\overline{t}_{\text{eval.}}$ [\si{\second}] & Description \\
\midrule
0 & \num{100000} & $\num{100}\times\num{1000}$ & 2~days, 23~h
& $\num{7.877122043981347} \pm \num{2.749485948560108}$ &
Testing run using old MC TBR version.\\
1 & \num{500000} & $\num{500}\times\num{1000}$ & 13~days, 20~h
& $\num{7.777049573054314} \pm \num{2.8103592103930337}$ &
Fully uniform sampling in the entire domain.\\
2 & \num{400000} & $\num{400}\times\num{1000}$ & 10~days
& $\num{7.944379778103232} \pm \num{2.601428571503671}$ &
Mixed sampling, discrete features fixed.\\
\bottomrule
\end{tabular}
}
\caption{Parameters of sampling runs. Here, $t_{\text{run}}$ denotes the total run
time (including waiting in the processing queue), and
$\overline{t}_{\text{eval.}}$ is the mean evaluation time of the MC TBR
model (per single sampled point).}
\label{tbl:sampling-runs}
\end{table}
Skipping run zero, which was performed using an older, fundamentally different
version of the MC TBR software, and was thus treated as a technical
proof-of-concept, we generated a total of~\num{900000} samples in two runs.
While the first run featured fully uniform sampling of the unrestricted feature
space, the second run used a more elaborate strategy. Interested in further study
of relationships between discrete and continuous features, we selected four
assignments of discrete features (listed in~\cref{tbl:slices}) and fixed them
for all points, effectively slicing the feature space into four corresponding
subspaces. In order to achieve comparability, all such \textit{slices} use the
same samples for the values of continuous features.
\begin{table}[h]
\centering
{\footnotesize
\begin{tabular}{rllllll}
\toprule
{} & \multicolumn{6}{c}{Discrete feature assignment}\\
\cmidrule(lr){2-7}
Batches & BBM & BCM & BMM & BSM & FCM & FSM \\
\midrule
0-99 & \ce{Li4SiO4} & \ce{H2O} & \ce{Be12Ti} & eurofer & \ce{H2O} & eurofer\\
100-199 & \ce{Li4SiO4} & \ce{He} & \ce{Be12Ti} & eurofer & \ce{H2O} & eurofer\\
200-299 & \ce{Li4SiO4} & \ce{H2O} & \ce{Be12Ti} & eurofer & \ce{He} & eurofer\\
300-399 & \ce{Li4SiO4} & \ce{He} & \ce{Be12Ti} & eurofer & \ce{He} & eurofer\\
\bottomrule
\end{tabular}
}
\caption{Selected discrete feature assignments corresponding to slices in run~2.}
\label{tbl:slices}
\end{table}
Since some surrogate modelling methods applied in this work are not scale-invariant or
perform suboptimally with arbitrarily scaled inputs, all obtained TBR~samples
(features and TBR~values) were standardised prior to further use. In this
commonly used statistical procedure, features and regression outputs are
independently scaled and offset to attain zero mean and unit variance.
\subsection{Dimensionality Reduction}
\label{sec:dimred}
% TODO: here maybe mention desirable effects of dim. red. (e.g. speedup,
% simplification of the problem, better convergence...)
Model training over high-dimensional parameter spaces (illustrated
in~\cref{fig:tbr-vs-features}) may be improved in many
aspects by carefully reducing the number of variables used to describe the
space. For many applications, feature selection strategies succeed in
identifying a sufficiently representative subset of the original input
variables. However, all given variables were assumed to be physically relevant
to the MC TBR model. On the other hand, feature extraction methods aim to
identify a transformation of the parameter space which decreases dimensionality; even if no individual parameter is separable from the space, some linear combinations of parameters or nonlinear functions of parameters may be.
\begin{figure}[h]
\centering
\includegraphics[width=\linewidth]{run1_500k_tbr_vs_feat}
\caption{Marginalised dependence of TBR on the choice of continuous
features in \num{500000}~points generated in run~1. Points are coloured by density.}
\label{fig:tbr-vs-features}
\end{figure}
\subsubsection{Principal Component Analysis}
To pursue linear feature extraction, principal component analysis (PCA)
\cite{Jolliffe2016} was performed via SciKit Learn~\cite{scikit-learn} on a set
of \num{300000} uniform samples of the MC TBR model. % TODO:which run? batch range?
\Cref{fig:pca} shows the resultant cumulative variance of the 11 principal components. The similar share of variance among all features
reveals irreducibility of the TBR model by linear methods.
\begin{figure}[h]
\centering
\includegraphics[width=0.6\linewidth]{fig2_pca.jpg}
\caption{Cumulative variance for optimal features identified by PCA}
\label{fig:pca}
\end{figure}
\begin{wrapfigure}[30]{r}{0.5\textwidth}
\centering
\hspace*{-.3\columnsep}\includegraphics[width=0.58\textwidth]{fig3_allvar.jpg}
\caption{Semivariograms for MC TBR data with coolant materials: (a) \ce{He},
(b) \ce{H2O}, (c) \ce{D2O}}
\label{fig:var}
\end{wrapfigure}
\subsubsection{Variogram Computations}
Kriging is a geostatistical surrogate modelling technique which relies on
correlation functions over distance (lag) in the feature space~\cite{Bouhlel2018}. Although kriging performed poorly for our use case due to high dimensionality, these correlation measures gave insight into similarities between discrete-parameter slices of the data.
\Cref{fig:var} shows the Matheron semivariance~\cite{Matheron1963} for three discrete slices with coolant material varied, but all other discrete parameters fixed. Fits~\cite{KrigingFig} to the Matérn covariance model confirmed numerically that the coolant material is the discrete parameter with the greatest distinguishability in the MC TBR model.
\subsubsection{Autoencoders}
Autoencoders~\cite{SCHMIDHUBER201585} are a family of approaches to
dimensionality reduction driven by artificial neural
networks (ANNs). Faced with a broad selection of alternatives, we opted for a
conventional autoencoder architecture with a single hidden layer. While it
follows that the input and output layers of such
network are sized to accommodate the analysed dataset, the
hidden layer, also called \textit{the bottleneck}, allows for variable number of
neurons that represent a smaller subspace. By scanning
over a range of bottleneck widths and investigating relative changes in the
validation loss, we assess the potential for dimensional reduction.
\begin{wrapfigure}[15]{l}{0.25\textwidth}
\centering
{\footnotesize \incfigscale{0.8}{autoencoder}}
\caption{Autoencoder with input width~$W_0$ and bottleneck width~$W_1$.
Here, $\text{Dense}(N)$ denotes a fully-connected layer of $N$~neurons.}
\label{fig:autoencoder}
\end{wrapfigure}
In particular, we consider two equally-sized sets\footnote{Each set contained
\num{100000}~samples from batches 0-99 of the corresponding runs.} of samples:
(a)~a~subset of data obtained
from run~1 and (b)~a~subset of a single slice obtained from run~2. Our
expectation was that while the former case would provide meaningful insights into
correlations within the feature space, the latter would validate our
autoencoder implementation by analysing a set of points that are trivially
reducible in dimensionality due to a number of fixed discrete features.
\begin{wrapfigure}[22]{r}{0.4\textwidth}
\centering
\vspace{-4ex}
\begin{subfigure}[b]{\linewidth}
\includegraphics[width=\linewidth,trim={0 48px 0 0},clip]{ae_mixed}
\end{subfigure}
\vspace{-0.2ex}
\begin{subfigure}[b]{\linewidth}
\includegraphics[width=\linewidth]{ae_single_slice}
\end{subfigure}
\caption{Autoencoder loss scan on the full feature space (top) and a single slice
(bottom). Dimensional reduction is indicated by a green arrow.}
\label{fig:autoencoder-loss}
\end{wrapfigure}
The results of both experiments are shown in~\cref{fig:autoencoder-loss}.
Consistent with our motivation, in each plot we can clearly identify a constant
plateau of low error in the region of large dimensionality followed by a point,
from which a steep increase is observed.
We consider this \textit{critical point} to mark the largest viable
dimensional reduction without significant information loss.
With this approach we find that the autoencoder was able to reduce the
datasets into a subspace of 18~dimensions in the first case and 10~dimensions in
the second case.
Confirming our expectation that in the latter, trivial case the
autoencoder should achieve greater dimensional reduction, we are inclined to
believe that our implementation is indeed operating as intended. However, we
must also conclude that in both examined cases this method failed to produce a
reduction that would prove superior to a naïve approach.\footnote{In both tested cases we
can trivially eliminate 6~dimensions due to overdetermination of one-hot-encoded
categorical features, and 2~dimensions corresponding to sum-to-one constraints. Furthermore, in the
single slice case we may omit 6~additional dimensions due to fixed feature
assignment.} This is consistent with the previous results obtained by PCA and kriging.
% TODO: Question: is it accurate to say this represents nonlinear feature extraction? re my intro paragraph
|
/-
Copyright (c) 2020 Yury G. Kudryashov. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Yury G. Kudryashov
! This file was ported from Lean 3 source module order.semiconj_Sup
! leanprover-community/mathlib commit c3291da49cfa65f0d43b094750541c0731edc932
! Please do not edit these lines, except to modify the commit id
! if you have ported upstream changes.
-/
import Mathbin.Logic.Function.Conjugate
import Mathbin.Order.Bounds.OrderIso
import Mathbin.Order.ConditionallyCompleteLattice.Basic
import Mathbin.Order.RelIso.Group
import Mathbin.Order.OrdContinuous
import Mathbin.Algebra.Hom.Equiv.Units.Basic
/-!
# Semiconjugate by `Sup`
> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
> Any changes to this file require a corresponding PR to mathlib4.
In this file we prove two facts about semiconjugate (families of) functions.
First, if an order isomorphism `fa : α → α` is semiconjugate to an order embedding `fb : β → β` by
`g : α → β`, then `fb` is semiconjugate to `fa` by `y ↦ Sup {x | g x ≤ y}`, see
`semiconj.symm_adjoint`.
Second, consider two actions `f₁ f₂ : G → α → α` of a group on a complete lattice by order
isomorphisms. Then the map `x ↦ ⨆ g : G, (f₁ g)⁻¹ (f₂ g x)` semiconjugates each `f₁ g'` to `f₂ g'`,
see `function.Sup_div_semiconj`. In the case of a conditionally complete lattice, a similar
statement holds true under an additional assumption that each set `{(f₁ g)⁻¹ (f₂ g x) | g : G}` is
bounded above, see `function.cSup_div_semiconj`.
The lemmas come from [Étienne Ghys, Groupes d'homeomorphismes du cercle et cohomologie
bornee][ghys87:groupes], Proposition 2.1 and 5.4 respectively. In the paper they are formulated for
homeomorphisms of the circle, so in order to apply results from this file one has to lift these
homeomorphisms to the real line first.
-/
variable {α β γ : Type _}
open Set
#print IsOrderRightAdjoint /-
/-- We say that `g : β → α` is an order right adjoint function for `f : α → β` if it sends each `y`
to a least upper bound for `{x | f x ≤ y}`. If `α` is a partial order, and `f : α → β` has
a right adjoint, then this right adjoint is unique. -/
def IsOrderRightAdjoint [Preorder α] [Preorder β] (f : α → β) (g : β → α) :=
∀ y, IsLUB { x | f x ≤ y } (g y)
#align is_order_right_adjoint IsOrderRightAdjoint
-/
/- warning: is_order_right_adjoint_Sup -> isOrderRightAdjoint_supₛ is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : CompleteLattice.{u1} α] [_inst_2 : Preorder.{u2} β] (f : α -> β), IsOrderRightAdjoint.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))) _inst_2 f (fun (y : β) => SupSet.supₛ.{u1} α (ConditionallyCompleteLattice.toHasSup.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α _inst_1)) (setOf.{u1} α (fun (x : α) => LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) (f x) y)))
but is expected to have type
forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : CompleteLattice.{u2} α] [_inst_2 : Preorder.{u1} β] (f : α -> β), IsOrderRightAdjoint.{u2, u1} α β (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))) _inst_2 f (fun (y : β) => SupSet.supₛ.{u2} α (ConditionallyCompleteLattice.toSupSet.{u2} α (CompleteLattice.toConditionallyCompleteLattice.{u2} α _inst_1)) (setOf.{u2} α (fun (x : α) => LE.le.{u1} β (Preorder.toLE.{u1} β _inst_2) (f x) y)))
Case conversion may be inaccurate. Consider using '#align is_order_right_adjoint_Sup isOrderRightAdjoint_supₛₓ'. -/
theorem isOrderRightAdjoint_supₛ [CompleteLattice α] [Preorder β] (f : α → β) :
IsOrderRightAdjoint f fun y => supₛ { x | f x ≤ y } := fun y => isLUB_supₛ _
#align is_order_right_adjoint_Sup isOrderRightAdjoint_supₛ
/- warning: is_order_right_adjoint_cSup -> isOrderRightAdjoint_csupₛ is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLattice.{u1} α] [_inst_2 : Preorder.{u2} β] (f : α -> β), (forall (y : β), Exists.{succ u1} α (fun (x : α) => LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) (f x) y)) -> (forall (y : β), BddAbove.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))) (setOf.{u1} α (fun (x : α) => LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) (f x) y))) -> (IsOrderRightAdjoint.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))) _inst_2 f (fun (y : β) => SupSet.supₛ.{u1} α (ConditionallyCompleteLattice.toHasSup.{u1} α _inst_1) (setOf.{u1} α (fun (x : α) => LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) (f x) y))))
but is expected to have type
forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : ConditionallyCompleteLattice.{u2} α] [_inst_2 : Preorder.{u1} β] (f : α -> β), (forall (y : β), Exists.{succ u2} α (fun (x : α) => LE.le.{u1} β (Preorder.toLE.{u1} β _inst_2) (f x) y)) -> (forall (y : β), BddAbove.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))) (setOf.{u2} α (fun (x : α) => LE.le.{u1} β (Preorder.toLE.{u1} β _inst_2) (f x) y))) -> (IsOrderRightAdjoint.{u2, u1} α β (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))) _inst_2 f (fun (y : β) => SupSet.supₛ.{u2} α (ConditionallyCompleteLattice.toSupSet.{u2} α _inst_1) (setOf.{u2} α (fun (x : α) => LE.le.{u1} β (Preorder.toLE.{u1} β _inst_2) (f x) y))))
Case conversion may be inaccurate. Consider using '#align is_order_right_adjoint_cSup isOrderRightAdjoint_csupₛₓ'. -/
theorem isOrderRightAdjoint_csupₛ [ConditionallyCompleteLattice α] [Preorder β] (f : α → β)
(hne : ∀ y, ∃ x, f x ≤ y) (hbdd : ∀ y, BddAbove { x | f x ≤ y }) :
IsOrderRightAdjoint f fun y => supₛ { x | f x ≤ y } := fun y => isLUB_csupₛ (hne y) (hbdd y)
#align is_order_right_adjoint_cSup isOrderRightAdjoint_csupₛ
namespace IsOrderRightAdjoint
/- warning: is_order_right_adjoint.unique -> IsOrderRightAdjoint.unique is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {g₁ : β -> α} {g₂ : β -> α}, (IsOrderRightAdjoint.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 f g₁) -> (IsOrderRightAdjoint.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 f g₂) -> (Eq.{max (succ u2) (succ u1)} (β -> α) g₁ g₂)
but is expected to have type
forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : PartialOrder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : α -> β} {g₁ : β -> α} {g₂ : β -> α}, (IsOrderRightAdjoint.{u2, u1} α β (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 f g₁) -> (IsOrderRightAdjoint.{u2, u1} α β (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 f g₂) -> (Eq.{max (succ u2) (succ u1)} (β -> α) g₁ g₂)
Case conversion may be inaccurate. Consider using '#align is_order_right_adjoint.unique IsOrderRightAdjoint.uniqueₓ'. -/
protected theorem unique [PartialOrder α] [Preorder β] {f : α → β} {g₁ g₂ : β → α}
(h₁ : IsOrderRightAdjoint f g₁) (h₂ : IsOrderRightAdjoint f g₂) : g₁ = g₂ :=
funext fun y => (h₁ y).unique (h₂ y)
#align is_order_right_adjoint.unique IsOrderRightAdjoint.unique
/- warning: is_order_right_adjoint.right_mono -> IsOrderRightAdjoint.right_mono is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {g : β -> α}, (IsOrderRightAdjoint.{u1, u2} α β _inst_1 _inst_2 f g) -> (Monotone.{u2, u1} β α _inst_2 _inst_1 g)
but is expected to have type
forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : α -> β} {g : β -> α}, (IsOrderRightAdjoint.{u2, u1} α β _inst_1 _inst_2 f g) -> (Monotone.{u1, u2} β α _inst_2 _inst_1 g)
Case conversion may be inaccurate. Consider using '#align is_order_right_adjoint.right_mono IsOrderRightAdjoint.right_monoₓ'. -/
theorem right_mono [Preorder α] [Preorder β] {f : α → β} {g : β → α} (h : IsOrderRightAdjoint f g) :
Monotone g := fun y₁ y₂ hy => (h y₁).mono (h y₂) fun x hx => le_trans hx hy
#align is_order_right_adjoint.right_mono IsOrderRightAdjoint.right_mono
/- warning: is_order_right_adjoint.order_iso_comp -> IsOrderRightAdjoint.orderIso_comp is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] [_inst_3 : Preorder.{u3} γ] {f : α -> β} {g : β -> α}, (IsOrderRightAdjoint.{u1, u2} α β _inst_1 _inst_2 f g) -> (forall (e : OrderIso.{u2, u3} β γ (Preorder.toLE.{u2} β _inst_2) (Preorder.toLE.{u3} γ _inst_3)), IsOrderRightAdjoint.{u1, u3} α γ _inst_1 _inst_3 (Function.comp.{succ u1, succ u2, succ u3} α β γ (coeFn.{max (succ u2) (succ u3), max (succ u2) (succ u3)} (OrderIso.{u2, u3} β γ (Preorder.toLE.{u2} β _inst_2) (Preorder.toLE.{u3} γ _inst_3)) (fun (_x : RelIso.{u2, u3} β γ (LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2)) (LE.le.{u3} γ (Preorder.toLE.{u3} γ _inst_3))) => β -> γ) (RelIso.hasCoeToFun.{u2, u3} β γ (LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2)) (LE.le.{u3} γ (Preorder.toLE.{u3} γ _inst_3))) e) f) (Function.comp.{succ u3, succ u2, succ u1} γ β α g (coeFn.{max (succ u3) (succ u2), max (succ u3) (succ u2)} (OrderIso.{u3, u2} γ β (Preorder.toLE.{u3} γ _inst_3) (Preorder.toLE.{u2} β _inst_2)) (fun (_x : RelIso.{u3, u2} γ β (LE.le.{u3} γ (Preorder.toLE.{u3} γ _inst_3)) (LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2))) => γ -> β) (RelIso.hasCoeToFun.{u3, u2} γ β (LE.le.{u3} γ (Preorder.toLE.{u3} γ _inst_3)) (LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2))) (OrderIso.symm.{u2, u3} β γ (Preorder.toLE.{u2} β _inst_2) (Preorder.toLE.{u3} γ _inst_3) e))))
but is expected to have type
forall {α : Type.{u3}} {β : Type.{u2}} {γ : Type.{u1}} [_inst_1 : Preorder.{u3} α] [_inst_2 : Preorder.{u2} β] [_inst_3 : Preorder.{u1} γ] {f : α -> β} {g : β -> α}, (IsOrderRightAdjoint.{u3, u2} α β _inst_1 _inst_2 f g) -> (forall (e : OrderIso.{u2, u1} β γ (Preorder.toLE.{u2} β _inst_2) (Preorder.toLE.{u1} γ _inst_3)), IsOrderRightAdjoint.{u3, u1} α γ _inst_1 _inst_3 (Function.comp.{succ u3, succ u2, succ u1} α β γ (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Function.Embedding.{succ u2, succ u1} β γ) β (fun (_x : β) => (fun ([email protected]._hyg.19 : β) => γ) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (Function.Embedding.{succ u2, succ u1} β γ) β γ (Function.instEmbeddingLikeEmbedding.{succ u2, succ u1} β γ)) (RelEmbedding.toEmbedding.{u2, u1} β γ (fun ([email protected]._hyg.1281 : β) ([email protected]._hyg.1283 : β) => LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) [email protected]._hyg.1281 [email protected]._hyg.1283) (fun ([email protected]._hyg.1296 : γ) ([email protected]._hyg.1298 : γ) => LE.le.{u1} γ (Preorder.toLE.{u1} γ _inst_3) [email protected]._hyg.1296 [email protected]._hyg.1298) (RelIso.toRelEmbedding.{u2, u1} β γ (fun ([email protected]._hyg.1281 : β) ([email protected]._hyg.1283 : β) => LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) [email protected]._hyg.1281 [email protected]._hyg.1283) (fun ([email protected]._hyg.1296 : γ) ([email protected]._hyg.1298 : γ) => LE.le.{u1} γ (Preorder.toLE.{u1} γ _inst_3) [email protected]._hyg.1296 [email protected]._hyg.1298) e))) f) (Function.comp.{succ u1, succ u2, succ u3} γ β α g (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Function.Embedding.{succ u1, succ u2} γ β) γ (fun (_x : γ) => (fun ([email protected]._hyg.19 : γ) => β) _x) (EmbeddingLike.toFunLike.{max (succ u1) (succ u2), succ u1, succ u2} (Function.Embedding.{succ u1, succ u2} γ β) γ β (Function.instEmbeddingLikeEmbedding.{succ u1, succ u2} γ β)) (RelEmbedding.toEmbedding.{u1, u2} γ β (fun ([email protected]._hyg.1281 : γ) ([email protected]._hyg.1283 : γ) => LE.le.{u1} γ (Preorder.toLE.{u1} γ _inst_3) [email protected]._hyg.1281 [email protected]._hyg.1283) (fun ([email protected]._hyg.1296 : β) ([email protected]._hyg.1298 : β) => LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) [email protected]._hyg.1296 [email protected]._hyg.1298) (RelIso.toRelEmbedding.{u1, u2} γ β (fun ([email protected]._hyg.1281 : γ) ([email protected]._hyg.1283 : γ) => LE.le.{u1} γ (Preorder.toLE.{u1} γ _inst_3) [email protected]._hyg.1281 [email protected]._hyg.1283) (fun ([email protected]._hyg.1296 : β) ([email protected]._hyg.1298 : β) => LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) [email protected]._hyg.1296 [email protected]._hyg.1298) (OrderIso.symm.{u2, u1} β γ (Preorder.toLE.{u2} β _inst_2) (Preorder.toLE.{u1} γ _inst_3) e))))))
Case conversion may be inaccurate. Consider using '#align is_order_right_adjoint.order_iso_comp IsOrderRightAdjoint.orderIso_compₓ'. -/
theorem orderIso_comp [Preorder α] [Preorder β] [Preorder γ] {f : α → β} {g : β → α}
(h : IsOrderRightAdjoint f g) (e : β ≃o γ) : IsOrderRightAdjoint (e ∘ f) (g ∘ e.symm) :=
fun y => by simpa [e.le_symm_apply] using h (e.symm y)
#align is_order_right_adjoint.order_iso_comp IsOrderRightAdjoint.orderIso_comp
/- warning: is_order_right_adjoint.comp_order_iso -> IsOrderRightAdjoint.comp_orderIso is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] [_inst_3 : Preorder.{u3} γ] {f : α -> β} {g : β -> α}, (IsOrderRightAdjoint.{u1, u2} α β _inst_1 _inst_2 f g) -> (forall (e : OrderIso.{u3, u1} γ α (Preorder.toLE.{u3} γ _inst_3) (Preorder.toLE.{u1} α _inst_1)), IsOrderRightAdjoint.{u3, u2} γ β _inst_3 _inst_2 (Function.comp.{succ u3, succ u1, succ u2} γ α β f (coeFn.{max (succ u3) (succ u1), max (succ u3) (succ u1)} (OrderIso.{u3, u1} γ α (Preorder.toLE.{u3} γ _inst_3) (Preorder.toLE.{u1} α _inst_1)) (fun (_x : RelIso.{u3, u1} γ α (LE.le.{u3} γ (Preorder.toLE.{u3} γ _inst_3)) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1))) => γ -> α) (RelIso.hasCoeToFun.{u3, u1} γ α (LE.le.{u3} γ (Preorder.toLE.{u3} γ _inst_3)) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1))) e)) (Function.comp.{succ u2, succ u1, succ u3} β α γ (coeFn.{max (succ u1) (succ u3), max (succ u1) (succ u3)} (OrderIso.{u1, u3} α γ (Preorder.toLE.{u1} α _inst_1) (Preorder.toLE.{u3} γ _inst_3)) (fun (_x : RelIso.{u1, u3} α γ (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1)) (LE.le.{u3} γ (Preorder.toLE.{u3} γ _inst_3))) => α -> γ) (RelIso.hasCoeToFun.{u1, u3} α γ (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1)) (LE.le.{u3} γ (Preorder.toLE.{u3} γ _inst_3))) (OrderIso.symm.{u3, u1} γ α (Preorder.toLE.{u3} γ _inst_3) (Preorder.toLE.{u1} α _inst_1) e)) g))
but is expected to have type
forall {α : Type.{u3}} {β : Type.{u2}} {γ : Type.{u1}} [_inst_1 : Preorder.{u3} α] [_inst_2 : Preorder.{u2} β] [_inst_3 : Preorder.{u1} γ] {f : α -> β} {g : β -> α}, (IsOrderRightAdjoint.{u3, u2} α β _inst_1 _inst_2 f g) -> (forall (e : OrderIso.{u1, u3} γ α (Preorder.toLE.{u1} γ _inst_3) (Preorder.toLE.{u3} α _inst_1)), IsOrderRightAdjoint.{u1, u2} γ β _inst_3 _inst_2 (Function.comp.{succ u1, succ u3, succ u2} γ α β f (FunLike.coe.{max (succ u1) (succ u3), succ u1, succ u3} (Function.Embedding.{succ u1, succ u3} γ α) γ (fun (_x : γ) => (fun ([email protected]._hyg.19 : γ) => α) _x) (EmbeddingLike.toFunLike.{max (succ u1) (succ u3), succ u1, succ u3} (Function.Embedding.{succ u1, succ u3} γ α) γ α (Function.instEmbeddingLikeEmbedding.{succ u1, succ u3} γ α)) (RelEmbedding.toEmbedding.{u1, u3} γ α (fun ([email protected]._hyg.1281 : γ) ([email protected]._hyg.1283 : γ) => LE.le.{u1} γ (Preorder.toLE.{u1} γ _inst_3) [email protected]._hyg.1281 [email protected]._hyg.1283) (fun ([email protected]._hyg.1296 : α) ([email protected]._hyg.1298 : α) => LE.le.{u3} α (Preorder.toLE.{u3} α _inst_1) [email protected]._hyg.1296 [email protected]._hyg.1298) (RelIso.toRelEmbedding.{u1, u3} γ α (fun ([email protected]._hyg.1281 : γ) ([email protected]._hyg.1283 : γ) => LE.le.{u1} γ (Preorder.toLE.{u1} γ _inst_3) [email protected]._hyg.1281 [email protected]._hyg.1283) (fun ([email protected]._hyg.1296 : α) ([email protected]._hyg.1298 : α) => LE.le.{u3} α (Preorder.toLE.{u3} α _inst_1) [email protected]._hyg.1296 [email protected]._hyg.1298) e)))) (Function.comp.{succ u2, succ u3, succ u1} β α γ (FunLike.coe.{max (succ u3) (succ u1), succ u3, succ u1} (Function.Embedding.{succ u3, succ u1} α γ) α (fun (_x : α) => (fun ([email protected]._hyg.19 : α) => γ) _x) (EmbeddingLike.toFunLike.{max (succ u3) (succ u1), succ u3, succ u1} (Function.Embedding.{succ u3, succ u1} α γ) α γ (Function.instEmbeddingLikeEmbedding.{succ u3, succ u1} α γ)) (RelEmbedding.toEmbedding.{u3, u1} α γ (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u3} α (Preorder.toLE.{u3} α _inst_1) [email protected]._hyg.1281 [email protected]._hyg.1283) (fun ([email protected]._hyg.1296 : γ) ([email protected]._hyg.1298 : γ) => LE.le.{u1} γ (Preorder.toLE.{u1} γ _inst_3) [email protected]._hyg.1296 [email protected]._hyg.1298) (RelIso.toRelEmbedding.{u3, u1} α γ (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u3} α (Preorder.toLE.{u3} α _inst_1) [email protected]._hyg.1281 [email protected]._hyg.1283) (fun ([email protected]._hyg.1296 : γ) ([email protected]._hyg.1298 : γ) => LE.le.{u1} γ (Preorder.toLE.{u1} γ _inst_3) [email protected]._hyg.1296 [email protected]._hyg.1298) (OrderIso.symm.{u1, u3} γ α (Preorder.toLE.{u1} γ _inst_3) (Preorder.toLE.{u3} α _inst_1) e)))) g))
Case conversion may be inaccurate. Consider using '#align is_order_right_adjoint.comp_order_iso IsOrderRightAdjoint.comp_orderIsoₓ'. -/
theorem comp_orderIso [Preorder α] [Preorder β] [Preorder γ] {f : α → β} {g : β → α}
(h : IsOrderRightAdjoint f g) (e : γ ≃o α) : IsOrderRightAdjoint (f ∘ e) (e.symm ∘ g) :=
by
intro y
change IsLUB (e ⁻¹' { x | f x ≤ y }) (e.symm (g y))
rw [e.is_lub_preimage, e.apply_symm_apply]
exact h y
#align is_order_right_adjoint.comp_order_iso IsOrderRightAdjoint.comp_orderIso
end IsOrderRightAdjoint
namespace Function
/- warning: function.semiconj.symm_adjoint -> Function.Semiconj.symm_adjoint is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {fa : OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))} {fb : OrderEmbedding.{u2, u2} β β (Preorder.toLE.{u2} β _inst_2) (Preorder.toLE.{u2} β _inst_2)} {g : α -> β}, (Function.Semiconj.{u1, u2} α β g (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (fun (_x : RelIso.{u1, u1} α α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))) => α -> α) (RelIso.hasCoeToFun.{u1, u1} α α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))) fa) (coeFn.{succ u2, succ u2} (OrderEmbedding.{u2, u2} β β (Preorder.toLE.{u2} β _inst_2) (Preorder.toLE.{u2} β _inst_2)) (fun (_x : RelEmbedding.{u2, u2} β β (LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2)) (LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2))) => β -> β) (RelEmbedding.hasCoeToFun.{u2, u2} β β (LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2)) (LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2))) fb)) -> (forall {g' : β -> α}, (IsOrderRightAdjoint.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 g g') -> (Function.Semiconj.{u2, u1} β α g' (coeFn.{succ u2, succ u2} (OrderEmbedding.{u2, u2} β β (Preorder.toLE.{u2} β _inst_2) (Preorder.toLE.{u2} β _inst_2)) (fun (_x : RelEmbedding.{u2, u2} β β (LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2)) (LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2))) => β -> β) (RelEmbedding.hasCoeToFun.{u2, u2} β β (LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2)) (LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2))) fb) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (fun (_x : RelIso.{u1, u1} α α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))) => α -> α) (RelIso.hasCoeToFun.{u1, u1} α α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))) fa)))
but is expected to have type
forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : PartialOrder.{u2} α] [_inst_2 : Preorder.{u1} β] {fa : OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))} {fb : OrderEmbedding.{u1, u1} β β (Preorder.toLE.{u1} β _inst_2) (Preorder.toLE.{u1} β _inst_2)} {g : α -> β}, (Function.Semiconj.{u2, u1} α β g (FunLike.coe.{succ u2, succ u2, succ u2} (Function.Embedding.{succ u2, succ u2} α α) α (fun (_x : α) => (fun ([email protected]._hyg.19 : α) => α) _x) (EmbeddingLike.toFunLike.{succ u2, succ u2, succ u2} (Function.Embedding.{succ u2, succ u2} α α) α α (Function.instEmbeddingLikeEmbedding.{succ u2, succ u2} α α)) (RelEmbedding.toEmbedding.{u2, u2} α α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1281 [email protected]._hyg.1283) (fun ([email protected]._hyg.1296 : α) ([email protected]._hyg.1298 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1296 [email protected]._hyg.1298) (RelIso.toRelEmbedding.{u2, u2} α α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1281 [email protected]._hyg.1283) (fun ([email protected]._hyg.1296 : α) ([email protected]._hyg.1298 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1296 [email protected]._hyg.1298) fa))) (FunLike.coe.{succ u1, succ u1, succ u1} (Function.Embedding.{succ u1, succ u1} β β) β (fun (_x : β) => (fun ([email protected]._hyg.19 : β) => β) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (Function.Embedding.{succ u1, succ u1} β β) β β (Function.instEmbeddingLikeEmbedding.{succ u1, succ u1} β β)) (RelEmbedding.toEmbedding.{u1, u1} β β (fun ([email protected]._hyg.680 : β) ([email protected]._hyg.682 : β) => LE.le.{u1} β (Preorder.toLE.{u1} β _inst_2) [email protected]._hyg.680 [email protected]._hyg.682) (fun ([email protected]._hyg.695 : β) ([email protected]._hyg.697 : β) => LE.le.{u1} β (Preorder.toLE.{u1} β _inst_2) [email protected]._hyg.695 [email protected]._hyg.697) fb))) -> (forall {g' : β -> α}, (IsOrderRightAdjoint.{u2, u1} α β (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 g g') -> (Function.Semiconj.{u1, u2} β α g' (FunLike.coe.{succ u1, succ u1, succ u1} (Function.Embedding.{succ u1, succ u1} β β) β (fun (_x : β) => (fun ([email protected]._hyg.19 : β) => β) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (Function.Embedding.{succ u1, succ u1} β β) β β (Function.instEmbeddingLikeEmbedding.{succ u1, succ u1} β β)) (RelEmbedding.toEmbedding.{u1, u1} β β (fun ([email protected]._hyg.680 : β) ([email protected]._hyg.682 : β) => LE.le.{u1} β (Preorder.toLE.{u1} β _inst_2) [email protected]._hyg.680 [email protected]._hyg.682) (fun ([email protected]._hyg.695 : β) ([email protected]._hyg.697 : β) => LE.le.{u1} β (Preorder.toLE.{u1} β _inst_2) [email protected]._hyg.695 [email protected]._hyg.697) fb)) (FunLike.coe.{succ u2, succ u2, succ u2} (Function.Embedding.{succ u2, succ u2} α α) α (fun (_x : α) => (fun ([email protected]._hyg.19 : α) => α) _x) (EmbeddingLike.toFunLike.{succ u2, succ u2, succ u2} (Function.Embedding.{succ u2, succ u2} α α) α α (Function.instEmbeddingLikeEmbedding.{succ u2, succ u2} α α)) (RelEmbedding.toEmbedding.{u2, u2} α α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1281 [email protected]._hyg.1283) (fun ([email protected]._hyg.1296 : α) ([email protected]._hyg.1298 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1296 [email protected]._hyg.1298) (RelIso.toRelEmbedding.{u2, u2} α α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1281 [email protected]._hyg.1283) (fun ([email protected]._hyg.1296 : α) ([email protected]._hyg.1298 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1296 [email protected]._hyg.1298) fa)))))
Case conversion may be inaccurate. Consider using '#align function.semiconj.symm_adjoint Function.Semiconj.symm_adjointₓ'. -/
/-- If an order automorphism `fa` is semiconjugate to an order embedding `fb` by a function `g`
and `g'` is an order right adjoint of `g` (i.e. `g' y = Sup {x | f x ≤ y}`), then `fb` is
semiconjugate to `fa` by `g'`.
This is a version of Proposition 2.1 from [Étienne Ghys, Groupes d'homeomorphismes du cercle et
cohomologie bornee][ghys87:groupes]. -/
theorem Semiconj.symm_adjoint [PartialOrder α] [Preorder β] {fa : α ≃o α} {fb : β ↪o β} {g : α → β}
(h : Function.Semiconj g fa fb) {g' : β → α} (hg' : IsOrderRightAdjoint g g') :
Function.Semiconj g' fb fa :=
by
refine' fun y => (hg' _).unique _
rw [← fa.surjective.image_preimage { x | g x ≤ fb y }, preimage_set_of_eq]
simp only [h.eq, fb.le_iff_le, fa.left_ord_continuous (hg' _)]
#align function.semiconj.symm_adjoint Function.Semiconj.symm_adjoint
variable {G : Type _}
/- warning: function.semiconj_of_is_lub -> Function.semiconj_of_isLUB is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} {G : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Group.{u2} G] (f₁ : MonoidHom.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))))))) (f₂ : MonoidHom.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))))))) {h : α -> α}, (forall (x : α), IsLUB.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) (Set.range.{u1, succ u2} α G (fun (g' : G) => coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (fun (_x : RelIso.{u1, u1} α α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))) => α -> α) (RelIso.hasCoeToFun.{u1, u1} α α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))) (Inv.inv.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (DivInvMonoid.toHasInv.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))))) (coeFn.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (MonoidHom.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))))))) (fun (_x : MonoidHom.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))))))) => G -> (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))) (MonoidHom.hasCoeToFun.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))))))) f₁ g')) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (fun (_x : RelIso.{u1, u1} α α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))) => α -> α) (RelIso.hasCoeToFun.{u1, u1} α α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))) (coeFn.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (MonoidHom.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))))))) (fun (_x : MonoidHom.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))))))) => G -> (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))) (MonoidHom.hasCoeToFun.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))))))) f₂ g') x))) (h x)) -> (forall (g : G), Function.Semiconj.{u1, u1} α α h (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (fun (_x : RelIso.{u1, u1} α α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))) => α -> α) (RelIso.hasCoeToFun.{u1, u1} α α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))) (coeFn.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (MonoidHom.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))))))) (fun (_x : MonoidHom.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))))))) => G -> (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))) (MonoidHom.hasCoeToFun.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))))))) f₂ g)) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (fun (_x : RelIso.{u1, u1} α α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))) => α -> α) (RelIso.hasCoeToFun.{u1, u1} α α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))) (coeFn.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (MonoidHom.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))))))) (fun (_x : MonoidHom.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))))))) => G -> (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))) (MonoidHom.hasCoeToFun.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))))))) f₁ g)))
but is expected to have type
forall {α : Type.{u2}} {G : Type.{u1}} [_inst_1 : PartialOrder.{u2} α] [_inst_2 : Group.{u1} G] (f₁ : MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) (f₂ : MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) {h : α -> α}, (forall (x : α), IsLUB.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) (Set.range.{u2, succ u1} α G (fun (g' : G) => FunLike.coe.{succ u2, succ u2, succ u2} (Function.Embedding.{succ u2, succ u2} α α) α (fun (_x : α) => (fun ([email protected]._hyg.19 : α) => α) _x) (EmbeddingLike.toFunLike.{succ u2, succ u2, succ u2} (Function.Embedding.{succ u2, succ u2} α α) α α (Function.instEmbeddingLikeEmbedding.{succ u2, succ u2} α α)) (RelEmbedding.toEmbedding.{u2, u2} α α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1281 [email protected]._hyg.1283) (fun ([email protected]._hyg.1296 : α) ([email protected]._hyg.1298 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1296 [email protected]._hyg.1298) (RelIso.toRelEmbedding.{u2, u2} α α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1281 [email protected]._hyg.1283) (fun ([email protected]._hyg.1296 : α) ([email protected]._hyg.1298 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1296 [email protected]._hyg.1298) (Inv.inv.{u2} ((fun ([email protected]._hyg.2391 : G) => OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) g') (InvOneClass.toInv.{u2} ((fun ([email protected]._hyg.2391 : G) => OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) g') (DivInvOneMonoid.toInvOneClass.{u2} ((fun ([email protected]._hyg.2391 : G) => OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) g') (DivisionMonoid.toDivInvOneMonoid.{u2} ((fun ([email protected]._hyg.2391 : G) => OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) g') (Group.toDivisionMonoid.{u2} ((fun ([email protected]._hyg.2391 : G) => OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) g') (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) G (fun (a : G) => (fun ([email protected]._hyg.2391 : G) => OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) a) (MulHomClass.toFunLike.{max u2 u1, u1, u2} (MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (MulOneClass.toMul.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u1, u2} (MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1281 [email protected]._hyg.1283))))) (MonoidHom.monoidHomClass.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1281 [email protected]._hyg.1283)))))))) f₁ g')))) (FunLike.coe.{succ u2, succ u2, succ u2} (Function.Embedding.{succ u2, succ u2} α α) α (fun (_x : α) => (fun ([email protected]._hyg.19 : α) => α) _x) (EmbeddingLike.toFunLike.{succ u2, succ u2, succ u2} (Function.Embedding.{succ u2, succ u2} α α) α α (Function.instEmbeddingLikeEmbedding.{succ u2, succ u2} α α)) (RelEmbedding.toEmbedding.{u2, u2} α α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1281 [email protected]._hyg.1283) (fun ([email protected]._hyg.1296 : α) ([email protected]._hyg.1298 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1296 [email protected]._hyg.1298) (RelIso.toRelEmbedding.{u2, u2} α α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1281 [email protected]._hyg.1283) (fun ([email protected]._hyg.1296 : α) ([email protected]._hyg.1298 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1296 [email protected]._hyg.1298) (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) G (fun (a : G) => (fun ([email protected]._hyg.2391 : G) => OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) a) (MulHomClass.toFunLike.{max u2 u1, u1, u2} (MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (MulOneClass.toMul.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u1, u2} (MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1281 [email protected]._hyg.1283))))) (MonoidHom.monoidHomClass.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1281 [email protected]._hyg.1283)))))))) f₂ g'))) x))) (h x)) -> (forall (g : G), Function.Semiconj.{u2, u2} α α h (FunLike.coe.{succ u2, succ u2, succ u2} (Function.Embedding.{succ u2, succ u2} α α) α (fun (_x : α) => (fun ([email protected]._hyg.19 : α) => α) _x) (EmbeddingLike.toFunLike.{succ u2, succ u2, succ u2} (Function.Embedding.{succ u2, succ u2} α α) α α (Function.instEmbeddingLikeEmbedding.{succ u2, succ u2} α α)) (RelEmbedding.toEmbedding.{u2, u2} α α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1281 [email protected]._hyg.1283) (fun ([email protected]._hyg.1296 : α) ([email protected]._hyg.1298 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1296 [email protected]._hyg.1298) (RelIso.toRelEmbedding.{u2, u2} α α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1281 [email protected]._hyg.1283) (fun ([email protected]._hyg.1296 : α) ([email protected]._hyg.1298 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1296 [email protected]._hyg.1298) (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) G (fun (a : G) => (fun ([email protected]._hyg.2391 : G) => OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) a) (MulHomClass.toFunLike.{max u2 u1, u1, u2} (MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (MulOneClass.toMul.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u1, u2} (MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1281 [email protected]._hyg.1283))))) (MonoidHom.monoidHomClass.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1281 [email protected]._hyg.1283)))))))) f₂ g)))) (FunLike.coe.{succ u2, succ u2, succ u2} (Function.Embedding.{succ u2, succ u2} α α) α (fun (_x : α) => (fun ([email protected]._hyg.19 : α) => α) _x) (EmbeddingLike.toFunLike.{succ u2, succ u2, succ u2} (Function.Embedding.{succ u2, succ u2} α α) α α (Function.instEmbeddingLikeEmbedding.{succ u2, succ u2} α α)) (RelEmbedding.toEmbedding.{u2, u2} α α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1281 [email protected]._hyg.1283) (fun ([email protected]._hyg.1296 : α) ([email protected]._hyg.1298 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1296 [email protected]._hyg.1298) (RelIso.toRelEmbedding.{u2, u2} α α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1281 [email protected]._hyg.1283) (fun ([email protected]._hyg.1296 : α) ([email protected]._hyg.1298 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1296 [email protected]._hyg.1298) (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) G (fun (a : G) => (fun ([email protected]._hyg.2391 : G) => OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) a) (MulHomClass.toFunLike.{max u2 u1, u1, u2} (MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (MulOneClass.toMul.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u1, u2} (MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1281 [email protected]._hyg.1283))))) (MonoidHom.monoidHomClass.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) [email protected]._hyg.1281 [email protected]._hyg.1283)))))))) f₁ g)))))
Case conversion may be inaccurate. Consider using '#align function.semiconj_of_is_lub Function.semiconj_of_isLUBₓ'. -/
theorem semiconj_of_isLUB [PartialOrder α] [Group G] (f₁ f₂ : G →* α ≃o α) {h : α → α}
(H : ∀ x, IsLUB (range fun g' => (f₁ g')⁻¹ (f₂ g' x)) (h x)) (g : G) :
Function.Semiconj h (f₂ g) (f₁ g) :=
by
refine' fun y => (H _).unique _
have := (f₁ g).LeftOrdContinuous (H y)
rw [← range_comp, ← (Equiv.mulRight g).Surjective.range_comp _] at this
simpa [(· ∘ ·)] using this
#align function.semiconj_of_is_lub Function.semiconj_of_isLUB
/- warning: function.Sup_div_semiconj -> Function.supₛ_div_semiconj is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} {G : Type.{u2}} [_inst_1 : CompleteLattice.{u1} α] [_inst_2 : Group.{u2} G] (f₁ : MonoidHom.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))))))))) (f₂ : MonoidHom.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))))))))) (g : G), Function.Semiconj.{u1, u1} α α (fun (x : α) => supᵢ.{u1, succ u2} α (ConditionallyCompleteLattice.toHasSup.{u1} α (CompleteLattice.toConditionallyCompleteLattice.{u1} α _inst_1)) G (fun (g' : G) => coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (fun (_x : RelIso.{u1, u1} α α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))))) => α -> α) (RelIso.hasCoeToFun.{u1, u1} α α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))))) (Inv.inv.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (DivInvMonoid.toHasInv.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))))))) (coeFn.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (MonoidHom.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))))))))) (fun (_x : MonoidHom.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))))))))) => G -> (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))))) (MonoidHom.hasCoeToFun.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))))))))) f₁ g')) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (fun (_x : RelIso.{u1, u1} α α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))))) => α -> α) (RelIso.hasCoeToFun.{u1, u1} α α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))))) (coeFn.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (MonoidHom.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))))))))) (fun (_x : MonoidHom.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))))))))) => G -> (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))))) (MonoidHom.hasCoeToFun.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))))))))) f₂ g') x))) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (fun (_x : RelIso.{u1, u1} α α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))))) => α -> α) (RelIso.hasCoeToFun.{u1, u1} α α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))))) (coeFn.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (MonoidHom.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))))))))) (fun (_x : MonoidHom.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))))))))) => G -> (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))))) (MonoidHom.hasCoeToFun.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))))))))) f₂ g)) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (fun (_x : RelIso.{u1, u1} α α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))))) => α -> α) (RelIso.hasCoeToFun.{u1, u1} α α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))))) (coeFn.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (MonoidHom.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))))))))) (fun (_x : MonoidHom.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))))))))) => G -> (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))))) (MonoidHom.hasCoeToFun.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))))))))) f₁ g))
but is expected to have type
forall {α : Type.{u2}} {G : Type.{u1}} [_inst_1 : CompleteLattice.{u2} α] [_inst_2 : Group.{u1} G] (f₁ : MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) (f₂ : MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) (g : G), Function.Semiconj.{u2, u2} α α (fun (x : α) => supᵢ.{u2, succ u1} α (ConditionallyCompleteLattice.toSupSet.{u2} α (CompleteLattice.toConditionallyCompleteLattice.{u2} α _inst_1)) G (fun (g' : G) => FunLike.coe.{succ u2, succ u2, succ u2} (Function.Embedding.{succ u2, succ u2} α α) α (fun (_x : α) => (fun ([email protected]._hyg.19 : α) => α) _x) (EmbeddingLike.toFunLike.{succ u2, succ u2, succ u2} (Function.Embedding.{succ u2, succ u2} α α) α α (Function.instEmbeddingLikeEmbedding.{succ u2, succ u2} α α)) (RelEmbedding.toEmbedding.{u2, u2} α α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) [email protected]._hyg.1281 [email protected]._hyg.1283) (fun ([email protected]._hyg.1296 : α) ([email protected]._hyg.1298 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) [email protected]._hyg.1296 [email protected]._hyg.1298) (RelIso.toRelEmbedding.{u2, u2} α α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) [email protected]._hyg.1281 [email protected]._hyg.1283) (fun ([email protected]._hyg.1296 : α) ([email protected]._hyg.1298 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) [email protected]._hyg.1296 [email protected]._hyg.1298) (Inv.inv.{u2} ((fun ([email protected]._hyg.2391 : G) => OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) g') (InvOneClass.toInv.{u2} ((fun ([email protected]._hyg.2391 : G) => OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) g') (DivInvOneMonoid.toInvOneClass.{u2} ((fun ([email protected]._hyg.2391 : G) => OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) g') (DivisionMonoid.toDivInvOneMonoid.{u2} ((fun ([email protected]._hyg.2391 : G) => OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) g') (Group.toDivisionMonoid.{u2} ((fun ([email protected]._hyg.2391 : G) => OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) g') (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) G (fun (a : G) => (fun ([email protected]._hyg.2391 : G) => OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) a) (MulHomClass.toFunLike.{max u2 u1, u1, u2} (MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (MulOneClass.toMul.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u1, u2} (MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) [email protected]._hyg.1281 [email protected]._hyg.1283))))) (MonoidHom.monoidHomClass.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))))) f₁ g')))) (FunLike.coe.{succ u2, succ u2, succ u2} (Function.Embedding.{succ u2, succ u2} α α) α (fun (_x : α) => (fun ([email protected]._hyg.19 : α) => α) _x) (EmbeddingLike.toFunLike.{succ u2, succ u2, succ u2} (Function.Embedding.{succ u2, succ u2} α α) α α (Function.instEmbeddingLikeEmbedding.{succ u2, succ u2} α α)) (RelEmbedding.toEmbedding.{u2, u2} α α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) [email protected]._hyg.1281 [email protected]._hyg.1283) (fun ([email protected]._hyg.1296 : α) ([email protected]._hyg.1298 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) [email protected]._hyg.1296 [email protected]._hyg.1298) (RelIso.toRelEmbedding.{u2, u2} α α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) [email protected]._hyg.1281 [email protected]._hyg.1283) (fun ([email protected]._hyg.1296 : α) ([email protected]._hyg.1298 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) [email protected]._hyg.1296 [email protected]._hyg.1298) (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) G (fun (a : G) => (fun ([email protected]._hyg.2391 : G) => OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) a) (MulHomClass.toFunLike.{max u2 u1, u1, u2} (MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (MulOneClass.toMul.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u1, u2} (MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) [email protected]._hyg.1281 [email protected]._hyg.1283))))) (MonoidHom.monoidHomClass.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))))) f₂ g'))) x))) (FunLike.coe.{succ u2, succ u2, succ u2} (Function.Embedding.{succ u2, succ u2} α α) α (fun (_x : α) => (fun ([email protected]._hyg.19 : α) => α) _x) (EmbeddingLike.toFunLike.{succ u2, succ u2, succ u2} (Function.Embedding.{succ u2, succ u2} α α) α α (Function.instEmbeddingLikeEmbedding.{succ u2, succ u2} α α)) (RelEmbedding.toEmbedding.{u2, u2} α α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) [email protected]._hyg.1281 [email protected]._hyg.1283) (fun ([email protected]._hyg.1296 : α) ([email protected]._hyg.1298 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) [email protected]._hyg.1296 [email protected]._hyg.1298) (RelIso.toRelEmbedding.{u2, u2} α α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) [email protected]._hyg.1281 [email protected]._hyg.1283) (fun ([email protected]._hyg.1296 : α) ([email protected]._hyg.1298 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) [email protected]._hyg.1296 [email protected]._hyg.1298) (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) G (fun (a : G) => (fun ([email protected]._hyg.2391 : G) => OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) a) (MulHomClass.toFunLike.{max u2 u1, u1, u2} (MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (MulOneClass.toMul.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u1, u2} (MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) [email protected]._hyg.1281 [email protected]._hyg.1283))))) (MonoidHom.monoidHomClass.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))))) f₂ g)))) (FunLike.coe.{succ u2, succ u2, succ u2} (Function.Embedding.{succ u2, succ u2} α α) α (fun (_x : α) => (fun ([email protected]._hyg.19 : α) => α) _x) (EmbeddingLike.toFunLike.{succ u2, succ u2, succ u2} (Function.Embedding.{succ u2, succ u2} α α) α α (Function.instEmbeddingLikeEmbedding.{succ u2, succ u2} α α)) (RelEmbedding.toEmbedding.{u2, u2} α α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) [email protected]._hyg.1281 [email protected]._hyg.1283) (fun ([email protected]._hyg.1296 : α) ([email protected]._hyg.1298 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) [email protected]._hyg.1296 [email protected]._hyg.1298) (RelIso.toRelEmbedding.{u2, u2} α α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) [email protected]._hyg.1281 [email protected]._hyg.1283) (fun ([email protected]._hyg.1296 : α) ([email protected]._hyg.1298 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) [email protected]._hyg.1296 [email protected]._hyg.1298) (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) G (fun (a : G) => (fun ([email protected]._hyg.2391 : G) => OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) a) (MulHomClass.toFunLike.{max u2 u1, u1, u2} (MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (MulOneClass.toMul.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u1, u2} (MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) [email protected]._hyg.1281 [email protected]._hyg.1283))))) (MonoidHom.monoidHomClass.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (CompleteSemilatticeInf.toPartialOrder.{u2} α (CompleteLattice.toCompleteSemilatticeInf.{u2} α _inst_1)))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))))) f₁ g))))
Case conversion may be inaccurate. Consider using '#align function.Sup_div_semiconj Function.supₛ_div_semiconjₓ'. -/
/-- Consider two actions `f₁ f₂ : G → α → α` of a group on a complete lattice by order
isomorphisms. Then the map `x ↦ ⨆ g : G, (f₁ g)⁻¹ (f₂ g x)` semiconjugates each `f₁ g'` to `f₂ g'`.
This is a version of Proposition 5.4 from [Étienne Ghys, Groupes d'homeomorphismes du cercle et
cohomologie bornee][ghys87:groupes]. -/
theorem supₛ_div_semiconj [CompleteLattice α] [Group G] (f₁ f₂ : G →* α ≃o α) (g : G) :
Function.Semiconj (fun x => ⨆ g' : G, (f₁ g')⁻¹ (f₂ g' x)) (f₂ g) (f₁ g) :=
semiconj_of_isLUB f₁ f₂ (fun x => isLUB_supᵢ) _
#align function.Sup_div_semiconj Function.supₛ_div_semiconj
/- warning: function.cSup_div_semiconj -> Function.csupₛ_div_semiconj is a dubious translation:
lean 3 declaration is
forall {α : Type.{u1}} {G : Type.{u2}} [_inst_1 : ConditionallyCompleteLattice.{u1} α] [_inst_2 : Group.{u2} G] (f₁ : MonoidHom.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))))))))) (f₂ : MonoidHom.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))))))))), (forall (x : α), BddAbove.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))) (Set.range.{u1, succ u2} α G (fun (g : G) => coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (fun (_x : RelIso.{u1, u1} α α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))))) => α -> α) (RelIso.hasCoeToFun.{u1, u1} α α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))))) (Inv.inv.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (DivInvMonoid.toHasInv.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))))))) (coeFn.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (MonoidHom.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))))))))) (fun (_x : MonoidHom.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))))))))) => G -> (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))))) (MonoidHom.hasCoeToFun.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))))))))) f₁ g)) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (fun (_x : RelIso.{u1, u1} α α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))))) => α -> α) (RelIso.hasCoeToFun.{u1, u1} α α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))))) (coeFn.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (MonoidHom.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))))))))) (fun (_x : MonoidHom.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))))))))) => G -> (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))))) (MonoidHom.hasCoeToFun.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))))))))) f₂ g) x)))) -> (forall (g : G), Function.Semiconj.{u1, u1} α α (fun (x : α) => supᵢ.{u1, succ u2} α (ConditionallyCompleteLattice.toHasSup.{u1} α _inst_1) G (fun (g' : G) => coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (fun (_x : RelIso.{u1, u1} α α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))))) => α -> α) (RelIso.hasCoeToFun.{u1, u1} α α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))))) (Inv.inv.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (DivInvMonoid.toHasInv.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))))))) (coeFn.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (MonoidHom.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))))))))) (fun (_x : MonoidHom.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))))))))) => G -> (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))))) (MonoidHom.hasCoeToFun.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))))))))) f₁ g')) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (fun (_x : RelIso.{u1, u1} α α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))))) => α -> α) (RelIso.hasCoeToFun.{u1, u1} α α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))))) (coeFn.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (MonoidHom.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))))))))) (fun (_x : MonoidHom.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))))))))) => G -> (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))))) (MonoidHom.hasCoeToFun.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))))))))) f₂ g') x))) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (fun (_x : RelIso.{u1, u1} α α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))))) => α -> α) (RelIso.hasCoeToFun.{u1, u1} α α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))))) (coeFn.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (MonoidHom.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))))))))) (fun (_x : MonoidHom.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))))))))) => G -> (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))))) (MonoidHom.hasCoeToFun.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))))))))) f₂ g)) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (fun (_x : RelIso.{u1, u1} α α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))))) => α -> α) (RelIso.hasCoeToFun.{u1, u1} α α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))))) (coeFn.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (MonoidHom.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))))))))) (fun (_x : MonoidHom.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))))))))) => G -> (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))))) (MonoidHom.hasCoeToFun.{u2, u1} G (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))) (Monoid.toMulOneClass.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (DivInvMonoid.toMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (Group.toDivInvMonoid.{u1} (OrderIso.{u1, u1} α α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)))))) (RelIso.group.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1))))))))))) f₁ g)))
but is expected to have type
forall {α : Type.{u2}} {G : Type.{u1}} [_inst_1 : ConditionallyCompleteLattice.{u2} α] [_inst_2 : Group.{u1} G] (f₁ : MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) (f₂ : MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))), (forall (x : α), BddAbove.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))) (Set.range.{u2, succ u1} α G (fun (g : G) => FunLike.coe.{succ u2, succ u2, succ u2} (Function.Embedding.{succ u2, succ u2} α α) α (fun (_x : α) => (fun ([email protected]._hyg.19 : α) => α) _x) (EmbeddingLike.toFunLike.{succ u2, succ u2, succ u2} (Function.Embedding.{succ u2, succ u2} α α) α α (Function.instEmbeddingLikeEmbedding.{succ u2, succ u2} α α)) (RelEmbedding.toEmbedding.{u2, u2} α α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283) (fun ([email protected]._hyg.1296 : α) ([email protected]._hyg.1298 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1296 [email protected]._hyg.1298) (RelIso.toRelEmbedding.{u2, u2} α α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283) (fun ([email protected]._hyg.1296 : α) ([email protected]._hyg.1298 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1296 [email protected]._hyg.1298) (Inv.inv.{u2} ((fun ([email protected]._hyg.2391 : G) => OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) g) (InvOneClass.toInv.{u2} ((fun ([email protected]._hyg.2391 : G) => OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) g) (DivInvOneMonoid.toInvOneClass.{u2} ((fun ([email protected]._hyg.2391 : G) => OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) g) (DivisionMonoid.toDivInvOneMonoid.{u2} ((fun ([email protected]._hyg.2391 : G) => OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) g) (Group.toDivisionMonoid.{u2} ((fun ([email protected]._hyg.2391 : G) => OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) g) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) G (fun (a : G) => (fun ([email protected]._hyg.2391 : G) => OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) a) (MulHomClass.toFunLike.{max u2 u1, u1, u2} (MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (MulOneClass.toMul.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u1, u2} (MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283))))) (MonoidHom.monoidHomClass.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))))) f₁ g)))) (FunLike.coe.{succ u2, succ u2, succ u2} (Function.Embedding.{succ u2, succ u2} α α) α (fun (_x : α) => (fun ([email protected]._hyg.19 : α) => α) _x) (EmbeddingLike.toFunLike.{succ u2, succ u2, succ u2} (Function.Embedding.{succ u2, succ u2} α α) α α (Function.instEmbeddingLikeEmbedding.{succ u2, succ u2} α α)) (RelEmbedding.toEmbedding.{u2, u2} α α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283) (fun ([email protected]._hyg.1296 : α) ([email protected]._hyg.1298 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1296 [email protected]._hyg.1298) (RelIso.toRelEmbedding.{u2, u2} α α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283) (fun ([email protected]._hyg.1296 : α) ([email protected]._hyg.1298 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1296 [email protected]._hyg.1298) (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) G (fun (a : G) => (fun ([email protected]._hyg.2391 : G) => OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) a) (MulHomClass.toFunLike.{max u2 u1, u1, u2} (MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (MulOneClass.toMul.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u1, u2} (MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283))))) (MonoidHom.monoidHomClass.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))))) f₂ g))) x)))) -> (forall (g : G), Function.Semiconj.{u2, u2} α α (fun (x : α) => supᵢ.{u2, succ u1} α (ConditionallyCompleteLattice.toSupSet.{u2} α _inst_1) G (fun (g' : G) => FunLike.coe.{succ u2, succ u2, succ u2} (Function.Embedding.{succ u2, succ u2} α α) α (fun (_x : α) => (fun ([email protected]._hyg.19 : α) => α) _x) (EmbeddingLike.toFunLike.{succ u2, succ u2, succ u2} (Function.Embedding.{succ u2, succ u2} α α) α α (Function.instEmbeddingLikeEmbedding.{succ u2, succ u2} α α)) (RelEmbedding.toEmbedding.{u2, u2} α α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283) (fun ([email protected]._hyg.1296 : α) ([email protected]._hyg.1298 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1296 [email protected]._hyg.1298) (RelIso.toRelEmbedding.{u2, u2} α α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283) (fun ([email protected]._hyg.1296 : α) ([email protected]._hyg.1298 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1296 [email protected]._hyg.1298) (Inv.inv.{u2} ((fun ([email protected]._hyg.2391 : G) => OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) g') (InvOneClass.toInv.{u2} ((fun ([email protected]._hyg.2391 : G) => OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) g') (DivInvOneMonoid.toInvOneClass.{u2} ((fun ([email protected]._hyg.2391 : G) => OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) g') (DivisionMonoid.toDivInvOneMonoid.{u2} ((fun ([email protected]._hyg.2391 : G) => OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) g') (Group.toDivisionMonoid.{u2} ((fun ([email protected]._hyg.2391 : G) => OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) g') (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) G (fun (a : G) => (fun ([email protected]._hyg.2391 : G) => OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) a) (MulHomClass.toFunLike.{max u2 u1, u1, u2} (MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (MulOneClass.toMul.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u1, u2} (MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283))))) (MonoidHom.monoidHomClass.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))))) f₁ g')))) (FunLike.coe.{succ u2, succ u2, succ u2} (Function.Embedding.{succ u2, succ u2} α α) α (fun (_x : α) => (fun ([email protected]._hyg.19 : α) => α) _x) (EmbeddingLike.toFunLike.{succ u2, succ u2, succ u2} (Function.Embedding.{succ u2, succ u2} α α) α α (Function.instEmbeddingLikeEmbedding.{succ u2, succ u2} α α)) (RelEmbedding.toEmbedding.{u2, u2} α α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283) (fun ([email protected]._hyg.1296 : α) ([email protected]._hyg.1298 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1296 [email protected]._hyg.1298) (RelIso.toRelEmbedding.{u2, u2} α α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283) (fun ([email protected]._hyg.1296 : α) ([email protected]._hyg.1298 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1296 [email protected]._hyg.1298) (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) G (fun (a : G) => (fun ([email protected]._hyg.2391 : G) => OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) a) (MulHomClass.toFunLike.{max u2 u1, u1, u2} (MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (MulOneClass.toMul.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u1, u2} (MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283))))) (MonoidHom.monoidHomClass.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))))) f₂ g'))) x))) (FunLike.coe.{succ u2, succ u2, succ u2} (Function.Embedding.{succ u2, succ u2} α α) α (fun (_x : α) => (fun ([email protected]._hyg.19 : α) => α) _x) (EmbeddingLike.toFunLike.{succ u2, succ u2, succ u2} (Function.Embedding.{succ u2, succ u2} α α) α α (Function.instEmbeddingLikeEmbedding.{succ u2, succ u2} α α)) (RelEmbedding.toEmbedding.{u2, u2} α α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283) (fun ([email protected]._hyg.1296 : α) ([email protected]._hyg.1298 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1296 [email protected]._hyg.1298) (RelIso.toRelEmbedding.{u2, u2} α α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283) (fun ([email protected]._hyg.1296 : α) ([email protected]._hyg.1298 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1296 [email protected]._hyg.1298) (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) G (fun (a : G) => (fun ([email protected]._hyg.2391 : G) => OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) a) (MulHomClass.toFunLike.{max u2 u1, u1, u2} (MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (MulOneClass.toMul.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u1, u2} (MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283))))) (MonoidHom.monoidHomClass.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))))) f₂ g)))) (FunLike.coe.{succ u2, succ u2, succ u2} (Function.Embedding.{succ u2, succ u2} α α) α (fun (_x : α) => (fun ([email protected]._hyg.19 : α) => α) _x) (EmbeddingLike.toFunLike.{succ u2, succ u2, succ u2} (Function.Embedding.{succ u2, succ u2} α α) α α (Function.instEmbeddingLikeEmbedding.{succ u2, succ u2} α α)) (RelEmbedding.toEmbedding.{u2, u2} α α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283) (fun ([email protected]._hyg.1296 : α) ([email protected]._hyg.1298 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1296 [email protected]._hyg.1298) (RelIso.toRelEmbedding.{u2, u2} α α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283) (fun ([email protected]._hyg.1296 : α) ([email protected]._hyg.1298 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1296 [email protected]._hyg.1298) (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) G (fun (a : G) => (fun ([email protected]._hyg.2391 : G) => OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) a) (MulHomClass.toFunLike.{max u2 u1, u1, u2} (MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (MulOneClass.toMul.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u1, u2} (MonoidHom.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))) G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283))))) (MonoidHom.monoidHomClass.{u1, u2} G (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (Monoid.toMulOneClass.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (DivInvMonoid.toMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (Group.toDivInvMonoid.{u2} (OrderIso.{u2, u2} α α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1)))))) (RelIso.instGroupRelIso.{u2} α (fun ([email protected]._hyg.1281 : α) ([email protected]._hyg.1283 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (ConditionallyCompleteLattice.toLattice.{u2} α _inst_1))))) [email protected]._hyg.1281 [email protected]._hyg.1283)))))))) f₁ g)))))
Case conversion may be inaccurate. Consider using '#align function.cSup_div_semiconj Function.csupₛ_div_semiconjₓ'. -/
/-- Consider two actions `f₁ f₂ : G → α → α` of a group on a conditionally complete lattice by order
isomorphisms. Suppose that each set $s(x)=\{f_1(g)^{-1} (f_2(g)(x)) | g \in G\}$ is bounded above.
Then the map `x ↦ Sup s(x)` semiconjugates each `f₁ g'` to `f₂ g'`.
This is a version of Proposition 5.4 from [Étienne Ghys, Groupes d'homeomorphismes du cercle et
cohomologie bornee][ghys87:groupes]. -/
theorem csupₛ_div_semiconj [ConditionallyCompleteLattice α] [Group G] (f₁ f₂ : G →* α ≃o α)
(hbdd : ∀ x, BddAbove (range fun g => (f₁ g)⁻¹ (f₂ g x))) (g : G) :
Function.Semiconj (fun x => ⨆ g' : G, (f₁ g')⁻¹ (f₂ g' x)) (f₂ g) (f₁ g) :=
semiconj_of_isLUB f₁ f₂ (fun x => isLUB_csupₛ (range_nonempty _) (hbdd x)) _
#align function.cSup_div_semiconj Function.csupₛ_div_semiconj
end Function
-- Guard against import creep
assert_not_exists Finset
|
module Twist.Util
import Data.Fin
import Data.Vect
%default total
%access export
|
from __future__ import division
import numpy as np
from scipy import constants as sc
from scipy import integrate
import nu
class bulk(object):
"""docstring for mat"""
def __init__(self, T=300):
# electron effective mass
self.m_e = .023*sc.m_e
# bandgap
self.Eg = 0.354*sc.eV
# carrier temperature in the quantum well
self.T = T
# constant for 2d density of states
self._cdos = 8*np.sqrt(2)*self.m_e**(1.5)/sc.h**3
# conduction band edge
self.Ec = self.Eg/2
return
# carrier density at given Fermi level
def f_d(self, E, muc):
return np.sqrt(E-self.Ec)/(np.exp((E-muc)/(sc.k*self.T))+1)
def density(self, Efn):
a = self.Ec
b = 20*sc.k*self.T+a
ret = integrate.quad(self.f_d, a, b, args=(Efn, ))
# print ret
return self._cdos*ret[0]
def main():
mat = bulk()
return
if __name__ == '__main__':
main()
|
# Information about code:
# This code corresponds to data wrangling code for my MSc thesis.
# This code is for creating dataset for taxonomic effort.
# @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
source('2019-06-19-jsa-type/clean/functions.R')
# @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
# Section - no of taxonomist active per year
# @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
print(paste0(Sys.time(), " --- 'describers': number of taxonomist active per year"))
# Read and filter data
describer_data <- read_escaped_data(paste0(dir_data_raw, basefile, " describers_5.0-describers-final.csv"))
describer_data <- describer_data[years_active > 0] # latest year: 2018
# # CHECK: since cut-off year is 2018, to exclude Silas Bossert
# describer_data[full.name.of.describer.n =="Silas Bossert"]
# describers[!is.finite(as.numeric(describers$ns_species_per_year_active))]
describer_date <-
read_escaped_data(paste0(dir_data_raw, basefile, " describers_4.0-denormalised2.csv"))
synonyms <- read_escaped_data(paste0(dir_data_raw, basefile, " oth_1-clean.csv"))
###########################
# For taxonomic_effort1
###########################
# Subset dataset for taxonomic_effort1: calculating number of describers + weighted
describers <- describer_data[, c("idx_auth", "full.name.of.describer.n",
"min", "max_corrected",
"ns_species_per_year_active")]
# Expand dataset by min and max years
seq <- mapply(function(a, b) seq(a, b), a=describers$min, b=describers$max_corrected)
describers$years <- seq
describers <- data.table(describers %>% unnest(years))
# Calculate number of describers, and weighted number of describers
taxonomic_effort1 <-
describers[, list(N_describers = length(idx_auth),
N_weighted_describers = sum(as.numeric(ns_species_per_year_active))),
by=years][order(as.numeric(years))][
,c("years", "N_describers", "N_weighted_describers")]
# Merge to template dataset
min_year <- min(taxonomic_effort1$years)
max_year <- max(taxonomic_effort1$years)
taxonomic_effort1 <- merge(data.frame(years=min_year:max_year), taxonomic_effort1,
by="years", all.x=T, all.y=F)
###########################
# For taxonomic_effort2
###########################
# Subset dataset for taxonomic_effort2: N_real_describers/ N_weighted_real_describers
# Exclude authors with no first author publications at all
to_exclude <- describer_data[spp_N_1st_auth_s == 0]$idx_auth
# N number of describers (N and weighted)
describers <- describer_data[!(idx_auth %in% to_exclude),
c("idx_auth", "full.name.of.describer.n",
"min", "max_corrected", "ns_species_per_year_active")]
# Expand dataset by min/max years for each author
seq <- mapply(function(a, b) seq(a, b), a=describers$min, b=describers$max_corrected)
describers$years <- seq
describers <- data.table(describers %>% unnest(years))
# Summarise metrics
taxonomic_effort2 <-
describers[, list(N_real_describers = length(idx_auth),
N_weighted_real_describers = sum(as.numeric(ns_species_per_year_active))),
by=years][order(as.numeric(years))][
, c("years", "N_real_describers", "N_weighted_real_describers")]
###########################
# For taxonomic_effort3
###########################
N_species <- 10
# Exclude authors that have no first author publications
describers <- describer_data[!(idx_auth %in% to_exclude) & as.numeric(spp_N) <= N_species,
c("idx_auth", "full.name.of.describer.n",
"min", "max_corrected", "ns_species_per_year_active", "spp_N")]
# Reshape data by number of species described
describers <- dcast(describers,
idx_auth + full.name.of.describer.n + min +
max_corrected ~ as.numeric(spp_N), value.var="ns_species_per_year_active")
# Sum the number of authors by number of species described
# Figure out how to loop this # TODO:
describers[!is.na(`2`), ]$`3` <- describers[!is.na(`2`), ]$`2`
describers[!is.na(`3`), ]$`4` <- describers[!is.na(`3`), ]$`3`
describers[!is.na(`4`), ]$`5` <- describers[!is.na(`4`), ]$`4`
describers[!is.na(`5`), ]$`6` <- describers[!is.na(`5`), ]$`5`
describers[!is.na(`6`), ]$`7` <- describers[!is.na(`6`), ]$`6`
describers[!is.na(`7`), ]$`8` <- describers[!is.na(`7`), ]$`7`
describers[!is.na(`8`), ]$`9` <- describers[!is.na(`8`), ]$`8`
describers[!is.na(`9`), ]$`10` <- describers[!is.na(`9`), ]$`9`
# Expand data by min/max for each author
seq <- mapply(function(a, b) seq(a, b), a=describers$min, b=describers$max_corrected)
describers$years <- seq
describers <- data.table(describers %>% unnest(years))
# Calculate authors that only authored 1,2,3,4,5.. publications
taxonomic_effort3 <-
describers[, list(N_real_describers.1 = length(which(!is.na(`1`))),
N_real_describers.2 = length(which(!is.na(`2`))),
N_real_describers.3 = length(which(!is.na(`3`))),
N_real_describers.4 = length(which(!is.na(`4`))),
N_real_describers.5 = length(which(!is.na(`5`))),
N_real_describers.6 = length(which(!is.na(`6`))),
N_real_describers.7 = length(which(!is.na(`7`))),
N_real_describers.8 = length(which(!is.na(`8`))),
N_real_describers.9 = length(which(!is.na(`9`))),
N_real_describers.10 = length(which(!is.na(`10`)))
), by=years][order(as.numeric(years))]
############################
# Merge taxonomic_effort
###########################
taxonomic_effort <- merge(taxonomic_effort1, taxonomic_effort2, by="years", all.x=T, all.y=F)
taxonomic_effort <- merge(taxonomic_effort, taxonomic_effort3, by="years", all.x=T, all.y=F)
############################
# Count species
###########################
# N species
described_species_by_year <-
describer_date[idxes %in% 1:20669,
list(N_species_described=length(unique(idxes))),
by="date.n"][,c("date.n", "N_species_described")]
per_year1 <- merge(taxonomic_effort, described_species_by_year,
by.x="years", by.y="date.n", all.x=T, all.y=F)
# N synonyms
described_species_by_year <-
synonyms[,
list(N_synonyms=length(unique(idx))),
by="date.n"][,c("date.n", "N_synonyms")]
# Combine data
per_year2 <- merge(per_year1, described_species_by_year,
by.x="years", by.y="date.n", all.x=T, all.y=F)
per_year2[is.na(per_year2)] <- 0
per_year2 <- data.table(per_year2)
# Write data
filepath <- paste0(dir_data_raw, basefile, " describers_6.0-active-by-year.csv")
write.csv(per_year2[years<=2018], filepath, na='', row.names=F, fileEncoding="UTF-8") |
(*
Copyright (C) 2017 M.A.L. Marques
This Source Code Form is subject to the terms of the Mozilla Public
License, v. 2.0. If a copy of the MPL was not distributed with this
file, You can obtain one at http://mozilla.org/MPL/2.0/.
*)
(* type: gga_exc *)
(* prefix:
gga_c_zvpbeint_params *params;
assert(p->params != NULL);
params = (gga_c_zvpbeint_params * )(p->params);
*)
params_a_gamma := (1 - log(2))/Pi^2:
params_a_BB := 1:
$include "gga_c_pbe.mpl"
zvpbeint_nu := (rs, z, t) ->
t*mphi(z)*(3/rs)^(1/6):
(* we write (z^2)^(omega/2) instead of z^omega in order to
avoid the use of abs(z). Max is required not to get float
exceptions for z->0 *)
zvpbeint_ff := (rs, z, t) ->
exp(-params_a_alpha*zvpbeint_nu(rs, z, t)^3*m_max(z^2, 1e-20)^(params_a_omega/2)):
f := (rs, z, xt, xs0, xs1) ->
f_pw(rs, z) + zvpbeint_ff(rs, z, tp(rs, z, xt))*fH(rs, z, tp(rs, z, xt)):
|
From UT Require Import Prelims Setoid.
Require Import Coq.Classes.CRelationClasses.
Require Import FunctionalExtensionality.
Definition flip {A B C : Type} (f : A -> B -> C) := fun x y => f y x.
Class Typoid (A: Type): Type :=
mkTypoid
{
st : Setoid A;
ett : ∏ {x y: A}, crelation (@et A st x y) where "a == b" := (ett a b);
ett_refl : ∏ {x y: A} (e: x ~> y), e == e;
ett_sym : ∏ {x y: A} (e d: x ~> y), e == d -> d == e;
ett_trans : ∏ {x y: A} (e d f: x ~> y), e == d -> d == f -> e == f;
Typ1_i : ∏ {x y: A} (e: x ~> y), (eqv x) o e == e;
Typ1_ii : ∏ {x y: A} (e: x ~> y), e o (eqv y) == e;
Typ2_i : ∏ {x y: A} (e: x ~> y), e o (inv e) == eqv x;
Typ2_ii : ∏ {x y: A} (e: x ~> y), (inv e) o e == eqv y;
Typ3 : ∏ {x y z t: A} (e1: x ~> y) (e2: y ~> z) (e3: z ~> t), ((e1 o e2) o e3) == (e1 o (e2 o e3));
Typ4 : ∏ {x y z: A} (e1 d1: x ~> y) (e2 d2: y ~> z), e1 == d1 -> e2 == d2 -> (e1 o e2) == (d1 o d2);
SP :> ∏ {x y z: A}, CMorphisms.Proper ((@ett x y) ===> (@ett y z) ===> (@ett x z)) (star);
EP :> ∏ {x: A}, CMorphisms.Proper (@ett x x) (eqv x);
IP :> ∏ {x y: A}, CMorphisms.Proper (@ett x y ===> @ett y x) (inv);
(* IdP :> ∏ {x y: A}, CMorphisms.Proper (@ett x y ===> @ett x y) (Id) *)
}.
(* Instance all_iff_morphism (A : Type) (x y: A) (T: Typoid A) :
CMorphisms.Proper (@ett A T x y ===> @ett A T x y ===> @ett A T x y) (Id).
Add Parametric Morphism A (x y: A) (T: Typoid A): (Id)
with signature (@ett A T x y) ===> (@ett A T x y) as www. *)
Notation "x '==' y" := (ett x y) : type_scope.
(* Instance EqRRel_ett: ∏ {A T} x y, RewriteRelation (@ett A T x y). *)
Instance EqRel_ett: ∏ {A T} x y, Equivalence (@ett A T x y).
constructor; intro.
apply ett_refl.
apply ett_sym.
apply ett_trans.
Defined.
Arguments et {_} _ _ _ .
Lemma Typ5: forall {A: Type} {x y z: A} {T: Typoid A} (f: x ~> y) (g: y ~> z),
inv (f o g) == inv g o inv f.
Proof. intros.
assert (inv (f o g) o (f o g) == eqv z).
{ now rewrite Typ2_ii. }
assert (inv (f o g) o (f o g) o inv g o inv f == inv g o inv f).
{ now rewrite X, Typ1_i. }
setoid_rewrite <- Typ3 at 1 in X0.
setoid_rewrite Typ3 at 2 in X0.
rewrite Typ2_i in X0.
setoid_rewrite Typ3 at 1 in X0.
rewrite Typ1_i in X0.
setoid_rewrite Typ3 at 1 in X0.
rewrite Typ2_i, Typ1_ii in X0. easy.
Qed.
Lemma Typ6: forall {A: Type} {x y: A} {T: Typoid A} (f: x ~> y),
inv (inv f) == f.
Proof. intros.
assert (inv (inv f) o (inv f) == eqv x).
{ now rewrite Typ2_ii. }
assert (inv (inv f) o inv f o f == f).
{ now rewrite X, Typ1_i. }
now rewrite Typ3, Typ2_ii, Typ1_ii in X0.
Qed.
Lemma Typ9: forall {A: Type} {x y: A} {T: Typoid A} (f: x ~> y),
inv (eqv x) o f == f.
Proof. intros. specialize (@Typ2_i _ T x y f); intro H.
now rewrite <- H, Typ5, Typ3, Typ6, Typ2_ii, Typ1_ii.
Defined.
Reserved Notation "x '~~>' y" (at level 70, y at next level).
Definition e3 A: Typoid A.
Proof. unshelve econstructor.
- unshelve econstructor.
+ exact (fun x y: A => Id x y).
+ exact (fun x => refl x).
+ exact (fun (x y z: A) (p: Id x y) (q: Id y z) => concat p q).
+ exact (fun (x y: A) (p: Id x y) => inverse p).
- exact (fun (x y: A) (e d: Id x y) => Id e d).
- intros. now cbn.
- cbn. intros. exact (inverse X).
- cbn. intros. now induction X, X0.
- cbn. intros. now induction e.
- intros. now destruct e.
- intros. cbn. now destruct e.
- intros. cbn. now destruct e.
- intros. cbn. now destruct e1, e2, e3.
- intros. cbn in *. now induction X, X0.
- repeat intros x y z p1 p2 r q1 q2 s. cbn in *.
now induction r, s.
- repeat intro.
simpl.
unfold CMorphisms.Proper.
apply refl.
- repeat intro.
induction X.
apply refl.
(* - repeat intro. now cbn.
- repeat intro. cbn. now induction X. *)
Defined.
Definition e4 (A B: Type): Typoid (A -> B).
Proof. unshelve econstructor.
- unshelve econstructor.
+ exact (fun (f g: A -> B) => ∏x: A, Id (f x) (g x)).
+ exact (fun (f: A -> B) (x: A) => refl (f x)).
+ cbn. exact (fun (f g h: A -> B) (e1: ∏ x : A, Id (f x) (g x)) (d: ∏ x : A, Id (g x) (h x)) (x: A) => concat (e1 x) (d x)).
+ exact (fun (f g: A -> B) (e1: ∏ x : A, Id (f x) (g x)) (x: A) => inverse (e1 x)).
- exact (fun (f g: A -> B) (e1 e2: ∏ x : A, Id (f x) (g x)) => ∏x: A, Id (e1 x) (e2 x)).
- cbn. intros. easy.
- cbn. intros.
exact (inverse (X x0)).
- cbn. intros.
exact (concat (X x0) (X0 x0)).
- cbn. intros.
now destruct (e x0).
- cbn. intros.
now destruct (e x0).
- cbn. intros.
now destruct (e x0).
- cbn. intros.
now destruct (e x0).
- cbn. intros.
apply inverse, concat_assoc.
- cbn. intros.
now induction (X x0), (X0 x0).
- repeat intro. cbn in *. now induction (X x2), (X0 x2).
- repeat intro.
simpl.
unfold CMorphisms.Proper.
apply refl.
- repeat intro.
unfold inv.
induction (X x1).
apply refl.
(* - repeat intro. now cbn.
- repeat intro. cbn. now induction (X x1). *)
Defined.
Definition OppositeT {A: Type} (T: Typoid A): Typoid A.
Proof. unshelve econstructor.
- exact (OppositeS (@st A T)).
- intros x y.
exact (@ett A T y x).
- intros.
exact (ett_refl e).
- intros x y e d p.
exact (ett_sym e d p).
- intros x y e d f p q.
exact (ett_trans e d f p q).
- intros x y e.
exact (Typ1_ii e).
- intros x y e.
exact (Typ1_i e).
- intros x y e.
exact (Typ2_ii e).
- intros x y e.
exact (Typ2_i e).
- intros x y z t e1 e2 e3.
exact (ett_sym _ _ (Typ3 e3 e2 e1)).
- intros x y z e1 d1 e2 d2 p q.
exact (Typ4 _ _ _ _ q p).
- repeat intro.
exact (SP x1 y1 X0 x0 y0 X).
- repeat intro. exact (EP).
- repeat intro. exact (IP x0 y0 X).
Defined.
(*
Definition OppositeTypoid {A: Type} (T: Typoid A): Typoid A.
Proof. destruct T, st0.
unshelve econstructor.
- exact (OppositeSetoid (mkSetoid A et eqv star inv)).
- unfold crelation in *.
intros x y.
(* exact (flip (ett0 y x)). *)
exact (ett0 y x).
- unfold flip.
intros x y e.
exact (ett_refl0 y x e).
- unfold flip.
intros x y e d eq.
exact (ett_sym0 y x e d eq).
- intros x y d e f eq1 eq2.
unfold flip in *.
exact (ett_trans0 y x d e f eq1 eq2).
- cbn in *. unfold flip.
intros x y e.
(* exact (ett_sym0 _ _ _ _ (Typ1_ii0 y x e)). *)
exact (Typ1_ii0 y x e).
- intros x y e.
exact (Typ1_i0 y x e).
- intros x y e.
exact (Typ2_ii0 y x e).
- intros x y e.
exact (Typ2_i0 y x e).
- intros x y z t e1 e2 e3.
exact (ett_sym0 _ _ _ _ (Typ7 t z y x e3 e2 e1)).
- intros x y z e1 d1 e2 d2 eq1 eq2.
exact (Typ8 z y x e2 d2 e1 d1 eq2 eq1).
- repeat intro.
exact (SP0 z y x x1 y1 X0 x0 y0 X).
- repeat intro. exact (EP0 x).
- repeat intro. exact (IP0 y x x0 y0 X).
Defined. *)
Definition ProductTypoid: ∏ {A B: Type} (TA: Typoid A) (TB: Typoid B), Typoid (A * B).
Proof. intros.
unshelve econstructor.
- exact (ProductSetoid (@st A TA) (@st B TB)).
- intros x y (e1, e2) (e1', e2').
exact (((e1 == e1') * (e2 == e2'))%type).
- intros x y (e1, e2).
easy.
- intros x y (e1, e2) (d1, d2) (p, q).
split; easy.
- intros x y (e1, e2) (d1, d2) (f1, f2) (p, q) (r, s).
split.
+ now rewrite p, r.
+ now rewrite q, s.
- intros x y (e1, d1).
split; now rewrite Typ1_i.
- intros x y (e1, d1).
split; now rewrite Typ1_ii.
- intros x y (e1, d1).
split; now rewrite Typ2_i.
- intros x y (e1, d1).
split; now rewrite Typ2_ii.
- intros x y z t (e1, e2) (d1, d2) (f1, f2).
split; now rewrite Typ3.
- intros x y z (e1, e2) (d1, d2) (f1, f2) (h1, h2) (p, q) (r, s).
split.
+ now rewrite p, r.
+ now rewrite q, s.
- repeat intro.
destruct x0 as (e1, e2).
destruct y0 as (d1, d2).
destruct x1 as (f1, f2).
destruct y1 as (h1, h2).
destruct X as (p, q).
destruct X0 as (r, s).
split.
+ now rewrite p, r.
+ now rewrite q, s.
- repeat intro. easy.
- repeat intro.
destruct x0 as (e1, e2).
destruct y0 as (d1, d2).
destruct X as (p, q).
split.
+ now rewrite p.
+ now rewrite q.
Defined.
Example UniT: Typoid Type.
Proof. unshelve econstructor.
- unshelve econstructor.
+ exact (fun A B: Type => Id A B).
+ intros. cbn. apply refl.
+ simpl. intros. apply @concat with (b := y); easy.
+ simpl. intros. induction X. apply refl.
- intros A B. simpl.
intros p q.
exact (Id p q).
- simpl. intros X Y p. apply refl.
- simpl. intros X Y p q H. induction H. apply refl.
- simpl. intros X Y p q r Ha Hb.
induction Ha; induction Hb. apply refl.
- simpl. intros X Y p. induction p. simpl. apply refl.
- simpl. intros X Y p. induction p. simpl. apply refl.
- simpl. intros X Y p. induction p. simpl. apply refl.
- simpl. intros X Y p. induction p. simpl. apply refl.
- simpl. intros X Y Z T p q r. induction p; induction q; induction r. simpl. apply refl.
- simpl. intros X Y Z p q r t Ha Hb. induction Ha; induction Hb. apply refl.
- repeat intro. induction X; induction X0. apply refl.
- repeat intro. simpl. unfold CMorphisms.Proper. apply refl.
- repeat intro. simpl. induction X. simpl. apply refl.
Defined.
Example UniS: Typoid Set.
Proof. unshelve econstructor.
- unshelve econstructor.
+ exact (fun A B: Set => Id A B).
+ intros. cbn. apply refl.
+ simpl. intros. apply @concat with (b := y); easy.
+ simpl. intros. induction X. apply refl.
- intros A B. simpl.
intros p q.
exact (Id p q).
- simpl. intros X Y p. apply refl.
- simpl. intros X Y p q H. induction H. apply refl.
- simpl. intros X Y p q r Ha Hb.
induction Ha; induction Hb. apply refl.
- simpl. intros X Y p. induction p. simpl. apply refl.
- simpl. intros X Y p. induction p. simpl. apply refl.
- simpl. intros X Y p. induction p. simpl. apply refl.
- simpl. intros X Y p. induction p. simpl. apply refl.
- simpl. intros X Y Z T p q r. induction p; induction q; induction r. simpl. apply refl.
- simpl. intros X Y Z p q r t Ha Hb. induction Ha; induction Hb. apply refl.
- repeat intro. induction X; induction X0. apply refl.
- repeat intro. simpl. unfold CMorphisms.Proper. apply refl.
- repeat intro. simpl. induction X. simpl. apply refl.
Defined.
Example Uni: Typoid Type.
Proof. unshelve econstructor.
- unshelve econstructor.
+ exact (fun A B: Type => ∑ f: A -> B, ishae f).
+ intros. cbn.
exists id. apply isequiv_ishae.
unshelve econstructor.
* exists id. easy.
* exists id. easy.
+ cbn. intros.
destruct X as (f, cc1).
destruct X0 as (g, cc2).
apply ishae_isequiv, h249_ii in cc1.
apply ishae_isequiv, h249_ii in cc2.
destruct cc1 as (invf, (cc1a, cc1b)).
destruct cc2 as (invg, (cc2a, cc2b)).
unfold compose, homotopy, id in *. cbn.
exists (compose f g).
apply isequiv_ishae, h249_i.
unshelve econstructor.
exact (compose invg invf).
split.
++ unfold compose, homotopy, id in *. cbn.
intro c.
specialize (cc1a (invg c)).
apply Id_eql in cc1a. rewrite cc1a.
easy.
++ unfold compose, homotopy, id in *. cbn.
intro a.
specialize (cc2b (f a)).
apply Id_eql in cc2b. rewrite cc2b.
easy.
+ cbn. intros.
destruct X as (f, cc1).
apply ishae_isequiv, h249_ii in cc1.
destruct cc1 as (invf, (cc1, cc2)).
exists invf.
apply isequiv_ishae, h249_i.
unshelve econstructor.
++ exact f.
++ split; easy.
- cbn. intros A B (f, u) (f', v).
(* (f, u) (f', u'). *)
exact (homotopy f f').
(* exact (fun (e1 e2: ∑ f: A -> B, ishae f) => ∏x: A, Id ((pr1 e1) x) ((pr1 e2) x)). *)
- cbn. intros. now destruct e.
- cbn. intros. destruct d, e.
intro a.
specialize (X a).
now apply inverse in X.
- cbn. intros.
destruct e, f, d.
intro a.
exact (concat (X a) (X0 a)).
- cbn. intros.
destruct e, (h249_ii (ishae_isequiv pr1 pr2)), pr3.
easy.
- cbn. intros.
destruct e, (h249_ii (ishae_isequiv pr1 pr2)), pr3.
easy.
- cbn. intros. destruct e.
cbn. destruct ( h249_ii (ishae_isequiv pr1 pr2)), pr3.
cbn.
unfold homotopy, compose, id in *.
intro x0.
now specialize (pr4 x0).
- cbn. intros. destruct e.
cbn. destruct ( h249_ii (ishae_isequiv pr1 pr2)), pr3.
cbn.
unfold homotopy, compose, id in *.
intro x0.
now specialize (pr3 x0).
- cbn. intros x y z t e1 e2 e3.
destruct e1, e2, e3, (h249_ii (ishae_isequiv pr1 pr2)), pr7,
(h249_ii (ishae_isequiv pr0 pr3)).
destruct pr10. cbn.
destruct (h249_ii (ishae_isequiv pr4 pr5)).
destruct pr13. now cbn.
- cbn. intros.
destruct e1, e2, d1, d2, (h249_ii (ishae_isequiv pr1 pr2)).
destruct pr9.
destruct (h249_ii (ishae_isequiv pr0 pr3)).
destruct pr12.
destruct (h249_ii (ishae_isequiv pr4 pr5)).
destruct pr15.
destruct (h249_ii (ishae_isequiv pr6 pr7)).
destruct pr18.
unfold homotopy in *.
intro x0.
specialize (X0 (pr1 x0)).
specialize (X x0).
apply Id_eql in X.
rewrite X in X0 at 2.
unfold compose.
exact X0.
- repeat intro. cbn.
destruct x0, x1, y0, y1, (h249_ii (ishae_isequiv pr1 pr2)).
destruct pr9.
destruct (h249_ii (ishae_isequiv pr0 pr3)).
destruct pr12.
destruct (h249_ii (ishae_isequiv pr4 pr5)).
destruct pr15.
destruct( h249_ii (ishae_isequiv pr6 pr7)).
destruct pr18.
unfold homotopy, compose in *.
intro x0.
specialize (X0 (pr1 x0)).
specialize (X x0).
now induction X, X0.
- repeat intro. now cbn.
- repeat intro.
destruct x0, y0 as (pr3, pr4).
rename pr4 into pr6.
rename pr3 into pr5.
rename pr1 into pr3.
rename pr2 into pr4.
destruct (h249_ii (ishae_isequiv pr3 pr4)) as (pr7, pr8).
destruct pr8 as (pr8, pr9).
destruct (h249_ii (ishae_isequiv pr5 pr6)) as (pr10, pr11).
destruct pr11 as (pr11, pr12).
cbn.
destruct (h249_ii (ishae_isequiv pr3 pr4)) as (pr13, pr14).
destruct pr14 as (pr14, pr15).
destruct (h249_ii (ishae_isequiv pr5 pr6)) as (pr16, pr17).
destruct pr17 as (pr17, pr18).
unfold homotopy, compose, id in *.
intro b.
pose proof X as HH.
specialize (pr15 (pr10 (pr5 (pr16 b)))).
specialize (pr12 (pr16 b)).
apply Id_eql in pr12.
rewrite pr12 in pr15.
specialize (X (pr16 b)).
apply Id_eql in X.
rewrite X in pr15.
specialize (pr17 b).
apply Id_eql in pr17.
now rewrite pr17 in pr15.
Defined.
(** Universe of Typoids [correspondingly Category of Sets] *)
Definition TypoidUni: Typoid Type.
Proof. unshelve econstructor.
- unshelve econstructor.
+ exact (et (@st _ Uni)).
+ cbn. intros. exists id.
apply qinv_ishae.
unshelve econstructor.
++ exact id.
++ easy.
+ cbn. intros.
destruct X as (f, Hf).
destruct X0 as (g, Hg).
exists (compose f g).
unfold compose. apply qinv_ishae.
unshelve econstructor.
destruct Hf as (finv, Hf).
destruct Hg as (ginv, Hg).
exact (compose ginv finv).
destruct Hf as (finv, (f_eta, (f_eps, Hf))).
destruct Hg as (ginv, (g_eta, (g_eps, Hg))).
split.
++ unfold compose, homotopy, id in *.
intro a. clear Hf.
specialize (f_eps (ginv a)).
specialize (ap g f_eps); intro H.
clear Hg.
specialize (g_eps a).
now induction g_eps.
++ unfold compose, homotopy, id in *.
intro a. clear Hg.
specialize (g_eta (f a)).
specialize (ap finv g_eta); intro H.
clear Hf.
specialize (f_eta a).
now induction f_eta.
+ cbn. intros. destruct X as (f, Hf).
destruct Hf as (finv, (eta, (eps, Hfinv))). exists finv.
apply qinv_ishae.
unshelve econstructor.
exact f.
split; [exact eta | exact eps].
- unfold crelation. cbn. intros X Y (f, x) (f', x').
exact (homotopy f f').
- cbn. intros. destruct e. easy.
- cbn. intros. destruct e, d. easy.
- cbn. intros. destruct e, d, f.
unfold homotopy in *.
intro a.
specialize (X a).
specialize (X0 a).
now induction X.
- intros. destruct e. easy.
- intros. destruct e. easy.
- intros. destruct e, pr2, pr2, pr3. easy.
- intros. destruct e, pr2, pr2, pr3. easy.
- intros x y z t e1 e2 e3.
destruct e1. destruct e2. destruct e3.
easy.
- intros.
destruct e1 as (pr3, pr4).
destruct e2 as (pr5, pr6).
destruct d1 as (pr7, pr8).
destruct d2 as (pr9, pr10).
unfold compose, homotopy, id in *.
intro a.
specialize (X a).
specialize (ap pr5 X); intro H.
specialize (X0 (pr7 a)).
now induction H.
- repeat intro.
destruct x0 as (pr3, pr4).
destruct y0 as (pr5, pr6).
destruct x1 as (pr7, pr8).
destruct y1 as (pr9, pr10).
unfold homotopy, compose, id in *.
intro a.
specialize (X a).
specialize (ap pr7 X); intro H.
specialize (X0 (pr5 a)).
now induction H.
- repeat intro. easy.
- repeat intro.
destruct x0 as (pr3, pr4).
destruct y0 as (pr5, pr6).
destruct pr4 as (pr4, pr7).
destruct pr7 as (pr7, pr8).
destruct pr8 as (pr8, pr9).
destruct pr6 as (pr6, pr10).
destruct pr10 as (pr10, pr11).
destruct pr11 as (pr11, pr12).
unfold homotopy, compose, id in *.
intro a.
pose proof X as HX.
pose proof HX as HXX.
specialize (X (pr4 a)).
specialize (HX (pr6 a)).
clear pr12.
specialize (pr11 a). induction pr11.
clear pr9.
specialize (pr8 a). induction pr8.
specialize (pr7 (pr6 a)).
now induction HX.
Defined.
(*
(** the setoid of Coq types *)
Definition CoqSetoidT: Setoid Type.
Proof. unshelve econstructor.
- exact iffT.
- intro x. easy.
- intros x y z (f, invf) (g, invg).
split.
+ exact (compose f g).
+ exact (compose invg invf).
- intros x y (f, invf).
split.
+ exact invf.
+ exact f.
Defined.
*)
|
1[$10>~]["Loop n. "$."!
"1+]#%
|
\section{Crème Pâtissière}
\label{cremePatissiere}
\setcounter{secnumdepth}{0}
Time: 30 minutes (10 minutes prep, 20 minutes cooking)
Serves: about 2 \( \frac{1}{2} \) cups
\begin{multicols}{2}
\subsection*{Ingredients}
\begin{itemize}
\item 2 cups whole milk
\item 5 egg yolks
\item 6 \( \frac{1}{2} \) ounces granulated sugar
\item 2 \( \frac{1}{2} \) ounces all purpose flour
\item 1 vanilla bean (substitute with 1 \( \frac{1}{2} \) Tablespoons vanilla extract)
\item \( \frac{1}{2} \) ounces unsalted butter
\end{itemize}
\subsection*{Hardware}
\begin{itemize}
\item Small pot
\item Stand mixer
\item Stock pot
\item Whisk
\item Plastic wrap
\end{itemize}
\clearpage
\subsection*{Instructions}
\begin{enumerate}
\item Put two cups of milk into small pot.
\item Allow milk to begin to warm, you want it to reach a very slight boil while doing the next few steps.
\item Place 5 egg yolks in a stand mixer, turn it on medium.
\item Gradually add in 6 \( \frac{1}{2} \) ounces sugar, ensuring first part is mixed in before adding more.
\item Continue to beat this until it is pale yellow and forms ribbons on top if you drip some mixture on top of the rest of the mixture (about 2-3 minutes)
\item Continue beating mixture while adding in 2 \( \frac{1}{2} \) ounces flour.
\item Remove milk from heat.
\item Split a vanilla bean down the middle, long ways.
\item Scrape the inside of the bean into the egg mixture, then throw in the empty shell.
\item Gradually dribble milk into the egg mixture while mixing.
\item The goal is to bring the eggs up to temperature slowly until all milk is mixed in.
\item Remove the bean shell.
\item Pour the mixture into the stock pot over medium-low heat.
\item At this point, you must constantly mix and scrape all sides and bottom of the dish while it comes to temperature.
\item After 15 or more minutes of constant low heat the mixture will begin to thicken.
\item Remove when it is at the desired thickness (it will thicken a little more as it cools, but adding the butter thins it a tad.)
\item Add \( \frac{1}{2} \) ounces unsalted butter and stir to combine.
\item If you use vanilla extract instead of a bean, add it at this point, otherwise too much may evaporate while cooking.
\item Cover with plastic wrap, ensuring that the custard is completely covered and the plastic wrap is pressed lightly onto the surface.
\item Allow to cool to room temperature before storing in the fridge.
\end{enumerate}
\subsection*{Notes}
\begin{itemize}
\item This is based on the recipe of Julia Child, Simone Beck, and Louisette Bertholle, as seen in Mastering the Art of French Cooking, Volume 1, page 590.
\begin{itemize}
\item Main differences are that I use a vanilla bean over vanilla extract (when I can find them at a reasonable price), and I don't usually substitute vanilla for other flavors (such as cognac or kirshwasser).
\item I converted units from volume to weight to get a more consistant cooking experience.
\end{itemize}
\item "Crème Pâtissière" translates to "Pastry Cream", and is a custard used in many French pastry recipes (mille-fuielles, tart au fraises, etc).
\item If you are using this custard a pudding-type dessert, such as for \nameref{bananaPudding}, then make sure to take it off the heat before it is too thick.
\item If you need to stiffen it a little more for something like mille-fuielles, then you can add in a half tablespoon of plain geletin.
\end{itemize}
\end{multicols}
\clearpage |
# Probably use FunctionWrappers.jl for interactive mode, to avoid
# excessive recompilation.
struct ProfileWrapper{P,F,T1,T2,R1,R2}#,C<:AbstractArray}
f::F
x::MutableFixedSizeVector{P,T1,R1,R1}
y::MutableFixedSizeVector{P,T2,R2,R2}
# z::C
i::Base.RefValue{Int}
v::Base.RefValue{T1}
end
function (pw::ProfileWrapper{P,F,T})(x::PaddedMatrices.AbstractMutableFixedSizeVector{Pm1,T}) where {P,Pm1,F,T}
debug() && @show x
@inbounds begin
for i in 1:pw.i[]-1
pw.x[i] = x[i]
end
# pw.x[pw.i[]] = pw.v[]
for i in pw.i[]:Pm1
pw.x[i+1] = x[i]
end
end
debug() && @show pw.x
- pw.f(pw.x)
end
function (pw::ProfileWrapper{P,F,T,T2})(y::PaddedMatrices.AbstractMutableFixedSizeVector{Pm1,T2}) where {P,Pm1,F,T,T2}
# @show y
@inbounds begin
for i in 1:pw.i[]-1
pw.y[i] = y[i]
end
# pw.x[pw.i[]] = pw.v[]
for i in pw.i[]:Pm1
pw.y[i+1] = y[i]
end
end
# @show pw.y
- pw.f(pw.y)
end
function set_profile_val_ind!(pw::ProfileWrapper, v, i::Int)
pw.v[] = v
pw.i[] = i
@inbounds pw.x[i] = v
@inbounds pw.y[i] = v
nothing
end
struct Swap{P,F}
f::F
i::Base.RefValue{Int}
end
function (s::Swap{P})(x) where P
@inbounds x[s.i[]], x[P] = x[P], x[s.i[]]
- s.f(x)
end
Swap(f::F, ::Val{P}) where {F,P} = Swap{P,F}(f,Ref(P))
function swappable_twice_differentiable(f, ::Val{P}) where {P}
TwiceDifferentiable(Swap(f, Val{P}()), Val{P}())
end
# struct Swappable{P,D <: DifferentiableObjects.AbstractTwiceDifferentiableObject{P}}
# obj::D
# i::Base.RefValue{Int}
# end
|
lemma lipschitz_on_cmult_upper [lipschitz_intros]: fixes f::"'a::metric_space \<Rightarrow> 'b::real_normed_vector" assumes "C-lipschitz_on U f" "abs(a) \<le> D" shows "(D * C)-lipschitz_on U (\<lambda>x. a *\<^sub>R f x)" |
module Test.Utils
import System
public export
Test : Type
Test = IO Int
export
assertThat : Bool -> String -> Test
assertThat test errorMsg =
if test
then do putStrLn "Test Passed"; pure 0
else do putStrLn ("Test Failed: " ++ errorMsg); pure 1
export
assertEq : (Eq a, Show a) => (expected : a) -> (given : a) -> Test
assertEq e g =
assertThat (g == e) $
"Expected == " ++ show e ++ ", Got: " ++ show g
export
runTests : List Test -> Test
runTests = foldl (\res, t => (+) <$> res <*> t) (pure 0)
export
runTestSuite : List Test -> IO ()
runTestSuite tests = do
failedCount <- runTests tests
if failedCount > 0
then exitFailure
else pure ()
--
|
/-
Copyright (c) 2019 Scott Morrison. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Scott Morrison, Bhavik Mehta, Adam Topaz
-/
import category_theory.functor.category
import category_theory.functor.fully_faithful
import category_theory.functor.reflects_isomorphisms
/-!
# Monads
> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
> Any changes to this file require a corresponding PR to mathlib4.
We construct the categories of monads and comonads, and their forgetful functors to endofunctors.
(Note that these are the category theorist's monads, not the programmers monads.
For the translation, see the file `category_theory.monad.types`.)
For the fact that monads are "just" monoids in the category of endofunctors, see the file
`category_theory.monad.equiv_mon`.
-/
namespace category_theory
open category
universes v₁ u₁ -- morphism levels before object levels. See note [category_theory universes].
variables (C : Type u₁) [category.{v₁} C]
/--
The data of a monad on C consists of an endofunctor T together with natural transformations
η : 𝟭 C ⟶ T and μ : T ⋙ T ⟶ T satisfying three equations:
- T μ_X ≫ μ_X = μ_(TX) ≫ μ_X (associativity)
- η_(TX) ≫ μ_X = 1_X (left unit)
- Tη_X ≫ μ_X = 1_X (right unit)
-/
structure monad extends C ⥤ C :=
(η' [] : 𝟭 _ ⟶ to_functor)
(μ' [] : to_functor ⋙ to_functor ⟶ to_functor)
(assoc' : ∀ X, to_functor.map (nat_trans.app μ' X) ≫ μ'.app _ = μ'.app _ ≫ μ'.app _ . obviously)
(left_unit' : ∀ X : C, η'.app (to_functor.obj X) ≫ μ'.app _ = 𝟙 _ . obviously)
(right_unit' : ∀ X : C, to_functor.map (η'.app X) ≫ μ'.app _ = 𝟙 _ . obviously)
/--
The data of a comonad on C consists of an endofunctor G together with natural transformations
ε : G ⟶ 𝟭 C and δ : G ⟶ G ⋙ G satisfying three equations:
- δ_X ≫ G δ_X = δ_X ≫ δ_(GX) (coassociativity)
- δ_X ≫ ε_(GX) = 1_X (left counit)
- δ_X ≫ G ε_X = 1_X (right counit)
-/
structure comonad extends C ⥤ C :=
(ε' [] : to_functor ⟶ 𝟭 _)
(δ' [] : to_functor ⟶ to_functor ⋙ to_functor)
(coassoc' : ∀ X, nat_trans.app δ' _ ≫ to_functor.map (δ'.app X) = δ'.app _ ≫ δ'.app _ . obviously)
(left_counit' : ∀ X : C, δ'.app X ≫ ε'.app (to_functor.obj X) = 𝟙 _ . obviously)
(right_counit' : ∀ X : C, δ'.app X ≫ to_functor.map (ε'.app X) = 𝟙 _ . obviously)
variables {C} (T : monad C) (G : comonad C)
instance coe_monad : has_coe (monad C) (C ⥤ C) := ⟨λ T, T.to_functor⟩
instance coe_comonad : has_coe (comonad C) (C ⥤ C) := ⟨λ G, G.to_functor⟩
@[simp] lemma monad_to_functor_eq_coe : T.to_functor = T := rfl
@[simp] lemma comonad_to_functor_eq_coe : G.to_functor = G := rfl
/-- The unit for the monad `T`. -/
def monad.η : 𝟭 _ ⟶ (T : C ⥤ C) := T.η'
/-- The multiplication for the monad `T`. -/
def monad.μ : (T : C ⥤ C) ⋙ (T : C ⥤ C) ⟶ T := T.μ'
/-- The counit for the comonad `G`. -/
def comonad.ε : (G : C ⥤ C) ⟶ 𝟭 _ := G.ε'
/-- The comultiplication for the comonad `G`. -/
def comonad.δ : (G : C ⥤ C) ⟶ (G : C ⥤ C) ⋙ G := G.δ'
/-- A custom simps projection for the functor part of a monad, as a coercion. -/
def monad.simps.coe := (T : C ⥤ C)
/-- A custom simps projection for the unit of a monad, in simp normal form. -/
def monad.simps.η : 𝟭 _ ⟶ (T : C ⥤ C) := T.η
/-- A custom simps projection for the multiplication of a monad, in simp normal form. -/
def monad.simps.μ : (T : C ⥤ C) ⋙ (T : C ⥤ C) ⟶ (T : C ⥤ C) := T.μ
/-- A custom simps projection for the functor part of a comonad, as a coercion. -/
def comonad.simps.coe := (G : C ⥤ C)
/-- A custom simps projection for the counit of a comonad, in simp normal form. -/
def comonad.simps.ε : (G : C ⥤ C) ⟶ 𝟭 _ := G.ε
/-- A custom simps projection for the comultiplication of a comonad, in simp normal form. -/
def comonad.simps.δ : (G : C ⥤ C) ⟶ (G : C ⥤ C) ⋙ (G : C ⥤ C) := G.δ
initialize_simps_projections category_theory.monad (to_functor → coe, η' → η, μ' → μ)
initialize_simps_projections category_theory.comonad (to_functor → coe, ε' → ε, δ' → δ)
@[reassoc]
lemma monad.assoc (T : monad C) (X : C) :
(T : C ⥤ C).map (T.μ.app X) ≫ T.μ.app _ = T.μ.app _ ≫ T.μ.app _ :=
T.assoc' X
@[simp, reassoc] lemma monad.left_unit (T : monad C) (X : C) :
T.η.app ((T : C ⥤ C).obj X) ≫ T.μ.app X = 𝟙 ((T : C ⥤ C).obj X) :=
T.left_unit' X
@[simp, reassoc] lemma monad.right_unit (T : monad C) (X : C) :
(T : C ⥤ C).map (T.η.app X) ≫ T.μ.app X = 𝟙 ((T : C ⥤ C).obj X) :=
T.right_unit' X
@[reassoc]
lemma comonad.coassoc (G : comonad C) (X : C) :
G.δ.app _ ≫ (G : C ⥤ C).map (G.δ.app X) = G.δ.app _ ≫ G.δ.app _ :=
G.coassoc' X
@[simp, reassoc] lemma comonad.left_counit (G : comonad C) (X : C) :
G.δ.app X ≫ G.ε.app ((G : C ⥤ C).obj X) = 𝟙 ((G : C ⥤ C).obj X) :=
G.left_counit' X
@[simp, reassoc] lemma comonad.right_counit (G : comonad C) (X : C) :
G.δ.app X ≫ (G : C ⥤ C).map (G.ε.app X) = 𝟙 ((G : C ⥤ C).obj X) :=
G.right_counit' X
/-- A morphism of monads is a natural transformation compatible with η and μ. -/
@[ext]
structure monad_hom (T₁ T₂ : monad C) extends nat_trans (T₁ : C ⥤ C) T₂ :=
(app_η' : ∀ X, T₁.η.app X ≫ app X = T₂.η.app X . obviously)
(app_μ' : ∀ X, T₁.μ.app X ≫ app X = ((T₁ : C ⥤ C).map (app X) ≫ app _) ≫ T₂.μ.app X . obviously)
/-- A morphism of comonads is a natural transformation compatible with ε and δ. -/
@[ext]
structure comonad_hom (M N : comonad C) extends nat_trans (M : C ⥤ C) N :=
(app_ε' : ∀ X, app X ≫ N.ε.app X = M.ε.app X . obviously)
(app_δ' : ∀ X, app X ≫ N.δ.app X = M.δ.app X ≫ app _ ≫ (N : C ⥤ C).map (app X) . obviously)
restate_axiom monad_hom.app_η'
restate_axiom monad_hom.app_μ'
attribute [simp, reassoc] monad_hom.app_η monad_hom.app_μ
restate_axiom comonad_hom.app_ε'
restate_axiom comonad_hom.app_δ'
attribute [simp, reassoc] comonad_hom.app_ε comonad_hom.app_δ
instance : category (monad C) :=
{ hom := monad_hom,
id := λ M, { to_nat_trans := 𝟙 (M : C ⥤ C) },
comp := λ _ _ _ f g,
{ to_nat_trans :=
{ app := λ X, f.app X ≫ g.app X,
naturality' := λ X Y h, by rw [assoc, f.1.naturality_assoc, g.1.naturality] } },
id_comp' := λ _ _ _, by {ext, apply id_comp},
comp_id' := λ _ _ _, by {ext, apply comp_id},
assoc' := λ _ _ _ _ _ _ _, by {ext, apply assoc} }
instance : category (comonad C) :=
{ hom := comonad_hom,
id := λ M, { to_nat_trans := 𝟙 (M : C ⥤ C) },
comp := λ _ _ _ f g,
{ to_nat_trans :=
{ app := λ X, f.app X ≫ g.app X,
naturality' := λ X Y h, by rw [assoc, f.1.naturality_assoc, g.1.naturality] } },
id_comp' := λ _ _ _, by {ext, apply id_comp},
comp_id' := λ _ _ _, by {ext, apply comp_id},
assoc' := λ _ _ _ _ _ _ _, by {ext, apply assoc} }
instance {T : monad C} : inhabited (monad_hom T T) := ⟨𝟙 T⟩
@[simp]
instance {G : comonad C} : inhabited (comonad_hom G G) := ⟨𝟙 G⟩
@[simp] lemma comonad_hom.id_to_nat_trans (T : comonad C) :
(𝟙 T : T ⟶ T).to_nat_trans = 𝟙 (T : C ⥤ C) :=
rfl
@[simp] lemma comp_to_nat_trans {T₁ T₂ T₃ : comonad C} (f : T₁ ⟶ T₂) (g : T₂ ⟶ T₃) :
(f ≫ g).to_nat_trans =
((f.to_nat_trans : _ ⟶ (T₂ : C ⥤ C)) ≫ g.to_nat_trans : (T₁ : C ⥤ C) ⟶ T₃) :=
rfl
/-- Construct a monad isomorphism from a natural isomorphism of functors where the forward
direction is a monad morphism. -/
@[simps]
def monad_iso.mk {M N : monad C} (f : (M : C ⥤ C) ≅ N) (f_η f_μ) :
M ≅ N :=
{ hom := { to_nat_trans := f.hom, app_η' := f_η, app_μ' := f_μ },
inv :=
{ to_nat_trans := f.inv,
app_η' := λ X, by simp [←f_η],
app_μ' := λ X,
begin
rw ←nat_iso.cancel_nat_iso_hom_right f,
simp only [nat_trans.naturality, iso.inv_hom_id_app, assoc, comp_id, f_μ,
nat_trans.naturality_assoc, iso.inv_hom_id_app_assoc, ←functor.map_comp_assoc],
simp,
end } }
/-- Construct a comonad isomorphism from a natural isomorphism of functors where the forward
direction is a comonad morphism. -/
@[simps]
def comonad_iso.mk {M N : comonad C} (f : (M : C ⥤ C) ≅ N) (f_ε f_δ) :
M ≅ N :=
{ hom := { to_nat_trans := f.hom, app_ε' := f_ε, app_δ' := f_δ },
inv :=
{ to_nat_trans := f.inv,
app_ε' := λ X, by simp [←f_ε],
app_δ' := λ X,
begin
rw ←nat_iso.cancel_nat_iso_hom_left f,
simp only [reassoc_of (f_δ X), iso.hom_inv_id_app_assoc, nat_trans.naturality_assoc],
rw [←functor.map_comp, iso.hom_inv_id_app, functor.map_id],
apply (comp_id _).symm
end } }
variable (C)
/--
The forgetful functor from the category of monads to the category of endofunctors.
-/
@[simps]
def monad_to_functor : monad C ⥤ (C ⥤ C) :=
{ obj := λ T, T,
map := λ M N f, f.to_nat_trans }
instance : faithful (monad_to_functor C) := {}.
@[simp]
lemma monad_to_functor_map_iso_monad_iso_mk {M N : monad C} (f : (M : C ⥤ C) ≅ N) (f_η f_μ) :
(monad_to_functor _).map_iso (monad_iso.mk f f_η f_μ) = f :=
by { ext, refl }
instance : reflects_isomorphisms (monad_to_functor C) :=
{ reflects := λ M N f i,
begin
resetI,
convert is_iso.of_iso (monad_iso.mk (as_iso ((monad_to_functor C).map f)) f.app_η f.app_μ),
ext; refl,
end }
/--
The forgetful functor from the category of comonads to the category of endofunctors.
-/
@[simps]
def comonad_to_functor : comonad C ⥤ (C ⥤ C) :=
{ obj := λ G, G,
map := λ M N f, f.to_nat_trans }
instance : faithful (comonad_to_functor C) := {}.
@[simp]
lemma comonad_to_functor_map_iso_comonad_iso_mk {M N : comonad C} (f : (M : C ⥤ C) ≅ N) (f_ε f_δ) :
(comonad_to_functor _).map_iso (comonad_iso.mk f f_ε f_δ) = f :=
by { ext, refl }
instance : reflects_isomorphisms (comonad_to_functor C) :=
{ reflects := λ M N f i,
begin
resetI,
convert is_iso.of_iso (comonad_iso.mk (as_iso ((comonad_to_functor C).map f)) f.app_ε f.app_δ),
ext; refl,
end }
variable {C}
/--
An isomorphism of monads gives a natural isomorphism of the underlying functors.
-/
@[simps {rhs_md := semireducible}]
def monad_iso.to_nat_iso {M N : monad C} (h : M ≅ N) : (M : C ⥤ C) ≅ N :=
(monad_to_functor C).map_iso h
/--
An isomorphism of comonads gives a natural isomorphism of the underlying functors.
-/
@[simps {rhs_md := semireducible}]
def comonad_iso.to_nat_iso {M N : comonad C} (h : M ≅ N) : (M : C ⥤ C) ≅ N :=
(comonad_to_functor C).map_iso h
variable (C)
namespace monad
/-- The identity monad. -/
@[simps]
def id : monad C :=
{ to_functor := 𝟭 C,
η' := 𝟙 (𝟭 C),
μ' := 𝟙 (𝟭 C) }
instance : inhabited (monad C) := ⟨monad.id C⟩
end monad
namespace comonad
/-- The identity comonad. -/
@[simps]
def id : comonad C :=
{ to_functor := 𝟭 _,
ε' := 𝟙 (𝟭 C),
δ' := 𝟙 (𝟭 C) }
instance : inhabited (comonad C) := ⟨comonad.id C⟩
end comonad
end category_theory
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.