text
stringlengths 0
3.34M
|
|---|
[STATEMENT]
lemma path_entry_is_trancl:
assumes "path_entry E l v"
and "l \<noteq> []"
shows "(0,v)\<in>E\<^sup>+"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. (0, v) \<in> E\<^sup>+
[PROOF STEP]
using assms
[PROOF STATE]
proof (prove)
using this:
path_entry E l v
l \<noteq> []
goal (1 subgoal):
1. (0, v) \<in> E\<^sup>+
[PROOF STEP]
apply induct
[PROOF STATE]
proof (prove)
goal (2 subgoals):
1. [] \<noteq> [] \<Longrightarrow> (0, 0) \<in> E\<^sup>+
2. \<And>u v l. \<lbrakk>(u, v) \<in> E; path_entry E l u; l \<noteq> [] \<Longrightarrow> (0, u) \<in> E\<^sup>+; u # l \<noteq> []\<rbrakk> \<Longrightarrow> (0, v) \<in> E\<^sup>+
[PROOF STEP]
apply auto []
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. \<And>u v l. \<lbrakk>(u, v) \<in> E; path_entry E l u; l \<noteq> [] \<Longrightarrow> (0, u) \<in> E\<^sup>+; u # l \<noteq> []\<rbrakk> \<Longrightarrow> (0, v) \<in> E\<^sup>+
[PROOF STEP]
apply (case_tac l)
[PROOF STATE]
proof (prove)
goal (2 subgoals):
1. \<And>u v l. \<lbrakk>(u, v) \<in> E; path_entry E l u; l \<noteq> [] \<Longrightarrow> (0, u) \<in> E\<^sup>+; u # l \<noteq> []; l = []\<rbrakk> \<Longrightarrow> (0, v) \<in> E\<^sup>+
2. \<And>u v l a list. \<lbrakk>(u, v) \<in> E; path_entry E l u; l \<noteq> [] \<Longrightarrow> (0, u) \<in> E\<^sup>+; u # l \<noteq> []; l = a # list\<rbrakk> \<Longrightarrow> (0, v) \<in> E\<^sup>+
[PROOF STEP]
apply (auto simp add:path_entry0_empty_conv)
[PROOF STATE]
proof (prove)
goal:
No subgoals!
[PROOF STEP]
done |
/-
Copyright (c) 2018 Kenny Lau. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Kenny Lau, Chris Hughes, Mario Carneiro
! This file was ported from Lean 3 source module ring_theory.ideal.local_ring
! leanprover-community/mathlib commit ec1c7d810034d4202b0dd239112d1792be9f6fdc
! Please do not edit these lines, except to modify the commit id
! if you have ported upstream changes.
-/
import Mathbin.Algebra.Algebra.Basic
import Mathbin.RingTheory.Ideal.Operations
import Mathbin.RingTheory.JacobsonIdeal
import Mathbin.Logic.Equiv.TransferInstance
/-!
# Local rings
Define local rings as commutative rings having a unique maximal ideal.
## Main definitions
* `local_ring`: A predicate on commutative semirings, stating that for any pair of elements that
adds up to `1`, one of them is a unit. This is shown to be equivalent to the condition that there
exists a unique maximal ideal.
* `local_ring.maximal_ideal`: The unique maximal ideal for a local rings. Its carrier set is the
set of non units.
* `is_local_ring_hom`: A predicate on semiring homomorphisms, requiring that it maps nonunits
to nonunits. For local rings, this means that the image of the unique maximal ideal is again
contained in the unique maximal ideal.
* `local_ring.residue_field`: The quotient of a local ring by its maximal ideal.
-/
universe u v w u'
variable {R : Type u} {S : Type v} {T : Type w} {K : Type u'}
/-- A semiring is local if it is nontrivial and `a` or `b` is a unit whenever `a + b = 1`.
Note that `local_ring` is a predicate. -/
class LocalRing (R : Type u) [Semiring R] extends Nontrivial R : Prop where
of_is_unit_or_is_unit_of_add_one ::
isUnit_or_isUnit_of_add_one {a b : R} (h : a + b = 1) : IsUnit a ∨ IsUnit b
#align local_ring LocalRing
section CommSemiring
variable [CommSemiring R]
namespace LocalRing
theorem of_isUnit_or_isUnit_of_isUnit_add [Nontrivial R]
(h : ∀ a b : R, IsUnit (a + b) → IsUnit a ∨ IsUnit b) : LocalRing R :=
⟨fun a b hab => h a b <| hab.symm ▸ isUnit_one⟩
#align local_ring.of_is_unit_or_is_unit_of_is_unit_add LocalRing.of_isUnit_or_isUnit_of_isUnit_add
/-- A semiring is local if it is nontrivial and the set of nonunits is closed under the addition. -/
theorem of_nonunits_add [Nontrivial R]
(h : ∀ a b : R, a ∈ nonunits R → b ∈ nonunits R → a + b ∈ nonunits R) : LocalRing R :=
⟨fun a b hab => or_iff_not_and_not.2 fun H => h a b H.1 H.2 <| hab.symm ▸ isUnit_one⟩
#align local_ring.of_nonunits_add LocalRing.of_nonunits_add
/-- A semiring is local if it has a unique maximal ideal. -/
theorem of_unique_max_ideal (h : ∃! I : Ideal R, I.IsMaximal) : LocalRing R :=
@of_nonunits_add _ _
(nontrivial_of_ne (0 : R) 1 <|
let ⟨I, Imax, _⟩ := h
fun H : 0 = 1 => Imax.1.1 <| I.eq_top_iff_one.2 <| H ▸ I.zero_mem)
fun x y hx hy H =>
let ⟨I, Imax, Iuniq⟩ := h
let ⟨Ix, Ixmax, Hx⟩ := exists_max_ideal_of_mem_nonunits hx
let ⟨Iy, Iymax, Hy⟩ := exists_max_ideal_of_mem_nonunits hy
have xmemI : x ∈ I := Iuniq Ix Ixmax ▸ Hx
have ymemI : y ∈ I := Iuniq Iy Iymax ▸ Hy
Imax.1.1 <| I.eq_top_of_isUnit_mem (I.add_mem xmemI ymemI) H
#align local_ring.of_unique_max_ideal LocalRing.of_unique_max_ideal
theorem of_unique_nonzero_prime (h : ∃! P : Ideal R, P ≠ ⊥ ∧ Ideal.IsPrime P) : LocalRing R :=
of_unique_max_ideal
(by
rcases h with ⟨P, ⟨hPnonzero, hPnot_top, _⟩, hPunique⟩
refine' ⟨P, ⟨⟨hPnot_top, _⟩⟩, fun M hM => hPunique _ ⟨_, Ideal.IsMaximal.isPrime hM⟩⟩
· refine' Ideal.maximal_of_no_maximal fun M hPM hM => ne_of_lt hPM _
exact (hPunique _ ⟨ne_bot_of_gt hPM, Ideal.IsMaximal.isPrime hM⟩).symm
· rintro rfl
exact hPnot_top (hM.1.2 P (bot_lt_iff_ne_bot.2 hPnonzero)))
#align local_ring.of_unique_nonzero_prime LocalRing.of_unique_nonzero_prime
variable [LocalRing R]
theorem isUnit_or_isUnit_of_isUnit_add {a b : R} (h : IsUnit (a + b)) : IsUnit a ∨ IsUnit b :=
by
rcases h with ⟨u, hu⟩
rw [← Units.inv_mul_eq_one, mul_add] at hu
apply Or.imp _ _ (is_unit_or_is_unit_of_add_one hu) <;> exact isUnit_of_mul_isUnit_right
#align local_ring.is_unit_or_is_unit_of_is_unit_add LocalRing.isUnit_or_isUnit_of_isUnit_add
theorem nonunits_add {a b : R} (ha : a ∈ nonunits R) (hb : b ∈ nonunits R) : a + b ∈ nonunits R :=
fun H => not_or_of_not ha hb (isUnit_or_isUnit_of_isUnit_add H)
#align local_ring.nonunits_add LocalRing.nonunits_add
variable (R)
/-- The ideal of elements that are not units. -/
def maximalIdeal : Ideal R where
carrier := nonunits R
zero_mem' := zero_mem_nonunits.2 <| zero_ne_one
add_mem' x y hx hy := nonunits_add hx hy
smul_mem' a x := mul_mem_nonunits_right
#align local_ring.maximal_ideal LocalRing.maximalIdeal
instance maximalIdeal.isMaximal : (maximalIdeal R).IsMaximal :=
by
rw [Ideal.isMaximal_iff]
constructor
· intro h
apply h
exact isUnit_one
· intro I x hI hx H
erw [Classical.not_not] at hx
rcases hx with ⟨u, rfl⟩
simpa using I.mul_mem_left (↑u⁻¹) H
#align local_ring.maximal_ideal.is_maximal LocalRing.maximalIdeal.isMaximal
theorem maximal_ideal_unique : ∃! I : Ideal R, I.IsMaximal :=
⟨maximalIdeal R, maximalIdeal.isMaximal R, fun I hI =>
hI.eq_of_le (maximalIdeal.isMaximal R).1.1 fun x hx => hI.1.1 ∘ I.eq_top_of_isUnit_mem hx⟩
#align local_ring.maximal_ideal_unique LocalRing.maximal_ideal_unique
variable {R}
theorem eq_maximalIdeal {I : Ideal R} (hI : I.IsMaximal) : I = maximalIdeal R :=
ExistsUnique.unique (maximal_ideal_unique R) hI <| maximalIdeal.isMaximal R
#align local_ring.eq_maximal_ideal LocalRing.eq_maximalIdeal
theorem le_maximalIdeal {J : Ideal R} (hJ : J ≠ ⊤) : J ≤ maximalIdeal R :=
by
rcases Ideal.exists_le_maximal J hJ with ⟨M, hM1, hM2⟩
rwa [← eq_maximal_ideal hM1]
#align local_ring.le_maximal_ideal LocalRing.le_maximalIdeal
@[simp]
theorem mem_maximalIdeal (x) : x ∈ maximalIdeal R ↔ x ∈ nonunits R :=
Iff.rfl
#align local_ring.mem_maximal_ideal LocalRing.mem_maximalIdeal
theorem isField_iff_maximalIdeal_eq : IsField R ↔ maximalIdeal R = ⊥ :=
not_iff_not.mp
⟨Ring.ne_bot_of_isMaximal_of_not_isField inferInstance, fun h =>
Ring.not_isField_iff_exists_prime.mpr ⟨_, h, Ideal.IsMaximal.isPrime' _⟩⟩
#align local_ring.is_field_iff_maximal_ideal_eq LocalRing.isField_iff_maximalIdeal_eq
end LocalRing
end CommSemiring
section CommRing
variable [CommRing R]
namespace LocalRing
theorem of_isUnit_or_isUnit_one_sub_self [Nontrivial R] (h : ∀ a : R, IsUnit a ∨ IsUnit (1 - a)) :
LocalRing R :=
⟨fun a b hab => add_sub_cancel' a b ▸ hab.symm ▸ h a⟩
#align local_ring.of_is_unit_or_is_unit_one_sub_self LocalRing.of_isUnit_or_isUnit_one_sub_self
variable [LocalRing R]
theorem isUnit_or_isUnit_one_sub_self (a : R) : IsUnit a ∨ IsUnit (1 - a) :=
isUnit_or_isUnit_of_isUnit_add <| (add_sub_cancel'_right a 1).symm ▸ isUnit_one
#align local_ring.is_unit_or_is_unit_one_sub_self LocalRing.isUnit_or_isUnit_one_sub_self
theorem isUnit_of_mem_nonunits_one_sub_self (a : R) (h : 1 - a ∈ nonunits R) : IsUnit a :=
or_iff_not_imp_right.1 (isUnit_or_isUnit_one_sub_self a) h
#align local_ring.is_unit_of_mem_nonunits_one_sub_self LocalRing.isUnit_of_mem_nonunits_one_sub_self
theorem isUnit_one_sub_self_of_mem_nonunits (a : R) (h : a ∈ nonunits R) : IsUnit (1 - a) :=
or_iff_not_imp_left.1 (isUnit_or_isUnit_one_sub_self a) h
#align local_ring.is_unit_one_sub_self_of_mem_nonunits LocalRing.isUnit_one_sub_self_of_mem_nonunits
theorem of_surjective' [CommRing S] [Nontrivial S] (f : R →+* S) (hf : Function.Surjective f) :
LocalRing S :=
of_isUnit_or_isUnit_one_sub_self
(by
intro b
obtain ⟨a, rfl⟩ := hf b
apply (is_unit_or_is_unit_one_sub_self a).imp f.is_unit_map _
rw [← f.map_one, ← f.map_sub]
apply f.is_unit_map)
#align local_ring.of_surjective' LocalRing.of_surjective'
theorem jacobson_eq_maximalIdeal (I : Ideal R) (h : I ≠ ⊤) :
I.jacobson = LocalRing.maximalIdeal R :=
by
apply le_antisymm
· exact infₛ_le ⟨LocalRing.le_maximalIdeal h, LocalRing.maximalIdeal.isMaximal R⟩
· exact le_infₛ fun J (hJ : I ≤ J ∧ J.IsMaximal) => le_of_eq (LocalRing.eq_maximalIdeal hJ.2).symm
#align local_ring.jacobson_eq_maximal_ideal LocalRing.jacobson_eq_maximalIdeal
end LocalRing
end CommRing
/-- A local ring homomorphism is a homomorphism `f` between local rings such that `a` in the domain
is a unit if `f a` is a unit for any `a`. See `local_ring.local_hom_tfae` for other equivalent
definitions. -/
class IsLocalRingHom [Semiring R] [Semiring S] (f : R →+* S) : Prop where
map_nonunit : ∀ a, IsUnit (f a) → IsUnit a
#align is_local_ring_hom IsLocalRingHom
section
variable [Semiring R] [Semiring S] [Semiring T]
instance isLocalRingHom_id (R : Type _) [Semiring R] : IsLocalRingHom (RingHom.id R)
where map_nonunit a := id
#align is_local_ring_hom_id isLocalRingHom_id
@[simp]
theorem isUnit_map_iff (f : R →+* S) [IsLocalRingHom f] (a) : IsUnit (f a) ↔ IsUnit a :=
⟨IsLocalRingHom.map_nonunit a, f.isUnit_map⟩
#align is_unit_map_iff isUnit_map_iff
@[simp]
theorem map_mem_nonunits_iff (f : R →+* S) [IsLocalRingHom f] (a) :
f a ∈ nonunits S ↔ a ∈ nonunits R :=
⟨fun h ha => h <| (isUnit_map_iff f a).mpr ha, fun h ha => h <| (isUnit_map_iff f a).mp ha⟩
#align map_mem_nonunits_iff map_mem_nonunits_iff
instance isLocalRingHom_comp (g : S →+* T) (f : R →+* S) [IsLocalRingHom g] [IsLocalRingHom f] :
IsLocalRingHom (g.comp f)
where map_nonunit a := IsLocalRingHom.map_nonunit a ∘ IsLocalRingHom.map_nonunit (f a)
#align is_local_ring_hom_comp isLocalRingHom_comp
instance isLocalRingHom_equiv (f : R ≃+* S) : IsLocalRingHom (f : R →+* S)
where map_nonunit a ha := by
convert(f.symm : S →+* R).isUnit_map ha
exact (RingEquiv.symm_apply_apply f a).symm
#align is_local_ring_hom_equiv isLocalRingHom_equiv
@[simp]
theorem isUnit_of_map_unit (f : R →+* S) [IsLocalRingHom f] (a) (h : IsUnit (f a)) : IsUnit a :=
IsLocalRingHom.map_nonunit a h
#align is_unit_of_map_unit isUnit_of_map_unit
theorem of_irreducible_map (f : R →+* S) [h : IsLocalRingHom f] {x} (hfx : Irreducible (f x)) :
Irreducible x :=
⟨fun h => hfx.not_unit <| IsUnit.map f h, fun p q hx =>
let ⟨H⟩ := h
Or.imp (H p) (H q) <| hfx.isUnit_or_isUnit <| f.map_mul p q ▸ congr_arg f hx⟩
#align of_irreducible_map of_irreducible_map
theorem isLocalRingHom_of_comp (f : R →+* S) (g : S →+* T) [IsLocalRingHom (g.comp f)] :
IsLocalRingHom f :=
⟨fun a ha => (isUnit_map_iff (g.comp f) _).mp (g.isUnit_map ha)⟩
#align is_local_ring_hom_of_comp isLocalRingHom_of_comp
/-- If `f : R →+* S` is a local ring hom, then `R` is a local ring if `S` is. -/
theorem RingHom.domain_localRing {R S : Type _} [CommSemiring R] [CommSemiring S] [H : LocalRing S]
(f : R →+* S) [IsLocalRingHom f] : LocalRing R :=
by
haveI : Nontrivial R := pullback_nonzero f f.map_zero f.map_one
apply LocalRing.of_nonunits_add
intro a b
simp_rw [← map_mem_nonunits_iff f, f.map_add]
exact LocalRing.nonunits_add
#align ring_hom.domain_local_ring RingHom.domain_localRing
end
section
open LocalRing
variable [CommSemiring R] [LocalRing R] [CommSemiring S] [LocalRing S]
/--
The image of the maximal ideal of the source is contained within the maximal ideal of the target.
-/
theorem map_nonunit (f : R →+* S) [IsLocalRingHom f] (a : R) (h : a ∈ maximalIdeal R) :
f a ∈ maximalIdeal S := fun H => h <| isUnit_of_map_unit f a H
#align map_nonunit map_nonunit
end
namespace LocalRing
section
variable [CommSemiring R] [LocalRing R] [CommSemiring S] [LocalRing S]
/-- A ring homomorphism between local rings is a local ring hom iff it reflects units,
i.e. any preimage of a unit is still a unit. https://stacks.math.columbia.edu/tag/07BJ
-/
theorem local_hom_tFAE (f : R →+* S) :
TFAE
[IsLocalRingHom f, f '' (maximalIdeal R).1 ⊆ maximalIdeal S,
(maximalIdeal R).map f ≤ maximalIdeal S, maximalIdeal R ≤ (maximalIdeal S).comap f,
(maximalIdeal S).comap f = maximalIdeal R] :=
by
tfae_have 1 → 2; rintro _ _ ⟨a, ha, rfl⟩
skip; exact map_nonunit f a ha
tfae_have 2 → 4; exact Set.image_subset_iff.1
tfae_have 3 ↔ 4; exact Ideal.map_le_iff_le_comap
tfae_have 4 → 1; intro h; fconstructor; exact fun x => not_imp_not.1 (@h x)
tfae_have 1 → 5; intro ; skip; ext
exact not_iff_not.2 (isUnit_map_iff f x)
tfae_have 5 → 4; exact fun h => le_of_eq h.symm
tfae_finish
#align local_ring.local_hom_tfae LocalRing.local_hom_tFAE
end
theorem of_surjective [CommSemiring R] [LocalRing R] [CommSemiring S] [Nontrivial S] (f : R →+* S)
[IsLocalRingHom f] (hf : Function.Surjective f) : LocalRing S :=
of_isUnit_or_isUnit_of_isUnit_add
(by
intro a b hab
obtain ⟨a, rfl⟩ := hf a
obtain ⟨b, rfl⟩ := hf b
rw [← map_add] at hab
exact
(is_unit_or_is_unit_of_is_unit_add <| IsLocalRingHom.map_nonunit _ hab).imp f.is_unit_map
f.is_unit_map)
#align local_ring.of_surjective LocalRing.of_surjective
/-- If `f : R →+* S` is a surjective local ring hom, then the induced units map is surjective. -/
theorem surjective_units_map_of_local_ringHom [CommRing R] [CommRing S] (f : R →+* S)
(hf : Function.Surjective f) (h : IsLocalRingHom f) :
Function.Surjective (Units.map <| f.toMonoidHom) :=
by
intro a
obtain ⟨b, hb⟩ := hf (a : S)
use
(isUnit_of_map_unit f _
(by
rw [hb]
exact Units.isUnit _)).Unit;
ext; exact hb
#align local_ring.surjective_units_map_of_local_ring_hom LocalRing.surjective_units_map_of_local_ringHom
section
variable (R) [CommRing R] [LocalRing R] [CommRing S] [LocalRing S] [CommRing T] [LocalRing T]
/-- The residue field of a local ring is the quotient of the ring by its maximal ideal. -/
def ResidueField :=
R ⧸ maximalIdeal R deriving Ring, CommRing, Inhabited
#align local_ring.residue_field LocalRing.ResidueField
noncomputable instance ResidueField.field : Field (ResidueField R) :=
Ideal.Quotient.field (maximalIdeal R)
#align local_ring.residue_field.field LocalRing.ResidueField.field
/-- The quotient map from a local ring to its residue field. -/
def residue : R →+* ResidueField R :=
Ideal.Quotient.mk _
#align local_ring.residue LocalRing.residue
instance ResidueField.algebra : Algebra R (ResidueField R) :=
Ideal.Quotient.algebra _
#align local_ring.residue_field.algebra LocalRing.ResidueField.algebra
theorem ResidueField.algebraMap_eq : algebraMap R (ResidueField R) = residue R :=
rfl
#align local_ring.residue_field.algebra_map_eq LocalRing.ResidueField.algebraMap_eq
instance : IsLocalRingHom (LocalRing.residue R) :=
⟨fun a ha =>
Classical.not_not.mp (Ideal.Quotient.eq_zero_iff_mem.Not.mp (isUnit_iff_ne_zero.mp ha))⟩
variable {R}
namespace ResidueField
/-- A local ring homomorphism into a field can be descended onto the residue field. -/
def lift {R S : Type _} [CommRing R] [LocalRing R] [Field S] (f : R →+* S) [IsLocalRingHom f] :
LocalRing.ResidueField R →+* S :=
Ideal.Quotient.lift _ f fun a ha =>
by_contradiction fun h => ha (isUnit_of_map_unit f a (isUnit_iff_ne_zero.mpr h))
#align local_ring.residue_field.lift LocalRing.ResidueField.lift
theorem lift_comp_residue {R S : Type _} [CommRing R] [LocalRing R] [Field S] (f : R →+* S)
[IsLocalRingHom f] : (lift f).comp (residue R) = f :=
RingHom.ext fun _ => rfl
#align local_ring.residue_field.lift_comp_residue LocalRing.ResidueField.lift_comp_residue
@[simp]
theorem lift_residue_apply {R S : Type _} [CommRing R] [LocalRing R] [Field S] (f : R →+* S)
[IsLocalRingHom f] (x) : lift f (residue R x) = f x :=
rfl
#align local_ring.residue_field.lift_residue_apply LocalRing.ResidueField.lift_residue_apply
/-- The map on residue fields induced by a local homomorphism between local rings -/
def map (f : R →+* S) [IsLocalRingHom f] : ResidueField R →+* ResidueField S :=
Ideal.Quotient.lift (maximalIdeal R) ((Ideal.Quotient.mk _).comp f) fun a ha =>
by
erw [Ideal.Quotient.eq_zero_iff_mem]
exact map_nonunit f a ha
#align local_ring.residue_field.map LocalRing.ResidueField.map
/-- Applying `residue_field.map` to the identity ring homomorphism gives the identity
ring homomorphism. -/
@[simp]
theorem map_id :
LocalRing.ResidueField.map (RingHom.id R) = RingHom.id (LocalRing.ResidueField R) :=
Ideal.Quotient.ringHom_ext <| RingHom.ext fun x => rfl
#align local_ring.residue_field.map_id LocalRing.ResidueField.map_id
/-- The composite of two `residue_field.map`s is the `residue_field.map` of the composite. -/
theorem map_comp (f : T →+* R) (g : R →+* S) [IsLocalRingHom f] [IsLocalRingHom g] :
LocalRing.ResidueField.map (g.comp f) =
(LocalRing.ResidueField.map g).comp (LocalRing.ResidueField.map f) :=
Ideal.Quotient.ringHom_ext <| RingHom.ext fun x => rfl
#align local_ring.residue_field.map_comp LocalRing.ResidueField.map_comp
theorem map_comp_residue (f : R →+* S) [IsLocalRingHom f] :
(ResidueField.map f).comp (residue R) = (residue S).comp f :=
rfl
#align local_ring.residue_field.map_comp_residue LocalRing.ResidueField.map_comp_residue
theorem map_residue (f : R →+* S) [IsLocalRingHom f] (r : R) :
ResidueField.map f (residue R r) = residue S (f r) :=
rfl
#align local_ring.residue_field.map_residue LocalRing.ResidueField.map_residue
theorem map_id_apply (x : ResidueField R) : map (RingHom.id R) x = x :=
FunLike.congr_fun map_id x
#align local_ring.residue_field.map_id_apply LocalRing.ResidueField.map_id_apply
@[simp]
theorem map_map (f : R →+* S) (g : S →+* T) (x : ResidueField R) [IsLocalRingHom f]
[IsLocalRingHom g] : map g (map f x) = map (g.comp f) x :=
FunLike.congr_fun (map_comp f g).symm x
#align local_ring.residue_field.map_map LocalRing.ResidueField.map_map
/-- A ring isomorphism defines an isomorphism of residue fields. -/
@[simps apply]
def mapEquiv (f : R ≃+* S) : LocalRing.ResidueField R ≃+* LocalRing.ResidueField S
where
toFun := map (f : R →+* S)
invFun := map (f.symm : S →+* R)
left_inv x := by simp only [map_map, RingEquiv.symm_comp, map_id, RingHom.id_apply]
right_inv x := by simp only [map_map, RingEquiv.comp_symm, map_id, RingHom.id_apply]
map_mul' := RingHom.map_mul _
map_add' := RingHom.map_add _
#align local_ring.residue_field.map_equiv LocalRing.ResidueField.mapEquiv
@[simp]
theorem mapEquiv.symm (f : R ≃+* S) : (mapEquiv f).symm = mapEquiv f.symm :=
rfl
#align local_ring.residue_field.map_equiv.symm LocalRing.ResidueField.mapEquiv.symm
@[simp]
theorem mapEquiv_trans (e₁ : R ≃+* S) (e₂ : S ≃+* T) :
mapEquiv (e₁.trans e₂) = (mapEquiv e₁).trans (mapEquiv e₂) :=
RingEquiv.toRingHom_injective <| map_comp (e₁ : R →+* S) (e₂ : S →+* T)
#align local_ring.residue_field.map_equiv_trans LocalRing.ResidueField.mapEquiv_trans
@[simp]
theorem mapEquiv_refl : mapEquiv (RingEquiv.refl R) = RingEquiv.refl _ :=
RingEquiv.toRingHom_injective map_id
#align local_ring.residue_field.map_equiv_refl LocalRing.ResidueField.mapEquiv_refl
/-- The group homomorphism from `ring_aut R` to `ring_aut k` where `k`
is the residue field of `R`. -/
@[simps]
def mapAut : RingAut R →* RingAut (LocalRing.ResidueField R)
where
toFun := mapEquiv
map_mul' e₁ e₂ := mapEquiv_trans e₂ e₁
map_one' := mapEquiv_refl
#align local_ring.residue_field.map_aut LocalRing.ResidueField.mapAut
section MulSemiringAction
variable (G : Type _) [Group G] [MulSemiringAction G R]
/-- If `G` acts on `R` as a `mul_semiring_action`, then it also acts on `residue_field R`. -/
instance : MulSemiringAction G (LocalRing.ResidueField R) :=
MulSemiringAction.compHom _ <| mapAut.comp (MulSemiringAction.toRingAut G R)
@[simp]
theorem residue_smul (g : G) (r : R) : residue R (g • r) = g • residue R r :=
rfl
#align local_ring.residue_field.residue_smul LocalRing.ResidueField.residue_smul
end MulSemiringAction
end ResidueField
theorem ker_eq_maximalIdeal [Field K] (φ : R →+* K) (hφ : Function.Surjective φ) :
φ.ker = maximalIdeal R :=
LocalRing.eq_maximalIdeal <| (RingHom.ker_isMaximal_of_surjective φ) hφ
#align local_ring.ker_eq_maximal_ideal LocalRing.ker_eq_maximalIdeal
theorem isLocalRingHom_residue : IsLocalRingHom (LocalRing.residue R) :=
by
constructor
intro a ha
by_contra
erw [ideal.quotient.eq_zero_iff_mem.mpr ((LocalRing.mem_maximalIdeal _).mpr h)] at ha
exact ha.ne_zero rfl
#align local_ring.is_local_ring_hom_residue LocalRing.isLocalRingHom_residue
end
end LocalRing
namespace Field
variable (K) [Field K]
open Classical
-- see Note [lower instance priority]
instance (priority := 100) : LocalRing K :=
LocalRing.of_isUnit_or_isUnit_one_sub_self fun a =>
if h : a = 0 then Or.inr (by rw [h, sub_zero] <;> exact isUnit_one)
else Or.inl <| IsUnit.mk0 a h
end Field
theorem LocalRing.maximalIdeal_eq_bot {R : Type _} [Field R] : LocalRing.maximalIdeal R = ⊥ :=
LocalRing.isField_iff_maximalIdeal_eq.mp (Field.toIsField R)
#align local_ring.maximal_ideal_eq_bot LocalRing.maximalIdeal_eq_bot
namespace RingEquiv
@[reducible]
protected theorem localRing {A B : Type _} [CommSemiring A] [LocalRing A] [CommSemiring B]
(e : A ≃+* B) : LocalRing B :=
haveI := e.symm.to_equiv.nontrivial
LocalRing.of_surjective (e : A →+* B) e.surjective
#align ring_equiv.local_ring RingEquiv.localRing
end RingEquiv
|
{-# OPTIONS_GHC -Wall #-}
{-# LANGUAGE QuasiQuotes #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE MultiWayIf #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE ScopedTypeVariables #-}
-----------------------------------------------------------------------------
-- |
-- Module : Numeric.Sundials.CVode.ODE
-- Copyright : Dominic Steinitz 2018,
-- Novadiscovery 2018
-- License : BSD
-- Maintainer : Dominic Steinitz
-- Stability : provisional
--
-- Solution of ordinary differential equation (ODE) initial value problems.
--
-- <https://computation.llnl.gov/projects/sundials/sundials-software>
--
-- A simple example:
--
-- <<diagrams/brusselator.png#diagram=brusselator&height=400&width=500>>
--
-- @
-- import Numeric.Sundials.CVode.ODE
-- import Numeric.LinearAlgebra
--
-- import Plots as P
-- import qualified Diagrams.Prelude as D
-- import Diagrams.Backend.Rasterific
--
-- brusselator :: Double -> [Double] -> [Double]
-- brusselator _t x = [ a - (w + 1) * u + v * u * u
-- , w * u - v * u * u
-- , (b - w) / eps - w * u
-- ]
-- where
-- a = 1.0
-- b = 3.5
-- eps = 5.0e-6
-- u = x !! 0
-- v = x !! 1
-- w = x !! 2
--
-- lSaxis :: [[Double]] -> P.Axis B D.V2 Double
-- lSaxis xs = P.r2Axis &~ do
-- let ts = xs!!0
-- us = xs!!1
-- vs = xs!!2
-- ws = xs!!3
-- P.linePlot' $ zip ts us
-- P.linePlot' $ zip ts vs
-- P.linePlot' $ zip ts ws
--
-- main = do
-- let res1 = odeSolve brusselator [1.2, 3.1, 3.0] (fromList [0.0, 0.1 .. 10.0])
-- renderRasterific "diagrams/brusselator.png"
-- (D.dims2D 500.0 500.0)
-- (renderAxis $ lSaxis $ [0.0, 0.1 .. 10.0]:(toLists $ tr res1))
-- @
--
-----------------------------------------------------------------------------
module Numeric.Sundials.CVode.ODE ( odeSolve
, odeSolveV
, odeSolveVWith
, odeSolveVWith'
, odeSolveRootVWith'
, ODEMethod(..)
, StepControl(..)
, SolverResult(..)
) where
import qualified Language.C.Inline as C
import qualified Language.C.Inline.Unsafe as CU
import Data.Monoid ((<>))
import Data.Maybe (isJust)
import Foreign.C.Types (CDouble, CInt, CLong)
import Foreign.Ptr (Ptr)
import Foreign.Storable (poke)
import qualified Data.Vector.Storable as V
import Data.Coerce (coerce)
import System.IO.Unsafe (unsafePerformIO)
import Numeric.LinearAlgebra.Devel (createVector)
import Numeric.LinearAlgebra.HMatrix (Vector, Matrix, toList, rows,
cols, toLists, size, reshape)
import Numeric.Sundials.Arkode (cV_ADAMS, cV_BDF,
getDataFromContents, putDataInContents,
vectorToC, cV_SUCCESS, cV_ROOT_RETURN)
import qualified Numeric.Sundials.Arkode as T
import Numeric.Sundials.ODEOpts (ODEOpts(..), Jacobian, SundialsDiagnostics(..))
C.context (C.baseCtx <> C.vecCtx <> C.funCtx <> T.sunCtx)
C.include "<stdlib.h>"
C.include "<stdio.h>"
C.include "<math.h>"
C.include "<cvode/cvode.h>" -- prototypes for CVODE fcts., consts.
C.include "<nvector/nvector_serial.h>" -- serial N_Vector types, fcts., macros
C.include "<sunmatrix/sunmatrix_dense.h>" -- access to dense SUNMatrix
C.include "<sunlinsol/sunlinsol_dense.h>" -- access to dense SUNLinearSolver
C.include "<cvode/cvode_direct.h>" -- access to CVDls interface
C.include "<sundials/sundials_types.h>" -- definition of type realtype
C.include "<sundials/sundials_math.h>"
C.include "../../../helpers.h"
C.include "Numeric/Sundials/Arkode_hsc.h"
-- | Stepping functions
data ODEMethod = ADAMS
| BDF
getMethod :: ODEMethod -> Int
getMethod (ADAMS) = cV_ADAMS
getMethod (BDF) = cV_BDF
getJacobian :: ODEMethod -> Maybe Jacobian
getJacobian _ = Nothing
-- | A version of 'odeSolveVWith' with reasonable default step control.
odeSolveV
:: ODEMethod
-> Maybe Double -- ^ initial step size - by default, CVode
-- estimates the initial step size to be the
-- solution \(h\) of the equation
-- \(\|\frac{h^2\ddot{y}}{2}\| = 1\), where
-- \(\ddot{y}\) is an estimated value of the
-- second derivative of the solution at \(t_0\)
-> Double -- ^ absolute tolerance for the state vector
-> Double -- ^ relative tolerance for the state vector
-> (Double -> Vector Double -> Vector Double) -- ^ The RHS of the system \(\dot{y} = f(t,y)\)
-> Vector Double -- ^ initial conditions
-> Vector Double -- ^ desired solution times
-> Matrix Double -- ^ solution
odeSolveV meth hi epsAbs epsRel f y0 ts =
odeSolveVWith meth (X epsAbs epsRel) hi g y0 ts
where
g t x0 = coerce $ f t x0
-- | A version of 'odeSolveV' with reasonable default parameters and
-- system of equations defined using lists. FIXME: we should say
-- something about the fact we could use the Jacobian but don't for
-- compatibility with hmatrix-gsl.
odeSolve :: (Double -> [Double] -> [Double]) -- ^ The RHS of the system \(\dot{y} = f(t,y)\)
-> [Double] -- ^ initial conditions
-> Vector Double -- ^ desired solution times
-> Matrix Double -- ^ solution
odeSolve f y0 ts =
-- FIXME: These tolerances are different from the ones in GSL
odeSolveVWith BDF (XX' 1.0e-6 1.0e-10 1 1) Nothing g (V.fromList y0) (V.fromList $ toList ts)
where
g t x0 = V.fromList $ f t (V.toList x0)
odeSolveVWith ::
ODEMethod
-> StepControl
-> Maybe Double -- ^ initial step size - by default, CVode
-- estimates the initial step size to be the
-- solution \(h\) of the equation
-- \(\|\frac{h^2\ddot{y}}{2}\| = 1\), where
-- \(\ddot{y}\) is an estimated value of the second
-- derivative of the solution at \(t_0\)
-> (Double -> V.Vector Double -> V.Vector Double) -- ^ The RHS of the system \(\dot{y} = f(t,y)\)
-> V.Vector Double -- ^ Initial conditions
-> V.Vector Double -- ^ Desired solution times
-> Matrix Double -- ^ Error code or solution
odeSolveVWith method control initStepSize f y0 tt =
case odeSolveVWith' opts method control initStepSize f y0 tt of
Left (c, _v) -> error $ show c -- FIXME
Right (v, _d) -> v
where
opts = ODEOpts { maxNumSteps = 10000
, minStep = 1.0e-12
, relTol = error "relTol"
, absTols = error "absTol"
, initStep = error "initStep"
, maxFail = 10
}
odeSolveVWith' ::
ODEOpts
-> ODEMethod
-> StepControl
-> Maybe Double -- ^ initial step size - by default, CVode
-- estimates the initial step size to be the
-- solution \(h\) of the equation
-- \(\|\frac{h^2\ddot{y}}{2}\| = 1\), where
-- \(\ddot{y}\) is an estimated value of the second
-- derivative of the solution at \(t_0\)
-> (Double -> V.Vector Double -> V.Vector Double) -- ^ The RHS of the system \(\dot{y} = f(t,y)\)
-> V.Vector Double -- ^ Initial conditions
-> V.Vector Double -- ^ Desired solution times
-> Either (Matrix Double, Int) (Matrix Double, SundialsDiagnostics) -- ^ Error code or solution
odeSolveVWith' opts method control initStepSize f y0 tt =
case solveOdeC (fromIntegral $ maxFail opts)
(fromIntegral $ maxNumSteps opts) (coerce $ minStep opts)
(fromIntegral $ getMethod method) (coerce initStepSize) jacH (scise control)
(coerce f) (coerce y0) (coerce tt) of
Left (v, c) -> Left (reshape l (coerce v), fromIntegral c)
Right (v, d) -> Right (reshape l (coerce v), d)
where
l = size y0
scise (X aTol rTol) = coerce (V.replicate l aTol, rTol)
scise (X' aTol rTol) = coerce (V.replicate l aTol, rTol)
scise (XX' aTol rTol yScale _yDotScale) = coerce (V.replicate l aTol, yScale * rTol)
-- FIXME; Should we check that the length of ss is correct?
scise (ScXX' aTol rTol yScale _yDotScale ss) = coerce (V.map (* aTol) ss, yScale * rTol)
jacH = fmap (\g t v -> matrixToSunMatrix $ g (coerce t) (coerce v)) $
getJacobian method
matrixToSunMatrix m = T.SunMatrix { T.rows = nr, T.cols = nc, T.vals = vs }
where
nr = fromIntegral $ rows m
nc = fromIntegral $ cols m
-- FIXME: efficiency
vs = V.fromList $ map coerce $ concat $ toLists m
solveOdeC ::
CInt ->
CLong ->
CDouble ->
CInt ->
Maybe CDouble ->
(Maybe (CDouble -> V.Vector CDouble -> T.SunMatrix)) ->
(V.Vector CDouble, CDouble) ->
(CDouble -> V.Vector CDouble -> V.Vector CDouble) -- ^ The RHS of the system \(\dot{y} = f(t,y)\)
-> V.Vector CDouble -- ^ Initial conditions
-> V.Vector CDouble -- ^ Desired solution times
-> Either (V.Vector CDouble, CInt) (V.Vector CDouble, SundialsDiagnostics) -- ^ Partial solution and error code or
-- solution and diagnostics
solveOdeC maxErrTestFails maxNumSteps_ minStep_ method initStepSize
jacH (aTols, rTol) fun f0 ts =
unsafePerformIO $ do
let isInitStepSize :: CInt
isInitStepSize = fromIntegral $ fromEnum $ isJust initStepSize
ss :: CDouble
ss = case initStepSize of
-- It would be better to put an error message here but
-- inline-c seems to evaluate this even if it is never
-- used :(
Nothing -> 0.0
Just x -> x
let dim = V.length f0
nEq :: CLong
nEq = fromIntegral dim
nTs :: CInt
nTs = fromIntegral $ V.length ts
quasiMatrixRes <- createVector ((fromIntegral dim) * (fromIntegral nTs))
qMatMut <- V.thaw quasiMatrixRes
diagnostics :: V.Vector CLong <- createVector 10 -- FIXME
diagMut <- V.thaw diagnostics
-- We need the types that sundials expects. These are tied together
-- in 'CLangToHaskellTypes'. FIXME: The Haskell type is currently empty!
let funIO :: CDouble -> Ptr T.SunVector -> Ptr T.SunVector -> Ptr () -> IO CInt
funIO x y f _ptr = do
-- Convert the pointer we get from C (y) to a vector, and then
-- apply the user-supplied function.
fImm <- fun x <$> getDataFromContents dim y
-- Fill in the provided pointer with the resulting vector.
putDataInContents fImm dim f
-- FIXME: I don't understand what this comment means
-- Unsafe since the function will be called many times.
[CU.exp| int{ 0 } |]
let isJac :: CInt
isJac = fromIntegral $ fromEnum $ isJust jacH
jacIO :: CDouble -> Ptr T.SunVector -> Ptr T.SunVector -> Ptr T.SunMatrix ->
Ptr () -> Ptr T.SunVector -> Ptr T.SunVector -> Ptr T.SunVector ->
IO CInt
jacIO t y _fy jacS _ptr _tmp1 _tmp2 _tmp3 = do
case jacH of
Nothing -> error "Numeric.Sundials.CVode.ODE: Jacobian not defined"
Just jacI -> do j <- jacI t <$> getDataFromContents dim y
poke jacS j
-- FIXME: I don't understand what this comment means
-- Unsafe since the function will be called many times.
[CU.exp| int{ 0 } |]
res <- [C.block| int {
/* general problem variables */
int flag; /* reusable error-checking flag */
int i, j; /* reusable loop indices */
N_Vector y = NULL; /* empty vector for storing solution */
N_Vector tv = NULL; /* empty vector for storing absolute tolerances */
SUNMatrix A = NULL; /* empty matrix for linear solver */
SUNLinearSolver LS = NULL; /* empty linear solver object */
void *cvode_mem = NULL; /* empty CVODE memory structure */
realtype t;
long int nst, nfe, nsetups, nje, nfeLS, nni, ncfn, netf, nge;
/* general problem parameters */
realtype T0 = RCONST(($vec-ptr:(double *ts))[0]); /* initial time */
sunindextype NEQ = $(sunindextype nEq); /* number of dependent vars. */
/* Initialize data structures */
y = N_VNew_Serial(NEQ); /* Create serial vector for solution */
if (check_flag((void *)y, "N_VNew_Serial", 0)) return 1;
/* Specify initial condition */
for (i = 0; i < NEQ; i++) {
NV_Ith_S(y,i) = ($vec-ptr:(double *f0))[i];
};
cvode_mem = CVodeCreate($(int method), CV_NEWTON);
if (check_flag((void *)cvode_mem, "CVodeCreate", 0)) return(1);
/* Call CVodeInit to initialize the integrator memory and specify the
* user's right hand side function in y'=f(t,y), the inital time T0, and
* the initial dependent variable vector y. */
flag = CVodeInit(cvode_mem, $fun:(int (* funIO) (double t, SunVector y[], SunVector dydt[], void * params)), T0, y);
if (check_flag(&flag, "CVodeInit", 1)) return(1);
tv = N_VNew_Serial(NEQ); /* Create serial vector for absolute tolerances */
if (check_flag((void *)tv, "N_VNew_Serial", 0)) return 1;
/* Specify tolerances */
for (i = 0; i < NEQ; i++) {
NV_Ith_S(tv,i) = ($vec-ptr:(double *aTols))[i];
};
flag = CVodeSetMinStep(cvode_mem, $(double minStep_));
if (check_flag(&flag, "CVodeSetMinStep", 1)) return 1;
flag = CVodeSetMaxNumSteps(cvode_mem, $(long int maxNumSteps_));
if (check_flag(&flag, "CVodeSetMaxNumSteps", 1)) return 1;
flag = CVodeSetMaxErrTestFails(cvode_mem, $(int maxErrTestFails));
if (check_flag(&flag, "CVodeSetMaxErrTestFails", 1)) return 1;
/* Call CVodeSVtolerances to specify the scalar relative tolerance
* and vector absolute tolerances */
flag = CVodeSVtolerances(cvode_mem, $(double rTol), tv);
if (check_flag(&flag, "CVodeSVtolerances", 1)) return(1);
/* Initialize dense matrix data structure and solver */
A = SUNDenseMatrix(NEQ, NEQ);
if (check_flag((void *)A, "SUNDenseMatrix", 0)) return 1;
LS = SUNDenseLinearSolver(y, A);
if (check_flag((void *)LS, "SUNDenseLinearSolver", 0)) return 1;
/* Attach matrix and linear solver */
flag = CVDlsSetLinearSolver(cvode_mem, LS, A);
if (check_flag(&flag, "CVDlsSetLinearSolver", 1)) return 1;
/* Set the initial step size if there is one */
if ($(int isInitStepSize)) {
/* FIXME: We could check if the initial step size is 0 */
/* or even NaN and then throw an error */
flag = CVodeSetInitStep(cvode_mem, $(double ss));
if (check_flag(&flag, "CVodeSetInitStep", 1)) return 1;
}
/* Set the Jacobian if there is one */
if ($(int isJac)) {
flag = CVDlsSetJacFn(cvode_mem, $fun:(int (* jacIO) (double t, SunVector y[], SunVector fy[], SunMatrix Jac[], void * params, SunVector tmp1[], SunVector tmp2[], SunVector tmp3[])));
if (check_flag(&flag, "CVDlsSetJacFn", 1)) return 1;
}
/* Store initial conditions */
for (j = 0; j < NEQ; j++) {
($vec-ptr:(double *qMatMut))[0 * $(int nTs) + j] = NV_Ith_S(y,j);
}
/* Main time-stepping loop: calls CVode to perform the integration */
/* Stops when the final time has been reached */
for (i = 1; i < $(int nTs); i++) {
flag = CVode(cvode_mem, ($vec-ptr:(double *ts))[i], y, &t, CV_NORMAL); /* call integrator */
if (check_flag(&flag, "CVode solver failure, stopping integration", 1)) return 1;
/* Store the results for Haskell */
for (j = 0; j < NEQ; j++) {
($vec-ptr:(double *qMatMut))[i * NEQ + j] = NV_Ith_S(y,j);
}
}
/* Get some final statistics on how the solve progressed */
flag = CVodeGetNumSteps(cvode_mem, &nst);
check_flag(&flag, "CVodeGetNumSteps", 1);
($vec-ptr:(long int *diagMut))[0] = nst;
/* FIXME */
($vec-ptr:(long int *diagMut))[1] = 0;
flag = CVodeGetNumRhsEvals(cvode_mem, &nfe);
check_flag(&flag, "CVodeGetNumRhsEvals", 1);
($vec-ptr:(long int *diagMut))[2] = nfe;
/* FIXME */
($vec-ptr:(long int *diagMut))[3] = 0;
flag = CVodeGetNumLinSolvSetups(cvode_mem, &nsetups);
check_flag(&flag, "CVodeGetNumLinSolvSetups", 1);
($vec-ptr:(long int *diagMut))[4] = nsetups;
flag = CVodeGetNumErrTestFails(cvode_mem, &netf);
check_flag(&flag, "CVodeGetNumErrTestFails", 1);
($vec-ptr:(long int *diagMut))[5] = netf;
flag = CVodeGetNumNonlinSolvIters(cvode_mem, &nni);
check_flag(&flag, "CVodeGetNumNonlinSolvIters", 1);
($vec-ptr:(long int *diagMut))[6] = nni;
flag = CVodeGetNumNonlinSolvConvFails(cvode_mem, &ncfn);
check_flag(&flag, "CVodeGetNumNonlinSolvConvFails", 1);
($vec-ptr:(long int *diagMut))[7] = ncfn;
flag = CVDlsGetNumJacEvals(cvode_mem, &nje);
check_flag(&flag, "CVDlsGetNumJacEvals", 1);
($vec-ptr:(long int *diagMut))[8] = ncfn;
flag = CVDlsGetNumRhsEvals(cvode_mem, &nfeLS);
check_flag(&flag, "CVDlsGetNumRhsEvals", 1);
($vec-ptr:(long int *diagMut))[9] = ncfn;
/* Clean up and return */
N_VDestroy(y); /* Free y vector */
N_VDestroy(tv); /* Free tv vector */
CVodeFree(&cvode_mem); /* Free integrator memory */
SUNLinSolFree(LS); /* Free linear solver */
SUNMatDestroy(A); /* Free A matrix */
return flag;
} |]
preD <- V.freeze diagMut
let d = SundialsDiagnostics (fromIntegral $ preD V.!0)
(fromIntegral $ preD V.!1)
(fromIntegral $ preD V.!2)
(fromIntegral $ preD V.!3)
(fromIntegral $ preD V.!4)
(fromIntegral $ preD V.!5)
(fromIntegral $ preD V.!6)
(fromIntegral $ preD V.!7)
(fromIntegral $ preD V.!8)
(fromIntegral $ preD V.!9)
m <- V.freeze qMatMut
if res == 0
then do
return $ Right (m, d)
else do
return $ Left (m, res)
solveOdeC' ::
CInt ->
CLong ->
CDouble ->
CInt ->
Maybe CDouble ->
(Maybe (CDouble -> V.Vector CDouble -> T.SunMatrix)) ->
(V.Vector CDouble, CDouble) ->
(CDouble -> V.Vector CDouble -> V.Vector CDouble) -- ^ The RHS of the system \(\dot{y} = f(t,y)\)
-> V.Vector CDouble -- ^ Initial conditions
-> CInt -- ^ FIXME
-> (CDouble -> V.Vector CDouble -> V.Vector CDouble) -- ^ FIXME
-> V.Vector CDouble -- ^ Desired solution times
-> SolverResult V.Vector V.Vector CInt CDouble
solveOdeC' maxErrTestFails maxNumSteps_ minStep_ method initStepSize
jacH (aTols, rTol) fun f0 nr g ts =
unsafePerformIO $ do
let isInitStepSize :: CInt
isInitStepSize = fromIntegral $ fromEnum $ isJust initStepSize
ss :: CDouble
ss = case initStepSize of
-- It would be better to put an error message here but
-- inline-c seems to evaluate this even if it is never
-- used :(
Nothing -> 0.0
Just x -> x
let dim = V.length f0
nEq :: CLong
nEq = fromIntegral dim
nTs :: CInt
nTs = fromIntegral $ V.length ts
quasiMatrixRes <- createVector ((fromIntegral dim) * (fromIntegral nTs))
qMatMut <- V.thaw quasiMatrixRes
diagnostics :: V.Vector CLong <- createVector 10 -- FIXME
diagMut <- V.thaw diagnostics
-- We need the types that sundials expects.
-- FIXME: The Haskell type is currently empty!
let funIO :: CDouble -> Ptr T.SunVector -> Ptr T.SunVector -> Ptr () -> IO CInt
funIO t y f _ptr = do
-- Convert the pointer we get from C (y) to a vector, and then
-- apply the user-supplied function.
fImm <- fun t <$> getDataFromContents dim y
-- Fill in the provided pointer with the resulting vector.
putDataInContents fImm dim f
-- FIXME: I don't understand what this comment means
-- Unsafe since the function will be called many times.
[CU.exp| int{ 0 } |]
let nrPre = fromIntegral nr
gResults :: V.Vector CInt <- createVector nrPre
gResMut <- V.thaw gResults
tRoot :: V.Vector CDouble <- createVector 1
tRootMut <- V.thaw tRoot
let gIO :: CDouble -> Ptr T.SunVector -> Ptr CDouble -> Ptr () -> IO CInt
gIO x y f _ptr = do
-- Convert the pointer we get from C (y) to a vector, and then
-- apply the user-supplied function.
gImm <- g x <$> getDataFromContents dim y
-- Fill in the provided pointer with the resulting vector.
vectorToC gImm nrPre f
-- FIXME: I don't understand what this comment means
-- Unsafe since the function will be called many times.
[CU.exp| int{ 0 } |]
let isJac :: CInt
isJac = fromIntegral $ fromEnum $ isJust jacH
jacIO :: CDouble -> Ptr T.SunVector -> Ptr T.SunVector -> Ptr T.SunMatrix ->
Ptr () -> Ptr T.SunVector -> Ptr T.SunVector -> Ptr T.SunVector ->
IO CInt
jacIO t y _fy jacS _ptr _tmp1 _tmp2 _tmp3 = do
case jacH of
Nothing -> error "Numeric.Sundials.CVode.ODE: Jacobian not defined"
Just jacI -> do j <- jacI t <$> getDataFromContents dim y
poke jacS j
-- FIXME: I don't understand what this comment means
-- Unsafe since the function will be called many times.
[CU.exp| int{ 0 } |]
res <- [C.block| int {
/* general problem variables */
int flag; /* reusable error-checking flag */
int flagr; /* root finding flag */
int i, j; /* reusable loop indices */
N_Vector y = NULL; /* empty vector for storing solution */
N_Vector tv = NULL; /* empty vector for storing absolute tolerances */
SUNMatrix A = NULL; /* empty matrix for linear solver */
SUNLinearSolver LS = NULL; /* empty linear solver object */
void *cvode_mem = NULL; /* empty CVODE memory structure */
realtype t;
long int nst, nfe, nsetups, nje, nfeLS, nni, ncfn, netf, nge;
realtype tout;
/* general problem parameters */
realtype T0 = RCONST(($vec-ptr:(double *ts))[0]); /* initial time */
sunindextype NEQ = $(sunindextype nEq); /* number of dependent vars. */
/* Initialize data structures */
y = N_VNew_Serial(NEQ); /* Create serial vector for solution */
if (check_flag((void *)y, "N_VNew_Serial", 0)) return 1;
/* Specify initial condition */
for (i = 0; i < NEQ; i++) {
NV_Ith_S(y,i) = ($vec-ptr:(double *f0))[i];
};
cvode_mem = CVodeCreate($(int method), CV_NEWTON);
if (check_flag((void *)cvode_mem, "CVodeCreate", 0)) return(1);
/* Call CVodeInit to initialize the integrator memory and specify the
* user's right hand side function in y'=f(t,y), the inital time T0, and
* the initial dependent variable vector y. */
flag = CVodeInit(cvode_mem, $fun:(int (* funIO) (double t, SunVector y[], SunVector dydt[], void * params)), T0, y);
if (check_flag(&flag, "CVodeInit", 1)) return(1);
tv = N_VNew_Serial(NEQ); /* Create serial vector for absolute tolerances */
if (check_flag((void *)tv, "N_VNew_Serial", 0)) return 1;
/* Specify tolerances */
for (i = 0; i < NEQ; i++) {
NV_Ith_S(tv,i) = ($vec-ptr:(double *aTols))[i];
};
flag = CVodeSetMinStep(cvode_mem, $(double minStep_));
if (check_flag(&flag, "CVodeSetMinStep", 1)) return 1;
flag = CVodeSetMaxNumSteps(cvode_mem, $(long int maxNumSteps_));
if (check_flag(&flag, "CVodeSetMaxNumSteps", 1)) return 1;
flag = CVodeSetMaxErrTestFails(cvode_mem, $(int maxErrTestFails));
if (check_flag(&flag, "CVodeSetMaxErrTestFails", 1)) return 1;
/* Call CVodeSVtolerances to specify the scalar relative tolerance
* and vector absolute tolerances */
flag = CVodeSVtolerances(cvode_mem, $(double rTol), tv);
if (check_flag(&flag, "CVodeSVtolerances", 1)) return(1);
/* Call CVodeRootInit to specify the root function g with nr components */
flag = CVodeRootInit(cvode_mem, $(int nr), $fun:(int (* gIO) (double t, SunVector y[], double gout[], void * params)));
if (check_flag(&flag, "CVodeRootInit", 1)) return(1);
/* Initialize dense matrix data structure and solver */
A = SUNDenseMatrix(NEQ, NEQ);
if (check_flag((void *)A, "SUNDenseMatrix", 0)) return 1;
LS = SUNDenseLinearSolver(y, A);
if (check_flag((void *)LS, "SUNDenseLinearSolver", 0)) return 1;
/* Attach matrix and linear solver */
flag = CVDlsSetLinearSolver(cvode_mem, LS, A);
if (check_flag(&flag, "CVDlsSetLinearSolver", 1)) return 1;
/* Set the initial step size if there is one */
if ($(int isInitStepSize)) {
/* FIXME: We could check if the initial step size is 0 */
/* or even NaN and then throw an error */
flag = CVodeSetInitStep(cvode_mem, $(double ss));
if (check_flag(&flag, "CVodeSetInitStep", 1)) return 1;
}
/* Set the Jacobian if there is one */
if ($(int isJac)) {
flag = CVDlsSetJacFn(cvode_mem, $fun:(int (* jacIO) (double t, SunVector y[], SunVector fy[], SunMatrix Jac[], void * params, SunVector tmp1[], SunVector tmp2[], SunVector tmp3[])));
if (check_flag(&flag, "CVDlsSetJacFn", 1)) return 1;
}
/* Store initial conditions */
for (j = 0; j < NEQ; j++) {
($vec-ptr:(double *qMatMut))[0 * $(int nTs) + j] = NV_Ith_S(y,j);
}
/* Main time-stepping loop: calls CVode to perform the integration */
/* Stops when the final time has been reached */
for (i = 1; i < $(int nTs); i++) {
flag = CVode(cvode_mem, ($vec-ptr:(double *ts))[i], y, &t, CV_NORMAL); /* call integrator */
if (check_flag(&flag, "CVode solver failure, stopping integration", 1)) return 1;
/* Store the results for Haskell */
for (j = 0; j < NEQ; j++) {
($vec-ptr:(double *qMatMut))[i * NEQ + j] = NV_Ith_S(y,j);
}
if (flag == CV_ROOT_RETURN) {
flagr = CVodeGetRootInfo(cvode_mem, ($vec-ptr:(int *gResMut)));
if (check_flag(&flagr, "CVodeGetRootInfo", 1)) return(1);
($vec-ptr:(double *tRootMut))[0] = t;
flagr = flag;
break;
}
}
/* Get some final statistics on how the solve progressed */
flag = CVodeGetNumSteps(cvode_mem, &nst);
check_flag(&flag, "CVodeGetNumSteps", 1);
($vec-ptr:(long int *diagMut))[0] = nst;
/* FIXME */
($vec-ptr:(long int *diagMut))[1] = 0;
flag = CVodeGetNumRhsEvals(cvode_mem, &nfe);
check_flag(&flag, "CVodeGetNumRhsEvals", 1);
($vec-ptr:(long int *diagMut))[2] = nfe;
/* FIXME */
($vec-ptr:(long int *diagMut))[3] = 0;
flag = CVodeGetNumLinSolvSetups(cvode_mem, &nsetups);
check_flag(&flag, "CVodeGetNumLinSolvSetups", 1);
($vec-ptr:(long int *diagMut))[4] = nsetups;
flag = CVodeGetNumErrTestFails(cvode_mem, &netf);
check_flag(&flag, "CVodeGetNumErrTestFails", 1);
($vec-ptr:(long int *diagMut))[5] = netf;
flag = CVodeGetNumNonlinSolvIters(cvode_mem, &nni);
check_flag(&flag, "CVodeGetNumNonlinSolvIters", 1);
($vec-ptr:(long int *diagMut))[6] = nni;
flag = CVodeGetNumNonlinSolvConvFails(cvode_mem, &ncfn);
check_flag(&flag, "CVodeGetNumNonlinSolvConvFails", 1);
($vec-ptr:(long int *diagMut))[7] = ncfn;
flag = CVDlsGetNumJacEvals(cvode_mem, &nje);
check_flag(&flag, "CVDlsGetNumJacEvals", 1);
($vec-ptr:(long int *diagMut))[8] = ncfn;
flag = CVDlsGetNumRhsEvals(cvode_mem, &nfeLS);
check_flag(&flag, "CVDlsGetNumRhsEvals", 1);
($vec-ptr:(long int *diagMut))[9] = ncfn;
/* Clean up and return */
N_VDestroy(y); /* Free y vector */
N_VDestroy(tv); /* Free tv vector */
CVodeFree(&cvode_mem); /* Free integrator memory */
SUNLinSolFree(LS); /* Free linear solver */
SUNMatDestroy(A); /* Free A matrix */
if (flag == CV_SUCCESS && flagr == CV_ROOT_RETURN) {
return CV_ROOT_RETURN;
}
else {
return flag;
}
} |]
preD <- V.freeze diagMut
let d = SundialsDiagnostics (fromIntegral $ preD V.!0)
(fromIntegral $ preD V.!1)
(fromIntegral $ preD V.!2)
(fromIntegral $ preD V.!3)
(fromIntegral $ preD V.!4)
(fromIntegral $ preD V.!5)
(fromIntegral $ preD V.!6)
(fromIntegral $ preD V.!7)
(fromIntegral $ preD V.!8)
(fromIntegral $ preD V.!9)
m <- V.freeze qMatMut
t <- V.freeze tRootMut
rs <- V.freeze gResMut
let f r | r == cV_SUCCESS = SolverSuccess m d
| r == cV_ROOT_RETURN = SolverRoot (t V.!0) rs m d
| otherwise = SolverError m res
return $ f $ fromIntegral res
data SolverResult f g a b =
SolverError (f b) a -- ^ Partial results and error code
| SolverSuccess (f b) SundialsDiagnostics -- ^ Results and diagnostics
| SolverRoot b (g a) (f b) SundialsDiagnostics -- ^ Time at which the root was found, the root itself and the
-- results and diagnostics. NB the final result will be at the time
-- at which the root was found not as specified by the times given
-- to the solver.
deriving Show
odeSolveRootVWith' ::
ODEOpts
-> ODEMethod
-> StepControl
-> Maybe Double -- ^ initial step size - by default, CVode
-- estimates the initial step size to be the
-- solution \(h\) of the equation
-- \(\|\frac{h^2\ddot{y}}{2}\| = 1\), where
-- \(\ddot{y}\) is an estimated value of the second
-- derivative of the solution at \(t_0\)
-> (Double -> V.Vector Double -> V.Vector Double) -- ^ The RHS of the system \(\dot{y} = f(t,y)\)
-> V.Vector Double -- ^ Initial conditions
-> Int -- ^ Dimension of the range of the roots function
-> (Double -> V.Vector Double -> V.Vector Double) -- ^ Roots function
-> V.Vector Double -- ^ Desired solution times
-> SolverResult Matrix Vector Int Double
odeSolveRootVWith' opts method control initStepSize f y0 is gg tt =
case solveOdeC' (fromIntegral $ maxFail opts)
(fromIntegral $ maxNumSteps opts) (coerce $ minStep opts)
(fromIntegral $ getMethod method) (coerce initStepSize) jacH (scise control)
(coerce f) (coerce y0) (fromIntegral is) (coerce gg) (coerce tt) of
SolverError v c -> SolverError (reshape l (coerce v)) (fromIntegral c)
SolverSuccess v d -> SolverSuccess (reshape l (coerce v)) d
SolverRoot t rs v d -> SolverRoot (coerce t) (V.map fromIntegral rs) (reshape l (coerce v)) d
where
l = size y0
scise (X aTol rTol) = coerce (V.replicate l aTol, rTol)
scise (X' aTol rTol) = coerce (V.replicate l aTol, rTol)
scise (XX' aTol rTol yScale _yDotScale) = coerce (V.replicate l aTol, yScale * rTol)
-- FIXME; Should we check that the length of ss is correct?
scise (ScXX' aTol rTol yScale _yDotScale ss) = coerce (V.map (* aTol) ss, yScale * rTol)
jacH = fmap (\g t v -> matrixToSunMatrix $ g (coerce t) (coerce v)) $
getJacobian method
matrixToSunMatrix m = T.SunMatrix { T.rows = nr, T.cols = nc, T.vals = vs }
where
nr = fromIntegral $ rows m
nc = fromIntegral $ cols m
-- FIXME: efficiency
vs = V.fromList $ map coerce $ concat $ toLists m
-- | Adaptive step-size control
-- functions.
--
-- [GSL](https://www.gnu.org/software/gsl/doc/html/ode-initval.html#adaptive-step-size-control)
-- allows the user to control the step size adjustment using
-- \(D_i = \epsilon^{abs}s_i + \epsilon^{rel}(a_{y} |y_i| + a_{dy/dt} h |\dot{y}_i|)\) where
-- \(\epsilon^{abs}\) is the required absolute error, \(\epsilon^{rel}\)
-- is the required relative error, \(s_i\) is a vector of scaling
-- factors, \(a_{y}\) is a scaling factor for the solution \(y\) and
-- \(a_{dydt}\) is a scaling factor for the derivative of the solution \(dy/dt\).
--
-- [ARKode](https://computation.llnl.gov/projects/sundials/arkode)
-- allows the user to control the step size adjustment using
-- \(\eta^{rel}|y_i| + \eta^{abs}_i\). For compatibility with
-- [hmatrix-gsl](https://hackage.haskell.org/package/hmatrix-gsl),
-- tolerances for \(y\) and \(\dot{y}\) can be specified but the latter have no
-- effect.
data StepControl = X Double Double -- ^ absolute and relative tolerance for \(y\); in GSL terms, \(a_{y} = 1\) and \(a_{dy/dt} = 0\); in ARKode terms, the \(\eta^{abs}_i\) are identical
| X' Double Double -- ^ absolute and relative tolerance for \(\dot{y}\); in GSL terms, \(a_{y} = 0\) and \(a_{dy/dt} = 1\); in ARKode terms, the latter is treated as the relative tolerance for \(y\) so this is the same as specifying 'X' which may be entirely incorrect for the given problem
| XX' Double Double Double Double -- ^ include both via relative tolerance
-- scaling factors \(a_y\), \(a_{{dy}/{dt}}\); in ARKode terms, the latter is ignored and \(\eta^{rel} = a_{y}\epsilon^{rel}\)
| ScXX' Double Double Double Double (Vector Double) -- ^ scale absolute tolerance of \(y_i\); in ARKode terms, \(a_{{dy}/{dt}}\) is ignored, \(\eta^{abs}_i = s_i \epsilon^{abs}\) and \(\eta^{rel} = a_{y}\epsilon^{rel}\)
|
<?xml version="1.0" encoding="utf-8"?>
<serviceModel xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="ContosoAdsCloudService" generation="1" functional="0" release="0" Id="1a1b26da-452a-44d6-8a4e-0f1c09994643" dslVersion="1.2.0.0" xmlns="http://schemas.microsoft.com/dsltools/RDSM">
<groups>
<group name="ContosoAdsCloudServiceGroup" generation="1" functional="0" release="0">
<componentports>
<inPort name="ContosoAdsWeb:Endpoint1" protocol="http">
<inToChannel>
<lBChannelMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/LB:ContosoAdsWeb:Endpoint1" />
</inToChannel>
</inPort>
<inPort name="ContosoAdsWorker:Microsoft.WindowsAzure.Plugins.RemoteForwarder.RdpInput" protocol="tcp">
<inToChannel>
<lBChannelMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/LB:ContosoAdsWorker:Microsoft.WindowsAzure.Plugins.RemoteForwarder.RdpInput" />
</inToChannel>
</inPort>
</componentports>
<settings>
<aCS name="Certificate|ContosoAdsWeb:Microsoft.WindowsAzure.Plugins.RemoteAccess.PasswordEncryption" defaultValue="">
<maps>
<mapMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/MapCertificate|ContosoAdsWeb:Microsoft.WindowsAzure.Plugins.RemoteAccess.PasswordEncryption" />
</maps>
</aCS>
<aCS name="Certificate|ContosoAdsWorker:Microsoft.WindowsAzure.Plugins.RemoteAccess.PasswordEncryption" defaultValue="">
<maps>
<mapMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/MapCertificate|ContosoAdsWorker:Microsoft.WindowsAzure.Plugins.RemoteAccess.PasswordEncryption" />
</maps>
</aCS>
<aCS name="ContosoAdsWeb:Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString" defaultValue="">
<maps>
<mapMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/MapContosoAdsWeb:Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString" />
</maps>
</aCS>
<aCS name="ContosoAdsWeb:Microsoft.WindowsAzure.Plugins.RemoteAccess.AccountEncryptedPassword" defaultValue="">
<maps>
<mapMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/MapContosoAdsWeb:Microsoft.WindowsAzure.Plugins.RemoteAccess.AccountEncryptedPassword" />
</maps>
</aCS>
<aCS name="ContosoAdsWeb:Microsoft.WindowsAzure.Plugins.RemoteAccess.AccountExpiration" defaultValue="">
<maps>
<mapMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/MapContosoAdsWeb:Microsoft.WindowsAzure.Plugins.RemoteAccess.AccountExpiration" />
</maps>
</aCS>
<aCS name="ContosoAdsWeb:Microsoft.WindowsAzure.Plugins.RemoteAccess.AccountUsername" defaultValue="">
<maps>
<mapMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/MapContosoAdsWeb:Microsoft.WindowsAzure.Plugins.RemoteAccess.AccountUsername" />
</maps>
</aCS>
<aCS name="ContosoAdsWeb:Microsoft.WindowsAzure.Plugins.RemoteAccess.Enabled" defaultValue="">
<maps>
<mapMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/MapContosoAdsWeb:Microsoft.WindowsAzure.Plugins.RemoteAccess.Enabled" />
</maps>
</aCS>
<aCS name="ContosoAdsWeb:StorageConnectionString" defaultValue="">
<maps>
<mapMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/MapContosoAdsWeb:StorageConnectionString" />
</maps>
</aCS>
<aCS name="ContosoAdsWebInstances" defaultValue="[1,1,1]">
<maps>
<mapMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/MapContosoAdsWebInstances" />
</maps>
</aCS>
<aCS name="ContosoAdsWorker:ContosoAdsDbConnectionString" defaultValue="">
<maps>
<mapMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/MapContosoAdsWorker:ContosoAdsDbConnectionString" />
</maps>
</aCS>
<aCS name="ContosoAdsWorker:Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString" defaultValue="">
<maps>
<mapMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/MapContosoAdsWorker:Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString" />
</maps>
</aCS>
<aCS name="ContosoAdsWorker:Microsoft.WindowsAzure.Plugins.RemoteAccess.AccountEncryptedPassword" defaultValue="">
<maps>
<mapMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/MapContosoAdsWorker:Microsoft.WindowsAzure.Plugins.RemoteAccess.AccountEncryptedPassword" />
</maps>
</aCS>
<aCS name="ContosoAdsWorker:Microsoft.WindowsAzure.Plugins.RemoteAccess.AccountExpiration" defaultValue="">
<maps>
<mapMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/MapContosoAdsWorker:Microsoft.WindowsAzure.Plugins.RemoteAccess.AccountExpiration" />
</maps>
</aCS>
<aCS name="ContosoAdsWorker:Microsoft.WindowsAzure.Plugins.RemoteAccess.AccountUsername" defaultValue="">
<maps>
<mapMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/MapContosoAdsWorker:Microsoft.WindowsAzure.Plugins.RemoteAccess.AccountUsername" />
</maps>
</aCS>
<aCS name="ContosoAdsWorker:Microsoft.WindowsAzure.Plugins.RemoteAccess.Enabled" defaultValue="">
<maps>
<mapMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/MapContosoAdsWorker:Microsoft.WindowsAzure.Plugins.RemoteAccess.Enabled" />
</maps>
</aCS>
<aCS name="ContosoAdsWorker:Microsoft.WindowsAzure.Plugins.RemoteForwarder.Enabled" defaultValue="">
<maps>
<mapMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/MapContosoAdsWorker:Microsoft.WindowsAzure.Plugins.RemoteForwarder.Enabled" />
</maps>
</aCS>
<aCS name="ContosoAdsWorker:StorageConnectionString" defaultValue="">
<maps>
<mapMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/MapContosoAdsWorker:StorageConnectionString" />
</maps>
</aCS>
<aCS name="ContosoAdsWorkerInstances" defaultValue="[1,1,1]">
<maps>
<mapMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/MapContosoAdsWorkerInstances" />
</maps>
</aCS>
</settings>
<channels>
<lBChannel name="LB:ContosoAdsWeb:Endpoint1">
<toPorts>
<inPortMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/ContosoAdsWeb/Endpoint1" />
</toPorts>
</lBChannel>
<lBChannel name="LB:ContosoAdsWorker:Microsoft.WindowsAzure.Plugins.RemoteForwarder.RdpInput">
<toPorts>
<inPortMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/ContosoAdsWorker/Microsoft.WindowsAzure.Plugins.RemoteForwarder.RdpInput" />
</toPorts>
</lBChannel>
<sFSwitchChannel name="SW:ContosoAdsWeb:Microsoft.WindowsAzure.Plugins.RemoteAccess.Rdp">
<toPorts>
<inPortMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/ContosoAdsWeb/Microsoft.WindowsAzure.Plugins.RemoteAccess.Rdp" />
</toPorts>
</sFSwitchChannel>
<sFSwitchChannel name="SW:ContosoAdsWorker:Microsoft.WindowsAzure.Plugins.RemoteAccess.Rdp">
<toPorts>
<inPortMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/ContosoAdsWorker/Microsoft.WindowsAzure.Plugins.RemoteAccess.Rdp" />
</toPorts>
</sFSwitchChannel>
</channels>
<maps>
<map name="MapCertificate|ContosoAdsWeb:Microsoft.WindowsAzure.Plugins.RemoteAccess.PasswordEncryption" kind="Identity">
<certificate>
<certificateMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/ContosoAdsWeb/Microsoft.WindowsAzure.Plugins.RemoteAccess.PasswordEncryption" />
</certificate>
</map>
<map name="MapCertificate|ContosoAdsWorker:Microsoft.WindowsAzure.Plugins.RemoteAccess.PasswordEncryption" kind="Identity">
<certificate>
<certificateMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/ContosoAdsWorker/Microsoft.WindowsAzure.Plugins.RemoteAccess.PasswordEncryption" />
</certificate>
</map>
<map name="MapContosoAdsWeb:Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString" kind="Identity">
<setting>
<aCSMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/ContosoAdsWeb/Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString" />
</setting>
</map>
<map name="MapContosoAdsWeb:Microsoft.WindowsAzure.Plugins.RemoteAccess.AccountEncryptedPassword" kind="Identity">
<setting>
<aCSMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/ContosoAdsWeb/Microsoft.WindowsAzure.Plugins.RemoteAccess.AccountEncryptedPassword" />
</setting>
</map>
<map name="MapContosoAdsWeb:Microsoft.WindowsAzure.Plugins.RemoteAccess.AccountExpiration" kind="Identity">
<setting>
<aCSMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/ContosoAdsWeb/Microsoft.WindowsAzure.Plugins.RemoteAccess.AccountExpiration" />
</setting>
</map>
<map name="MapContosoAdsWeb:Microsoft.WindowsAzure.Plugins.RemoteAccess.AccountUsername" kind="Identity">
<setting>
<aCSMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/ContosoAdsWeb/Microsoft.WindowsAzure.Plugins.RemoteAccess.AccountUsername" />
</setting>
</map>
<map name="MapContosoAdsWeb:Microsoft.WindowsAzure.Plugins.RemoteAccess.Enabled" kind="Identity">
<setting>
<aCSMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/ContosoAdsWeb/Microsoft.WindowsAzure.Plugins.RemoteAccess.Enabled" />
</setting>
</map>
<map name="MapContosoAdsWeb:StorageConnectionString" kind="Identity">
<setting>
<aCSMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/ContosoAdsWeb/StorageConnectionString" />
</setting>
</map>
<map name="MapContosoAdsWebInstances" kind="Identity">
<setting>
<sCSPolicyIDMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/ContosoAdsWebInstances" />
</setting>
</map>
<map name="MapContosoAdsWorker:ContosoAdsDbConnectionString" kind="Identity">
<setting>
<aCSMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/ContosoAdsWorker/ContosoAdsDbConnectionString" />
</setting>
</map>
<map name="MapContosoAdsWorker:Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString" kind="Identity">
<setting>
<aCSMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/ContosoAdsWorker/Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString" />
</setting>
</map>
<map name="MapContosoAdsWorker:Microsoft.WindowsAzure.Plugins.RemoteAccess.AccountEncryptedPassword" kind="Identity">
<setting>
<aCSMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/ContosoAdsWorker/Microsoft.WindowsAzure.Plugins.RemoteAccess.AccountEncryptedPassword" />
</setting>
</map>
<map name="MapContosoAdsWorker:Microsoft.WindowsAzure.Plugins.RemoteAccess.AccountExpiration" kind="Identity">
<setting>
<aCSMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/ContosoAdsWorker/Microsoft.WindowsAzure.Plugins.RemoteAccess.AccountExpiration" />
</setting>
</map>
<map name="MapContosoAdsWorker:Microsoft.WindowsAzure.Plugins.RemoteAccess.AccountUsername" kind="Identity">
<setting>
<aCSMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/ContosoAdsWorker/Microsoft.WindowsAzure.Plugins.RemoteAccess.AccountUsername" />
</setting>
</map>
<map name="MapContosoAdsWorker:Microsoft.WindowsAzure.Plugins.RemoteAccess.Enabled" kind="Identity">
<setting>
<aCSMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/ContosoAdsWorker/Microsoft.WindowsAzure.Plugins.RemoteAccess.Enabled" />
</setting>
</map>
<map name="MapContosoAdsWorker:Microsoft.WindowsAzure.Plugins.RemoteForwarder.Enabled" kind="Identity">
<setting>
<aCSMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/ContosoAdsWorker/Microsoft.WindowsAzure.Plugins.RemoteForwarder.Enabled" />
</setting>
</map>
<map name="MapContosoAdsWorker:StorageConnectionString" kind="Identity">
<setting>
<aCSMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/ContosoAdsWorker/StorageConnectionString" />
</setting>
</map>
<map name="MapContosoAdsWorkerInstances" kind="Identity">
<setting>
<sCSPolicyIDMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/ContosoAdsWorkerInstances" />
</setting>
</map>
</maps>
<components>
<groupHascomponents>
<role name="ContosoAdsWeb" generation="1" functional="0" release="0" software="C:\Users\himasing\Downloads\Simple Azure Cloud Service with Web Role and Worker Role-New\C#\ContosoAdsCloudService\csx\Release\roles\ContosoAdsWeb" entryPoint="base\x64\WaHostBootstrapper.exe" parameters="base\x64\WaIISHost.exe " memIndex="-1" hostingEnvironment="frontendadmin" hostingEnvironmentVersion="2">
<componentports>
<inPort name="Endpoint1" protocol="http" portRanges="80" />
<inPort name="Microsoft.WindowsAzure.Plugins.RemoteAccess.Rdp" protocol="tcp" portRanges="3389" />
<outPort name="ContosoAdsWeb:Microsoft.WindowsAzure.Plugins.RemoteAccess.Rdp" protocol="tcp">
<outToChannel>
<sFSwitchChannelMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/SW:ContosoAdsWeb:Microsoft.WindowsAzure.Plugins.RemoteAccess.Rdp" />
</outToChannel>
</outPort>
<outPort name="ContosoAdsWorker:Microsoft.WindowsAzure.Plugins.RemoteAccess.Rdp" protocol="tcp">
<outToChannel>
<sFSwitchChannelMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/SW:ContosoAdsWorker:Microsoft.WindowsAzure.Plugins.RemoteAccess.Rdp" />
</outToChannel>
</outPort>
</componentports>
<settings>
<aCS name="Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString" defaultValue="" />
<aCS name="Microsoft.WindowsAzure.Plugins.RemoteAccess.AccountEncryptedPassword" defaultValue="" />
<aCS name="Microsoft.WindowsAzure.Plugins.RemoteAccess.AccountExpiration" defaultValue="" />
<aCS name="Microsoft.WindowsAzure.Plugins.RemoteAccess.AccountUsername" defaultValue="" />
<aCS name="Microsoft.WindowsAzure.Plugins.RemoteAccess.Enabled" defaultValue="" />
<aCS name="StorageConnectionString" defaultValue="" />
<aCS name="__ModelData" defaultValue="<m role="ContosoAdsWeb" xmlns="urn:azure:m:v1"><r name="ContosoAdsWeb"><e name="Endpoint1" /><e name="Microsoft.WindowsAzure.Plugins.RemoteAccess.Rdp" /></r><r name="ContosoAdsWorker"><e name="Microsoft.WindowsAzure.Plugins.RemoteAccess.Rdp" /><e name="Microsoft.WindowsAzure.Plugins.RemoteForwarder.RdpInput" /></r></m>" />
</settings>
<resourcereferences>
<resourceReference name="DiagnosticStore" defaultAmount="[4096,4096,4096]" defaultSticky="true" kind="Directory" />
<resourceReference name="EventStore" defaultAmount="[1000,1000,1000]" defaultSticky="false" kind="LogStore" />
</resourcereferences>
<storedcertificates>
<storedCertificate name="Stored0Microsoft.WindowsAzure.Plugins.RemoteAccess.PasswordEncryption" certificateStore="My" certificateLocation="System">
<certificate>
<certificateMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/ContosoAdsWeb/Microsoft.WindowsAzure.Plugins.RemoteAccess.PasswordEncryption" />
</certificate>
</storedCertificate>
</storedcertificates>
<certificates>
<certificate name="Microsoft.WindowsAzure.Plugins.RemoteAccess.PasswordEncryption" />
</certificates>
</role>
<sCSPolicy>
<sCSPolicyIDMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/ContosoAdsWebInstances" />
<sCSPolicyUpdateDomainMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/ContosoAdsWebUpgradeDomains" />
<sCSPolicyFaultDomainMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/ContosoAdsWebFaultDomains" />
</sCSPolicy>
</groupHascomponents>
<groupHascomponents>
<role name="ContosoAdsWorker" generation="1" functional="0" release="0" software="C:\Users\himasing\Downloads\Simple Azure Cloud Service with Web Role and Worker Role-New\C#\ContosoAdsCloudService\csx\Release\roles\ContosoAdsWorker" entryPoint="base\x64\WaHostBootstrapper.exe" parameters="base\x64\WaWorkerHost.exe " memIndex="-1" hostingEnvironment="consoleroleadmin" hostingEnvironmentVersion="2">
<componentports>
<inPort name="Microsoft.WindowsAzure.Plugins.RemoteForwarder.RdpInput" protocol="tcp" />
<inPort name="Microsoft.WindowsAzure.Plugins.RemoteAccess.Rdp" protocol="tcp" portRanges="3389" />
<outPort name="ContosoAdsWeb:Microsoft.WindowsAzure.Plugins.RemoteAccess.Rdp" protocol="tcp">
<outToChannel>
<sFSwitchChannelMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/SW:ContosoAdsWeb:Microsoft.WindowsAzure.Plugins.RemoteAccess.Rdp" />
</outToChannel>
</outPort>
<outPort name="ContosoAdsWorker:Microsoft.WindowsAzure.Plugins.RemoteAccess.Rdp" protocol="tcp">
<outToChannel>
<sFSwitchChannelMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/SW:ContosoAdsWorker:Microsoft.WindowsAzure.Plugins.RemoteAccess.Rdp" />
</outToChannel>
</outPort>
</componentports>
<settings>
<aCS name="ContosoAdsDbConnectionString" defaultValue="" />
<aCS name="Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString" defaultValue="" />
<aCS name="Microsoft.WindowsAzure.Plugins.RemoteAccess.AccountEncryptedPassword" defaultValue="" />
<aCS name="Microsoft.WindowsAzure.Plugins.RemoteAccess.AccountExpiration" defaultValue="" />
<aCS name="Microsoft.WindowsAzure.Plugins.RemoteAccess.AccountUsername" defaultValue="" />
<aCS name="Microsoft.WindowsAzure.Plugins.RemoteAccess.Enabled" defaultValue="" />
<aCS name="Microsoft.WindowsAzure.Plugins.RemoteForwarder.Enabled" defaultValue="" />
<aCS name="StorageConnectionString" defaultValue="" />
<aCS name="__ModelData" defaultValue="<m role="ContosoAdsWorker" xmlns="urn:azure:m:v1"><r name="ContosoAdsWeb"><e name="Endpoint1" /><e name="Microsoft.WindowsAzure.Plugins.RemoteAccess.Rdp" /></r><r name="ContosoAdsWorker"><e name="Microsoft.WindowsAzure.Plugins.RemoteAccess.Rdp" /><e name="Microsoft.WindowsAzure.Plugins.RemoteForwarder.RdpInput" /></r></m>" />
</settings>
<resourcereferences>
<resourceReference name="DiagnosticStore" defaultAmount="[4096,4096,4096]" defaultSticky="true" kind="Directory" />
<resourceReference name="EventStore" defaultAmount="[1000,1000,1000]" defaultSticky="false" kind="LogStore" />
</resourcereferences>
<storedcertificates>
<storedCertificate name="Stored0Microsoft.WindowsAzure.Plugins.RemoteAccess.PasswordEncryption" certificateStore="My" certificateLocation="System">
<certificate>
<certificateMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/ContosoAdsWorker/Microsoft.WindowsAzure.Plugins.RemoteAccess.PasswordEncryption" />
</certificate>
</storedCertificate>
</storedcertificates>
<certificates>
<certificate name="Microsoft.WindowsAzure.Plugins.RemoteAccess.PasswordEncryption" />
</certificates>
</role>
<sCSPolicy>
<sCSPolicyIDMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/ContosoAdsWorkerInstances" />
<sCSPolicyUpdateDomainMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/ContosoAdsWorkerUpgradeDomains" />
<sCSPolicyFaultDomainMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/ContosoAdsWorkerFaultDomains" />
</sCSPolicy>
</groupHascomponents>
</components>
<sCSPolicy>
<sCSPolicyUpdateDomain name="ContosoAdsWebUpgradeDomains" defaultPolicy="[5,5,5]" />
<sCSPolicyUpdateDomain name="ContosoAdsWorkerUpgradeDomains" defaultPolicy="[5,5,5]" />
<sCSPolicyFaultDomain name="ContosoAdsWebFaultDomains" defaultPolicy="[2,2,2]" />
<sCSPolicyFaultDomain name="ContosoAdsWorkerFaultDomains" defaultPolicy="[2,2,2]" />
<sCSPolicyID name="ContosoAdsWebInstances" defaultPolicy="[1,1,1]" />
<sCSPolicyID name="ContosoAdsWorkerInstances" defaultPolicy="[1,1,1]" />
</sCSPolicy>
</group>
</groups>
<implements>
<implementation Id="e7d474d0-626c-452a-ad68-cba0fbba9e73" ref="Microsoft.RedDog.Contract\ServiceContract\ContosoAdsCloudServiceContract@ServiceDefinition">
<interfacereferences>
<interfaceReference Id="c8ea4707-95b3-439e-8f2a-041b9c6ead50" ref="Microsoft.RedDog.Contract\Interface\ContosoAdsWeb:Endpoint1@ServiceDefinition">
<inPort>
<inPortMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/ContosoAdsWeb:Endpoint1" />
</inPort>
</interfaceReference>
<interfaceReference Id="e1f4d372-0da8-4828-b335-b138dc08f596" ref="Microsoft.RedDog.Contract\Interface\ContosoAdsWorker:Microsoft.WindowsAzure.Plugins.RemoteForwarder.RdpInput@ServiceDefinition">
<inPort>
<inPortMoniker name="/ContosoAdsCloudService/ContosoAdsCloudServiceGroup/ContosoAdsWorker:Microsoft.WindowsAzure.Plugins.RemoteForwarder.RdpInput" />
</inPort>
</interfaceReference>
</interfacereferences>
</implementation>
</implements>
</serviceModel> |
%% ****** Start of file apstemplate.tex ****** %
%%
%%
%% This file is part of the APS files in the REVTeX 4 distribution.
%% Version 4.1r of REVTeX, August 2010
%%
%%
%% Copyright (c) 2001, 2009, 2010 The American Physical Society.
%%
%% See the REVTeX 4 README file for restrictions and more information.
%%
%
% This is a template for producing manuscripts for use with REVTEX 4.0
% Copy this file to another name and then work on that file.
% That way, you always have this original template file to use.
%
% Group addresses by affiliation; use superscriptaddress for long
% author lists, or if there are many overlapping affiliations.
% For Phys. Rev. appearance, change preprint to twocolumn.
% Choose pra, prb, prc, prd, pre, prl, prstab, prstper, or rmp for journal
% Add 'draft' option to mark overfull boxes with black boxes
% Add 'showpacs' option to make PACS codes appear
% Add 'showkeys' option to make keywords appear
%\documentclass[aps,prl,preprint,groupedaddress]{revtex4-1}
%\documentclass[aps,prl,preprint,superscriptaddress]{revtex4-1}
%\documentclass[aps,prl,reprint,groupedaddress]{revtex4-1}
\documentclass[%
reprint,
%superscriptaddress,
%groupedaddress,
%unsortedaddress,
%runinaddress,
%frontmatterverbose,
%preprint,
%showpacs,preprintnumbers,
%nofootinbib,
%nobibnotes,
%bibnotes,
amsmath,amssymb,
aps,
%pra,
%prb,
%rmp,
%prstab,
%prstper,
%floatfix,
]{revtex4-1}
\usepackage{graphicx}
\usepackage[space]{grffile}
\usepackage{latexsym}
\usepackage{textcomp}
\usepackage{longtable}
\usepackage{tabulary}
\usepackage{booktabs,array,multirow}
\usepackage{amsfonts,amsmath,amssymb}
\usepackage{natbib}
\usepackage{url}
\usepackage{hyperref}
\hypersetup{colorlinks=false,pdfborder={0 0 0}}
\usepackage{etoolbox}
\makeatletter
\patchcmd\@combinedblfloats{\box\@outputbox}{\unvbox\@outputbox}{}{%
\errmessage{\noexpand\@combinedblfloats could not be patched}%
}%
\makeatother
% You can conditionalize code for latexml or normal latex using this.
\newif\iflatexml\latexmlfalse
\providecommand{\tightlist}{\setlength{\itemsep}{0pt}\setlength{\parskip}{0pt}}%
\AtBeginDocument{\DeclareGraphicsExtensions{.pdf,.PDF,.eps,.EPS,.png,.PNG,.tif,.TIF,.jpg,.JPG,.jpeg,.JPEG}}
\usepackage[utf8]{inputenc}
\usepackage[ngerman,english]{babel}
%\usepackage{babel}
\begin{document}
\title{Can we run quantum circuits on ultra-cold atom devices?}
\author{Fred Jendrzejewski}
\affiliation{Kirchhoff-Institut für Physik}
\author{Manuel Rudolph}
\affiliation{Kirchhoff-Institut für Physik}
\selectlanguage{english}
\begin{abstract}
In this blog-post, we present our path and thoughts towards using
ultra-cold atom experiments for quantum computation. They are the result
of a two month internship where we studied the feasibility of such an
undertaking in our group. Many associate only universal devices,
especially qubit devices, to be valid quantum computers. We show how we
think of our ultra-cold atoms in terms of quantum circuits and implement
first steps in the software
framework~\href{https://pennylane.ai/}{PennyLane}.%
\end{abstract}%
%\pacs{Valid PACS appear here}% PACS, the Physics and Astronomy
% Classification Scheme.
%\keywords{Suggested keywords}%Use showkeys class option if keyword
%display desired
\maketitle
\section*{Motivation}
{\label{773840}}
Over recent years, interest in quantum information processing has
increased tremendously. This rise was fueled by activities of massive
commercial players
like~{\href{https://www.ibm.com/quantum-computing/}{IBM},}
\href{https://research.google/teams/applied-science/quantum/}{Google},
\href{https://www.microsoft.com/en-us/quantum}{Microsoft} and large
investments in startups like \href{https://www.dwavesys.com/}{D-Wave},
\href{https://rigetti.com/}{Rigetti},
\href{https://www.xanadu.ai/}{Xanadu},
\href{https://www.zapatacomputing.com/}{Zapata}and
\href{https://cambridgequantum.com/}{Cambridge Quantum Computing}. The
work of these companies typically focuses on \textbf{universal quantum
computers}, which hold the premise of exponential speed-up for a variety
of NP-hard problems. However, this \textbf{universality usually comes at
the price} of algorithmic overhead for a wide range of tasks which
generally leads to worse overall fidelity. If we give up the constraint
of a universal quantum computer, we can build \textbf{specialized
quantum hardware} for the problems of interest. Such systems are
called~\textbf{quantum simulators}.~
\textbf{Ultra-cold atoms~have become}~\textbf{a leading platform of such
quantum simulators at a large scale}. Most importantly for us, they are
the experimental platform our research group is working on. Already
demonstrated applications involve an enormous variety of
condensed-matter problems like e.g. the Hubbard model
\cite{Bloch_2008}, topological systems \cite{Goldman_2014} ,
superfluidity \cite{Regal_2007} and disorder \cite{Lagendijk_2009} . More
recently, cold atoms started to find applications to Ising models
\cite{Bernien2017} and high-energy physics \cite{Zohar2016}. ~
However, \textbf{quantum simulators
are}~\textbf{currently}~\textbf{limited to an academic environment}
because of~
\begin{enumerate}
\tightlist
\item
the \textbf{complexity of constructing the experimental hardware},
which involves substantial technical know-how and funding.
\item
the \textbf{specificity of knowledge and language required} to
understand/communicate the experiment.
\item
the need to \textbf{formulate the target problem as a Hamiltonian}.
\item
the~\textbf{manual}~\textbf{compilation of programs} on this hardware
class.~
\end{enumerate}
A~\textbf{circuit-based approach to ultra-cold atom quantum simulators}
would alleviate points 2) and 3) as we could agree on the quantum
circuit, given the hardware-specific operations, and run it on the
experiment. Integrating the system with a software stack
like~\href{https://pennylane.ai/}{PennyLane~}would additionally allow to
address and run the experiment on a higher level
and~\textbf{substantially lower the barrier of entry for users outside
of the cold-atom and quantum physics community}. ~
These points motivated our research group to have a look how our
experimental hardware, which is controlled by
the~\href{http://labscriptsuite.org/}{Labscript Suite},~can be
integrated into PennyLane to run quantum circuits on ultra-cold atom
devices.~ Our group is part of
\href{http://www.kip.uni-heidelberg.de/synqs/}{SynQS}, working on two
ultra-cold atom experiments, the NaLi and SoPa (named after the two
atomic species used in the lab).
\par\null
\subsection*{Why use ultra-cold atoms as a quantum information platform
?}
{\label{677154}}
For ultra-cold atoms, the~\textbf{processing unit is not a qubit} and as
such, the \textbf{natural operations are not} generally
\textbf{the~commonly used and widely known qubit operations} such
as~\(X,Y,Z\) rotations, Hadamard~\(H\) gates,
entangling~\(CNOT \) or~\(XX\) gates with
oberservables like~\(\sigma^z\) expectations.~{{Instead, our NaLi
experiment implements a~}}\(X(\theta)\){ \textbf{rotation on a long
spin} of many bosons on one optical lattice site. Additionally, the
system naturally evolves under a many-body
Hamiltonian~}\(H_{mb}\), coupling the the atomic species.
What is the qubit equivalent of those operations?~{The relation is
pretty complex -} and that is the nice thing!~\textbf{Cold atoms are
different}. Given their success in the quantum simulation of many-body
problems, they could make for an exciting quantum information processor
that is~\textbf{complementary to~}{\textbf{universal devices.}} So as a
general rule of thumb, it could be argued that cold atom machines often
give up some control over individual particles, leading to much bigger
systems. Additionally, because we work with a large number of atoms, we
can measure obtain rather precise estimates of expectation
values~\textbf{{{with a~single state preparation and one
measurement}}}.~
\par\null
\section*{A concrete example from our
group}
{\label{216843}}
Before we go into more detailed discussion of our implementation, we
will present a \textbf{concrete example of our device}, where
\textbf{we} \textbf{study lattice gauge theories}. These theories have
become a popular benchmark for quantum simulators~\cite{Kokail_2019} and
quantum computers~\cite{Martinez_2016,tavernelli2020} in recent years. On our NaLi
machine, we recently performed experiments on the building block for
certain quantum simulators that would be suited for theories from
high-energy physics~\cite{Mil2020}. ~These experiments are performed
with two atomic species, sodium and lithium, that can be prepared in two
internal spin states.~
\textbf{Re-thinking our analog quantum simulation} for the purpose of
quantum circuits, we can \textbf{represent the sodium atoms as a very
long spin} state~\(\left|\psi_N\right\rangle\). The observable outcomes
are~\(L_z=-\frac{N}{2},\cdots,\frac{N}{2}\), where~\(N\sim10^5\) is the number of sodium
atoms. On a quantum computer this should be compared to a qubit, for
which we can only measure two outcomes~\(L_z=\pm\frac{1}{2}\).
The \textbf{lithium atoms} on the other hand can be \textbf{described by
the states on two independent sites~}\(\left|\psi_p\right\rangle\)
and~\(|\psi_v\rangle\). For each site we can observe that number of
atoms that sit on it. The observable outcomes are
then~\(n_{p/v} = 0, \dots, n\) where~\(n\sim 10^4\) is the number of
lithium atoms.~
\par\null
In this formulation and \textbf{analogous to other circuit-based quantum
computing devices}, the NaLi experiment then consists of three main
stages:
\begin{enumerate}
\tightlist
\item
The atoms are prepared in some initial state\ldots{}
\item
controlled through a set of operations/gates\ldots{}
\item
and then measured to evaluate the operators~\(L_z\)
and~\(N_{p,v}\)
\end{enumerate}
Without having to dig through all the physical details to understand the
publication~\cite{Mil2020}, the figures in it intuitively open
themselves up to \textbf{readers with varying backgrounds} when plotting
the \textbf{corresponding circuits} next to them as shown in Fig.
{\ref{428832}}.\selectlanguage{english}
\begin{figure}[h!]
\begin{center}
\includegraphics[width=0.70\columnwidth]{figures/AlexAsCircuit/mil-with-circuits}
\caption{{Scetched quantum circuits that correspond to selected figures from Mil
et al.~\protect\cite{Mil2020}. The results gain a clear intuitive meaning
through the quantum circuits even though the system that is being
simulated is not known. The color blue signifies the Sodium atoms and
the orange color Lithium.
{\label{428832}}%
}}
\end{center}
\end{figure}
\par\null
\textbf{Additional benefits of using the circuit language} include
\begin{itemize}
\tightlist
\item
a \textbf{more uniform definition of~}\emph{\textbf{fidelity}} for
ultra-cold atom experiments relative to fidelity in qubit devices
where each operation and the final result can be quantified.
\item
\textbf{improved communication} with \textbf{and feedback} of
theorists involved in the project by working on the same level of
resolution.
\item
more easily \textbf{generalizing the capabilities of the device} to
work on \textbf{other problems.}
\item
general accessibility and a~\textbf{path towards using ultra-cold
atoms experiments in the quantum computing community.}
\end{itemize}
\section*{}\label{section}
\section*{Choice of framework software for our quantum
circuits}\label{choice-of-framework-software-for-our-quantum-circuits}
The choice of which framework software to use for our circuit-based
approach was not a particularly hard one for us. We have our own
experiment in the lab which implements a non-standard device for quantum
simulation and thus some of our requirements are (roughly in order of
importance):
\begin{enumerate}
\tightlist
\item
Can we \textbf{integrate our own experimental hardware} into the
framework and potentially run it from there?
\item
How strong of an \textbf{assumption} is made \textbf{about the
computational unit} of the hardware? Does it have to be strictly
qubits/photons etc.?
\item
Is the framework \textbf{open-source} and shows \textbf{openness to
the academic community}?
\item
Can also \textbf{integrate classical simulators} that are based on our
hardware?
\item
Does it provide some sort of \textbf{user management and safety
measures} to avoid unqualified users from killing the system?
\end{enumerate}
Lets give a brief overview of how we answered those questions with
regard to PennyLane.~\textbf{PennyLane is designed for users to write
and use their own~}\emph{\textbf{plugin}}, which is what they call the
integration of quantum computing devices into the framework. Officially,
it only supports~\emph{qubit~}and~\emph{continuous variable} devices and
not more general approaches but we may be able to~\textbf{integrate
bosonic and fermionic atoms flexibly} as the code itself is not very
restricted. Other big platorms
like~\href{https://qiskit.org/}{Qiskit},~\href{http://docs.rigetti.com/en/stable/}{Forest}
and~\href{https://strawberryfields.readthedocs.io/en/stable/}{Strawberry
Fields} focus exclusively on their own quantum computing hardware or
simulator without the possibility to integrate your own. PennyLane
is~\textbf{open-source and Python-based,} which is perfect as the
\emph{Labscript Suite} controlling our experiment is so, too.
Additionally, the company behind
PennyLane,~\href{https://www.xanadu.ai/}{Xanadu}, is a partly academic
player who is very open in their publications and \textbf{supports a
great community} around the software. The framework allows to add
simulators to the framework device which mirror the functionality of the
hardware. It performs various parameter range checks for the system and
the operations used. Not built-in is user a system for management which
allows only registered users to run the experiment from a queue. We
would have to implement this ourselves.
All-in-all,~\textbf{PennyLane seems to be the best and likely only fit}
for our endeavors. Let's talk about it in more detail.
\section*{Pennylane}
{\label{935975}}
\begin{quote}
\emph{A cross-platform Python library for quantum machine learning,
automatic differentiation, and optimization of hybrid quantum-classical
computations.}
\end{quote}\selectlanguage{english}
\begin{figure}[h!]
\begin{center}
\includegraphics[width=0.63\columnwidth]{figures/PennyLane-puzzle/PennyLane-puzzle}
\caption{{PennyLane as the connecting puzzle piece.
\href{https://pennylane.readthedocs.io/en/stable/introduction/pennylane.html}{Source}
{\label{477211}}%
}}
\end{center}
\end{figure}
\href{https://pennylane.ai/}{PennyLane}\protect\hyperlink{killoran2018}{(Bergholm
2018)} is created by
\emph{\href{https://www.xanadu.ai/}{Xanadu~}}and~presents itself as
the~\textbf{connecting puzzle piece} \textbf{between powerful
established python libraries for machine learning, and quantum computing
platforms}. It provides readily implemented quantum algorithms for
quantum machine learning, quantum chemistry and optimization. A
particular algorithm provided in PennyLane is automatic differentiation
of quantum circuits which allows to perform shot-efficient application
of classical-quantum algorithms such as the~\emph{Variational Quantum
Eigensolver} (VQE). ~~
Existing popular quantum computing platforms such as
\href{https://qiskit.org/}{Qiskit}for qubits and
\href{https://strawberryfields.readthedocs.io/en/stable/\#}{Strawberry
Fields} (also created by \emph{Xanadu}) for photons have written plugins
for PennyLane which make their \textbf{quantum simulators or quantum
hardware accessible through it} and with that PennyLane's quantum
algorithms and automatic differentiation feature.~
In fact,~\textbf{any quantum lab can adapt
the~}\href{https://github.com/XanaduAI/pennylane-plugin-template}{\textbf{plugin
template}} \textbf{for their own experiment and simulators} to
assimilate their own specific workflow with PennyLane where users are
generally able to use the same workflow accross platforms and know what
to expect. Fig.~{\ref{757073}} shows a typical way of
using PennyLane in a classical-quantum hybrid algorithm. Here, the
default qubit simulator by PennyLane is used. After writing our own
plugin, we can call that device, change the quantum circuit to contain
the supported operations and the workflow is otherwise the same.
All-in-all, \textbf{the interface is very robust towards changing up the
quantum backend} (especially when they support the same operations).\selectlanguage{english}
\begin{figure}[h!]
\begin{center}
\includegraphics[width=0.35\columnwidth]{figures/PennyLane-use/PennyLane-use}
\caption{{Typical simple way of using PennyLane by instantiating the device,
defining the parametrized quantum circuit and the cost, and calculating
the gradient for the classical parameters.
\href{https://pennylane.readthedocs.io/en/stable/introduction/pennylane.html}{Source}
{\label{757073}}%
}}
\end{center}
\end{figure}
\section*{}\label{section}
\section*{Our workflow and connecting PennyLane to our
hardware}\label{our-workflow-and-connecting-pennylane-to-our-hardware}
The current state of our \textbf{\emph{pennylane\_ls}}~\textbf{plugin
for ultra-cold atom experiments} can be viewed
in~\href{https://github.com/synqs/pennylane-ls}{\textbf{this public
github repository}}. It provides examples from our labs and can guide
you to adapting it to your own experiment and needs.
Our group uses \textbf{} the
\href{http://labscriptsuite.org/}{\textbf{Labscript suite}} \textbf{to
coordinate and execute experimental sequences} with cold atoms. ~
\begin{quote}
~\emph{The labscript suite is a collection of programs, which work
together to form a control system for autonomous, hardware timed
experiments}. ~
\end{quote}
On the deepest level it is very nuts and bolts with plenty of commands
in the style of Fig. {\ref{799186}} below.\selectlanguage{english}
\begin{figure}[h!]
\begin{center}
\includegraphics[width=0.98\columnwidth]{figures/Labscript-NaLi-code/Labscript-NaLi-code}
\caption{{The Experiment.py (left) defines the experimental sequence of a
Labscript-controlled lab experiment, here by calling functions from
NaLiFunctions.py at given times. The function UMPUMP (right) shows the
exact low level hardware instructions that are to be executed.
{\label{799186}}%
}}
\end{center}
\end{figure}
The~\emph{\textbf{Experiment.py}} \textbf{file~}(Fig.
{\ref{799186}}) \textbf{determines the exact sequence
of hardware controls} that is executed during the measurement. It
contains Labscript syntax and is fed into the Labscript Python
compiler~\emph{\textbf{Runmanager}.~~}
Our approach for \textbf{combining Labscript with PennyLane} is
sumarized in Fig.~{\ref{547624}}.
With the help of the plugin functions~\emph{\textbf{pre\_apply()},
\textbf{apply()}~}and~\emph{\textbf{post\_apply()}}, \textbf{we generate
a new~}\emph{\textbf{Experiment.py}} \textbf{on the fly} depending on
the quantum circuit programmed through the PennyLane interface.\selectlanguage{english}
\begin{figure}[h!]
\begin{center}
\includegraphics[width=0.56\columnwidth]{figures/pre-post-apply/pre-post-apply}
\caption{{The functions~\emph{pre\_apply(), apply()~}and~\emph{post\_apply()} are
used to generate a new~\emph{Experiment.py} on the fly for each quantum
circuit in PennyLane.~\emph{apply()} loops through the operations in the
circuit while the other functions always write the same necessary code
for the compilation.
{\label{547624}}%
}}
\end{center}
\end{figure}
In other words, \textbf{our PennyLane plugin translates a quantum
circuit to an} \emph{\textbf{Experiment.py}} which our control system
can interpret.
The~\emph{\textbf{expval()}}~method from the plugin is then used to
\textbf{send the newly generated file to the~}\emph{\textbf{Runmanager}}
and engage the sequence. The output shots are then evaluated and the
method returns an expectation.
A detailled discussion of the technical details can be found in the
README.md of the~\href{https://github.com/synqs/pennylane_ls}{public
repository}. ~The \textbf{features of our plugin} currently include:
\begin{itemize}
\tightlist
\item
\textbf{Proposing a higher-level control of experiments} that are run
controlled by the Labscript Suite through PennyLane.
\item
A \textbf{framework device that provides a template for labs with
Labscript} to quickly adapt code for their own setup.
\item
Including \textbf{two devices of the SynQS group at the
Kirchhoff-Institute} \textbf{for Physics} of Prof. Fred Jendrzejewski.
\end{itemize}
The framework device in~\emph{SynQSDevice.py} is written such that
\textbf{a group which uses the Labscript Suite} to run their experiment
\textbf{can} \textbf{adapt the module easily to their own setup}.
\par\null
Finishing up this project,~we have \textbf{succeed in providing first
circuit control to our experiments~}through PennyLane and extract the
results. However, much \textbf{further automation will be needed} to
fully leverage the possibilities of the quantum circuits that we can run
on our ultra-cold atom devices.
\section*{Future steps}\label{future-steps}
To get the project \textbf{towards} \textbf{a full Pennylane plugin}, we
have to:
\begin{enumerate}
\tightlist
\item
Give \emph{\textbf{wires}} \textbf{} a \textbf{} meaning.
\item
\textbf{Operations need to be restricted to certain wires}, especially
when different atomic species are involved.
\item
Implement~\textbf{true remote control} of the lab through the
\emph{pennylane\_ls} module.
\item
Implement \textbf{full result post-processing} that is currently used
in the lab.
\item
Implement some kind of \textbf{user management}.
\end{enumerate}
While it seems quite clear how we can implement points 1 - 4, it seems
to be a whole new problem to implement some kind of user management for
our systems.~
In any case the \textbf{first steps are remarkably promising} and we
will see how the quantum circuits can be efficiently employed in
ultra-cold atom experiments.
\selectlanguage{english}
\FloatBarrier
\nocite{*}
\bibliographystyle{apsrev4-1}
\bibliography{bibliography/converted_to_latex.bib%
}
\end{document}
|
Formal statement is: lemma prime_ge_2_nat: "p \<ge> 2" if "prime p" for p :: nat Informal statement is: If $p$ is a prime number, then $p \geq 2$. |
mutable struct OrderBook
bids::OrderedDict(Float64, Float64)
asks::OrderedDict(Float64, Float64)
end
|
Formal statement is: lemma eventually_filtercomap_at_topological: "eventually P (filtercomap f (at A within B)) \<longleftrightarrow> (\<exists>S. open S \<and> A \<in> S \<and> (\<forall>x. f x \<in> S \<inter> B - {A} \<longrightarrow> P x))" (is "?lhs = ?rhs") Informal statement is: The filtercomap of the filter at a point is the filter of the complement of the point. |
Formal statement is: lemma norm_cauchy_schwarz_abs_eq: "\<bar>x \<bullet> y\<bar> = norm x * norm y \<longleftrightarrow> norm x *\<^sub>R y = norm y *\<^sub>R x \<or> norm x *\<^sub>R y = - norm y *\<^sub>R x" (is "?lhs \<longleftrightarrow> ?rhs") Informal statement is: $\langle x, y \rangle = \|x\| \|y\|$ if and only if $x = \|x\| \frac{y}{\|y\|}$ or $x = -\|x\| \frac{y}{\|y\|}$. |
------------------------------------------------------------------------
-- The Agda standard library
--
-- A categorical view of List⁺
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.List.NonEmpty.Categorical where
open import Agda.Builtin.List
import Data.List.Categorical as List
open import Data.List.NonEmpty
open import Data.Product using (uncurry)
open import Category.Functor
open import Category.Applicative
open import Category.Monad
open import Category.Comonad
open import Function
------------------------------------------------------------------------
-- List⁺ applicative functor
functor : ∀ {f} → RawFunctor {f} List⁺
functor = record
{ _<$>_ = map
}
applicative : ∀ {f} → RawApplicative {f} List⁺
applicative = record
{ pure = [_]
; _⊛_ = λ fs as → concatMap (λ f → map f as) fs
}
------------------------------------------------------------------------
-- List⁺ monad
monad : ∀ {f} → RawMonad {f} List⁺
monad = record
{ return = [_]
; _>>=_ = flip concatMap
}
------------------------------------------------------------------------
-- List⁺ comonad
comonad : ∀ {f} → RawComonad {f} List⁺
comonad = record
{ extract = head
; extend = λ f → uncurry (extend f) ∘′ uncons
} where
extend : ∀ {A B} → (List⁺ A → B) → A → List A → List⁺ B
extend f x xs@[] = f (x ∷ xs) ∷ []
extend f x xs@(y ∷ ys) = f (x ∷ xs) ∷⁺ extend f y ys
------------------------------------------------------------------------
-- Get access to other monadic functions
module _ {f F} (App : RawApplicative {f} F) where
open RawApplicative App
sequenceA : ∀ {A} → List⁺ (F A) → F (List⁺ A)
sequenceA (x ∷ xs) = _∷_ <$> x ⊛ List.sequenceA App xs
mapA : ∀ {a} {A : Set a} {B} → (A → F B) → List⁺ A → F (List⁺ B)
mapA f = sequenceA ∘ map f
forA : ∀ {a} {A : Set a} {B} → List⁺ A → (A → F B) → F (List⁺ B)
forA = flip mapA
module _ {m M} (Mon : RawMonad {m} M) where
private App = RawMonad.rawIApplicative Mon
sequenceM = sequenceA App
mapM = mapA App
forM = forA App
------------------------------------------------------------------------
-- List⁺ monad transformer
monadT : ∀ {f} → RawMonadT {f} (_∘′ List⁺)
monadT M = record
{ return = pure ∘′ [_]
; _>>=_ = λ mas f → mas >>= λ as → concat <$> mapM M f as
} where open RawMonad M
|
"""
Copyright 2020 The OneFlow Authors. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""
import unittest
import os
from collections import OrderedDict
import numpy as np
import oneflow as flow
import tensorflow as tf
import test_global_storage
from test_util import GenArgList, type_name_to_flow_type
gpus = tf.config.experimental.list_physical_devices("GPU")
for gpu in gpus:
tf.config.experimental.set_memory_growth(gpu, True)
def compare_with_tensorflow(
device_type,
a_shape,
b_shape,
transpose_a,
transpose_b,
data_type,
fuse_add_to_output,
enable_tf32,
alpha,
):
assert device_type in ["gpu", "cpu"]
flow.clear_default_session()
func_config = flow.FunctionConfig()
func_config.default_data_type(flow.float)
func_config.enable_fuse_add_to_output(fuse_add_to_output)
flow.config.enable_tensor_float_32_compute(enable_tf32)
if data_type == "float16":
dtype = flow.float
else:
dtype = type_name_to_flow_type[data_type]
@flow.global_function(type="train", function_config=func_config)
def MatmulJob():
with flow.scope.placement(device_type, "0:0"):
a = flow.get_variable(
"a",
shape=a_shape,
dtype=dtype,
initializer=flow.random_uniform_initializer(minval=0, maxval=1),
trainable=True,
)
b = flow.get_variable(
"b",
shape=b_shape,
dtype=dtype,
initializer=flow.random_uniform_initializer(minval=0, maxval=1),
trainable=True,
)
if data_type == "float16":
out = flow.matmul(
flow.cast(a, dtype=flow.float16),
flow.cast(b, dtype=flow.float16),
transpose_a,
transpose_b,
alpha,
)
c = flow.get_variable(
"c",
shape=out.shape,
dtype=dtype,
initializer=flow.random_uniform_initializer(minval=-1, maxval=1),
trainable=True,
)
loss = flow.cast(
out + flow.cast(c, dtype=flow.float16), dtype=flow.float
)
else:
out = flow.matmul(a, b, transpose_a, transpose_b, alpha)
c = flow.get_variable(
"c",
shape=out.shape,
dtype=dtype,
initializer=flow.random_uniform_initializer(minval=-1, maxval=1),
trainable=True,
)
loss = out + c
flow.optimizer.SGD(
flow.optimizer.PiecewiseConstantScheduler([], [1e-4]), momentum=0
).minimize(loss)
flow.watch(a, test_global_storage.Setter("a"))
flow.watch_diff(a, test_global_storage.Setter("a_diff"))
flow.watch(b, test_global_storage.Setter("b"))
flow.watch_diff(b, test_global_storage.Setter("b_diff"))
flow.watch(c, test_global_storage.Setter("c"))
flow.watch_diff(c, test_global_storage.Setter("c_diff"))
flow.watch(loss, test_global_storage.Setter("loss"))
flow.watch_diff(loss, test_global_storage.Setter("loss_diff"))
return loss
# OneFlow
of_out = MatmulJob().get()
# TensorFlow
with tf.GradientTape(persistent=True) as tape:
a = tf.Variable(test_global_storage.Get("a"))
b = tf.Variable(test_global_storage.Get("b"))
c = tf.Variable(test_global_storage.Get("c"))
if data_type == "float16":
a = tf.cast(a, tf.float16)
b = tf.cast(b, tf.float16)
c = tf.cast(c, tf.float16)
tf_out = tf.matmul(a, b, transpose_a, transpose_b)
tf_out = tf_out * alpha
tf_out = tf_out + c
if data_type == "float16":
tf_out = tf.cast(tf_out, tf.float32)
loss_diff = test_global_storage.Get("loss_diff")
tf_a_diff = tape.gradient(tf_out, a, loss_diff)
tf_b_diff = tape.gradient(tf_out, b, loss_diff)
tf_c_diff = tape.gradient(tf_out, c, loss_diff)
if data_type == "float16":
tolerance = 2e-3
else:
tolerance = 1e-3
assert np.allclose(
of_out.numpy(), tf_out.numpy(), rtol=tolerance, atol=tolerance
), np.max(np.abs(of_out.numpy() - tf_out.numpy()))
assert np.allclose(
test_global_storage.Get("a_diff"),
tf_a_diff.numpy(),
rtol=tolerance,
atol=tolerance,
)
assert np.allclose(
test_global_storage.Get("b_diff"),
tf_b_diff.numpy(),
rtol=tolerance,
atol=tolerance,
)
assert np.allclose(
test_global_storage.Get("c_diff"),
tf_c_diff.numpy(),
rtol=tolerance,
atol=tolerance,
)
def filter_args(arg_list):
def trans_shape(shape):
tmp_shape = shape[:-2]
tmp_shape += (shape[-1], shape[-2])
return tmp_shape
ret = []
for arg in arg_list:
a_shape = arg[1]
b_shape = arg[2]
if arg[3]: # transpose_a
a_shape = trans_shape(a_shape)
if arg[4]: # transpose_b
b_shape = trans_shape(b_shape)
if a_shape[-1] == b_shape[-2]:
ret.append(tuple(arg))
return ret
def gen_arg_list():
arg_dict = OrderedDict()
arg_dict["device_type"] = ["gpu", "cpu"]
arg_dict["a_shape"] = [(512, 256), (256, 512)]
arg_dict["b_shape"] = [(256, 1024), (1024, 256)]
arg_dict["transpose_a"] = [True, False]
arg_dict["transpose_b"] = [True, False]
arg_dict["data_type"] = ["float16", "float32", "double"]
arg_dict["fuse_add_to_output"] = [True, False]
arg_dict["enable_tf32"] = [True, False]
arg_dict["alpha"] = [1.5, 1]
matmul_args = filter_args(GenArgList(arg_dict))
arg_dict.clear()
arg_dict["device_type"] = ["gpu", "cpu"]
arg_dict["a_shape"] = [(10, 10, 64, 32), (10, 10, 32, 64)]
arg_dict["b_shape"] = [(10, 10, 32, 128), (10, 10, 128, 32)]
arg_dict["transpose_a"] = [True, False]
arg_dict["transpose_b"] = [True, False]
arg_dict["data_type"] = ["float16", "float32", "double"]
arg_dict["fuse_add_to_output"] = [True, False]
arg_dict["enable_tf32"] = [True, False]
arg_dict["alpha"] = [2.0]
batch_matmul_args = filter_args(GenArgList(arg_dict))
return matmul_args + batch_matmul_args
@flow.unittest.skip_unless_1n1d()
class TestMatmul(flow.unittest.TestCase):
def test_matmul(test_case):
for arg in gen_arg_list():
if arg[0] == "cpu" and (arg[5] == "float16" or arg[7] == True):
continue
if arg[5] != "float32" and arg[7] == True:
continue
compare_with_tensorflow(*arg)
if __name__ == "__main__":
unittest.main()
|
From sflib Require Import sflib.
From Paco Require Import paco.
From PromisingLib Require Import Axioms.
From PromisingLib Require Import Basic.
From PromisingLib Require Import Loc.
From PromisingLib Require Import Language.
Require Import Event.
Require Import View.
Require Import Cell.
Require Import Memory.
Require Import TView.
Require Import Thread.
Require Import Configuration.
Require Import Behavior.
Set Implicit Arguments.
Section Simulation.
Definition SIM := forall (c1_src c1_tgt: Configuration.t), Prop.
Definition _sim (sim: SIM) (c1_src c1_tgt:Configuration.t): Prop :=
forall (WF_SRC: Configuration.wf c1_src)
(WF_TGT: Configuration.wf c1_tgt),
<<TERMINAL:
forall (TERMINAL_TGT: Threads.is_terminal (Configuration.threads c1_tgt)),
exists c2_src,
<<STEPS_SRC: rtc Configuration.tau_step c1_src c2_src>> /\
<<TERMINAL_SRC: Threads.is_terminal (Configuration.threads c2_src)>>>> /\
<<STEP:
forall e tid c2_tgt
(STEP_TGT: Configuration.step e tid c1_tgt c2_tgt),
exists c2_src,
<<STEP_SRC: Configuration.opt_step e tid c1_src c2_src>> /\
<<SIM: sim c2_src c2_tgt>>>>
.
Lemma _sim_mon: monotone2 _sim.
Proof.
ii. exploit IN; eauto. i. des.
econs; eauto. ii.
exploit STEP; eauto. i. des. eauto.
Qed.
#[local]
Hint Resolve _sim_mon: paco.
Definition sim: SIM := paco2 _sim bot2.
End Simulation.
#[export]
Hint Resolve _sim_mon: paco.
Lemma sim_adequacy
c_src c_tgt
(WF_SRC: Configuration.wf c_src)
(WF_TGT: Configuration.wf c_tgt)
(SIM: sim c_src c_tgt):
behaviors Configuration.step c_tgt <1= behaviors Configuration.step c_src.
Proof.
i. revert c_src WF_SRC WF_TGT SIM.
induction PR; i.
- punfold SIM0. exploit SIM0; eauto. i. des.
hexploit TERMINAL0; eauto. i. des.
eapply rtc_tau_step_behavior; eauto.
econs 1. eauto.
- punfold SIM0. exploit SIM0; eauto. i. des.
exploit STEP0; eauto. i. des.
exploit Configuration.step_future; try exact STEP; eauto. i. des.
exploit Configuration.opt_step_future; try exact STEP_SRC; eauto. i. des.
inv SIM1; ss. inv STEP_SRC.
econs 2; eauto.
- punfold SIM0. exploit SIM0; eauto. i. des.
exploit STEP0; eauto. i. des.
exploit Configuration.step_future; try exact STEP; eauto. i. des.
exploit Configuration.opt_step_future; try exact STEP_SRC; eauto. i. des.
inv SIM1; ss. inv STEP_SRC.
econs 3; eauto.
- punfold SIM0. exploit SIM0; eauto. i. des.
exploit STEP0; eauto. i. des.
exploit Configuration.step_future; try exact STEP; eauto. i. des.
exploit Configuration.opt_step_future; try exact STEP_SRC; eauto. i. des.
inv SIM1; ss. inv STEP_SRC; eauto.
econs 4; eauto.
Qed.
|
[STATEMENT]
lemma diamond_x_top:
"|x>top = n(x * L)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. | x > top = n (x * L)
[PROOF STEP]
by (metis mult_assoc n_top_L ndiamond_def top_mult_top) |
State Before: R : Type u
M : Type v
S : Type u_1
N : Type ?u.185417
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup N
inst✝² : Ring S
inst✝¹ : Module R M
inst✝ : Module R N
f : R →+* S
hf : Surjective ↑f
I : Ideal S
hI : IsPrincipal (comap f I)
⊢ I = Submodule.span S {↑f (IsPrincipal.generator (comap f I))} State After: no goals Tactic: rw [Ideal.submodule_span_eq, ← Set.image_singleton, ← Ideal.map_span,
Ideal.span_singleton_generator, Ideal.map_comap_of_surjective f hf] |
From iris.algebra Require Import auth gmap excl.
From aneris.algebra Require Import monotone.
From aneris.aneris_lang Require Import network resources proofmode.
From aneris.prelude Require Import time.
From aneris.aneris_lang.lib Require Import list_proof lock_proof vector_clock_proof.
From aneris.aneris_lang.program_logic Require Import lightweight_atomic.
From aneris.examples.rcb.spec Require Import base events resources.
(** Specifications for read and write operations. *)
Section Specification.
Context `{!anerisG Mdl Σ, !RCB_params, !RCB_events, !RCB_resources Mdl Σ}.
Definition deliver_spec
(deliver : val) (i: nat) (z : socket_address) : iProp Σ :=
⌜RCB_addresses !! i = Some z⌝ -∗
<<< ∀∀ (s : lstate), OwnLocal i s >>>
deliver #() @[ip_of_address z] ↑RCB_InvName
<<<▷ ∃∃ s' vo,
RET vo; OwnLocal i s' ∗
((⌜s' = s⌝ ∗ ⌜vo = NONEV⌝) ∨
(∃ a,
⌜s' = s ∪ {[ a ]}⌝ ∗
⌜a ∉ s⌝ ∗
⌜a ∈ compute_maximals LE_vc s'⌝ ∗
⌜(LE_origin a) ≠ i⌝ ∗
OwnGlobalSnapshot {[ erasure a ]} ∗
∃ v, ⌜vo = SOMEV v⌝ ∗
⌜is_le v a⌝)) >>>.
Definition broadcast_spec
(broadcast : val) (i: nat) (z : socket_address) : iProp Σ :=
∀ (v : SerializableVal),
⌜RCB_addresses !! i = Some z⌝ -∗
<<< ∀∀ (h : gstate) (s : lstate), OwnGlobal h ∗ OwnLocal i s >>>
broadcast v @[ip_of_address z] ↑RCB_InvName
<<<▷ ∃∃ w (a : le),
RET w;
⌜is_le w a⌝ ∗
⌜a ∉ s⌝ ∗
⌜erasure a ∉ h⌝ ∗
⌜LE_payload a = v⌝ ∗
⌜LE_origin a = i⌝ ∗
let e := erasure a in
let s' := s ∪ {[ a ]} in
let h' := h ∪ {[ e ]} in
⌜e ∈ compute_maximals GE_vc h'⌝ ∗
⌜compute_maximum LE_vc s' = Some a⌝ ∗
OwnGlobal h' ∗
OwnLocal i s' >>>.
Definition init_spec (init : val) : iProp Σ :=
□ ∀ (i : nat) (z : socket_address)
(v : val),
⌜is_list RCB_addresses v⌝ →
⌜RCB_addresses !! i = Some z⌝ →
{{{ ([∗ list] i ↦ z ∈ RCB_addresses, z ⤇ RCB_socket_proto i) ∗
z ⤳ (∅, ∅) ∗
free_ports (ip_of_address z) {[port_of_address z]} ∗
init_token i}}}
init v #i @[ip_of_address z]
{{{ deliver broadcast, RET (deliver, broadcast);
OwnLocal i ∅ ∗ deliver_spec deliver i z ∗
broadcast_spec broadcast i z}}}.
Definition simplified_deliver_spec
(deliver : val) (i: nat) (z : socket_address) : iProp Σ :=
∀ (s : lstate),
⌜RCB_addresses !! i = Some z⌝ -∗
{{{ OwnLocal i s }}}
deliver #() @[ip_of_address z]
{{{ vo, RET vo;
((⌜vo = NONEV⌝ ∗ OwnLocal i s) ∨
(∃ (v: val) (e : le),
⌜vo = SOMEV v⌝ ∗ ⌜is_le v e⌝
∗ OwnLocal i (s ∪ {[ e ]})
∗ ⌜e ∉ s⌝
∗ ⌜((LE_origin e) ≠ i)⌝
∗ OwnGlobalSnapshot ({[ erasure e ]})
∗ ⌜e ∈ compute_maximals LE_vc (s ∪ {[ e ]})⌝))
}}}.
Lemma deliver_spec_implies_simplified_spec deliver i z :
deliver_spec deliver i z ⊢ simplified_deliver_spec deliver i z.
Proof.
iIntros "#Hdeliver".
rewrite /simplified_deliver_spec.
iIntros (s) "%Haddr".
iIntros (Φ) "!> Hloc HΦ".
iApply "Hdeliver"; [done |].
iApply fupd_mask_intro; [set_solver |].
iIntros "Hcl".
iExists s; iFrame.
iIntros "!>" (s' vo) "[Hloc [[-> ->] |Hsome]]";
iMod "Hcl"; iModIntro; iApply "HΦ".
- eauto with iFrame.
- iDestruct "Hsome" as (a) "(-> & ? & ? & ? & ? & Hv)".
iDestruct "Hv" as (v) "[? ?]".
eauto with iFrame.
Qed.
Definition simplified_broadcast_spec
(broadcast : val) (i: nat) (z : socket_address)
(v : SerializableVal) (h : gstate) (s : lstate) : iProp Σ :=
⌜RCB_addresses !! i = Some z⌝ -∗
{{{ OwnGlobal h ∗ OwnLocal i s }}}
broadcast v @[ip_of_address z]
{{{ (w : val), RET w;
∃ (a : le),
⌜LE_payload a = v⌝ ∗
⌜LE_origin a = i⌝ ∗
⌜is_le w a⌝ ∗
⌜compute_maximum LE_vc (s ∪ {[ a ]}) = Some a⌝ ∗
let e := erasure a in
⌜e ∈ compute_maximals GE_vc (h ∪ {[ e ]})⌝ ∗
OwnLocal i (s ∪ {[ a ]}) ∗
OwnGlobal (h ∪ {[ e ]}) }}}.
Lemma broadcast_spec_implies_simplified_spec broadcast i z :
broadcast_spec broadcast i z ⊢ ∀ v h s, simplified_broadcast_spec broadcast i z v h s.
Proof.
iIntros "#Hbr" (v h s).
rewrite /simplified_broadcast_spec.
iIntros (Hi Φ) "!>".
iIntros "[Hglob Hloc] HΦ".
iApply "Hbr"; [done |].
iApply fupd_mask_intro; [set_solver |].
iIntros "Hmask".
iExists h, s. iFrame.
iIntros "!>" (w a) "(? & ? & ? & ? & ? & ? & ? & ? & ?)".
iMod "Hmask". iModIntro.
iApply "HΦ". eauto with iFrame.
Qed.
End Specification.
(* An example of using the deliver and broadcast specs through invariants (logical atomicity) *)
Section DeliverBroadcastInvExample.
Context `{!anerisG Mdl Σ, !RCB_params, !RCB_events, !RCB_resources Mdl Σ}.
Context (LInv : namespace) (names_disj : LInv ## RCB_InvName).
(* TODO: here we'd like to take local snapshots, but we can't.
Implement local snapshots. *)
Definition deliver_with_inv_example
(deliver : val) (i: nat) (z : socket_address) : iProp Σ :=
(⌜RCB_addresses !! i = Some z⌝ -∗
{{{ inv LInv (∃ s, OwnLocal i s) }}}
deliver #() @[ip_of_address z]
{{{ (vo : val), RET vo;
(⌜vo = NONEV⌝ ∨
(∃ (s : lstate) (v: val) (e : le),
⌜vo = SOMEV v⌝
∗ ⌜is_le v e⌝
∗ ⌜e ∉ s⌝
∗ ⌜(LE_origin e) ≠ i⌝
∗ OwnGlobalSnapshot ({[ erasure e ]})
∗ ⌜e ∈ compute_maximals LE_vc (s ∪ {[ e ]})⌝))
}}})%I.
Lemma deliver_spec_implies_inv_example deliver i z :
deliver_spec deliver i z ⊢ deliver_with_inv_example deliver i z.
Proof.
iIntros "#Hdel".
rewrite /deliver_with_inv_example.
iIntros "#Haddr !>" (Φ) "#Hinv HΦ".
iApply "Hdel"; [done |].
(* Before we intro the mask as in the sequential case, we have to open
the local invariant. *)
iInv LInv as "> Hloc" "Hcl". iDestruct "Hloc" as (s) "Hloc".
iApply fupd_mask_intro; [set_solver |]. iIntros "Hmask".
iExists s; iFrame. iIntros "!>" (s' vo) "[Hloc Hopt]".
iMod "Hmask". iMod ("Hcl" with "[Hloc]") as "_".
{ eauto with iFrame. }
iModIntro.
iApply "HΦ". iDestruct "Hopt" as "[[? ?] | Hsome]".
- eauto with iFrame.
- iDestruct "Hsome" as (a) "(-> & ? & ? & ? & ? & Hv)".
iDestruct "Hv" as (v) "[-> ?]".
eauto 15 with iFrame.
Qed.
Definition broadcast_with_inv_example
(broadcast : val) (i: nat) (z : socket_address)
(v : SerializableVal) : iProp Σ :=
(⌜RCB_addresses !! i = Some z⌝ -∗
{{{ inv LInv (∃ h s, OwnGlobal h ∗ OwnLocal i s) }}}
broadcast v @[ip_of_address z]
{{{ (w : val), RET w;
∃ (a : le) h s,
⌜LE_payload a = v⌝ ∗
⌜LE_origin a = i⌝ ∗
⌜is_le w a⌝ ∗
⌜compute_maximum LE_vc (s ∪ {[ a ]}) = Some a⌝ ∗
let e := erasure a in
⌜e ∈ compute_maximals GE_vc (h ∪ {[ e ]})⌝ }}})%I.
Lemma broadcast_spec_implies_inv_example broadcast i z :
broadcast_spec broadcast i z ⊢ ∀ v, broadcast_with_inv_example broadcast i z v.
Proof.
iIntros "#Hbr" (v).
rewrite /broadcast_with_inv_example.
iIntros (Hi Φ) "!> #HInv HΦ".
iApply "Hbr"; [done |].
iInv LInv as "> Hinv" "Hcl".
iDestruct "Hinv" as (h s) "[Hglob Hloc]".
iApply fupd_mask_intro; [set_solver|]. iIntros "Hmask".
iExists h, s; iFrame.
iIntros "!>" (w a) "(? & ? & ? & ? & ? & ? & ? & Hloc & Hglob)".
iMod "Hmask". iMod ("Hcl" with "[Hloc Hglob]").
{ eauto with iFrame. }
iModIntro. iApply "HΦ".
eauto with iFrame.
Qed.
End DeliverBroadcastInvExample.
(** Modular specification for causal memory
vector-clock based implementation. *)
Class RCBG `{!RCB_events} Σ := {
RCBG_global_history_excl :> inG Σ (prodR fracR (agreeR (gsetO ge)));
RCBG_global_history_pers :> inG Σ (authUR (gsetUR ge));
RCBG_local_history_excl :> inG Σ (prodR fracR (agreeR (gsetO le)));
RCBG_lockG :> lockG Σ;
}.
Definition RCBΣ `{!RCB_events} : gFunctors :=
#[GFunctor (prodR fracR (agreeR (gsetO ge)));
GFunctor (authUR (gsetUR ge));
GFunctor (prodR fracR (agreeR (gsetO le)));
lockΣ].
Instance subG_RCBΣ `{!RCB_events} {Σ} : subG RCBΣ Σ → RCBG Σ.
Proof. econstructor; solve_inG. Qed.
Class RCB_init_function := { init : val }.
Section Init.
Context `{!anerisG Mdl Σ, !RCB_params, !RCB_events, !RCBG Σ, !RCB_init_function}.
Class RCB_init := {
RCB_init_events :> RCB_events;
RCB_init_setup E :
True ⊢ |={E}=> ∃ (RCBRS : RCB_resources Mdl Σ),
GlobalInv ∗
([∗ list] i ↦ _ ∈ RCB_addresses, init_token i) ∗
(OwnGlobal ∅) ∗
init_spec init;
}.
End Init.
Section Helpers.
Context `{!anerisG Mdl Σ, !RCB_params, !RCB_events, !RCB_resources Mdl Σ}.
(** Definition and specification of a deliver procedure that actively waits until a message is
delivered. *)
Definition wait_deliver : val :=
λ: "deliver",
rec: "wd" <> :=
match: "deliver" #() with
NONE => "wd" #()
| SOME "m" => "m"
end.
Definition wait_deliver_spec
(wait_deliver : val) (i: nat) (z : socket_address) : iProp Σ :=
⌜RCB_addresses !! i = Some z⌝ -∗
□ (∀ (Φ : val -> iProp Σ),
□ (|={⊤, ↑RCB_InvName}=>
∃ (s : lstate),
OwnLocal i s ∗
((OwnLocal i s ={↑RCB_InvName, ⊤}=∗ emp) ∧
(∀ (a : le) (v : val),
let s' := s ∪ {[ a ]} in
⌜a ∉ s⌝ -∗
⌜a ∈ compute_maximals LE_vc s'⌝ -∗
⌜is_le v a⌝ -∗
OwnLocal i s' -∗
OwnGlobalSnapshot {[ erasure a ]} ={↑RCB_InvName, ⊤}=∗
Φ v))) -∗
WP wait_deliver #() @[ip_of_address z] {{ Φ }}
).
Lemma deliver_spec_implies_wait_deliver_spec
(deliver : val) (i : nat) (z : socket_address) :
{{{ deliver_spec deliver i z }}}
wait_deliver deliver @[ip_of_address z]
{{{ wd, RET wd; wait_deliver_spec wd i z }}}.
Proof.
iIntros (Φ) "#Hdeliver HΦ".
unfold wait_deliver. wp_pures. iApply "HΦ".
clear Φ.
iIntros "#Hi !>" (Φ) "#Hvs".
iLöb as "IH".
wp_rec.
wp_apply "Hdeliver"; [done |].
iMod "Hvs". iModIntro.
iDestruct "Hvs" as (s) "[Hloc Hvs]".
iExists s; iFrame. iModIntro.
iIntros (s' vo) "[Hloc' [[-> ->] | Hsome]]".
- iMod ("Hvs" with "Hloc'") as "_".
iModIntro. wp_match.
iApply "IH".
- iDestruct "Hsome" as (a) "(-> & #? & #? & #? & #? & Hv)".
iDestruct "Hv" as (v) "[-> #?]".
iDestruct "Hvs" as "[_ Hvs]".
iMod ("Hvs" with "[] [] [] Hloc' []") as "Hvs"; eauto with iFrame.
iModIntro. wp_pures. iFrame.
Qed.
Definition simplified_wait_deliver_spec
(deliver : val) (i: nat) (z : socket_address) : iProp Σ :=
Eval simpl in
∀ (s : lstate),
⌜RCB_addresses !! i = Some z⌝ -∗
{{{ OwnLocal i s }}}
deliver #() @[ip_of_address z]
{{{ e v, RET v; let s' := s ∪ {[ e ]} in
⌜is_le v e⌝
∗ OwnLocal i s'
∗ ⌜e ∉ s⌝
∗ ⌜(LE_origin e) ≠ i⌝
∗ OwnGlobalSnapshot ({[ erasure e ]})
∗ ⌜e ∈ compute_maximals LE_vc s'⌝
}}}.
Lemma deliver_spec_implies_simplified_wait_deliver_spec
(deliver : val) (i : nat) (z : socket_address) :
{{{ deliver_spec deliver i z }}}
wait_deliver deliver @[ip_of_address z]
{{{ wd, RET wd; simplified_wait_deliver_spec wd i z }}}.
Proof.
iIntros (Φ) "Hdeliver HΦ".
iPoseProof (deliver_spec_implies_simplified_spec with "Hdeliver") as "#Hsimpl".
unfold wait_deliver. wp_pures. iApply "HΦ".
clear Φ.
iIntros (s) "#Hi !>".
iIntros (Φ) "HLoc HΦ".
iLöb as "IH".
wp_rec.
wp_apply ("Hsimpl" with "Hi HLoc").
iIntros (vo) "[HNone | HSome]".
- iDestruct "HNone" as "[-> HLoc]".
wp_match.
iApply ("IH" with "HLoc HΦ").
- iDestruct "HSome" as (v e) "(-> & H)".
wp_pures.
iApply "HΦ". iAssumption.
Qed.
End Helpers.
|
Formal statement is: lemma polynomial_function_minus [intro]: assumes f: "polynomial_function f" shows "polynomial_function (\<lambda>x. - f x)" Informal statement is: If $f$ is a polynomial function, then so is $-f$. |
-- This file just tests that the options --no-save-metas and
-- --save-metas are parsed correctly.
{-# OPTIONS --no-save-metas --save-metas #-}
|
Require Import VST.veric.juicy_base.
Require Import VST.veric.juicy_mem VST.veric.juicy_mem_lemmas VST.veric.juicy_mem_ops.
Require Import VST.veric.res_predicates.
Require Import VST.veric.extend_tc.
Require Import VST.veric.Clight_seplog.
Require Import VST.veric.Clight_assert_lemmas.
Require Import VST.veric.Clight_core.
Require Import VST.sepcomp.extspec.
Require Import VST.sepcomp.step_lemmas.
Require Import VST.veric.tycontext.
Require Import VST.veric.expr2.
Require Import VST.veric.expr_lemmas.
Require Import VST.veric.juicy_extspec.
Require Import VST.veric.semax.
Require Import VST.veric.Clight_lemmas.
Require Import VST.veric.own.
Import Ctypes.
Local Open Scope pred.
#[export] Hint Resolve now_later andp_derives sepcon_derives : core.
Lemma no_dups_swap:
forall F V a b c, @no_dups F V (a++b) c -> @no_dups F V (b++a) c.
Proof.
unfold no_dups; intros.
rewrite map_app in *.
forget (map (@fst _ _) b) as bb.
forget (map (@fst _ _) a) as aa.
forget (map (var_name V) c) as cc.
clear - H.
destruct (list_norepet_append_inv _ _ _ H) as [? [? ?]].
apply list_norepet_append; auto.
apply list_norepet_append_commut; auto.
clear - H2.
unfold Coqlib.list_disjoint in *.
intros; apply H2; auto.
clear - H.
rewrite in_app in *.
tauto.
Qed.
Lemma join_sub_share_top: forall sh, join_sub Share.top sh -> sh = Share.top.
Proof.
intros.
generalize (top_correct' sh); intro.
apply join_sub_antisym; auto.
Qed.
Lemma opt2list2opt: forall {A:Type} (l: option A), list2opt (opt2list l) = l.
destruct l; auto.
Qed.
Lemma nat_of_Z_minus_le : forall z a b,
b <= a ->
(Z.to_nat (z - a) <= Z.to_nat (z - b))%nat.
Proof.
intros.
apply inj_le_rev.
do 2 rewrite Z_to_nat_max.
rewrite Coqlib.Zmax_spec.
destruct (zlt 0 (z-a)).
rewrite Coqlib.Zmax_spec.
destruct (zlt 0 (z-b)).
lia.
lia.
rewrite Coqlib.Zmax_spec.
destruct (zlt 0 (z-b)); lia.
Qed.
Section SemaxContext.
Lemma universal_imp_unfold {A} {agA: ageable A}:
forall B (P Q: B -> pred A) w,
(ALL psi : B, P psi --> Q psi) w = (forall psi : B, (P psi --> Q psi) w).
Proof.
intros.
apply prop_ext; split; intros.
eapply H; eauto.
intro b; apply H.
Qed.
Lemma guard_environ_put_te':
forall ge te ve Delta id v k,
guard_environ Delta k (mkEnviron ge ve te) ->
(forall t,
(temp_types Delta) ! id = Some t -> tc_val' t v) ->
guard_environ Delta k (mkEnviron ge ve (Map.set id v te)).
Proof.
intros.
destruct H; split.
apply typecheck_environ_put_te; auto.
destruct k; auto.
Qed.
Lemma prop_imp_derives {A}{agA: ageable A}:
forall (P: Prop) (Q Q': pred A), (P -> Q |-- Q') -> !!P --> Q |-- !!P --> Q'.
Proof.
intros.
repeat intro.
apply H; auto.
Qed.
Lemma prop_imp {A}{agA: ageable A}:
forall (P: Prop) (Q Q': pred A), (P -> Q = Q') -> !!P --> Q = !!P --> Q'.
Proof.
intros.
apply pred_ext; apply prop_imp_derives.
+ intros; rewrite H by auto; auto.
+ intros; rewrite H by auto; auto.
Qed.
Lemma age_laterR {A} `{ageable A}: forall {x y}, age x y -> laterR x y.
Proof.
intros. constructor 1; auto.
Qed.
Local Hint Resolve age_laterR : core.
Lemma typecheck_environ_sub:
forall Delta Delta', tycontext_sub Delta Delta' ->
forall rho,
typecheck_environ Delta' rho -> typecheck_environ Delta rho.
Proof.
intros ? ? [? [? [? [? Hs]]]] ? [? [? ?]].
split; [ | split].
* clear - H H3.
hnf; intros.
specialize (H id); rewrite H0 in H.
destruct ((temp_types Delta') ! id) eqn:?H; try contradiction.
destruct H; subst.
specialize (H3 id ty H1).
destruct H3 as [v [? ?]].
exists v; split; auto.
* clear - H0 H4.
red in H4|-*.
intros id ty. specialize (H4 id ty). rewrite <- H4.
rewrite H0. clear; tauto.
* clear - H2 H5.
hnf; intros. eapply H5.
specialize (H2 id). hnf in H2. rewrite H in H2. eauto.
Qed.
Lemma funassert_resource: forall Delta rho a a' (Hl: level a = level a')
(Hr: resource_at a = resource_at a'),
funassert Delta rho a -> funassert Delta rho a'.
Proof.
intros.
destruct H as [H1 H2]; split; repeat intro. (*rename H into H1; repeat intro.*)
- destruct (H1 _ _ _ (rt_refl _ _ _) H0) as (b1 & ? & ?).
exists b1; split; auto.
destruct b0; simpl in *.
rewrite Hr in H4.
pose proof (necR_level _ _ H).
eapply necR_PURE in H; eauto.
rewrite H; simpl; f_equal; f_equal.
extensionality i a0 a1 a2.
match goal with |-context[compcert_rmaps.R.approx ?a (approx ?b ?c)] =>
change (compcert_rmaps.R.approx a (approx b c)) with ((approx a oo approx b) c) end.
rewrite fmap_app, approx_oo_approx', approx'_oo_approx by lia; auto.
- specialize (H2 b b0 b1). clear H1.
destruct b0; simpl in *.
apply (H2 _ (rt_refl _ _ _)).
rewrite Hr, Hl.
destruct H0 as [p Hp].
pose proof (necR_level _ _ H).
rewrite <- resource_at_approx.
eapply necR_PURE' in H as [? ->]; simpl; eauto.
Qed.
Lemma cl_corestep_fun: forall ge m q m1 q1 m2 q2,
cl_step ge q m q1 m1 ->
cl_step ge q m q2 m2 ->
(q1,m1)=(q2,m2).
Proof.
intros.
inv H; inv H0; repeat fun_tac; auto;
repeat match goal with H: _ = _ \/ _ = _ |- _ => destruct H; try discriminate end;
try contradiction.
-
inversion2 H1 H16; fun_tac; auto.
-
rewrite andb_true_iff in H15; destruct H15.
pose proof (ef_deterministic_fun _ H0 _ _ _ _ _ _ _ _ _ H3 H17).
inv H4; auto.
-
inv H1. inv H8.
fun_tac.
pose proof (alloc_variables_fun H3 H7). inv H8. auto.
-
rewrite andb_true_iff in H1; destruct H1.
pose proof (ef_deterministic_fun _ H0 _ _ _ _ _ _ _ _ _ H2 H13).
inv H1; auto.
Qed.
Lemma age1_resource_decay:
forall jm jm', age jm jm' -> resource_decay (nextblock (m_dry jm)) (m_phi jm) (m_phi jm').
Proof.
intros. split.
apply age_level in H.
change (level (m_phi jm)) with (level jm).
change (level (m_phi jm')) with (level jm').
lia.
intro l. split. apply juicy_mem_alloc_cohere. left.
symmetry; apply age1_resource_at with (m_phi jm); eauto.
destruct (age1_juicy_mem_unpack _ _ H); auto.
symmetry; apply resource_at_approx.
Qed.
Lemma jsafeN_local_step:
forall {Espec: OracleKind} ge ora s1 m s2,
cl_step ge s1 (m_dry m) s2 (m_dry m) ->
(forall m', age m m' ->
jsafeN (@OK_spec Espec) ge (level m') ora s2 m') ->
jsafeN (@OK_spec Espec) ge (level m) ora s1 m.
Proof.
intros.
rename H into Hstep.
remember (level m) as N.
destruct N; [constructor|].
case_eq (age1 m); [intros m' H | intro; apply age1_level0 in H; lia].
eapply jsafeN_step with
(m'0 := m').
split3.
replace (m_dry m') with (m_dry m) by (destruct (age1_juicy_mem_unpack _ _ H); auto).
apply Hstep.
apply age1_resource_decay; auto. split; [apply age_level; auto|].
apply age_jm_phi in H.
erewrite (age1_ghost_of _ _ H) by (symmetry; apply ghost_of_approx).
unfold level at 1; simpl.
repeat intro; auto.
assert (N = level m')%nat.
apply age_level in H; lia.
apply jm_bupd_intro.
subst. apply H0. auto.
Qed.
Lemma derives_skip:
forall {CS: compspecs} {Espec: OracleKind} p Delta (R: ret_assert),
(forall rho, p rho |-- proj_ret_assert R EK_normal None rho) ->
semax Espec Delta p Clight.Sskip R.
Proof.
intros ? ? ? ?; intros.
intros n.
rewrite semax_fold_unfold.
intros psi Delta' CS'.
apply prop_imp_i; intros [? HGG].
clear H0 Delta. rename Delta' into Delta.
intros ?w _ _. clear n.
intros k F f.
intros ?w _ ?.
clear w. rename w0 into n.
intros te ve w ?.
destruct H0 as [H0' H0].
specialize (H0 EK_normal None te ve w H1).
simpl exit_cont in H0.
simpl in H0'. clear n H1. remember ((construct_rho (filter_genv psi) ve te)) as rho.
revert w H0.
apply imp_derives; auto.
apply andp_derives; auto.
apply andp_derives; auto.
repeat intro.
simpl.
split; auto.
specialize (H rho). destruct R; simpl in H. simpl tycontext.RA_normal.
rewrite prop_true_andp in H by auto.
rewrite sepcon_comm.
eapply sepcon_derives; try apply H0; auto.
repeat intro.
destruct (H0 _ H1) as (b & ? & m' & ? & ? & ? & HP); clear H0.
exists b; split; auto; exists m'; repeat split; auto.
simpl.
intros ? ? ? ? ? ?.
specialize (HP ora jm H0 H6 H7 LW).
simpl in HP.
rewrite <- H7 in HP|-*.
change (level (m_phi jm)) with (level jm) in HP|-*.
destruct k as [ | s ctl' | | | |]; try contradiction; auto.
-
inv HP; try contradiction.
change (level jm) with (level (m_phi jm)); rewrite <- H9.
constructor.
change (level jm) with (level (m_phi jm)); rewrite <- H8.
eapply jsafeN_step; eauto.
destruct H9; split; auto.
inv H5.
econstructor; eauto.
simpl. auto.
inv H9.
-
eapply jsafeN_local_step. constructor.
intros.
eapply age_safe in HP; try apply H8.
auto.
-
eapply jsafeN_local_step. constructor.
intros.
eapply age_safe in HP; try apply H8.
auto.
-
inv HP; try contradiction.
change (level jm) with (level (m_phi jm)); rewrite <- H9.
constructor.
change (level jm) with (level (m_phi jm)); rewrite <- H8.
eapply jsafeN_step; eauto.
destruct H9; split; auto.
inv H5.
econstructor; eauto.
simpl. auto.
inv H9.
Qed.
Lemma semax_unfold {CS: compspecs} {Espec: OracleKind}:
semax Espec = fun Delta P c R =>
forall (psi: Clight.genv) Delta' CS' (w: nat)
(TS: tycontext_sub Delta Delta')
(HGG: cenv_sub (@cenv_cs CS) (@cenv_cs CS') /\ cenv_sub (@cenv_cs CS') (genv_cenv psi))
(Prog_OK: @believe CS' Espec Delta' psi Delta' w) (k: cont) (F: assert) f,
closed_wrt_modvars c F ->
rguard Espec psi Delta' f (frame_ret_assert R F) k w ->
guard Espec psi Delta' f (fun rho => F rho * P rho) (Kseq c k) w.
Proof.
unfold semax; rewrite semax_fold_unfold.
extensionality Delta P c R.
apply prop_ext; split; intros.
+ eapply (H w); eauto.
- split; auto.
- split; trivial.
+ intros psi Delta' CS'.
apply prop_imp_i; intros [? HGG].
intros w' ? ? k F f w'' ? [? ?].
apply (H psi Delta' CS' w'' H0 HGG); trivial.
eapply pred_nec_hereditary; eauto.
Qed.
Fixpoint list_drop (A: Type) (n: nat) (l: list A) {struct n} : list A :=
match n with O => l | S i => match l with nil => nil | _ :: l' => list_drop A i l' end end.
Arguments list_drop [A] _ _.
Definition straightline (c: Clight.statement) :=
forall ge f ve te k m f' ve' te' c' k' m',
cl_step ge (State f c k ve te) m (State f' c' k' ve' te') m' -> (c'=Sskip /\ k=k').
Lemma straightline_assign: forall e0 e, straightline (Clight.Sassign e0 e).
Proof.
unfold straightline; intros.
inv H; auto.
destruct H13; inv H; auto.
destruct H13; inv H; auto.
Qed.
Lemma extract_exists_pre_later {CS: compspecs} {Espec: OracleKind}:
forall (A : Type) (Q: assert) (P : A -> assert) c Delta (R: ret_assert),
(forall x, semax Espec Delta (fun rho => Q rho && |> P x rho) c R) ->
semax Espec Delta (fun rho => Q rho && |> exp (fun x => P x rho)) c R.
Proof.
rewrite semax_unfold in *.
intros.
intros.
intros te ve ?w ? ?w ? ?.
destruct H4.
destruct H4.
destruct H6 as [w2 [w3 [? [? [HQ ?]]]]].
destruct (age1 w2) as [w2' | ] eqn:?.
*
destruct (@age1_join _ _ _ _ _ _ _ _ H6 Heqo)
as [w3' [w1' [? [? ?]]]].
hnf in H8.
specialize (H8 _ (age_laterR H10)).
destruct H8 as [x H8].
specialize (H x psi Delta' CS' w TS HGG Prog_OK k F f H0 H1).
unfold guard, _guard in H.
specialize (H te ve).
cbv beta in H.
specialize (H w0 H2 w1 H3).
apply H.
split; auto. split; auto.
exists w2, w3. split3; auto.
split; auto.
intros w3x ?.
eapply pred_nec_hereditary; [ | apply H8].
clear - H10 H12.
eapply age_later_nec; eauto.
*
assert (level w1 = O). {
clear - H6 Heqo.
apply join_level in H6. destruct H6.
rewrite <- H. apply age1_level0. auto.
}
hnf.
intros.
eexists; split.
apply H10.
exists w1.
split3; auto. split; auto.
simpl.
hnf; intros.
rewrite H9.
constructor.
Qed.
Lemma extract_exists_pre {CS: compspecs} {Espec: OracleKind}:
forall (A : Type) (P : A -> assert) c Delta (R: ret_assert),
(forall x, semax Espec Delta (P x) c R) ->
semax Espec Delta (fun rho => exp (fun x => P x rho)) c R.
Proof.
rewrite semax_unfold in *.
intros.
intros.
intros te ve ?w ? ?w ? ?.
rewrite exp_sepcon2 in H4.
destruct H4 as [[TC [x H5]] ?].
specialize (H x).
specialize (H psi Delta' CS' w TS HGG Prog_OK k F f H0).
spec H. {
clear - H1.
unfold rguard in *.
intros ek vl tx vx. specialize (H1 ek vl tx vx).
red in H1.
eapply subp_trans'; [| apply H1 ].
apply derives_subp.
apply andp_derives; auto.
}
eapply H; eauto.
split; auto.
split; auto.
Qed.
Definition G0: funspecs := nil.
Definition empty_genv prog_pub cenv: Clight.genv :=
Build_genv (Genv.globalenv (AST.mkprogram (F:=Clight.fundef)(V:=type) nil prog_pub (1%positive))) cenv.
Lemma empty_program_ok {CS: compspecs} {Espec: OracleKind}: forall Delta ge w,
glob_specs Delta = PTree.empty _ ->
believe Espec Delta ge Delta w.
Proof.
intros Delta ge w ?.
intro b.
intros fsig cc A P Q.
intros ?n ? ?.
destruct H1 as [id [? [b0 [? ?]]]].
rewrite H in H1. rewrite PTree.gempty in H1.
inv H1.
Qed.
Definition all_assertions_computable :=
forall (Espec: OracleKind) psi f tx vx (Q: assert),
exists k, assert_safe Espec psi f tx vx k = Q.
(* This is not generally true, but could be made true by adding an "assert" operator
to the programming language
*)
Lemma ewand_TT_emp {A} {JA: Join A}{PA: Perm_alg A}{SA: Sep_alg A}{CA: Canc_alg A}:
ewand TT emp = emp.
Proof.
intros.
apply pred_ext; intros w ?.
destruct H as [w1 [w3 [? [? ?]]]].
hnf; eapply split_identity.
eapply join_comm; eauto.
auto.
exists w; exists w; split; auto.
change (identity w) in H.
apply identity_unit'; auto.
Qed.
Lemma subp_derives' {A}{agA: ageable A}:
forall P Q: pred A, (forall n, (P >=> Q) n) -> P |-- Q.
Proof.
intros.
intros n ?. eapply H; eauto.
Qed.
Lemma guard_environ_sub:
forall {Delta Delta' f rho},
tycontext_sub Delta Delta' ->
guard_environ Delta' f rho ->
guard_environ Delta f rho.
Proof.
intros.
destruct H0; split; auto.
eapply typecheck_environ_sub; eauto.
destruct f; auto.
destruct H1; split; auto.
destruct H as [? [? [? ?]]]. rewrite H4; auto.
Qed.
Lemma proj_frame_ret_assert:
forall (R: ret_assert) (F: assert) ek vl,
proj_ret_assert (frame_ret_assert R F) ek vl =
seplog.sepcon (proj_ret_assert R ek vl) F.
Proof.
intros; extensionality rho; destruct R, ek; simpl;
rewrite ?sepcon_andp_prop1; auto.
Qed.
Lemma semax_extensionality0 {CS: compspecs} {Espec: OracleKind}:
TT |--
ALL Delta:tycontext, ALL Delta':tycontext,
ALL P:assert, ALL P':assert,
ALL c: statement, ALL R:ret_assert, ALL R':ret_assert,
((!! tycontext_sub Delta Delta'
&& (ALL ek: exitkind, ALL vl : option val, ALL rho: environ,
(proj_ret_assert R ek vl rho >=> proj_ret_assert R' ek vl rho))
&& (ALL rho:environ, P' rho >=> P rho) && semax' Espec Delta P c R) >=> semax' Espec Delta' P' c R').
Proof.
apply loeb.
intros w ? Delta Delta' P P' c R R'.
intros w1 ? w2 ? [[[? ?] ?] ?].
do 3 red in H2.
rewrite semax_fold_unfold; rewrite semax_fold_unfold in H5.
intros gx Delta'' CS'.
apply prop_imp_i. intros [TS HGG].
intros w3 ? ?.
specialize (H5 gx Delta'' CS' _ (necR_refl _)
(conj (tycontext_sub_trans _ _ _ H2 TS) HGG)
_ H6 H7).
intros k F f w4 Hw4 [? ?].
specialize (H5 k F f w4 Hw4).
assert ((rguard Espec gx Delta'' f (frame_ret_assert R F) k) w4).
do 9 intro.
apply (H9 b b0 b1 b2 y H10 a' H11).
destruct H12; split; auto; clear H13.
pose proof I.
destruct H12; split; auto.
rewrite proj_frame_ret_assert in H14|-*.
clear H12 H13.
revert a' H11 H14.
apply sepcon_subp' with (level w2).
apply H3.
auto.
apply necR_level in H6.
apply necR_level in Hw4.
eapply le_trans; try eassumption.
eapply le_trans; try eassumption.
specialize (H5 (conj H8 H10)). clear H8 H9 H10.
do 7 intro.
apply (H5 b b0 y H8 _ H9).
destruct H10; split; auto.
destruct H10; split; auto.
clear H10 H11.
revert a' H9 H12.
apply sepcon_subp' with (level w2); auto.
apply necR_level in H6.
apply necR_level in Hw4.
eapply le_trans; try eassumption.
eapply le_trans; try eassumption.
Qed.
Lemma semax_extensionality1 {CS: compspecs} {Espec: OracleKind}:
forall Delta Delta' (P P': assert) c (R R': ret_assert) ,
tycontext_sub Delta Delta' ->
((ALL ek: exitkind, ALL vl : option val, ALL rho: environ,
(proj_ret_assert R ek vl rho >=> proj_ret_assert R' ek vl rho))
&& (ALL rho:environ, P' rho >=> P rho) && (semax' Espec Delta P c R) |-- semax' Espec Delta' P' c R').
Proof.
intros.
intros n ?.
apply (semax_extensionality0 n I Delta Delta' P P' c R R' _ (le_refl _) _ (necR_refl _)).
destruct H0;
split; auto.
destruct H0;
split; auto.
split; auto.
Qed.
Lemma semax_frame {CS: compspecs} {Espec: OracleKind}: forall Delta P s R F,
closed_wrt_modvars s F ->
semax Espec Delta P s R ->
semax Espec Delta (fun rho => P rho * F rho) s (frame_ret_assert R F).
Proof.
intros until F. intros CL H.
rewrite semax_unfold.
rewrite semax_unfold in H.
intros.
pose (F0F := fun rho => F0 rho * F rho).
specialize (H psi Delta' CS' w TS HGG Prog_OK k F0F f).
spec H. {
unfold F0F.
clear - H0 CL.
hnf in *; intros; simpl in *.
rewrite <- CL. rewrite <- H0. auto.
tauto. tauto.
}
replace (fun rho : environ => F0 rho * (P rho * F rho))
with (fun rho : environ => F0F rho * P rho).
*
apply H.
unfold F0F; clear - H1.
intros ek vl tx vx; specialize (H1 ek vl tx vx).
red in H1.
remember ((construct_rho (filter_genv psi) vx tx)) as rho.
red.
hnf; intros. specialize (H1 _ H).
hnf; intros. apply H1; auto.
destruct H2; split; auto. destruct H2; split; auto.
rewrite proj_frame_ret_assert in H4|-*.
rewrite proj_frame_ret_assert.
rewrite seplog.sepcon_assoc.
eapply sepcon_derives; try apply H4; auto. simpl.
rewrite sepcon_comm; auto.
*
unfold F0F.
extensionality rho.
rewrite sepcon_assoc.
f_equal. apply sepcon_comm.
Qed.
Lemma assert_safe_last:
forall {Espec: OracleKind} f ge ve te c k rho w,
(forall w', age w w' -> assert_safe Espec f ge ve te (Cont (Kseq c k)) rho w) ->
assert_safe Espec f ge ve te (Cont (Kseq c k)) rho w.
Proof.
intros.
case_eq (age1 w). auto.
clear H.
intro; apply bupd_intro; repeat intro.
apply age1_level0 in H. lia.
Qed.
Lemma pred_sub_later' {A} `{H: ageable A}:
forall (P Q: pred A),
(|> P >=> |> Q) |-- (|> (P >=> Q)).
Proof.
intros.
rewrite later_fash; auto.
rewrite later_imp.
auto.
Qed.
Lemma later_strengthen_safe1:
forall {Espec: OracleKind} (P: pred rmap) f ge ve te k rho,
((|> P) >=> assert_safe Espec f ge ve te k rho) |-- |> (P >=> assert_safe Espec f ge ve te k rho).
Proof.
intros.
intros w ?.
apply (@pred_sub_later' _ _ P (assert_safe Espec f ge ve te k rho)); auto.
eapply subp_trans'; try apply H.
apply derives_subp; clear.
apply now_later.
Qed.
End SemaxContext.
#[export] Hint Resolve age_laterR : core.
Fixpoint filter_seq (k: cont) : cont :=
match k with
| Kseq s k1 => filter_seq k1
| _ => k
end.
Fixpoint app_cont (k1 k2: cont) : cont :=
match k1 with
| Kstop => k2
| Kseq c k1' => Kseq c (app_cont k1' k2)
| Kloop1 c1 c2 k1' => Kloop1 c1 c2 (app_cont k1' k2)
| Kloop2 c1 c2 k1' => Kloop2 c1 c2 (app_cont k1' k2)
| Kswitch k1' => Kswitch (app_cont k1' k2)
| Kcall i f ve te k1' => Kcall i f ve te (app_cont k1' k2)
end.
Lemma cons_app: forall x y,
Kseq x y = app_cont (Kseq x Kstop) y.
Proof. auto. Qed.
Lemma cons_app': forall x y z,
Kseq x (app_cont y z) = app_cont (Kseq x y) z.
Proof. auto. Qed.
Fixpoint length_cont (k: cont) :=
match k with
| Kstop => O
| Kseq _ k' => S (length_cont k')
| Kloop1 _ _ k' => S (length_cont k')
| Kloop2 _ _ k' => S (length_cont k')
| Kswitch k' => S (length_cont k')
| Kcall _ _ _ _ k' => S (length_cont k')
end.
Lemma app_cont_length: forall k1 k2,
length_cont (app_cont k1 k2) = (length_cont k1 + length_cont k2)%nat.
Proof.
induction k1; simpl; intros; auto.
Qed.
Lemma cat_prefix_empty:
forall prefix ctl, ctl = app_cont prefix ctl -> prefix = Kstop.
Proof.
intros.
pose proof (app_cont_length prefix ctl).
rewrite <- H in H0.
assert (length_cont prefix = O) by lia.
clear - H1.
destruct prefix; inv H1; auto.
Qed.
Definition true_expr : Clight.expr := Clight.Econst_int Int.one (Tint I32 Signed noattr).
(*
(* BEGIN Lemmas duplicated from Clight_sim. v *)
Lemma dec_skip: forall s, {s=Sskip}+{s<>Sskip}.
Proof.
destruct s; try (left; congruence); right; congruence.
Qed.
Lemma strip_step: (* This one uses equality, one in Clight_sim uses <-> *)
forall ge ve te k m st' m',
cl_step ge (State ve te (strip_skip k)) m st' m' =
cl_step ge (State ve te k) m st' m'.
Proof.
intros.
apply prop_ext.
induction k; intros; split; simpl; intros; try destruct IHk; auto.
destruct a; try destruct s; auto.
constructor; auto.
destruct a; try destruct s; auto.
inv H. auto.
Qed.
(* END lemmas duplicated *)
Lemma strip_skip_app:
forall k k', strip_skip k = nil -> strip_skip (k++k') = strip_skip k'.
Proof. induction k; intros; auto. destruct a; inv H. destruct s; inv H1; auto.
simpl. apply IHk. auto.
Qed.
Lemma strip_strip: forall k, strip_skip (strip_skip k) = strip_skip k.
Proof.
induction k; simpl.
auto.
destruct a; simpl; auto.
destruct (dec_skip s).
subst; auto.
destruct s; auto.
Qed.
Lemma strip_skip_app_cons:
forall {k c l}, strip_skip k = c::l -> forall k', strip_skip (k++k') = c::l++k'.
Proof. intros. revert k H; induction k; intros. inv H.
destruct a; try solve [simpl in *; auto];
try solve [simpl in *; rewrite cons_app'; rewrite H; auto].
destruct (dec_skip s). subst. simpl in *; auto.
destruct s; inv H; simpl; auto.
Qed.
Lemma filter_seq_current_function:
forall ctl1 ctl2, filter_seq ctl1 = filter_seq ctl2 ->
current_function ctl1 = current_function ctl2.
Proof.
intros ? ? H0. revert ctl2 H0; induction ctl1; simpl; intros.
revert H0; induction ctl2; simpl; intros; try destruct a; try congruence; auto.
destruct a; auto; revert H0; induction ctl2; simpl; intros; try destruct a; try congruence; auto.
Qed.
*)
Lemma filter_seq_call_cont:
forall ctl1 ctl2, filter_seq ctl1 = filter_seq ctl2 -> call_cont ctl1 = call_cont ctl2.
Proof.
intros ? ? H0.
revert ctl2 H0; induction ctl1; simpl; intros; auto;
revert H0; induction ctl2; simpl; intros; try destruct a; try congruence; auto.
Qed.
Lemma call_cont_app_nil:
forall l k, call_cont l = Kstop -> call_cont (app_cont l k) = call_cont k.
Proof.
intros l k; revert k; induction l; simpl; intros;
try destruct a; simpl in *; try congruence; auto.
Qed.
Lemma call_cont_app_cons:
forall l, call_cont l <> Kstop ->
forall k, call_cont (app_cont l k) = app_cont (call_cont l) k.
Proof.
induction l; simpl; intros; try congruence; auto.
Qed.
Lemma and_FF : forall {A} `{ageable A} (P:pred A),
P && FF = FF.
Proof.
intros. rewrite andp_comm. apply FF_and.
Qed.
Lemma sepcon_FF : forall {A}{JA: Join A}{PA: Perm_alg A}{AG: ageable A}{XA: Age_alg A} (P:pred A),
(P * FF = FF)%pred.
Proof.
intros. rewrite sepcon_comm. apply FF_sepcon.
Qed.
Section extensions.
Lemma safe_loop_skip:
forall {Espec: OracleKind}
ge ora f ve te k m,
jsafeN (@OK_spec Espec) ge (level m) ora
(State f (Sloop Clight.Sskip Clight.Sskip) k ve te ) m.
Proof.
intros.
pose (M := level m).
assert (Hge: (M >= level m)%nat) by lia.
clearbody M.
revert m Hge; induction M; intros.
assert (level m = O) by lia. rewrite H.
constructor.
eapply jsafeN_local_step. constructor.
intros.
eapply jsafeN_local_step. constructor. auto.
intros.
eapply jsafeN_local_step. constructor.
intros.
apply IHM.
apply age_level in H. apply age_level in H0. apply age_level in H1. lia.
Qed.
(*
Lemma safe_seq_skip {Espec: OracleKind} ge n ora ve te k m :
jsafeN OK_spec ge n ora (State ve te k) m ->
jsafeN OK_spec ge n ora (State ve te (Kseq Sskip :: k)) m.
Proof.
inversion 1; subst. constructor.
econstructor; eauto. simpl. destruct H0 as (?&?&?). split3; eauto.
eapply step_skip; eauto.
simpl in *; congruence.
contradiction.
Qed.
Lemma safe_seq_skip' {Espec: OracleKind} ge n ora ve te k m :
jsafeN OK_spec ge n ora (State ve te (Kseq Sskip :: k)) m ->
jsafeN OK_spec ge n ora (State ve te k) m.
Proof.
inversion 1; subst. constructor.
econstructor; eauto. simpl. destruct H0 as (?&?&?). split3; eauto.
inv H0; auto.
simpl in *; congruence.
contradiction.
Qed.
*)
Local Open Scope nat_scope.
Definition control_as_safex {Espec: OracleKind} ge c1 k1 c2 k2 :=
forall (ora : OK_ty) f (ve : env) (te : temp_env) (m : juicy_mem),
jsafeN (@OK_spec Espec) ge (level m) ora (State f c1 k1 ve te) m ->
jsafeN (@OK_spec Espec) ge (level m) ora (State f c2 k2 ve te) m.
Definition control_as_safe {Espec: OracleKind} ge ctl1 ctl2 :=
match ctl1, ctl2 with
| Kseq c1 k1, Kseq c2 k2 =>
control_as_safex ge c1 k1 c2 k2
| Kseq c1 k1, Kloop1 _ _ _ =>
control_as_safex ge c1 k1 Sskip ctl2
| Kseq c1 k1, Kloop2 body incr k2 =>
control_as_safex ge c1 k1 (Sloop body incr) k2
| Kseq c1 k1, Kstop =>
control_as_safex ge c1 k1 (Sreturn None) Kstop
| Kseq c1 k1, Kcall _ _ _ _ _ =>
control_as_safex ge c1 k1 (Sreturn None) ctl2
| Kseq _ _, _ =>
False
| Kloop1 _ _ _, Kseq c2 k2 =>
control_as_safex ge Sskip ctl1 c2 k2
| Kloop1 _ _ _, Kloop1 _ _ _ =>
control_as_safex ge Sskip ctl1 Sskip ctl2
| Kloop1 _ _ _, Kloop2 body incr k2 =>
control_as_safex ge Sskip ctl1 (Sloop body incr) k2
| Kloop1 _ _ _, _ =>
False
| Kloop2 b1 i1 k1, Kseq c2 k2 =>
control_as_safex ge (Sloop b1 i1) k1 c2 k2
| Kloop2 b1 i1 k1, Kloop1 _ _ _ =>
control_as_safex ge (Sloop b1 i1) k1 Sskip ctl2
| Kloop2 b1 i1 k1, Kloop2 b2 i2 k2 =>
control_as_safex ge (Sloop b1 i1) k1 (Sloop b2 i2) k2
| Kloop2 _ _ _, _ =>
False
| Kstop, Kseq c2 k2 =>
control_as_safex ge (Sreturn None) Kstop c2 k2
| Kcall _ _ _ _ _, Kseq c2 k2=>
control_as_safex ge (Sreturn None) ctl1 c2 k2
| _, _ => ctl1 = ctl2
end.
Fixpoint prebreak_cont (k: cont) : cont :=
match k with
| Kloop1 s e3 k' => k
| Kseq s k' => prebreak_cont k'
| Kloop2 s e3 k' => k
| Kswitch k' => k
| _ => Kstop (* stuck *)
end.
Lemma prebreak_cont_is: forall k,
match (prebreak_cont k) with
| Kloop1 _ _ _ => True
| Kloop2 _ _ _ => True
| Kswitch _ => True
| Kstop => True
| _ => False
end.
Proof.
induction k; simpl; auto.
Qed.
Lemma app_cont_ass: forall j k l,
app_cont (app_cont j k) l = app_cont j (app_cont k l).
Proof.
intros.
induction j; simpl; f_equal; auto.
Qed.
Lemma find_label_prefix:
forall lbl s ctl s' k, find_label lbl s ctl = Some (s',k) ->
exists j, Kseq s' k = app_cont j ctl
with
find_label_ls_prefix:
forall lbl s ctl s' k, find_label_ls lbl s ctl = Some (s',k) ->
exists j, Kseq s' k = app_cont j ctl.
Proof.
-
intros.
clear find_label_prefix.
revert ctl k H; induction s; simpl; intros; try congruence.
+ revert H; case_eq (find_label lbl s1 (Kseq s2 ctl)); intros; [inv H0 | auto ].
destruct (IHs1 _ _ H) as [j ?].
exists (app_cont j (Kseq s2 Kstop)); rewrite app_cont_ass; auto.
+ revert H; case_eq (find_label lbl s1 ctl); intros; [inv H0 | auto ]; auto.
+ destruct (find_label lbl s1 (Kloop1 s1 s2 ctl)) eqn:H0; inv H.
apply IHs1 in H0. destruct H0 as [j ?]. exists (app_cont j (Kloop1 s1 s2 Kstop)).
rewrite app_cont_ass. auto.
apply IHs2 in H2. destruct H2 as [j ?].
exists (app_cont j (Kloop2 s1 s2 Kstop)). rewrite app_cont_ass; auto.
+ destruct (find_label_ls_prefix _ _ _ _ _ H) as [j ?].
exists (app_cont j (Kswitch Kstop)); rewrite app_cont_ass; auto.
+
if_tac in H. subst l. inv H.
exists (Kseq s' Kstop); auto.
apply IHs; auto.
-
induction s; simpl; intros. inv H.
destruct (find_label lbl s (Kseq (seq_of_labeled_statement s0) ctl)) eqn:?H.
inv H.
destruct (find_label_prefix _ _ _ _ _ H0) as [j ?].
exists (app_cont j (Kseq (seq_of_labeled_statement s0) Kstop)).
rewrite app_cont_ass; auto.
auto.
Qed.
Lemma find_label_None:
forall lbl s ctl, find_label lbl s ctl = None -> forall ctl', find_label lbl s ctl' = None
with
find_label_ls_None:
forall lbl s ctl, find_label_ls lbl s ctl = None -> forall ctl', find_label_ls lbl s ctl' = None.
Proof.
clear find_label_None; induction s; simpl; intros; try congruence;
try match type of H with match ?A with Some _ => _| None => _ end = _
=> revert H; case_eq A; intros; [inv H0 | ]
end;
try (rewrite (IHs1 _ H); eauto).
eauto.
destruct (ident_eq lbl l). inv H. eapply IHs; eauto.
clear find_label_ls_None; induction s; simpl; intros; try congruence;
try match type of H with match ?A with Some _ => _| None => _ end = _
=> revert H; case_eq A; intros; [inv H0 | ]
end;
try (rewrite (IHs1 _ H); eauto).
eauto.
rewrite (find_label_None _ _ _ H). eauto.
Qed.
Lemma guard_safe_adj {Espec: OracleKind}:
forall
psi Delta f P c1 k1 c2 k2,
(forall ora m ve te n,
jsafeN (@OK_spec Espec) psi n ora (State f c1 k1 ve te) m ->
jsafeN (@OK_spec Espec) psi n ora (State f c2 k2 ve te) m) ->
guard Espec psi Delta f P (Kseq c1 k1) |-- guard Espec psi Delta f P (Kseq c2 k2).
Proof.
intros.
unfold guard.
apply allp_derives. intros tx.
apply allp_derives. intros vx.
apply subp_derives; auto.
apply bupd_mono.
intros w ? ? ? ? .
simpl in H0.
specialize (H0 ora jm H1).
simpl.
intros.
apply H; auto.
Qed.
Lemma guard_safe_adj' {Espec: OracleKind}:
forall
psi Delta f P c1 k1 c2 k2,
(forall ora m ve te,
jsafeN (@OK_spec Espec) psi (level m) ora (State f c1 k1 ve te) m ->
jsafeN (@OK_spec Espec) psi (level m) ora (State f c2 k2 ve te) m) ->
guard Espec psi Delta f P (Kseq c1 k1) |-- guard Espec psi Delta f P (Kseq c2 k2).
Proof.
intros.
unfold guard.
apply allp_derives. intros tx.
apply allp_derives. intros vx.
apply subp_derives; auto.
apply bupd_mono.
simpl.
intros ? ? ? ? ? ? ? ?.
simpl in H0.
subst.
apply H; auto.
Qed.
Lemma assert_safe_adj:
forall {Espec: OracleKind} ge f ve te k k' rho,
control_as_safe ge k k' ->
assert_safe Espec ge f ve te (Cont k) rho
|-- assert_safe Espec ge f ve te (Cont k') rho.
Proof.
intros. apply bupd_mono.
simpl in *.
intros w ?. simpl in H0|-*.
intros ? ?. specialize (H0 ora jm).
intros. specialize (H0 H1 H2 H3 LW).
simpl in H0.
subst w. change (level (m_phi jm)) with (level jm).
red in H.
destruct k as [ | s ctl' | | | |] eqn:Hk; try contradiction;
destruct k' as [ | s2 ctl2' | | | |] eqn:Hk'; try contradiction;
try discriminate; auto;
try solve [apply H; auto].
inv H; auto.
Qed.
Lemma assert_safe_adj':
forall {Espec: OracleKind} ge f ve te k k' rho P w,
(control_as_safe ge k k') ->
app_pred (P >=> assert_safe Espec ge f ve te (Cont k) rho) w ->
app_pred (P >=> assert_safe Espec ge f ve te (Cont k') rho) w.
Proof.
intros.
eapply subp_trans'; [ | apply derives_subp; eapply assert_safe_adj; try eassumption; eauto].
auto.
Qed.
Lemma assert_safe_last': forall {Espec: OracleKind} ge f ve te c k rho w,
(age1 w <> None -> assert_safe Espec ge f ve te (Cont (Kseq c k)) rho w) ->
assert_safe Espec ge f ve te (Cont (Kseq c k)) rho w.
Proof.
intros. apply assert_safe_last; intros. apply H. rewrite H0. congruence.
Qed.
Lemma pjoinable_emp_None {A}{JA: Join A}{PA: Perm_alg A}{SA: Sep_alg A}:
forall w: option (psepalg.lifted JA), identity w -> w=None.
Proof.
intros.
destruct w; auto.
elimtype False.
specialize (H None (Some l)).
spec H.
constructor.
inversion H.
Qed.
Lemma pjoinable_None_emp {A}{JA: Join A}{PA: Perm_alg A}{SA: Sep_alg A}:
identity (None: option (psepalg.lifted JA)).
Proof.
intros; intro; intros.
inv H; auto.
Qed.
Lemma unage_mapsto:
forall sh t v1 v2 w, age1 w <> None -> (|> mapsto sh t v1 v2) w -> mapsto sh t v1 v2 w.
Proof.
intros.
case_eq (age1 w); intros; try contradiction.
clear H.
specialize (H0 _ (age_laterR H1)).
unfold mapsto in *.
revert H0; case_eq (access_mode t); intros; auto.
destruct (type_is_volatile t); try contradiction.
destruct v1; try contradiction.
rename H into Hmode.
if_tac; rename H into H_READ.
+ destruct H0 as [H0|H0]; [left | right].
destruct H0 as [H0' H0]; split; auto.
destruct H0 as [bl [[] ?]]; exists bl; split; [split|]; auto.
clear - H0 H1.
intro loc'; specialize (H0 loc').
hnf in *.
if_tac.
destruct H0 as [p ?]; exists p.
hnf in *.
rewrite preds_fmap_NoneP in *.
apply (age1_YES w r); auto.
unfold noat in *; simpl in *.
apply <- (age1_resource_at_identity _ _ loc' H1); auto.
eapply age1_ghost_of_identity; eauto.
destruct H0 as [? [v2' [bl [[] ?]]]].
hnf in H. subst v2. split; hnf; auto. exists v2', bl; split; [split|]; auto.
clear - H2 H1; rename H2 into H0.
intro loc'; specialize (H0 loc').
hnf in *.
if_tac.
destruct H0 as [p ?]; exists p.
hnf in *.
rewrite preds_fmap_NoneP in *.
apply (age1_YES w r); auto.
unfold noat in *; simpl in *.
apply <- (age1_resource_at_identity _ _ loc' H1); auto.
eapply age1_ghost_of_identity; eauto.
+ split; [exact (proj1 H0) |].
destruct H0 as [_ [? Hg]].
split; [|eapply age1_ghost_of_identity; eauto].
intro loc'; specialize (H loc').
hnf in *.
if_tac.
- unfold shareat in *; simpl in *.
pose proof H1.
apply age1_resource_share with (l := loc') in H1.
apply age1_nonlock with (l := loc') in H2.
rewrite H1; tauto.
- unfold noat in *; simpl in *.
apply <- (age1_resource_at_identity _ _ loc' H1); auto.
Qed.
Lemma semax_Delta_subsumption {CS: compspecs} {Espec: OracleKind}:
forall Delta Delta' P c R,
tycontext_sub Delta Delta' ->
semax Espec Delta P c R -> semax Espec Delta' P c R.
Proof.
intros.
unfold semax in *.
intros.
specialize (H0 n).
apply (semax_extensionality1 Delta Delta' P P c R R); auto.
split; auto.
split; auto.
intros ? ? ?; auto.
Qed.
End extensions.
Definition Cnot (e: Clight.expr) : Clight.expr :=
Clight.Eunop Cop.Onotbool e type_bool.
(* Mutually recursive induction scheme for [statement] and [labeled_statements] *)
Section statement_rect.
Variable P : statement -> Type.
Variable Q : labeled_statements -> Type.
Variable f : P Sskip.
Variable f0 : forall e e0 : expr, P (Sassign e e0).
Variable f1 : forall (i : ident) (e : expr), P (Sset i e).
Variable f2 : forall (o : option ident) (e : expr) (l : list expr), P (Scall o e l).
Variable f3 : forall (o : option ident) (e : external_function) (t : typelist) (l : list expr), P (Sbuiltin o e t l).
Variable f4 : forall s : statement, P s -> forall s0 : statement, P s0 -> P (Ssequence s s0).
Variable f5 : forall (e : expr) (s : statement), P s -> forall s0 : statement, P s0 -> P (Sifthenelse e s s0).
Variable f6 : forall s : statement, P s -> forall s0 : statement, P s0 -> P (Sloop s s0).
Variable f7 : P Sbreak.
Variable f8 : P Scontinue.
Variable f9 : forall o : option expr, P (Sreturn o).
Variable f10 : forall (e : expr) (l : labeled_statements), Q l -> P (Sswitch e l).
Variable f11 : forall (l : label) (s : statement), P s -> P (Slabel l s).
Variable f12 : forall l : label, P (Sgoto l).
Variable f13 : Q LSnil.
Variable f14 : forall (o : option Z) (s : statement) (l : labeled_statements), P s -> Q l -> Q (LScons o s l).
Fixpoint statement_rect (s : statement) : P s :=
match s as s0 return (P s0) with
| Sskip => f
| Sassign e e0 => f0 e e0
| Sset i e => f1 i e
| Scall o e l => f2 o e l
| Sbuiltin o e t l => f3 o e t l
| Ssequence s0 s1 => f4 s0 (statement_rect s0) s1 (statement_rect s1)
| Sifthenelse e s0 s1 => f5 e s0 (statement_rect s0) s1 (statement_rect s1)
| Sloop s0 s1 => f6 s0 (statement_rect s0) s1 (statement_rect s1)
| Sbreak => f7
| Scontinue => f8
| Sreturn o => f9 o
| Sswitch e l => f10 e l (labeled_statements_rect l)
| Slabel l s0 => f11 l s0 (statement_rect s0)
| Sgoto l => f12 l
end
with labeled_statements_rect (l : labeled_statements) : Q l :=
match l as l0 return (Q l0) with
| LSnil => f13
| LScons o s l0 => f14 o s l0 (statement_rect s) (labeled_statements_rect l0)
end.
End statement_rect.
Require Import VST.msl.eq_dec.
(* Equality is decidable on statements *)
Section eq_dec.
Local Ltac t := hnf; decide equality; auto.
Let eq_dec_type := type_eq.
Let eq_dec_float := Float.eq_dec.
Let eq_dec_float32 := Float32.eq_dec.
Let eq_dec_int := Int.eq_dec.
Let eq_dec_int64 := Int64.eq_dec.
Let eq_dec_ident := ident_eq.
Let eq_dec_signature := signature_eq.
Let eq_dec_attr : EqDec attr. repeat t. Defined.
Let eq_dec_signedness : EqDec signedness. t. Defined.
Let eq_dec_intsize : EqDec intsize. t. Defined.
Let eq_dec_floatsize : EqDec floatsize. t. Defined.
Let eq_dec_Z : EqDec Z. repeat t. Defined.
Let eq_dec_calling_convention : EqDec calling_convention. repeat t. Defined.
Lemma eq_dec_external_function : EqDec external_function. repeat t. Defined.
Let eq_dec_option_ident := option_eq (ident_eq).
Let eq_dec_option_Z : EqDec (option Z). repeat t. Defined.
Let eq_dec_typelist : EqDec typelist. repeat t. Defined.
Lemma eq_dec_expr : EqDec expr.
Proof. repeat t. Defined.
Let eq_dec_expr := eq_dec_expr.
Let eq_dec_option_expr : EqDec (option expr). repeat t. Defined.
Let eq_dec_list_expr : EqDec (list expr). repeat t. Defined.
Local Ltac eq_dec a a' :=
let H := fresh in
assert (H : {a = a'} + {a <> a'}) by (auto; repeat (decide equality ; auto));
destruct H; [subst; auto | try (right; congruence)].
Lemma eq_dec_statement : forall s s' : statement, { s = s' } + { s <> s' }.
Proof.
apply
(statement_rect
(fun s => forall s', { s = s' } + { s <> s' })
(fun l => forall l', { l = l' } + { l <> l' }));
try (intros until s'; destruct s'); intros;
try (destruct l');
try solve [right; congruence | left; reflexivity];
repeat
match goal with
| |- context [ ?x ?a = ?x ?b ] => eq_dec a b
| |- context [ ?x ?y ?a = ?x ?y ?b ] => eq_dec a b
| |- context [ ?x ?a _ = ?x ?b _ ] => eq_dec a b
| |- context [ ?x ?y ?z ?a = ?x ?y ?z ?b ] => eq_dec a b
| |- context [ ?x ?y ?a _ = ?x ?y ?b _ ] => eq_dec a b
| |- context [ ?x ?a _ _ = ?x ?b _ _ ] => eq_dec a b
| |- context [ ?x ?y ?z ?t ?a = ?x ?y ?z ?t ?b ] => eq_dec a b
| |- context [ ?x ?y ?z ?a _ = ?x ?y ?z ?b _ ] => eq_dec a b
| |- context [ ?x ?y ?a _ _ = ?x ?y ?b _ _ ] => eq_dec a b
| |- context [ ?x ?a _ _ _ = ?x ?b _ _ _ ] => eq_dec a b
end.
Defined.
Lemma eq_dec_labeled_statements : forall l l' : labeled_statements, { l = l' } + { l <> l' }.
Proof.
decide equality.
apply eq_dec_statement.
Defined.
End eq_dec.
Instance EqDec_statement: EqDec statement := eq_dec_statement.
Instance EqDec_external_function: EqDec external_function := eq_dec_external_function.
Lemma closed_Slabel l c F: closed_wrt_modvars (Slabel l c) F = closed_wrt_modvars c F.
Proof. unfold closed_wrt_modvars. rewrite modifiedvars_Slabel. trivial. Qed.
Lemma closed_Sifthenelse b c1 c2 F: closed_wrt_modvars (Sifthenelse b c1 c2) F <-> closed_wrt_modvars c1 F /\ closed_wrt_modvars c2 F.
Proof.
unfold closed_wrt_modvars.
pose proof modifiedvars_Sifthenelse b c1 c2.
pose proof modifiedvars_computable c1 as TC.
forget (modifiedvars (Sifthenelse b c1 c2)) as S.
forget (modifiedvars c1) as S1.
forget (modifiedvars c2) as S2.
clear b c1 c2.
unfold closed_wrt_vars.
split; [intros; split; intros | intros [? ?]; intros].
+ apply H0.
intros.
specialize (H1 i).
specialize (H i).
clear - H H1.
tauto.
+ apply H0.
intros.
specialize (H1 i).
specialize (H i).
clear - H H1.
tauto.
+ specialize (TC (te_of rho) te').
destruct TC as [te'' [? ?]].
transitivity (F (mkEnviron (ge_of rho) (ve_of rho) te'')).
- apply H1.
clear H0 H1.
intros.
specialize (H3 i).
specialize (H i).
specialize (H2 i).
specialize (H4 i).
destruct H2; [| rewrite <- H0 in *]; tauto.
- change (mkEnviron (ge_of rho) (ve_of rho) te') with (mkEnviron (ge_of (mkEnviron (ge_of rho) (ve_of rho) te'')) (ve_of (mkEnviron (ge_of rho) (ve_of rho) te'')) te').
change te'' with (te_of (mkEnviron (ge_of rho) (ve_of rho) te'')) in H3, H4, H2.
forget (mkEnviron (ge_of rho) (ve_of rho) te'') as rho'.
apply H0.
clear H0 H1 H2 H3 H te''.
intros.
specialize (H4 i).
destruct H4; [auto | right; congruence].
Qed.
Lemma closed_Sloop c1 c2 F: closed_wrt_modvars (Sloop c1 c2) F <-> closed_wrt_modvars c1 F /\ closed_wrt_modvars c2 F.
Proof.
unfold closed_wrt_modvars.
pose proof modifiedvars_Sloop c1 c2.
pose proof modifiedvars_computable c1 as TC.
forget (modifiedvars (Sloop c1 c2)) as S.
forget (modifiedvars c1) as S1.
forget (modifiedvars c2) as S2.
clear c1 c2.
unfold closed_wrt_vars.
split; [intros; split; intros | intros [? ?]; intros].
+ apply H0.
intros.
specialize (H1 i).
specialize (H i).
clear - H H1.
tauto.
+ apply H0.
intros.
specialize (H1 i).
specialize (H i).
clear - H H1.
tauto.
+ specialize (TC (te_of rho) te').
destruct TC as [te'' [? ?]].
transitivity (F (mkEnviron (ge_of rho) (ve_of rho) te'')).
- apply H1.
clear H0 H1.
intros.
specialize (H3 i).
specialize (H i).
specialize (H2 i).
specialize (H4 i).
destruct H2; [| rewrite <- H0 in *]; tauto.
- change (mkEnviron (ge_of rho) (ve_of rho) te') with (mkEnviron (ge_of (mkEnviron (ge_of rho) (ve_of rho) te'')) (ve_of (mkEnviron (ge_of rho) (ve_of rho) te'')) te').
change te'' with (te_of (mkEnviron (ge_of rho) (ve_of rho) te'')) in H3, H4, H2.
forget (mkEnviron (ge_of rho) (ve_of rho) te'') as rho'.
apply H0.
clear H0 H1 H2 H3 H te''.
intros.
specialize (H4 i).
destruct H4; [auto | right; congruence].
Qed.
Lemma closed_Ssequence c1 c2 F: closed_wrt_modvars (Ssequence c1 c2) F <-> closed_wrt_modvars c1 F /\ closed_wrt_modvars c2 F.
Proof.
unfold closed_wrt_modvars.
pose proof modifiedvars_Ssequence c1 c2.
pose proof modifiedvars_computable c1 as TC.
forget (modifiedvars (Ssequence c1 c2)) as S.
forget (modifiedvars c1) as S1.
forget (modifiedvars c2) as S2.
clear c1 c2.
unfold closed_wrt_vars.
split; [intros; split; intros | intros [? ?]; intros].
+ apply H0.
intros.
specialize (H1 i).
specialize (H i).
clear - H H1.
tauto.
+ apply H0.
intros.
specialize (H1 i).
specialize (H i).
clear - H H1.
tauto.
+ specialize (TC (te_of rho) te').
destruct TC as [te'' [? ?]].
transitivity (F (mkEnviron (ge_of rho) (ve_of rho) te'')).
- apply H1.
clear H0 H1.
intros.
specialize (H3 i).
specialize (H i).
specialize (H2 i).
specialize (H4 i).
destruct H2; [| rewrite <- H0 in *]; tauto.
- change (mkEnviron (ge_of rho) (ve_of rho) te') with (mkEnviron (ge_of (mkEnviron (ge_of rho) (ve_of rho) te'')) (ve_of (mkEnviron (ge_of rho) (ve_of rho) te'')) te').
change te'' with (te_of (mkEnviron (ge_of rho) (ve_of rho) te'')) in H3, H4, H2.
forget (mkEnviron (ge_of rho) (ve_of rho) te'') as rho'.
apply H0.
clear H0 H1 H2 H3 H te''.
intros.
specialize (H4 i).
destruct H4; [auto | right; congruence].
Qed.
Lemma closed_Sswitch e sl F:
closed_wrt_modvars (Sswitch e sl) F ->
(forall n, closed_wrt_modvars (seq_of_labeled_statement (select_switch (Int.unsigned n) sl)) F).
Proof.
intros.
unfold closed_wrt_modvars, closed_wrt_vars in *.
intros.
apply H.
intros.
specialize (H0 i); destruct H0; auto.
left.
eapply modifiedvars_Sswitch; eauto.
Qed.
Lemma semax_eq:
forall {CS: compspecs} {Espec: OracleKind} Delta P c R,
semax Espec Delta P c R =
(TT |-- (ALL psi : genv,
ALL Delta' : tycontext, ALL CS':compspecs,
!! (tycontext_sub Delta Delta' /\ cenv_sub (@cenv_cs CS) (@cenv_cs CS') /\
cenv_sub (@cenv_cs CS') (genv_cenv psi)) -->
@believe CS' Espec Delta' psi Delta' -->
ALL k : cont ,
ALL F : assert , ALL f: function,
!! closed_wrt_modvars c F &&
rguard Espec psi Delta' f (frame_ret_assert R F) k -->
guard Espec psi Delta' f (fun rho : environ => F rho * P rho) (Kseq c k))).
Proof.
intros.
extensionality w.
rewrite semax_fold_unfold.
apply prop_ext; intuition.
Qed.
Lemma semax_Slabel {cs:compspecs} {Espec: OracleKind}
(Gamma:tycontext) (P:environ -> mpred) (c:statement) (Q:ret_assert) l:
@semax cs Espec Gamma P c Q -> @semax cs Espec Gamma P (Slabel l c) Q.
Proof. intros.
rewrite semax_eq. rewrite semax_eq in H.
eapply derives_trans. eassumption. clear H.
apply allp_derives; intros psi.
apply allp_derives; intros Delta.
apply allp_derives; intros CS'.
apply prop_imp_derives; intros TC.
apply imp_derives; [ apply derives_refl | ].
apply allp_derives; intros k.
apply allp_derives; intros F.
apply allp_derives; intros f.
apply imp_derives; [ apply derives_refl | ].
apply guard_safe_adj'.
intros.
clear - H.
eapply jsafeN_local_step.
constructor.
intros.
eapply age_safe; eauto.
Qed.
Lemma denote_tc_resource: forall {cs: compspecs} rho a a' t, resource_at a = resource_at a' ->
denote_tc_assert t rho a -> denote_tc_assert t rho a'.
Proof.
induction t; auto; intros; simpl in *.
- destruct H0; auto.
- destruct H0; auto.
- unfold liftx in *; simpl in *.
unfold lift in *; simpl in *.
destruct (eval_expr e rho); auto; simpl in *; if_tac; auto.
- unfold liftx in *; simpl in *.
unfold lift in *; simpl in *.
destruct (eval_expr e rho); auto; simpl in *; if_tac; auto.
- unfold liftx in *; simpl in *.
unfold lift in *; simpl in *.
destruct (eval_expr e rho), (eval_expr e0 rho); auto; simpl in *.
+ simple_if_tac; auto.
destruct H0; split; auto.
destruct H1; [left | right]; simpl in *; rewrite <- H; auto.
+ simple_if_tac; auto.
destruct H0; split; auto.
destruct H1; [left | right]; simpl in *; rewrite <- H; auto.
+ unfold test_eq_ptrs in *.
destruct (sameblock _ _), H0; split; simpl in *; rewrite <- H; auto.
- unfold liftx in *; simpl in *.
unfold lift in *; simpl in *.
destruct (eval_expr e rho), (eval_expr e0 rho); auto; simpl in *.
unfold test_order_ptrs in *.
destruct (sameblock _ _), H0; split; simpl in *; rewrite <- H; auto.
- unfold liftx in *; simpl in *.
unfold lift in *; simpl in *.
destruct (eval_expr e rho); auto; simpl in *; if_tac; auto.
- unfold liftx in *; simpl in *.
unfold lift in *; simpl in *.
destruct (eval_expr e rho); auto; simpl in *; if_tac; auto.
- unfold liftx in *; simpl in *.
unfold lift in *; simpl in *.
destruct (eval_expr e rho); auto; simpl in *.
+ destruct (Zoffloat f); auto.
+ destruct (Zofsingle f); auto.
- unfold liftx in *; simpl in *.
unfold lift in *; simpl in *.
destruct (eval_expr e rho); auto; simpl in *.
+ destruct (Zoffloat f); auto.
+ destruct (Zofsingle f); auto.
- unfold liftx in *; simpl in *.
unfold lift in *; simpl in *.
destruct (eval_expr e rho), (eval_expr e0 rho); auto.
- unfold liftx in *; simpl in *.
unfold lift in *; simpl in *.
destruct (eval_expr e rho), (eval_expr e0 rho); auto.
Qed.
Lemma bupd_denote_tc: forall {cs: compspecs} P t rho a,
denote_tc_assert t rho a -> bupd P a -> bupd (denote_tc_assert t rho && P) a.
Proof.
repeat intro.
destruct (H0 _ H1) as (b & ? & m & ? & ? & ? & ?); subst.
eexists; split; eauto; exists m; repeat split; eauto.
eapply denote_tc_resource; [|eauto]; auto.
Qed.
Lemma assert_safe_jsafe: forall {Espec: OracleKind} ge f ve te c k ora jm,
assert_safe Espec ge f ve te (Cont (Kseq c k)) (construct_rho (filter_genv ge) ve te) (m_phi jm) ->
jm_bupd ora (jsafeN OK_spec ge (level jm) ora (State f c k ve te)) jm.
Proof.
repeat intro.
destruct (H _ H1) as (? & ? & ? & Hl & Hr & ? & Hsafe); subst.
do 2 red in Hsafe.
destruct (juicy_mem_resource _ _ Hr) as (jm' & ? & ?); subst.
exists jm'; repeat split; auto.
rewrite level_juice_level_phi, <- Hl.
destruct (gt_dec (level (m_phi jm')) O).
specialize (Hsafe ora jm').
apply Hsafe; auto.
eapply joins_comm, join_sub_joins_trans, joins_comm, H2.
destruct H0.
change (Some (ghost_PCM.ext_ref ora, NoneP) :: nil) with
(ghost_approx (m_phi jm) (Some (ghost_PCM.ext_ref ora, NoneP) :: nil)).
eexists; apply ghost_fmap_join; eauto.
replace (level (m_phi jm')) with O by lia. constructor.
Qed.
Lemma assert_safe_jsafe': forall {Espec: OracleKind} ge f ve te k ora jm,
assert_safe Espec ge f ve te (Cont k) (construct_rho (filter_genv ge) ve te) (m_phi jm) ->
jm_bupd ora (jsafeN OK_spec ge (level jm) ora (State f Sskip k ve te)) jm.
Proof.
intros.
repeat intro.
destruct (H _ H1) as (? & ? & ? & Hl & Hr & ? & Hsafe); subst.
simpl in Hsafe.
destruct (juicy_mem_resource _ _ Hr) as (jm' & ? & ?); subst.
exists jm'; repeat split; auto.
rewrite level_juice_level_phi, <- Hl.
specialize (Hsafe ora jm').
spec Hsafe. {
eapply joins_comm, join_sub_joins_trans, joins_comm, H2.
destruct H0.
change (Some (ghost_PCM.ext_ref ora, NoneP) :: nil) with
(ghost_approx (m_phi jm) (Some (ghost_PCM.ext_ref ora, NoneP) :: nil)).
eexists; apply ghost_fmap_join; eauto.
}
do 2 (spec Hsafe; [auto|]).
destruct (gt_dec (level (m_phi jm')) O).
2: replace (level (m_phi jm')) with O by lia; constructor.
spec Hsafe; [auto |].
destruct k; try contradiction; auto.
destruct (level (m_phi jm')); try lia.
inv Hsafe; try discriminate; try contradiction.
eapply jsafeN_step; eauto.
destruct H5; split; auto. inv H3; econstructor; simpl; eauto.
eapply jsafeN_local_step. constructor.
intros.
eapply age_safe; eauto.
eapply jsafeN_local_step. constructor.
intros.
eapply age_safe; eauto.
destruct (level (m_phi jm')); try lia.
inv Hsafe; try discriminate; try contradiction.
eapply jsafeN_step; eauto.
destruct H5; split; auto. inv H3; econstructor; simpl; eauto.
Qed.
Lemma jm_bupd_local_step
: forall {Espec: OracleKind} (ge : genv) (ora : OK_ty) (s1 : CC_core)
(m : juicy_mem) (s2 : CC_core),
cl_step ge s1 (m_dry m) s2 (m_dry m) ->
(forall m' : juicy_mem,
age m m' -> jm_bupd ora (jsafeN (@OK_spec Espec) ge (level m') ora s2) m') ->
jm_bupd ora (jsafeN (@OK_spec Espec) ge (level m) ora s1) m.
Proof.
intros.
destruct (age1 m) as [m' | ] eqn:?H.
Abort. |
\chapter{Making the Bibliography with BiB\TeX{}}\label{c:bib}
\index{Making the Bibliography with BiBTeX%
@\emph{Making the Bibliography with BiB\TeX{}}}%
BiB\TeX{}
\index{BiBTeX@BiB\TeX{}}%
allows one to generate automatically the bibliography
from a database of bibliographic
items. You need to do the following:
\begin{enumerate}
\item Create the bibliographic database,
\index{bibliographic database}%
which is a file whose name ends in \texttt{.bib}.
\index{.bib@\texttt{.bib}}%
Let us call it \texttt{diss.bib}. Entries in this file are like this:
\begin{verbatim}
@BOOK{knuth:tb,
author = "Donald K. Knuth",
title = "The \TeXbook",
publisher = "Addison-Wesley",
year = "1984",
}
@TECHREPORT{poorten:sp,
author = "Alf~J.~van der Poorten",
title = "Some problems of recurrent interest",
institution = "School of Mathematics and Physics,
Macquarie University",
address = "North Ryde, Australia 2113",
number = "81-0037",
month = "August",
year = "1981",
}
@ARTICLE{erdos:oap,
author = "Paul Erd{\"o}s and Paul Turan",
title = "On a problem in the theory of uniform
distribution, {I}",
journal = "Indag. Math.",
volume = "10",
year = "1948",
pages = "370--378",
}
\end{verbatim}
\item Include a \cn{bibliographystyle}
\index{commands!bibliographystyle@\cn{bibliographystyle}}%
command in your \LaTeX{} file, say
\cn{bibliographystyle\{plain\}}
and a \cn{bibliography}
\index{commands!bibliography@\cn{bibliography}}%
command to load the bibliography,
in this case \cn{bibliography\{diss\}}, at the point of your
document where the bibliography should be inserted.
The document at this point will look like this:
\begin{verbatim}
\bibliographystyle{plain}
\bibliography{diss}
\end{verbatim}
\item Run \LaTeX{} on your main file, say \texttt{foo.tex}:
\texttt{latex foo}. This generates an auxiliary file
\texttt{foo.aux} with a list of \cn{cite}
\index{commands!cite@\cn{cite}}
references.
\item Run BiB\TeX{} on your file: \texttt{bibtex foo}.
BiB\TeX{} reads the auxiliary file, looks up the
bibliographic database (\texttt{diss.bib}),
and writes a \texttt{.bbl}
\index{.bbl@\texttt{.bbl}}%
file with the bibliographic information formated according to
the bibliographic style file (\texttt{.bst},
\index{.bst@\texttt{.bst}}%
say \texttt{plain.bst})
\index{plain.bst@\texttt{plain.bst}}%
specified. Messages about resources used and error messages
are written to a \texttt{.blg}
\index{.blg@\texttt{.blg}}%
file (in the case of this template, disstemplate.blg).
\item Run \LaTeX{} again: \texttt{latex foo}, which now
reads the \texttt{.bbl}
\index{.bbl@\texttt{.bbl}}%
reference file.
\item Run \LaTeX{} for a third time: \texttt{latex foo},
resolving all references.
\end{enumerate}
This includes all bibliographic items that have been cited
in the document with a \cn{cite}
\index{commands!cite@\cn{cite}}%
command. In order to include non cited items in the bibliography,
use the command \cn{nocite}. For example, \cn{nocite\{knuth:tb\}}
anywhere in the document (after \cn{begin\{document\}}) includes
in the bibliography the item with label \texttt{knuth:tb}.
In order to include \emph{all} items of the bibliographic
database, use the command \cn{nocite\{*\}}.
\index{commands!nocite@\cn{nocite}}%
|
{-# OPTIONS --rewriting --without-K #-}
open import Prelude
open import GSeTT.Syntax
open import GSeTT.Rules
open import GSeTT.Uniqueness-Derivations
open import Sets ℕ eqdecℕ
open import GSeTT.Dec-Type-Checking
open import CaTT.Ps-contexts
open import CaTT.Relation
{- PS-contexts -}
module CaTT.Uniqueness-Derivations-Ps where
Γ⊢psx-dim≤ : ∀ {Γ x A} → Γ ⊢ps x # A → dim A ≤ dimC Γ
Γ⊢psx-dim≤ pss = n≤n 0
Γ⊢psx-dim≤ (psd Γ⊢psy) = Sn≤m→n≤m (Γ⊢psx-dim≤ Γ⊢psy)
Γ⊢psx-dim≤ {((Γ :: (_ , A)) :: (_ , _))} {_} {_} (pse Γ⊢psx idp idp idp idp idp) with dec-≤ (dimC (Γ :: (length Γ , A))) (S (dim A))
... | inr res = Sn≤m→n≤m (≰ res)
... | inl res = n≤n (S (dim A))
Γ⊢psx-dim : ∀ {Γ x y A B} → Γ ⊢ps x # A → Γ ⊢ps y # B → dim A == dim B → x == y
Γ⊢psx-dim pss pss dimA=dimB = idp
Γ⊢psx-dim {x = x} {y = y} {A = A} {B = B} (psd {x = x₁} Γ⊢psx) (psd {x = x₂} Γ⊢psy) dimA=dimB = =Var (tgt= (unique-type (Γ⊢psx:A→Γ⊢x:A Γ⊢psx) (Γ⊢psx:A→Γ⊢x:A Γ⊢psy) (ap Var (Γ⊢psx-dim Γ⊢psx Γ⊢psy (ap S dimA=dimB)))))
Γ⊢psx-dim {B = ∗} pss (psd Γ⊢psy) dimA=dimB = ⊥-elim (Sn≰n _ ((Γ⊢psx-dim≤ Γ⊢psy)))
Γ⊢psx-dim {A = ∗} (psd Γ⊢psx) pss dimA=dimB = ⊥-elim (Sn≰n _ ((Γ⊢psx-dim≤ Γ⊢psx)))
Γ⊢psx-dim (pse _ _ _ _ idp idp) (pse _ _ _ _ idp idp) dimA==dimB = idp
Γ⊢psx-dim Γ++⊢psx@(psd Γ++⊢_) Γ++⊢psy@(pse _ idp idp idp idp idp) dimA=dimB with psx-◃-linear→ Γ++⊢psx _ _ (Γ⊢x:A→x∈Γ (psvar Γ++⊢psx)) (Γ⊢x:A→x∈Γ (psvar Γ++⊢psy))
... | inl (inl x◃Sl) = ⊥-elim (Sn≰n-t (dimA=dimB ^) (⟿dim (psvar Γ++⊢psx) (psvar Γ++⊢psy) (⊢psx-◃→⟿ Γ++⊢psx x◃Sl)))
... | inl (inr Sl◃x) = ⊥-elim (Sn≰n-t (dimA=dimB) (⟿dim (psvar Γ++⊢psy) (psvar Γ++⊢psx) (⊢psx-◃→⟿ Γ++⊢psy Sl◃x)))
... | inr idp = idp
Γ⊢psx-dim Γ++⊢psx@(pse _ idp idp idp idp idp) Γ++⊢psy@(psd _) dimA=dimB with psx-◃-linear→ Γ++⊢psx _ _ (Γ⊢x:A→x∈Γ (psvar Γ++⊢psx)) (Γ⊢x:A→x∈Γ (psvar Γ++⊢psy))
... | inl (inl Sl◃y) = ⊥-elim (Sn≰n-t (dimA=dimB ^) (⟿dim (psvar Γ++⊢psx) (psvar Γ++⊢psy) (⊢psx-◃→⟿ Γ++⊢psx Sl◃y)))
... | inl (inr y◃Sl) = ⊥-elim (Sn≰n-t (dimA=dimB) (⟿dim (psvar Γ++⊢psy) (psvar Γ++⊢psx) (⊢psx-◃→⟿ Γ++⊢psy y◃Sl)))
... | inr idp = idp
has-all-paths-⊢psx : ∀ {Γ x A} → has-all-paths (Γ ⊢ps x # A)
has-all-paths-⊢psx pss pss = idp
has-all-paths-⊢psx (psd a) (psd b) with (Γ⊢psx-dim a b idp)
... | idp with unique-type (psvar a) (psvar b) idp
... | p = psd↓ a b (=Var (snd (fst (=⇒ p)))) (has-all-paths-⊢psx _ _)
has-all-paths-⊢psx pss (psd b) with (psvar b)
... | var _ (inl ())
... | var _ (inr ())
has-all-paths-⊢psx (psd a) pss with (psvar a)
... | var _ (inl ())
... | var _ (inr ())
has-all-paths-⊢psx (psd a) (pse b idp idp idp idp idp) with (psvar a)
... | var _ (inl (inl contra)) = ⊥-elim (l∉ (psv b) (n≤Sn _) (Γ⊢x:A→x∈Γ (Γ⊢tgt (Γ⊢t:A→Γ⊢A (var (psv b) contra)))))
has-all-paths-⊢psx (pse a idp idp idp idp idp) (psd b) with psvar b
... | var _ (inl (inl contra)) = ⊥-elim (l∉ (psv a) (n≤Sn _) (Γ⊢x:A→x∈Γ (Γ⊢tgt (Γ⊢t:A→Γ⊢A (var (psv a) contra)))))
has-all-paths-⊢psx (pse a idp idp idp idp idp) (pse b p q r s u) = let eq = =Var (snd (fst (=⇒ r))) in pse↓ a _ _ _ _ _ b _ _ _ _ _ eq (has-all-paths-⊢psx _ _)
has-all-paths-⊢ps : ∀ Γ → has-all-paths (Γ ⊢ps)
has-all-paths-⊢ps Γ (ps Γ⊢psx₁) (ps Γ⊢psx₂) = ps↓ Γ⊢psx₁ Γ⊢psx₂ (Γ⊢psx-dim Γ⊢psx₁ Γ⊢psx₂ idp) (has-all-paths-⊢psx _ _)
is-prop-⊢ps : ∀ Γ → is-prop (Γ ⊢ps)
is-prop-⊢ps Γ = has-all-paths-is-prop (has-all-paths-⊢ps Γ)
eqdec-ps : eqdec ps-ctx
eqdec-ps (Γ , Γ⊢ps) (Δ , Δ⊢ps) with eqdec-PreCtx Γ Δ
... | inl idp = inl (Σ= idp (is-prop-has-all-paths (is-prop-⊢ps Γ) _ _))
... | inr Γ≠Δ = inr λ{idp → Γ≠Δ idp}
|
export plot!, plot, scatter!, scatter,
fill_between!,
hist!, hist, bar!, bar,
boxplot, heatmap, heatmap_ticks
"""
plot_data(x)
plot_data(x, ys...)
I/ Preprocess data for a 2D plot.
"""
function plot_data(
x::AVM{<:CanMiss{<:Real}}
)::NamedTuple
isempty(x) && throw(
ArgumentError("Cannot display empty vectors.")
)
hasmissing = Missing <: eltype(x) ||
any(isinf, x) ||
any(isnan, x)
return (
data = zip(1:size(x, 1), eachcol(x)...),
hasmissing = hasmissing,
nobj = size(x, 2)
)
end
# NOTE: these typechecks within the function body is to avoid clashes/ambiguity with plot_data(x)
function plot_data(
x,
ys...
)::NamedTuple
isempty(x) && throw(
ArgumentError("Cannot display empty vectors.")
)
x isa AV{<:CanMiss{<:Real}} || throw(
ArgumentError("x has un-handled type $(typeof(x))")
)
nobj = 0
hasmissing = Missing <: eltype(x) ||
any(isinf, x) ||
any(isnan, x)
for y ∈ ys
y isa AVM{<:CanMiss{<:Real}} || throw(
ArgumentError("y has un-handled type $(typeof(y))")
)
size(y, 1) == length(x) || throw(
DimensionMismatch("y data must match x")
)
nobj += size(y, 2)
hasmissing |= Missing <: eltype(y) ||
any(isinf, y) ||
any(isnan, y)
end
return (
data = zip(x, (view(y, :, j) for y ∈ ys for j ∈ axes(y, 2))...),
hasmissing = hasmissing,
nobj = nobj
)
end
"""
fill_data(x, y1, y2)
I/ Preprocess data for a Fill2D.
"""
function fill_data(
x::AVR,
y1::Union{Real, AVR},
y2::Union{Real,AVR}
)::NamedTuple
isempty(x) && throw(
ArgumentError("Cannot display empty vectors.")
)
y1 isa AV || (y1 = fill(y1, length(x)))
y2 isa AV || (y2 = fill(y2, length(x)))
length(x) == length(y1) == length(y2) ||throw(
DimensionMismatch("vectors x,y1,y2 must have matching lengths"))
return (
data = zip(x, y1, y2),
)
end
"""
hist_data(x)
I/ Preprocess data for a Hist2D.
Missing values are allowed but are not counted as observations.
"""
function hist_data(
x::AV{<:CanMiss{<:Real}}
)::NamedTuple
isempty(x) && throw(
ArgumentError("Cannot have a histogram with an empty vector.")
)
sx = skipmissing(x)
isempty(sx) && throw(
ArgumentError("Cannot have a histogram with only missing values")
)
return (
data = zip(x),
hasmissing = (Missing <: eltype(x)),
nobs = sum(e -> 1, sx),
range = Float64.(extrema(sx))
)
end
#################################################################################
#################################################################################
"""
plot!(...)
E/ Add a plot. Keyword arguments can be passed to specify the linestyle(s),
label(s) and markerstyle(s).
## Example
x = range(-2, 2, length=100)
y = @. exp(-abs(x)+sin(x))
plot(x, y,
color = "blue",
lstyle = "--",
marker = "o",
lwidth = 0.05,
label = "First plot"
)
"""
function plot!(
x, ys...;
#
axes::Option{Axes2D} = nothing,
overwrite::Bool = false,
o...
)::DrawingHandle{<:Scatter2D}
# are current axes empty?
# -> if so don't do anything as the user may have pre-specified things
# like xlim etc and want the plot to appear with those
# -> if it's not empty, reset the axes (will destroy xlim settings etc
# as it should)
axes = check_axes(axes)
if overwrite && !all(isempty, (axes.drawings, axes.objects))
reset!(axes; parent=axes.parent)
end
# Form the scatter object
pd = plot_data(x, ys...)
scatter = Scatter2D(pd.data, pd.hasmissing, pd.nobj)
# Add properties & add scatter to axes
set_properties!(scatter; o...)
push!(axes.drawings, scatter)
return DrawingHandle(scatter)
end
function plot!(
f::Function,
from::Real,
to::Real;
#
length::Int = 100,
o...
)
x = range(from, stop=to, length=length)
plot!(x, f.(x); o...)
end
plot(a...; o...) = plot!(a...; overwrite=true, o...)
scatter!(a...; o...) = plot!(a...; ls="none", marker=".", o...)
scatter(a...; o...) = scatter!(a...; overwrite=true, o...)
"""
fill_between!(...)
Add a fill plot between two lines. The arguments must not have missings but
`y1` and/or `y2` can be specified as single numbers (= horizontal line).
"""
function fill_between!(
x, y1, y2;
#
axes::Option{Axes2D} = nothing,
overwrite::Bool = false,
o...
)::DrawingHandle{<:Fill2D}
axes = check_axes(axes)
if overwrite && !all(isempty, (axes.drawings, axes.objects))
reset!(axes; parent=axes.parent)
end
# form the fill2d object
fd = fill_data(x, y1, y2)
fill = Fill2D(fd)
set_properties!(fill; o...)
push!(axes.drawings, fill)
return DrawingHandle(fill)
end
fill_between(a...; o...) = fill_between!(a...; overwrite=true, o...)
"""
hist!(...)
Add a histogram of `x` on the current axes.
"""
function hist!(
x;
#
axes::Option{Axes2D} = nothing,
overwrite::Bool = false,
o...
)::DrawingHandle{<:Hist2D}
axes = check_axes(axes)
if overwrite
all(isempty, (axes.drawings, axes.objects)) || reset!(axes; parent=axes.parent)
end
hd = hist_data(x)
hist = Hist2D(hd.data, hd.hasmissing, hd.nobs, hd.range)
set_properties!(hist; o...)
push!(axes.drawings, hist)
return DrawingHandle(hist)
end
hist(a...; o...) = hist!(a...; overwrite=true, o...)
####
#### bar!, bar
####
"""
bar!(...)
Add a bar plot.
"""
function bar!(
x, ys...;
#
axes::Option{Axes2D} = nothing,
overwrite::Bool = false,
o...
)::DrawingHandle{<:Bar2D}
axes = check_axes(axes)
if overwrite
all(isempty, (axes.drawings, axes.objects)) || reset!(axes; parent=axes.parent)
end
bd = plot_data(x, ys...)
bar = Bar2D(bd.data, bd.hasmissing, bd.nobj)
set_properties!(bar; o...)
push!(axes.drawings, bar)
return DrawingHandle(bar)
end
bar(a...; o...) = bar!(a...; overwrite=true, o...)
#################################################################################
#################################################################################
#
# Extra drawings that are not meant to be overlaid with anything
# else such as boxplot, heatmap, polarplot, pieplot
#
"""
boxplot(...)
Erase previous drawings and add a boxplot. Missing values are allowed but not
Infinities or Nans.
"""
function boxplot(
ys...;
#
axes::Option{Axes2D} = nothing,
o...
)::DrawingHandle{Boxplot}
isempty(first(ys)) && throw(
ArgumentError("Cannot display empty vectors.")
)
# always on fresh axes
axes = check_axes(axes)
reset!(axes; parent=axes.parent)
# setting an empty struct first so that we can exploit the options
# the actual data will be provided after analysis
nobj = sum(size(y, 2) for y ∈ ys)
bp = Boxplot(Matrix{Float64}(undef,0,0), nobj)
set_properties!(bp; o...)
# analyse data
# 6 -> 1:wlow, 2:q25, 3:q50, 4:q75, 5:whigh, 6:mean
stats = Matrix{Float64}(undef, nobj, 6)
outliers = Vector{Vector{Float64}}(undef, nobj)
boxcounter = 1
axmin = Inf
axmax = -Inf
for y ∈ ys
for k ∈ Base.axes(y, 2)
yk = collect(skipmissing(view(y, :, k)))
if any(isnan, yk) || any(isinf, yk)
throw(
ArgumentError("Inf or NaN values not allowed in boxplot.")
)
end
q00, q25, q50, q75, q100 = quantile(yk, [.0, .25, .5, .75, 1.0])
iqr = q75 - q25
mu = mean(yk)
wrlength = bp.boxstyles[k].wrlength
wlow = q25 - wrlength * iqr
whigh = q75 + wrlength * iqr
if isinf(wrlength)
wlow, whigh = q00, q100 # min/max values
end
stats[k, :] = [wlow, q25, q50, q75, whigh, mu]
# outliers
outliers[k] = filter(e->(e<wlow || whigh<e), yk)
# Keep track of extremes to set axis limits afterwards
axmin_ = min(q00, wlow)
axmin_ -= 0.5abs(axmin_)
axmin_ < axmin && (axmin = axmin_)
axmax_ = max(q100, whigh)
axmax_ += 0.5abs(axmax_)
axmax_ > axmax && (axmax = axmax_)
boxcounter += 1
end
end
#
bp.stats = stats
push!(axes.drawings, bp)
if bp.horiz # horizontal boxplot
ylim(0, nobj+1)
yticks(1:nobj)
xlim(axmin, axmax)
for k ∈ 1:nobj
bp.boxstyles[k].oshow || continue
nok = length(outliers[k])
s = bp.boxstyles[k].omstyle # style of outliers
if nok > 0
scatter!(outliers[k], fill(k, nok); marker=s.marker, msize=s.msize, mcol=s.color)
end
end
else # vertical boxplot
xlim(0, nobj+1)
xticks(1:nobj)
ylim(axmin, axmax)
for k ∈ 1:nobj
bp.boxstyles[k].oshow || continue
nok = length(outliers[k])
s = bp.boxstyles[k].omstyle # style of outliers
if nok > 0
scatter!(fill(k, nok), outliers[k]; marker=s.marker, msize=s.msize, mcol=s.color)
end
end
end
return DrawingHandle(bp)
end
"""
heatmap_ticks(ax)
Returns ticks position centered appropriately for a heatmap.
### Example
heatmap(randn(2, 2))
xticks(heatmap_ticks("x"), ["var1", "var2"]; angle=45)
"""
function heatmap_ticks(
ax::String,
axes::Axes2D
)::Vector{F64}
# it must necessarily be the first object since heatmap resets the axes
(isempty(axes.drawings) || !(axes.drawings[1] isa Heatmap)) && throw(
ArgumentError("No heatmap found.")
)
nrows, ncols = size(axes.drawings[1].data)
ax_lc = lowercase(ax)
ax_lc ∈ ["x", "x2"] && return (collect(0:(ncols-1)) .+ 0.5) ./ ncols
ax_lc ∈ ["y", "y2"] && return (collect((nrows-1):-1:0) .+ 0.5) ./ nrows
throw(
ArgumentError("""
Unrecognised ax descriptor expected one of [x, x2, y, y2].
"""
)
)
end
heatmap_ticks(ax::String) = heatmap_ticks(ax, gca())
"""
heatmap(X; opts...)
Creates a heatmap corresponding to matrix `X`. Doing this with matrices larger
than 100x100 with the GLE backend can be slow. As an indication, 500x500 takes
about 15-20 seconds on a standard laptop. Time scales with the number of elements
with, as a rough order of magnitude, around 10k elements per second.
You can provide ticks using `xticks(heatmap_ticks("x"), ["tick1", ...]; o...)`.
See also `heatmap_ticks`.
Note: handles missing values but not NaN or Inf.
"""
function heatmap(
data::Matrix{<:CanMiss{Real}};
#
axes::Option{Axes2D} = nothing,
o...
)::DrawingHandle{Heatmap}
nrows, ncols = size(data)
min(nrows, ncols) <= 1000 || throw(
ArgumentError(
"""
The matrix is too large to be displayed as a heatmap.
"""
)
)
# always on fresh axes
axes = check_axes(axes)
reset!(axes; parent=axes.parent)
zmin, zmax = extrema(skipmissing(data))
h = Heatmap(data=Matrix{Int}(undef, 0, 0), zmin=zmin, zmax=zmax)
h.transpose = (nrows < ncols)
set_properties!(h; o...)
push!(axes.drawings, h)
ncolors = length(h.cmap)
minv, maxv = extrema(skipmissing(data))
incr = (maxv - minv) / ncolors
data2 = Matrix{Int}(undef, nrows, ncols)
if iszero(incr)
data2 .= ceil(ncols/2)
else
@inbounds for i=1:nrows, j=1:ncols
dij = data[i,j]
if ismissing(dij)
data2[i,j] = ncolors + 1 # offset doesn't matter, anything ≥ 1 is fine
else
data2[i,j] = ceil(Integer, (dij - minv) / incr)
end
end
end
# NOTE: there may be a few 0 (min values), will be treated as 1 see add_sub_heatmap!
# store the color assignments
h.data = data2
# set axis
xlim(0,1); ylim(0,1)
# add labels if provided to the heatmap object
xplaces = heatmap_ticks("x")
yplaces = heatmap_ticks("y")
# used for sparse labelling in case ncols > 20
stepx = (ncols<=50)*10 + (50<ncols<=200)*50 + (200<ncols)*100
lastx = ncols - mod(ncols, stepx) + 1
maskx = collect(1:stepx:lastx) .- 1
maskx[1] = 1
stepy = (nrows<=50)*10 + (50<nrows<=200)*50 + (200<nrows)*100
lasty = nrows - mod(nrows, stepy) + 1
masky = collect(1:stepy:lasty) .- 1
masky[1] = 1
if ncols <= 20
xticks(xplaces, ["$i" for i ∈ 1:ncols]; axes=axes, fontsize=12)
else
xticks(xplaces[maskx], ["$i" for i ∈ maskx]; axes=axes, fontsize=12)
end
if nrows <= 20
yticks(yplaces, ["$i" for i ∈ 1:nrows]; axes=axes, fontsize=12)
else
yticks(yplaces[masky], ["$i" for i ∈ masky]; axes=axes, fontsize=12)
end
x2ticks("off")
y2ticks("off")
return DrawingHandle(h)
end
|
subroutine runP_iiii(k,i1,i2,i3,i4,f,Gr,Shat5,N0)
implicit none
include 'pvDnames.f'
include 'pvDv.f'
include 'Darraydef.f'
include 'Darrays.f'
integer ep,N0,k,i1,i2,i3,i4,np
parameter(np=3)
double precision f(np),Gr(np,np)
double complex Shat5(np,z4max,-2:0)
do ep=-2,0
Dv(diiii(z4(i1,i2,i3,i4))+N0,ep)=
. (Shat5(k,z4(i1,i2,i3,i4),ep)
. -2d0*delta(k,i1)*Dv(dzziii(z3(i2,i3,i4))+N0,ep)
. -2d0*delta(k,i2)*Dv(dzziii(z3(i1,i3,i4))+N0,ep)
. -2d0*delta(k,i3)*Dv(dzziii(z3(i1,i2,i4))+N0,ep)
. -2d0*delta(k,i4)*Dv(dzziii(z3(i1,i2,i3))+N0,ep)
. -Gr(k,1)*Dv(diiiii(z5(1,i1,i2,i3,i4))+N0,ep)
. -Gr(k,2)*Dv(diiiii(z5(2,i1,i2,i3,i4))+N0,ep)
. -Gr(k,3)*Dv(diiiii(z5(3,i1,i2,i3,i4))+N0,ep))/f(k)
enddo
return
end
|
variables {α : Type*} (P : α → Prop)
/- Tactics you may consider
-intro
-exact
-apply
-by_contra
-/
example (h : ¬ ∃ x, P x) : ∀ x, ¬ P x :=
begin
intro x,
by_contra h',
exact h ⟨x, h'⟩,
end
example (h : ∀ x, ¬ P x) : ¬ ∃ x, P x :=
begin
intro h,
cases h with x p,
exact h x p,
end
example (h : ¬ ∀ x, P x) : ∃ x, ¬ P x :=
begin
by_contra h',
apply h,
intro x,
show P x,
by_contra h'',
exact h' ⟨x, h''⟩,
end
example (h : ∃ x, ¬ P x) : ¬ ∀ x, P x :=
begin
intro h',
cases h with x np,
exact np (h' x),
end |
example (p q : ℕ → Prop) : (∃ x, p x) → ∃ x, p x ∨ q x :=
begin
intro h,
cases h with x hpx,
existsi x, left, exact hpx
end
|
theory Presimplified_Semantics_Manual2
imports reassembly_all.Presimplified_Semantics
begin
(* This file contains instructions for which we unecessarily use manual semantics
For each of these instructions, we need to add the learned semantics to the strata_rules_5flags file,
and prove two theorems in Presimplified_Semantics.thy: one that is_manual returns False, and one that provides semantics.
Keeping it out of a heap for now so it's easy to change.
*)
context presimplified_semantics
begin
subsection div
lemma is_manual_div_r64[is_manual]: (* TODO: To be merged *)
shows \<open>is_manual assembly semantics (Unary (IS_8088 Div) (Storage (Reg (General SixtyFour r64)))) = True\<close>
by (auto simp add: is_manual_def Let'_def simp_rules unfold_semantics)
schematic_goal get_semantics_div_r64[presimplify]: (* TODO: To be merged *)
shows \<open>get_semantics \<alpha> semantics (Unary (IS_8088 Div) (Storage (Reg (General SixtyFour r64)))) si = ?x\<close>
apply (rule ext)
apply (subst get_semantics_def)
apply (subst unfold_semantics)
apply (auto simp add: Let'_def simp_rules)
done
section Mul
lemma is_manual_mul_m32[is_manual]: (* TODO: To be merged *)
shows \<open>is_manual assembly semantics (Unary (IS_8088 Mul) (Storage (Memory 32 Mem))) = True\<close>
by (auto simp add: is_manual_def Let'_def simp_rules unfold_semantics)
schematic_goal get_semantics_mul_m32[presimplify]: (* TODO: To be merged *)
shows \<open>get_semantics \<alpha> semantics (Unary (IS_8088 Mul) (Storage (Memory 32 Mem))) si = ?x\<close>
apply (rule ext)
apply (subst get_semantics_def)
apply (subst unfold_semantics)
apply (auto simp add: Let'_def simp_rules)
done
subsection add
lemma is_manual_add_m32_r32[is_manual]: (* TODO: To be merged *)
shows \<open>is_manual assembly semantics (Binary (IS_8088 Add) (Memory 32 Mem) (Storage (Reg (General ThirtyTwo r32)))) = True\<close>
by (auto simp add: is_manual_def Let'_def simp_rules unfold_semantics)
schematic_goal get_semantics_add_m32_r32[presimplify]: (* TODO: To be merged *)
shows \<open>get_semantics \<alpha> semantics (Binary (IS_8088 Add) (Memory 32 Mem) (Storage (Reg (General ThirtyTwo r32)))) si = ?x\<close>
apply (rule ext)
apply (subst get_semantics_def)
apply (subst unfold_semantics)
apply (auto simp add: Let'_def simp_rules)
done
subsection sub
lemma is_manual_sub_r16_m16[is_manual]: (* TODO: To be merged *)
shows \<open>is_manual assembly semantics (Binary (IS_8088 Sub) (Reg (General Sixteen rx)) (Storage (Memory 16 Mem))) = True\<close>
by (auto simp add: is_manual_def Let'_def simp_rules unfold_semantics)
schematic_goal get_semantics_sub_r16_m16[presimplify]: (* TODO: To be merged *)
shows \<open>get_semantics \<alpha> semantics (Binary (IS_8088 Sub) (Reg (General Sixteen rx)) (Storage (Memory 16 Mem))) si = ?x\<close>
apply (rule ext)
apply (subst get_semantics_def)
apply (subst unfold_semantics)
apply (auto simp add: Let'_def simp_rules)
done
lemma is_manual_sub_r64_m64[is_manual]: (* TODO: To be merged *)
shows \<open>is_manual assembly semantics (Binary (IS_8088 Sub) (Reg (General SixtyFour r64)) (Storage (Memory 64 Mem))) = True\<close>
by (auto simp add: is_manual_def Let'_def simp_rules unfold_semantics)
schematic_goal get_semantics_sub_r64_m64[presimplify]: (* TODO: To be merged *)
shows \<open>get_semantics \<alpha> semantics (Binary (IS_8088 Sub) (Reg (General SixtyFour r64)) (Storage (Memory 64 Mem))) si = ?x\<close>
apply (rule ext)
apply (subst get_semantics_def)
apply (subst unfold_semantics)
apply (auto simp add: Let'_def simp_rules)
done
subsection cmp
lemma is_manual_cmp_m64_r64[is_manual]:
shows "is_manual assembly semantics (Binary (IS_8088 Cmp) (Memory 64 a) (Storage (Reg (General SixtyFour r64)))) = True"
by (auto simp add: is_manual_def Let'_def simp_rules unfold_semantics)
schematic_goal get_semantics_cmp_m64_r64[presimplify]:
shows "get_semantics \<alpha> semantics (Binary (IS_8088 Cmp) (Memory 64 a) (Storage (Reg (General SixtyFour r64)))) si = ?x"
apply (rule ext)
apply (subst get_semantics_def)
apply (subst unfold_semantics)
apply (auto simp add: Let'_def simp_rules)
done
lemma is_manual_cmp_r64_m64[is_manual]: (* TODO: To be merged *)
shows \<open>is_manual assembly semantics (Binary (IS_8088 Cmp) (Reg (General SixtyFour r64)) (Storage (Memory 64 a))) = True\<close>
by (auto simp add: is_manual_def Let'_def simp_rules unfold_semantics)
schematic_goal get_semantics_cmp_r64_m64[presimplify]: (* TODO: To be merged *)
shows \<open>get_semantics \<alpha> semantics (Binary (IS_8088 Cmp) (Reg (General SixtyFour r64)) (Storage (Memory 64 a))) si = ?x\<close>
apply (rule ext)
apply (subst get_semantics_def)
apply (subst unfold_semantics)
apply (auto simp add: Let'_def simp_rules)
done
lemma is_manual_cmp_r8_r8[is_manual]: (* TODO: To be merged *)
\<open>is_manual assembly semantics (Binary (IS_8088 Cmp) (Reg (General EightLow r1)) (Storage (Reg (General EightLow r2)))) = True\<close>
by (auto simp add: is_manual_def Let'_def simp_rules unfold_semantics)
schematic_goal get_semantics_cmp_r8_r8[presimplify]: (* TODO: To be merged *)
\<open>get_semantics \<alpha> semantics (Binary (IS_8088 Cmp) (Reg (General EightLow r1)) (Storage (Reg (General EightLow r2)))) si = ?x\<close>
apply (rule ext)
apply (subst get_semantics_def)
apply (subst unfold_semantics)
apply (auto simp add: Let'_def simp_rules)
done
lemma is_manual_cmp_r16_r16[is_manual]: (* TODO: To be merged *)
\<open>is_manual assembly semantics (Binary (IS_8088 Cmp) (Reg (General Sixteen r1)) (Storage (Reg (General Sixteen r2)))) = True\<close>
by (auto simp add: is_manual_def Let'_def simp_rules unfold_semantics)
schematic_goal get_semantics_cmp_r16_r16[presimplify]: (* TODO: To be merged *)
\<open>get_semantics \<alpha> semantics (Binary (IS_8088 Cmp) (Reg (General Sixteen r1)) (Storage (Reg (General Sixteen r2)))) si = ?x\<close>
apply (rule ext)
apply (subst get_semantics_def)
apply (subst unfold_semantics)
apply (auto simp add: Let'_def simp_rules)
done
lemma is_manual_cmp_r64_r64[is_manual]: (* TODO: To be merged *)
\<open>is_manual assembly semantics (Binary (IS_8088 Cmp) (Reg (General SixtyFour r1)) (Storage (Reg (General SixtyFour r2)))) = True\<close>
by (auto simp add: is_manual_def Let'_def simp_rules unfold_semantics)
schematic_goal get_semantics_cmp_r64_r64[presimplify]: (* TODO: To be merged *)
\<open>get_semantics \<alpha> semantics (Binary (IS_8088 Cmp) (Reg (General SixtyFour r1)) (Storage (Reg (General SixtyFour r64)))) si = ?x\<close>
apply (rule ext)
apply (subst get_semantics_def)
apply (subst unfold_semantics)
apply (auto simp add: Let'_def simp_rules)
done
subsection mov
lemma is_manual_mov_r32_immLabel[is_manual]:
shows "is_manual assembly semantics (Binary (IS_8088 Mov) (Reg (General ThirtyTwo r1_32)) (Immediate (ImmLabel imm))) = True"
by (auto simp add: is_manual_def Let'_def simp_rules unfold_semantics)
schematic_goal get_semantics_mov_r32_immLabel[presimplify]:
shows "get_semantics \<alpha> semantics (Binary (IS_8088 Mov) (Reg (General ThirtyTwo r1_32)) (Immediate (ImmLabel Imm))) si = ?x"
apply (rule ext)
apply (subst get_semantics_def)
apply (subst unfold_semantics)
apply (auto simp add: Let'_def simp_rules )
done
lemma is_manual_movq_xmm_m64[is_manual]: (* TODO: to be merged (and then replaced once we have presimplified semantics) *)
shows \<open>is_manual assembly semantics (Binary (IS_PentiumMMX_MMX Movq) (Reg (SSE a b c d)) (Storage (Memory 64 m))) = True\<close>
by (auto simp add: is_manual_def Let'_def simp_rules unfold_semantics)
schematic_goal get_semantics_movq_xmm_m64[presimplify]: (* TODO: to be merged (and then replaced once we have presimplified semantics) *)
shows \<open>get_semantics \<alpha> semantics (Binary (IS_PentiumMMX_MMX Movq) (Reg (SSE a b c d)) (Storage (Memory 64 m))) si = ?x\<close>
apply (rule ext)
apply (subst get_semantics_def)
apply (subst unfold_semantics)
apply (auto simp add: Let'_def simp_rules)
done
lemma is_manual_movups_m128_xmm[is_manual]: (* TODO: to be merged (and then replaced once we have presimplified semantics) *)
shows \<open>is_manual assembly semantics (Binary (IS_SSE_SIMD Movups) (Memory 128 Mem) (Storage (Reg (SSE a b c d)))) = True\<close>
by (auto simp add: is_manual_def Let'_def simp_rules unfold_semantics)
schematic_goal get_semantics_movups_m128_xmm[presimplify]: (* TODO: to be merged (and then replaced once we have presimplified semantics) *)
shows \<open>get_semantics \<alpha> semantics (Binary (IS_SSE_SIMD Movups) (Memory 128 Mem) (Storage (Reg (SSE a b c d)))) si = ?x\<close>
apply (rule ext)
apply (subst get_semantics_def)
apply (subst unfold_semantics)
apply (auto simp add: Let'_def simp_rules)
done
subsection Jumps
lemma is_manual_Js[is_manual]: (* TODO: To be merged *)
shows \<open>is_manual assembly semantics (Unary (IS_8088 Js) label) = True\<close>
by (auto simp add: is_manual_def Let'_def simp_rules unfold_semantics)
schematic_goal get_semantics_Js[presimplify]: (* TODO: To be merged *)
shows \<open>get_semantics assembly semantics (Unary (IS_8088 Js) label) = ?x\<close>
apply (rule ext)
apply (subst get_semantics_def)
apply (subst unfold_semantics)
apply (auto simp add: Let'_def simp_rules)
done
lemma is_manual_Jns[is_manual]: (* TODO: To be merged *)
shows \<open>is_manual assembly semantics (Unary (IS_8088 Jns) label) = True\<close>
by (auto simp add: is_manual_def Let'_def simp_rules unfold_semantics)
schematic_goal get_semantics_Jns[presimplify]: (* TODO: To be merged *)
shows \<open>get_semantics assembly semantics (Unary (IS_8088 Jns) label) = ?x\<close>
apply (rule ext)
apply (subst get_semantics_def)
apply (subst unfold_semantics)
apply (auto simp add: Let'_def simp_rules)
done
lemma is_manual_Jl[is_manual]: (* TODO: To be merged *)
shows \<open>is_manual assembly semantics (Unary (IS_8088 Jl) label) = True\<close>
by (auto simp add: is_manual_def Let'_def simp_rules unfold_semantics)
schematic_goal get_semantics_Jl[presimplify]: (* TODO: To be merged *)
shows \<open>get_semantics assembly semantics (Unary (IS_8088 Jl) label) = ?x\<close>
apply (rule ext)
apply (subst get_semantics_def)
apply (subst unfold_semantics)
apply (auto simp add: Let'_def simp_rules)
done
lemma is_manual_Jg[is_manual]: (* TODO: To be merged *)
shows \<open>is_manual assembly semantics (Unary (IS_8088 Jg) label) = True\<close>
by (auto simp add: is_manual_def Let'_def simp_rules unfold_semantics)
schematic_goal get_semantics_Jg[presimplify]: (* TODO: To be merged *)
shows \<open>get_semantics assembly semantics (Unary (IS_8088 Jg) label) = ?x\<close>
apply (rule ext)
apply (subst get_semantics_def)
apply (subst unfold_semantics)
apply (auto simp add: Let'_def simp_rules)
done
section Misc
lemma is_manual_movsd_m64_xmm[is_manual]:
shows "is_manual assembly semantics (Binary (IS_SSE2_SIMD Movsd) (Memory 64 Mem) (Storage (Reg (SSE r0 r1 r2 r3)))) = True"
by (auto simp add: is_manual_def Let'_def simp_rules unfold_semantics)
schematic_goal get_semantics_movsd_m64_xmm[presimplify]:
shows "get_semantics \<alpha> semantics (Binary (IS_SSE2_SIMD Movsd) (Memory 64 Mem) (Storage (Reg (SSE r0 r1 r2 r3)))) si = ?x"
apply (rule ext)
apply (subst get_semantics_def)
apply (subst unfold_semantics)
apply (auto simp add: Let'_def simp_rules )
done
lemma is_manual_ucomisd_xmm_m64[is_manual]:
shows "is_manual assembly semantics (Binary (IS_SSE2_SIMD Ucomisd) (Reg (SSE r0 r1 r2 r3)) (Storage (Memory 64 Mem))) = True"
by (auto simp add: is_manual_def Let'_def simp_rules unfold_semantics)
schematic_goal get_semantics_ucomisd_xmm_m64[presimplify]:
shows "get_semantics \<alpha> semantics (Binary (IS_SSE2_SIMD Ucomisd) (Reg (SSE r0 r1 r2 r3)) (Storage (Memory 64 Mem))) si = ?x"
apply (rule ext)
apply (subst get_semantics_def)
apply (subst unfold_semantics)
apply (auto simp add: Let'_def simp_rules )
done
lemma is_manual_ucomisd_cvttsd2si_r32_xmm[is_manual]:
shows "is_manual assembly semantics (Binary (IS_SSE2_SIMD Cvttsd2si) (Reg (General ThirtyTwo r4)) (Storage (Reg (SSE r0 r1 r2 r3)))) = False"
by (auto simp add: is_manual_def Let'_def simp_rules unfold_semantics)
lemma get_semantics_cvttsd2si_r32_xmm[presimplify]:
shows "get_semantics \<alpha> semantics (Binary (IS_SSE2_SIMD Cvttsd2si) (Reg (General ThirtyTwo r4)) (Storage (Reg (SSE r0 r1 r2 r3)))) si =
(\<lambda> \<sigma> . \<sigma>\<lparr> regs := (regs \<sigma>)(r4 := ucast (cvttsd2si (regs \<sigma> r3)))\<rparr>)"
apply (rule ext)
apply (subst get_semantics_def)
apply (rewrite_one_let')
apply (rewrite_one_let' add: semantics_def)
apply (rewrite_one_let')+
by (simp add: simp_rules)
lemma is_manual_pause[is_manual]: (* TODO: To be merged *)
shows \<open>is_manual assembly semantics (Nullary (IS_SSE2 Pause)) = True\<close>
by (auto simp add: is_manual_def Let'_def simp_rules unfold_semantics)
schematic_goal get_semantics_pause[presimplify]: (* TODO: To be merged *)
shows \<open>get_semantics assembly semantics (Nullary (IS_SSE2 Pause)) = ?x\<close>
apply (rule ext)
apply (subst get_semantics_def)
apply (subst unfold_semantics)
apply (auto simp add: Let'_def simp_rules)
done
lemma simplify_setcc1[simp]: (* TODO: To be merged *)
fixes x :: \<open>'a::len word\<close>
assumes \<open>LENGTH('a) \<ge> 8\<close>
shows \<open>\<langle>7,0\<rangle>((x << 8) OR 1) = (1::64 word)\<close>
using assms
by (intro word_eqI) (auto simp: word_size test_bit_of_take_bits word_ao_nth nth_shiftl)
lemma simplify_setcc0[simp]: (* TODO: To be merged *)
fixes x :: \<open>'a::len word\<close>
assumes \<open>LENGTH('a) \<ge> 8\<close>
shows \<open>\<langle>7,0\<rangle>(x << 8) = (0::64 word)\<close>
using assms
by (intro word_eqI) (auto simp: word_size test_bit_of_take_bits nth_shiftl)
lemma is_manual_Sar[is_manual]:
shows "is_manual assembly semantics (Binary (IS_8088 Sar) op1 op2) = True"
by (auto simp add: is_manual_def Let'_def simp_rules unfold_semantics)
schematic_goal get_semantics_Sar[presimplify]:
shows "get_semantics \<alpha> semantics (Binary (IS_8088 Sar) op1 op2) si = ?x"
apply (rule ext)
apply (subst get_semantics_def)
apply (subst unfold_semantics)
apply (auto simp add: Let'_def simp_rules )
done
lemma is_manual_test_r8_r8[is_manual]: (* TODO: to be merged (until presimplification for the learned semantics are done) *)
shows \<open>is_manual assembly semantics (Binary (IS_8088 Test) (Reg (General EightLow r1)) (Storage (Reg (General EightLow r2)))) = True\<close>
by (auto simp add: is_manual_def Let'_def simp_rules unfold_semantics)
schematic_goal get_semantics_test_r8_r8[presimplify]: (* TODO: to be merged (until presimplification for the learned semantics are done) *)
shows \<open>get_semantics \<alpha> semantics (Binary (IS_8088 Test) (Reg (General EightLow r1)) (Storage (Reg (General EightLow r2)))) si = ?x\<close>
apply (rule ext)
apply (subst get_semantics_def)
apply (subst unfold_semantics)
apply (auto simp add: Let'_def simp_rules)
done
lemma is_manual_punpcklqdq_xmm_xmm[is_manual]: (* TODO: to be merged (until presimplification for the learned semantics are done) *)
shows \<open>is_manual assembly semantics (Binary (IS_SSE2_SIMD Punpcklqdq) (Reg (SSE r1_3 r1_2 r1_1 r1_0)) (Storage (Reg (SSE r2_3 r2_2 r2_1 r2_0)))) = True\<close>
by (auto simp add: is_manual_def Let'_def simp_rules unfold_semantics)
schematic_goal get_semantics_punpcklqdq_xmm_xmm[presimplify]: (* TODO: to be merged (until presimplification for the learned semantics are done) *)
\<open>get_semantics \<alpha> semantics (Binary (IS_SSE2_SIMD Punpcklqdq) (Reg (SSE r1_3 r1_2 r1_1 r1_0)) (Storage (Reg (SSE r2_3 r2_2 r2_1 r2_0)))) si = ?x\<close>
apply (rule ext)
apply (subst get_semantics_def)
apply (subst unfold_semantics)
apply (auto simp add: Let'_def simp_rules)
done
end
end
|
{-# language
ScopedTypeVariables
#-}
module Main (main) where
import Test.QuickCheck.Classes
import Test.QuickCheck (Arbitrary(..))
import Data.Complex (Complex(..))
import GHC.Fingerprint (Fingerprint(..))
import GHC.Real (Ratio(..))
import Data.Proxy (Proxy(..))
import Data.Primitive.Instances ()
main :: IO ()
main = lawsCheckMany
[ ("Complex Double", [primLaws (Proxy :: Proxy (Complex Double))])
, ("Ratio Double", [primLaws (Proxy :: Proxy (Ratio Int))])
, ("Fingerprint", [primLaws (Proxy :: Proxy Fingerprint)])
]
instance Arbitrary Fingerprint where
arbitrary = Fingerprint <$> arbitrary <*> arbitrary
|
/-
Copyright (c) 2019 Kenny Lau. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Kenny Lau
-/
import algebra.algebra.basic
/-!
# Multiplication and division of submodules of an algebra.
An interface for multiplication and division of sub-R-modules of an R-algebra A is developed.
## Main definitions
Let `R` be a commutative ring (or semiring) and aet `A` be an `R`-algebra.
* `1 : submodule R A` : the R-submodule R of the R-algebra A
* `has_mul (submodule R A)` : multiplication of two sub-R-modules M and N of A is defined to be
the smallest submodule containing all the products `m * n`.
* `has_div (submodule R A)` : `I / J` is defined to be the submodule consisting of all `a : A` such
that `a • J ⊆ I`
It is proved that `submodule R A` is a semiring, and also an algebra over `set A`.
## Tags
multiplication of submodules, division of subodules, submodule semiring
-/
universes u v
open algebra set
namespace submodule
variables {R : Type u} [comm_semiring R]
section ring
variables {A : Type v} [semiring A] [algebra R A]
variables (S T : set A) {M N P Q : submodule R A} {m n : A}
/-- `1 : submodule R A` is the submodule R of A. -/
instance : has_one (submodule R A) :=
⟨submodule.map (of_id R A).to_linear_map (⊤ : submodule R R)⟩
theorem one_eq_map_top :
(1 : submodule R A) = submodule.map (of_id R A).to_linear_map (⊤ : submodule R R) := rfl
theorem one_eq_span : (1 : submodule R A) = R ∙ 1 :=
begin
apply submodule.ext,
intro a,
erw [mem_map, mem_span_singleton],
apply exists_congr,
intro r,
simpa [smul_def],
end
theorem one_le : (1 : submodule R A) ≤ P ↔ (1 : A) ∈ P :=
by simpa only [one_eq_span, span_le, set.singleton_subset_iff]
/-- Multiplication of sub-R-modules of an R-algebra A. The submodule `M * N` is the
smallest R-submodule of `A` containing the elements `m * n` for `m ∈ M` and `n ∈ N`. -/
instance : has_mul (submodule R A) :=
⟨λ M N, ⨆ s : M, N.map $ algebra.lmul R A s.1⟩
theorem mul_mem_mul (hm : m ∈ M) (hn : n ∈ N) : m * n ∈ M * N :=
(le_supr _ ⟨m, hm⟩ : _ ≤ M * N) ⟨n, hn, rfl⟩
theorem mul_le : M * N ≤ P ↔ ∀ (m ∈ M) (n ∈ N), m * n ∈ P :=
⟨λ H m hm n hn, H $ mul_mem_mul hm hn,
λ H, supr_le $ λ ⟨m, hm⟩, map_le_iff_le_comap.2 $ λ n hn, H m hm n hn⟩
@[elab_as_eliminator] protected theorem mul_induction_on
{C : A → Prop} {r : A} (hr : r ∈ M * N)
(hm : ∀ (m ∈ M) (n ∈ N), C (m * n))
(h0 : C 0) (ha : ∀ x y, C x → C y → C (x + y))
(hs : ∀ (r : R) x, C x → C (r • x)) : C r :=
(@mul_le _ _ _ _ _ _ _ ⟨C, h0, ha, hs⟩).2 hm hr
variables R
theorem span_mul_span : span R S * span R T = span R (S * T) :=
begin
apply le_antisymm,
{ rw mul_le, intros a ha b hb,
apply span_induction ha,
work_on_goal 0 { intros, apply span_induction hb,
work_on_goal 0 { intros, exact subset_span ⟨_, _, ‹_›, ‹_›, rfl⟩ } },
all_goals { intros, simp only [mul_zero, zero_mul, zero_mem,
left_distrib, right_distrib, mul_smul_comm, smul_mul_assoc],
try {apply add_mem _ _ _}, try {apply smul_mem _ _ _} }, assumption' },
{ rw span_le, rintros _ ⟨a, b, ha, hb, rfl⟩,
exact mul_mem_mul (subset_span ha) (subset_span hb) }
end
variables {R}
variables (M N P Q)
protected theorem mul_assoc : (M * N) * P = M * (N * P) :=
le_antisymm (mul_le.2 $ λ mn hmn p hp,
suffices M * N ≤ (M * (N * P)).comap (algebra.lmul_right R p), from this hmn,
mul_le.2 $ λ m hm n hn, show m * n * p ∈ M * (N * P), from
(mul_assoc m n p).symm ▸ mul_mem_mul hm (mul_mem_mul hn hp))
(mul_le.2 $ λ m hm np hnp,
suffices N * P ≤ (M * N * P).comap (algebra.lmul_left R m), from this hnp,
mul_le.2 $ λ n hn p hp, show m * (n * p) ∈ M * N * P, from
mul_assoc m n p ▸ mul_mem_mul (mul_mem_mul hm hn) hp)
@[simp] theorem mul_bot : M * ⊥ = ⊥ :=
eq_bot_iff.2 $ mul_le.2 $ λ m hm n hn, by rw [submodule.mem_bot] at hn ⊢; rw [hn, mul_zero]
@[simp] theorem bot_mul : ⊥ * M = ⊥ :=
eq_bot_iff.2 $ mul_le.2 $ λ m hm n hn, by rw [submodule.mem_bot] at hm ⊢; rw [hm, zero_mul]
@[simp] protected theorem one_mul : (1 : submodule R A) * M = M :=
by { conv_lhs { rw [one_eq_span, ← span_eq M] }, erw [span_mul_span, one_mul, span_eq] }
@[simp] protected theorem mul_one : M * 1 = M :=
by { conv_lhs { rw [one_eq_span, ← span_eq M] }, erw [span_mul_span, mul_one, span_eq] }
variables {M N P Q}
@[mono] theorem mul_le_mul (hmp : M ≤ P) (hnq : N ≤ Q) : M * N ≤ P * Q :=
mul_le.2 $ λ m hm n hn, mul_mem_mul (hmp hm) (hnq hn)
theorem mul_le_mul_left (h : M ≤ N) : M * P ≤ N * P :=
mul_le_mul h (le_refl P)
theorem mul_le_mul_right (h : N ≤ P) : M * N ≤ M * P :=
mul_le_mul (le_refl M) h
variables (M N P)
theorem sup_mul : (M ⊔ N) * P = M * P ⊔ N * P :=
le_antisymm (mul_le.2 $ λ mn hmn p hp, let ⟨m, hm, n, hn, hmn⟩ := mem_sup.1 hmn in
mem_sup.2 ⟨_, mul_mem_mul hm hp, _, mul_mem_mul hn hp, hmn ▸ (add_mul m n p).symm⟩)
(sup_le (mul_le_mul_left le_sup_left) (mul_le_mul_left le_sup_right))
lemma mul_subset_mul : (↑M : set A) * (↑N : set A) ⊆ (↑(M * N) : set A) :=
by { rintros _ ⟨i, j, hi, hj, rfl⟩, exact mul_mem_mul hi hj }
lemma map_mul {A'} [semiring A'] [algebra R A'] (f : A →ₐ[R] A') :
map f.to_linear_map (M * N) = map f.to_linear_map M * map f.to_linear_map N :=
calc map f.to_linear_map (M * N)
= ⨆ (i : M), (N.map (lmul R A i)).map f.to_linear_map : map_supr _ _
... = map f.to_linear_map M * map f.to_linear_map N :
begin
apply congr_arg Sup,
ext S,
split; rintros ⟨y, hy⟩,
{ use [f y, mem_map.mpr ⟨y.1, y.2, rfl⟩],
refine trans _ hy,
ext,
simp },
{ obtain ⟨y', hy', fy_eq⟩ := mem_map.mp y.2,
use [y', hy'],
refine trans _ hy,
rw f.to_linear_map_apply at fy_eq,
ext,
simp [fy_eq] }
end
section decidable_eq
open_locale classical
lemma mem_span_mul_finite_of_mem_span_mul {S : set A} {S' : set A} {x : A}
(hx : x ∈ span R (S * S')) :
∃ (T T' : finset A), ↑T ⊆ S ∧ ↑T' ⊆ S' ∧ x ∈ span R (T * T' : set A) :=
begin
obtain ⟨U, h, hU⟩ := mem_span_finite_of_mem_span hx,
obtain ⟨T, T', hS, hS', h⟩ := finset.subset_mul h,
use [T, T', hS, hS'],
have h' : (U : set A) ⊆ T * T', { assumption_mod_cast, },
have h'' := span_mono h' hU,
assumption,
end
end decidable_eq
lemma mem_span_mul_finite_of_mem_mul {P Q : submodule R A} {x : A} (hx : x ∈ P * Q) :
∃ (T T' : finset A), (T : set A) ⊆ P ∧ (T' : set A) ⊆ Q ∧ x ∈ span R (T * T' : set A) :=
submodule.mem_span_mul_finite_of_mem_span_mul
(by rwa [← submodule.span_eq P, ← submodule.span_eq Q, submodule.span_mul_span] at hx)
variables {M N P}
/-- Sub-R-modules of an R-algebra form a semiring. -/
instance : semiring (submodule R A) :=
{ one_mul := submodule.one_mul,
mul_one := submodule.mul_one,
mul_assoc := submodule.mul_assoc,
zero_mul := bot_mul,
mul_zero := mul_bot,
left_distrib := mul_sup,
right_distrib := sup_mul,
..submodule.add_comm_monoid_submodule,
..submodule.has_one,
..submodule.has_mul }
variables (M)
lemma pow_subset_pow {n : ℕ} : (↑M : set A)^n ⊆ ↑(M^n : submodule R A) :=
begin
induction n with n ih,
{ erw [pow_zero, pow_zero, set.singleton_subset_iff],
rw [set_like.mem_coe, ← one_le],
exact le_refl _ },
{ rw [pow_succ, pow_succ],
refine set.subset.trans (set.mul_subset_mul (subset.refl _) ih) _,
apply mul_subset_mul }
end
/-- `span` is a semiring homomorphism (recall multiplication is pointwise multiplication of subsets
on either side). -/
def span.ring_hom : set_semiring A →+* submodule R A :=
{ to_fun := submodule.span R,
map_zero' := span_empty,
map_one' := le_antisymm (span_le.2 $ singleton_subset_iff.2 ⟨1, ⟨⟩, (algebra_map R A).map_one⟩)
(map_le_iff_le_comap.2 $ λ r _, mem_span_singleton.2 ⟨r, (algebra_map_eq_smul_one r).symm⟩),
map_add' := span_union,
map_mul' := λ s t, by erw [span_mul_span, ← image_mul_prod] }
end ring
section comm_ring
variables {A : Type v} [comm_semiring A] [algebra R A]
variables {M N : submodule R A} {m n : A}
theorem mul_mem_mul_rev (hm : m ∈ M) (hn : n ∈ N) : n * m ∈ M * N :=
mul_comm m n ▸ mul_mem_mul hm hn
variables (M N)
protected theorem mul_comm : M * N = N * M :=
le_antisymm (mul_le.2 $ λ r hrm s hsn, mul_mem_mul_rev hsn hrm)
(mul_le.2 $ λ r hrn s hsm, mul_mem_mul_rev hsm hrn)
/-- Sub-R-modules of an R-algebra A form a semiring. -/
instance : comm_semiring (submodule R A) :=
{ mul_comm := submodule.mul_comm,
.. submodule.semiring }
variables (R A)
/-- R-submodules of the R-algebra A are a module over `set A`. -/
instance module_set : module (set_semiring A) (submodule R A) :=
{ smul := λ s P, span R s * P,
smul_add := λ _ _ _, mul_add _ _ _,
add_smul := λ s t P, show span R (s ⊔ t) * P = _, by { erw [span_union, right_distrib] },
mul_smul := λ s t P, show _ = _ * (_ * _),
by { rw [← mul_assoc, span_mul_span, ← image_mul_prod] },
one_smul := λ P, show span R {(1 : A)} * P = _,
by { conv_lhs {erw ← span_eq P}, erw [span_mul_span, one_mul, span_eq] },
zero_smul := λ P, show span R ∅ * P = ⊥, by erw [span_empty, bot_mul],
smul_zero := λ _, mul_bot _ }
variables {R A}
lemma smul_def {s : set_semiring A} {P : submodule R A} : s • P = span R s * P := rfl
lemma smul_le_smul {s t : set_semiring A} {M N : submodule R A} (h₁ : s.down ≤ t.down)
(h₂ : M ≤ N) : s • M ≤ t • N :=
mul_le_mul (span_mono h₁) h₂
lemma smul_singleton (a : A) (M : submodule R A) :
({a} : set A).up • M = M.map (lmul_left _ a) :=
begin
conv_lhs {rw ← span_eq M},
change span _ _ * span _ _ = _,
rw [span_mul_span],
apply le_antisymm,
{ rw span_le,
rintros _ ⟨b, m, hb, hm, rfl⟩,
rw [set_like.mem_coe, mem_map, set.mem_singleton_iff.mp hb],
exact ⟨m, hm, rfl⟩ },
{ rintros _ ⟨m, hm, rfl⟩, exact subset_span ⟨a, m, set.mem_singleton a, hm, rfl⟩ }
end
section quotient
/-- The elements of `I / J` are the `x` such that `x • J ⊆ I`.
In fact, we define `x ∈ I / J` to be `∀ y ∈ J, x * y ∈ I` (see `mem_div_iff_forall_mul_mem`),
which is equivalent to `x • J ⊆ I` (see `mem_div_iff_smul_subset`), but nicer to use in proofs.
This is the general form of the ideal quotient, traditionally written $I : J$.
-/
instance : has_div (submodule R A) :=
⟨ λ I J, {
carrier := { x | ∀ y ∈ J, x * y ∈ I },
zero_mem' := λ y hy, by { rw zero_mul, apply submodule.zero_mem },
add_mem' := λ a b ha hb y hy, by { rw add_mul, exact submodule.add_mem _ (ha _ hy) (hb _ hy) },
smul_mem' := λ r x hx y hy, by { rw algebra.smul_mul_assoc,
exact submodule.smul_mem _ _ (hx _ hy) } } ⟩
lemma mem_div_iff_forall_mul_mem {x : A} {I J : submodule R A} :
x ∈ I / J ↔ ∀ y ∈ J, x * y ∈ I :=
iff.refl _
lemma mem_div_iff_smul_subset {x : A} {I J : submodule R A} : x ∈ I / J ↔ x • (J : set A) ⊆ I :=
⟨ λ h y ⟨y', hy', xy'_eq_y⟩, by { rw ← xy'_eq_y, apply h, assumption },
λ h y hy, h (set.smul_mem_smul_set hy) ⟩
lemma le_div_iff {I J K : submodule R A} : I ≤ J / K ↔ ∀ (x ∈ I) (z ∈ K), x * z ∈ J := iff.refl _
lemma le_div_iff_mul_le {I J K : submodule R A} : I ≤ J / K ↔ I * K ≤ J :=
by rw [le_div_iff, mul_le]
@[simp] lemma one_le_one_div {I : submodule R A} :
1 ≤ 1 / I ↔ I ≤ 1 :=
begin
split, all_goals {intro hI},
{rwa [le_div_iff_mul_le, one_mul] at hI},
{rwa [le_div_iff_mul_le, one_mul]},
end
lemma le_self_mul_one_div {I : submodule R A} (hI : I ≤ 1) :
I ≤ I * (1 / I) :=
begin
rw [← mul_one I] {occs := occurrences.pos [1]},
apply mul_le_mul_right (one_le_one_div.mpr hI),
end
lemma mul_one_div_le_one {I : submodule R A} : I * (1 / I) ≤ 1 :=
begin
rw submodule.mul_le,
intros m hm n hn,
rw [submodule.mem_div_iff_forall_mul_mem] at hn,
rw mul_comm,
exact hn m hm,
end
@[simp] lemma map_div {B : Type*} [comm_ring B] [algebra R B]
(I J : submodule R A) (h : A ≃ₐ[R] B) :
(I / J).map h.to_linear_map = I.map h.to_linear_map / J.map h.to_linear_map :=
begin
ext x,
simp only [mem_map, mem_div_iff_forall_mul_mem],
split,
{ rintro ⟨x, hx, rfl⟩ _ ⟨y, hy, rfl⟩,
exact ⟨x * y, hx _ hy, h.map_mul x y⟩ },
{ rintro hx,
refine ⟨h.symm x, λ z hz, _, h.apply_symm_apply x⟩,
obtain ⟨xz, xz_mem, hxz⟩ := hx (h z) ⟨z, hz, rfl⟩,
convert xz_mem,
apply h.injective,
erw [h.map_mul, h.apply_symm_apply, hxz] }
end
end quotient
end comm_ring
end submodule
|
module Tools.NatUtils
%access public export
-- Proof of the type that an implication implies its contrapositive
impliesContrapositive : (A : Type) -> (B : Type) -> (A -> B) -> (B -> Void) -> (A -> Void)
impliesContrapositive typeA typeB proofAimpliesB proofBfalse a = proofBfalse (proofAimpliesB a)
-- Proof that S m = S n implies m = n
meqnSmeqSn : (m : Nat) -> (n : Nat) -> (S m = S n) -> (m = n)
meqnSmeqSn Z Z Refl = Refl
meqnSmeqSn (S k) (S k) Refl = Refl
-- Proof that m = n implies f(m) = f(n), taken from Lecture.intro (apNat)
functionExtendEquality : (f : Nat -> Nat) -> (n : Nat) -> (m : Nat) -> (n = m) -> (f n = f m)
functionExtendEquality f m m Refl = Refl
-- Proof that m != n implies S m != S n
proofSmneqSn : (m : Nat) -> (n : Nat) -> ((m = n) -> Void) -> ((S m = S n) -> Void)
proofSmneqSn m n proofmneqn = impliesContrapositive (S m = S n) (m = n) (meqnSmeqSn m n) proofmneqn
-- Proof that m<n implies S m = n or S m < n
proofLTimplieseqorLT : (m : Nat) -> (n : Nat) -> (LT m n) -> Either (S m = n) (LT (S m) n)
proofLTimplieseqorLT Z (S Z) (LTESucc LTEZero) = Left Refl
proofLTimplieseqorLT Z (S (S n)) (LTESucc LTEZero) = Right (LTESucc (LTESucc LTEZero))
proofLTimplieseqorLT (S m) (S n) proofSmLTSn = case (proofLTimplieseqorLT m n (fromLteSucc proofSmLTSn)) of
(Left proofSmeqn) => Left (functionExtendEquality S (S m) n proofSmeqn)
(Right proofSmLTn) => Right (LTESucc proofSmLTn)
|||The theorem that (m<=n) and (n<=m) implies n=m
lteAndGteImpliesEqual:{m:Nat}-> {n:Nat}->(LTE m n)-> (LTE n m)->(n=m)
lteAndGteImpliesEqual LTEZero LTEZero = Refl
lteAndGteImpliesEqual (LTESucc x) (LTESucc y) = cong (lteAndGteImpliesEqual x y)
|||The theorem (m<=n) implies (m<=(c+n))
plusConstantLeftSide:{m:Nat}->{n:Nat}->(c:Nat)->LTE m n ->LTE m (c+n)
plusConstantLeftSide Z x = x
plusConstantLeftSide (S k) x = lteSuccRight (plusConstantLeftSide k x)
plusConstantLeftPreservesLte:{m:Nat}-> {n:Nat}->(c:Nat)->(LTE m n)->(LTE (c+m) (c+n))
plusConstantLeftPreservesLte Z x = x
plusConstantLeftPreservesLte (S k) x = LTESucc (plusConstantLeftPreservesLte k x)
plusConstantRightPreservesLte:{m:Nat}-> {n:Nat}->(c:Nat)->(LTE m n)->(LTE (m+c) (n+c))
plusConstantRightPreservesLte {m}{n}c x = rewrite (plusCommutative m c) in (rewrite (plusCommutative n c) in (plusConstantLeftPreservesLte c x))
|||The theorem that for any natural numbers k and m (m<= (S k)*m)
natLteMultNatNat: (k:Nat)->(m:Nat)->(LTE m ((S k)*m))
natLteMultNatNat Z m = rewrite (multOneLeftNeutral m) in (lteRefl)
natLteMultNatNat (S k) m = plusConstantLeftSide m (natLteMultNatNat k m)
|
# This function samples k indices from 1:n starting with very dense sampling
# (every value) and then getting more and more sparse
#' Sampling for qq plots
#'
#' Returns k indices between 1:max.idx (x) such that -log(x/n) is uniformly
#' distributed. This is useful to reduce overplotting when plotting
#' log-transformed uniform data (such as p-values in a qq plot).
#'
#' @examples
#' n <- 1e5
#' x <- sort(runif(n))
#' thin.idx <- thin(n, 500)
#' par(mfcol=c(1, 2))
#' plot(-log10(1:n/n), -log10(x), ann=FALSE)
#' plot(-log10(thin.idx/n), -log10(x[thin.idx]), ann=FALSE)
#'
#' @export
thin <- function(n, k=2000, max.idx=n) {
if ( max.idx > n ) max.idx <- n
if ( max.idx <= k ) return (1:max.idx)
# Generate k samples between 1 and max.idx
# such that -log10(x/n) is uniformly distributed
x <- round(max.idx*exp(-(k:1)/k*log(n)))
# Ensure each x is unique (Equivalently, diff(x) != 0)
prev <- 0
offset <- 0
for ( i in 1:k ) {
if ( x[i] + offset == prev ) {
offset <- offset + 1
} else if ( x[i] + offset > prev + 1 && offset > 0 ) {
if ( x[i] > prev ) {
offset <- 0
} else {
offset <- prev + 1 - x[i]
}
}
prev <- x[i] <- x[i] + offset
}
x
}
#' Fast QQ plots
#'
#' QQ plots with lots of points can be slow. Since most of the points overlap
#' we don't actually have to plot all of them (and in most cases the output
#' will be identical.)
#'
#' This function will take a value k (default 2000) and sample that many
#' pvalues in an intelligent way such that we don't lose information, then
#' plot the log observed vs expected pvals in a nice way.
#'
#' The optimal value of k depends on the resolution/size of the plot. Very high
#' resolution or very large plots may need larger k to look correct.
#'
#' Additional arguments in ... are passed to plot().
#'
#' @export
fastqq <- function(pvals, k=2000, ...) {
np <- length(pvals)
thin.idx <- thin(np, k)
thin.cint.95 <- qbeta(0.95, thin.idx, np - thin.idx + 1)
thin.cint.05 <- qbeta(0.05, thin.idx, np - thin.idx + 1)
thin.logp.exp <- -log10(thin.idx/np)
thin.logp.obs <- -log10(pvals[order(pvals)[thin.idx]])
plot(thin.logp.exp, thin.logp.obs, xlab=expression(-log[10](p[expected])), ylab=expression(-log[10](p[observed])), ...)
abline(0, 1, col='gray', lty=2)
lines(thin.logp.exp, -log10(thin.cint.95), lty=2, col='red')
lines(thin.logp.exp, -log10(thin.cint.05), lty=2, col='red')
}
#' @export
thin.qqplot <- function(pvals, thin.idx=NULL, k=2000, ...) {
warning('This function is deprecated, use fastqq')
fastqq(pvals, k, ...)
} |
/-
Copyright (c) 2022 Jakob von Raumer. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Jakob von Raumer, Kevin Klinge
! This file was ported from Lean 3 source module ring_theory.ore_localization.basic
! leanprover-community/mathlib commit b6da1a0b3e7cd83b1f744c49ce48ef8c6307d2f6
! Please do not edit these lines, except to modify the commit id
! if you have ported upstream changes.
-/
import Mathbin.GroupTheory.MonoidLocalization
import Mathbin.RingTheory.NonZeroDivisors
import Mathbin.RingTheory.OreLocalization.OreSet
import Mathbin.Tactic.NoncommRing
/-!
# Localization over right Ore sets.
> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
> Any changes to this file require a corresponding PR to mathlib4.
This file defines the localization of a monoid over a right Ore set and proves its universal
mapping property. It then extends the definition and its properties first to semirings and then
to rings. We show that in the case of a commutative monoid this definition coincides with the
common monoid localization. Finally we show that in a ring without zero divisors, taking the Ore
localization at `R - {0}` results in a division ring.
## Notations
Introduces the notation `R[S⁻¹]` for the Ore localization of a monoid `R` at a right Ore
subset `S`. Also defines a new heterogeneos division notation `r /ₒ s` for a numerator `r : R` and
a denominator `s : S`.
## References
* <https://ncatlab.org/nlab/show/Ore+localization>
* [Zoran Škoda, *Noncommutative localization in noncommutative geometry*][skoda2006]
## Tags
localization, Ore, non-commutative
-/
universe u
open OreLocalization
namespace OreLocalization
variable (R : Type _) [Monoid R] (S : Submonoid R) [OreSet S]
/- warning: ore_localization.ore_eqv -> OreLocalization.oreEqv is a dubious translation:
lean 3 declaration is
forall (R : Type.{u1}) [_inst_1 : Monoid.{u1} R] (S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S], Setoid.{succ u1} (Prod.{u1, u1} R (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S))
but is expected to have type
forall (R : Type.{u1}) [_inst_1 : Monoid.{u1} R] (S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S], Setoid.{succ u1} (Prod.{u1, u1} R (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)))
Case conversion may be inaccurate. Consider using '#align ore_localization.ore_eqv OreLocalization.oreEqvₓ'. -/
/-- The setoid on `R × S` used for the Ore localization. -/
def oreEqv : Setoid (R × S)
where
R rs rs' := ∃ (u : S)(v : R), rs'.1 * u = rs.1 * v ∧ (rs'.2 : R) * u = rs.2 * v
iseqv := by
refine' ⟨_, _, _⟩
· rintro ⟨r, s⟩
use 1
use 1
simp [Submonoid.one_mem]
· rintro ⟨r, s⟩ ⟨r', s'⟩ ⟨u, v, hru, hsu⟩
rcases ore_condition (s : R) s' with ⟨r₂, s₂, h₁⟩
rcases ore_condition r₂ u with ⟨r₃, s₃, h₂⟩
have : (s : R) * ((v : R) * r₃) = (s : R) * (s₂ * s₃) :=
by
assoc_rw [h₁, h₂, hsu]
symm
apply mul_assoc
rcases ore_left_cancel (v * r₃) (s₂ * s₃) s this with ⟨w, hw⟩
use s₂ * s₃ * w
use u * r₃ * w
constructor <;> simp only [Submonoid.coe_mul]
· assoc_rw [hru, ← hw]
simp [mul_assoc]
· assoc_rw [hsu, ← hw]
simp [mul_assoc]
· rintro ⟨r₁, s₁⟩ ⟨r₂, s₂⟩ ⟨r₃, s₃⟩ ⟨u, v, hur₁, hs₁u⟩ ⟨u', v', hur₂, hs₂u⟩
rcases ore_condition v' u with ⟨r', s', h⟩
use u' * s'
use v * r'
constructor <;> simp only [Submonoid.coe_mul]
· assoc_rw [hur₂, h, hur₁, mul_assoc]
· assoc_rw [hs₂u, h, hs₁u, mul_assoc]
#align ore_localization.ore_eqv OreLocalization.oreEqv
end OreLocalization
#print OreLocalization /-
/-- The ore localization of a monoid and a submonoid fulfilling the ore condition. -/
def OreLocalization (R : Type _) [Monoid R] (S : Submonoid R) [OreSet S] :=
Quotient (OreLocalization.oreEqv R S)
#align ore_localization OreLocalization
-/
namespace OreLocalization
section Monoid
variable {R : Type _} [Monoid R] {S : Submonoid R}
variable (R S) [OreSet S]
-- mathport name: «expr [ ⁻¹]»
notation:1075 R "[" S "⁻¹]" => OreLocalization R S
attribute [local instance] ore_eqv
variable {R S}
/- warning: ore_localization.ore_div -> OreLocalization.oreDiv is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S], R -> (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) -> (OreLocalization.{u1} R _inst_1 S _inst_2)
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S], R -> (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) -> (OreLocalization.{u1} R _inst_1 S _inst_2)
Case conversion may be inaccurate. Consider using '#align ore_localization.ore_div OreLocalization.oreDivₓ'. -/
/-- The division in the ore localization `R[S⁻¹]`, as a fraction of an element of `R` and `S`. -/
def oreDiv (r : R) (s : S) : R[S⁻¹] :=
Quotient.mk' (r, s)
#align ore_localization.ore_div OreLocalization.oreDiv
-- mathport name: «expr /ₒ »
infixl:70 " /ₒ " => oreDiv
/- warning: ore_localization.ind -> OreLocalization.ind is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] {β : (OreLocalization.{u1} R _inst_1 S _inst_2) -> Prop}, (forall (r : R) (s : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S), β (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r s)) -> (forall (q : OreLocalization.{u1} R _inst_1 S _inst_2), β q)
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] {β : (OreLocalization.{u1} R _inst_1 S _inst_2) -> Prop}, (forall (r : R) (s : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)), β (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r s)) -> (forall (q : OreLocalization.{u1} R _inst_1 S _inst_2), β q)
Case conversion may be inaccurate. Consider using '#align ore_localization.ind OreLocalization.indₓ'. -/
@[elab_as_elim]
protected theorem ind {β : R[S⁻¹] → Prop} (c : ∀ (r : R) (s : S), β (r /ₒ s)) : ∀ q, β q :=
by
apply Quotient.ind
rintro ⟨r, s⟩
exact c r s
#align ore_localization.ind OreLocalization.ind
/- warning: ore_localization.ore_div_eq_iff -> OreLocalization.oreDiv_eq_iff is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] {r₁ : R} {r₂ : R} {s₁ : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S} {s₂ : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S}, Iff (Eq.{succ u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r₁ s₁) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r₂ s₂)) (Exists.{succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (fun (u : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) => Exists.{succ u1} R (fun (v : R) => And (Eq.{succ u1} R (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) r₂ ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S))))) u)) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) r₁ v)) (Eq.{succ u1} R (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S))))) s₂) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S))))) u)) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S))))) s₁) v)))))
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] {r₁ : R} {r₂ : R} {s₁ : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)} {s₂ : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)}, Iff (Eq.{succ u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r₁ s₁) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r₂ s₂)) (Exists.{succ u1} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (fun (u : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) => Exists.{succ u1} R (fun (v : R) => And (Eq.{succ u1} R (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) r₂ (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) S)) u)) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) r₁ v)) (Eq.{succ u1} R (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) S)) s₂) (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) S)) u)) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) S)) s₁) v)))))
Case conversion may be inaccurate. Consider using '#align ore_localization.ore_div_eq_iff OreLocalization.oreDiv_eq_iffₓ'. -/
theorem oreDiv_eq_iff {r₁ r₂ : R} {s₁ s₂ : S} :
r₁ /ₒ s₁ = r₂ /ₒ s₂ ↔ ∃ (u : S)(v : R), r₂ * u = r₁ * v ∧ (s₂ : R) * u = s₁ * v :=
Quotient.eq''
#align ore_localization.ore_div_eq_iff OreLocalization.oreDiv_eq_iff
/- warning: ore_localization.expand -> OreLocalization.expand is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] (r : R) (s : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (t : R) (hst : Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S))))) s) t) S), Eq.{succ u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r s) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) r t) (Subtype.mk.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S))))) s) t) hst))
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] (r : R) (s : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (t : R) (hst : Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) S)) s) t) S), Eq.{succ u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r s) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) r t) (Subtype.mk.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) S)) s) t) hst))
Case conversion may be inaccurate. Consider using '#align ore_localization.expand OreLocalization.expandₓ'. -/
/-- A fraction `r /ₒ s` is equal to its expansion by an arbitrary factor `t` if `s * t ∈ S`. -/
protected theorem expand (r : R) (s : S) (t : R) (hst : (s : R) * t ∈ S) :
r /ₒ s = r * t /ₒ ⟨s * t, hst⟩ := by
apply Quotient.sound
refine' ⟨s, t * s, _, _⟩ <;> dsimp <;> rw [mul_assoc] <;> rfl
#align ore_localization.expand OreLocalization.expand
/- warning: ore_localization.expand' -> OreLocalization.expand' is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] (r : R) (s : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (s' : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S), Eq.{succ u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r s) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) r ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S))))) s')) (HMul.hMul.{u1, u1, u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (instHMul.{u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (Submonoid.mul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S)) s s'))
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] (r : R) (s : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (s' : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)), Eq.{succ u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r s) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) r (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) S)) s')) (HMul.hMul.{u1, u1, u1} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (instHMul.{u1} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (Submonoid.mul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S)) s s'))
Case conversion may be inaccurate. Consider using '#align ore_localization.expand' OreLocalization.expand'ₓ'. -/
/-- A fraction is equal to its expansion by an factor from s. -/
protected theorem expand' (r : R) (s s' : S) : r /ₒ s = r * s' /ₒ (s * s') :=
OreLocalization.expand r s s' (by norm_cast <;> apply SetLike.coe_mem)
#align ore_localization.expand' OreLocalization.expand'
/- warning: ore_localization.eq_of_num_factor_eq -> OreLocalization.eq_of_num_factor_eq is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] {r : R} {r' : R} {r₁ : R} {r₂ : R} {s : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S} {t : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S}, (Eq.{succ u1} R (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) r ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S))))) t)) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) r' ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S))))) t))) -> (Eq.{succ u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) r₁ r) r₂) s) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) r₁ r') r₂) s))
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] {r : R} {r' : R} {r₁ : R} {r₂ : R} {s : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)} {t : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)}, (Eq.{succ u1} R (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) r (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) S)) t)) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) r' (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) S)) t))) -> (Eq.{succ u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) r₁ r) r₂) s) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) r₁ r') r₂) s))
Case conversion may be inaccurate. Consider using '#align ore_localization.eq_of_num_factor_eq OreLocalization.eq_of_num_factor_eqₓ'. -/
/-- Fractions which differ by a factor of the numerator can be proven equal if
those factors expand to equal elements of `R`. -/
protected theorem eq_of_num_factor_eq {r r' r₁ r₂ : R} {s t : S} (h : r * t = r' * t) :
r₁ * r * r₂ /ₒ s = r₁ * r' * r₂ /ₒ s :=
by
rcases ore_condition r₂ t with ⟨r₂', t', hr₂⟩
calc
r₁ * r * r₂ /ₒ s = r₁ * r * r₂ * t' /ₒ (s * t') := OreLocalization.expand _ _ t' _
_ = r₁ * r * (r₂ * t') /ₒ (s * t') := by simp [← mul_assoc]
_ = r₁ * r * (t * r₂') /ₒ (s * t') := by rw [hr₂]
_ = r₁ * (r * t) * r₂' /ₒ (s * t') := by simp [← mul_assoc]
_ = r₁ * (r' * t) * r₂' /ₒ (s * t') := by rw [h]
_ = r₁ * r' * (t * r₂') /ₒ (s * t') := by simp [← mul_assoc]
_ = r₁ * r' * (r₂ * t') /ₒ (s * t') := by rw [hr₂]
_ = r₁ * r' * r₂ * t' /ₒ (s * t') := by simp [← mul_assoc]
_ = r₁ * r' * r₂ /ₒ s := by symm <;> apply OreLocalization.expand
#align ore_localization.eq_of_num_factor_eq OreLocalization.eq_of_num_factor_eq
/- warning: ore_localization.lift_expand -> OreLocalization.liftExpand is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] {C : Sort.{u2}} (P : R -> (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) -> C), (forall (r : R) (t : R) (s : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (ht : Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S))))) s) t) S), Eq.{u2} C (P r s) (P (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) r t) (Subtype.mk.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S))))) s) t) ht))) -> (OreLocalization.{u1} R _inst_1 S _inst_2) -> C
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] {C : Sort.{u2}} (P : R -> (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) -> C), (forall (r : R) (t : R) (s : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (ht : Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) S)) s) t) S), Eq.{u2} C (P r s) (P (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) r t) (Subtype.mk.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) S)) s) t) ht))) -> (OreLocalization.{u1} R _inst_1 S _inst_2) -> C
Case conversion may be inaccurate. Consider using '#align ore_localization.lift_expand OreLocalization.liftExpandₓ'. -/
/-- A function or predicate over `R` and `S` can be lifted to `R[S⁻¹]` if it is invariant
under expansion on the right. -/
def liftExpand {C : Sort _} (P : R → S → C)
(hP : ∀ (r t : R) (s : S) (ht : (s : R) * t ∈ S), P r s = P (r * t) ⟨s * t, ht⟩) : R[S⁻¹] → C :=
Quotient.lift (fun p : R × S => P p.1 p.2) fun p q pq =>
by
cases' p with r₁ s₁
cases' q with r₂ s₂
rcases pq with ⟨u, v, hr₂, hs₂⟩
dsimp at *
have s₁vS : (s₁ : R) * v ∈ S := by
rw [← hs₂, ← S.coe_mul]
exact SetLike.coe_mem (s₂ * u)
replace hs₂ : s₂ * u = ⟨(s₁ : R) * v, s₁vS⟩
· ext
simp [hs₂]
rw [hP r₁ v s₁ s₁vS,
hP r₂ u s₂
(by
norm_cast
rw [hs₂]
assumption),
hr₂]
simpa [← hs₂]
#align ore_localization.lift_expand OreLocalization.liftExpand
/- warning: ore_localization.lift_expand_of -> OreLocalization.liftExpand_of is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] {C : Sort.{u2}} {P : R -> (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) -> C} {hP : forall (r : R) (t : R) (s : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (ht : Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S))))) s) t) S), Eq.{u2} C (P r s) (P (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) r t) (Subtype.mk.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S))))) s) t) ht))} (r : R) (s : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S), Eq.{u2} C (OreLocalization.liftExpand.{u1, u2} R _inst_1 S _inst_2 C P hP (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r s)) (P r s)
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] {C : Sort.{u2}} {P : R -> (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) -> C} {hP : forall (r : R) (t : R) (s : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (ht : Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) S)) s) t) S), Eq.{u2} C (P r s) (P (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) r t) (Subtype.mk.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) S)) s) t) ht))} (r : R) (s : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)), Eq.{u2} C (OreLocalization.liftExpand.{u1, u2} R _inst_1 S _inst_2 C P hP (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r s)) (P r s)
Case conversion may be inaccurate. Consider using '#align ore_localization.lift_expand_of OreLocalization.liftExpand_ofₓ'. -/
@[simp]
theorem liftExpand_of {C : Sort _} {P : R → S → C}
{hP : ∀ (r t : R) (s : S) (ht : (s : R) * t ∈ S), P r s = P (r * t) ⟨s * t, ht⟩} (r : R)
(s : S) : liftExpand P hP (r /ₒ s) = P r s :=
rfl
#align ore_localization.lift_expand_of OreLocalization.liftExpand_of
/- warning: ore_localization.lift₂_expand -> OreLocalization.lift₂Expand is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] {C : Sort.{u2}} (P : R -> (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) -> R -> (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) -> C), (forall (r₁ : R) (t₁ : R) (s₁ : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (ht₁ : Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S))))) s₁) t₁) S) (r₂ : R) (t₂ : R) (s₂ : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (ht₂ : Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S))))) s₂) t₂) S), Eq.{u2} C (P r₁ s₁ r₂ s₂) (P (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) r₁ t₁) (Subtype.mk.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S))))) s₁) t₁) ht₁) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) r₂ t₂) (Subtype.mk.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S))))) s₂) t₂) ht₂))) -> (OreLocalization.{u1} R _inst_1 S _inst_2) -> (OreLocalization.{u1} R _inst_1 S _inst_2) -> C
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] {C : Sort.{u2}} (P : R -> (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) -> R -> (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) -> C), (forall (r₁ : R) (t₁ : R) (s₁ : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (ht₁ : Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) S)) s₁) t₁) S) (r₂ : R) (t₂ : R) (s₂ : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (ht₂ : Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) S)) s₂) t₂) S), Eq.{u2} C (P r₁ s₁ r₂ s₂) (P (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) r₁ t₁) (Subtype.mk.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) S)) s₁) t₁) ht₁) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) r₂ t₂) (Subtype.mk.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) S)) s₂) t₂) ht₂))) -> (OreLocalization.{u1} R _inst_1 S _inst_2) -> (OreLocalization.{u1} R _inst_1 S _inst_2) -> C
Case conversion may be inaccurate. Consider using '#align ore_localization.lift₂_expand OreLocalization.lift₂Expandₓ'. -/
/-- A version of `lift_expand` used to simultaneously lift functions with two arguments
in ``R[S⁻¹]`.-/
def lift₂Expand {C : Sort _} (P : R → S → R → S → C)
(hP :
∀ (r₁ t₁ : R) (s₁ : S) (ht₁ : (s₁ : R) * t₁ ∈ S) (r₂ t₂ : R) (s₂ : S)
(ht₂ : (s₂ : R) * t₂ ∈ S),
P r₁ s₁ r₂ s₂ = P (r₁ * t₁) ⟨s₁ * t₁, ht₁⟩ (r₂ * t₂) ⟨s₂ * t₂, ht₂⟩) :
R[S⁻¹] → R[S⁻¹] → C :=
liftExpand
(fun r₁ s₁ =>
liftExpand (P r₁ s₁) fun r₂ t₂ s₂ ht₂ => by simp [hP r₁ 1 s₁ (by simp) r₂ t₂ s₂ ht₂])
fun r₁ t₁ s₁ ht₁ => by
ext x; induction' x using OreLocalization.ind with r₂ s₂
rw [lift_expand_of, lift_expand_of, hP r₁ t₁ s₁ ht₁ r₂ 1 s₂ (by simp)]; simp
#align ore_localization.lift₂_expand OreLocalization.lift₂Expand
/- warning: ore_localization.lift₂_expand_of -> OreLocalization.lift₂Expand_of is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] {C : Sort.{u2}} {P : R -> (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) -> R -> (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) -> C} {hP : forall (r₁ : R) (t₁ : R) (s₁ : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (ht₁ : Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S))))) s₁) t₁) S) (r₂ : R) (t₂ : R) (s₂ : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (ht₂ : Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S))))) s₂) t₂) S), Eq.{u2} C (P r₁ s₁ r₂ s₂) (P (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) r₁ t₁) (Subtype.mk.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S))))) s₁) t₁) ht₁) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) r₂ t₂) (Subtype.mk.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S))))) s₂) t₂) ht₂))} (r₁ : R) (s₁ : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (r₂ : R) (s₂ : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S), Eq.{u2} C (OreLocalization.lift₂Expand.{u1, u2} R _inst_1 S _inst_2 C P hP (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r₁ s₁) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r₂ s₂)) (P r₁ s₁ r₂ s₂)
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] {C : Sort.{u2}} {P : R -> (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) -> R -> (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) -> C} {hP : forall (r₁ : R) (t₁ : R) (s₁ : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (ht₁ : Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) S)) s₁) t₁) S) (r₂ : R) (t₂ : R) (s₂ : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (ht₂ : Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) S)) s₂) t₂) S), Eq.{u2} C (P r₁ s₁ r₂ s₂) (P (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) r₁ t₁) (Subtype.mk.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) S)) s₁) t₁) ht₁) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) r₂ t₂) (Subtype.mk.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) S)) s₂) t₂) ht₂))} (r₁ : R) (s₁ : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (r₂ : R) (s₂ : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)), Eq.{u2} C (OreLocalization.lift₂Expand.{u1, u2} R _inst_1 S _inst_2 C P hP (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r₁ s₁) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r₂ s₂)) (P r₁ s₁ r₂ s₂)
Case conversion may be inaccurate. Consider using '#align ore_localization.lift₂_expand_of OreLocalization.lift₂Expand_ofₓ'. -/
@[simp]
theorem lift₂Expand_of {C : Sort _} {P : R → S → R → S → C}
{hP :
∀ (r₁ t₁ : R) (s₁ : S) (ht₁ : (s₁ : R) * t₁ ∈ S) (r₂ t₂ : R) (s₂ : S)
(ht₂ : (s₂ : R) * t₂ ∈ S),
P r₁ s₁ r₂ s₂ = P (r₁ * t₁) ⟨s₁ * t₁, ht₁⟩ (r₂ * t₂) ⟨s₂ * t₂, ht₂⟩}
(r₁ : R) (s₁ : S) (r₂ : R) (s₂ : S) : lift₂Expand P hP (r₁ /ₒ s₁) (r₂ /ₒ s₂) = P r₁ s₁ r₂ s₂ :=
rfl
#align ore_localization.lift₂_expand_of OreLocalization.lift₂Expand_of
private def mul' (r₁ : R) (s₁ : S) (r₂ : R) (s₂ : S) : R[S⁻¹] :=
r₁ * oreNum r₂ s₁ /ₒ (s₂ * oreDenom r₂ s₁)
#align ore_localization.mul' ore_localization.mul'
private theorem mul'_char (r₁ r₂ : R) (s₁ s₂ : S) (u : S) (v : R) (huv : r₂ * (u : R) = s₁ * v) :
mul' r₁ s₁ r₂ s₂ = r₁ * v /ₒ (s₂ * u) :=
by
simp only [mul']
have h₀ := ore_eq r₂ s₁; set v₀ := ore_num r₂ s₁; set u₀ := ore_denom r₂ s₁
rcases ore_condition (u₀ : R) u with ⟨r₃, s₃, h₃⟩
have :=
calc
(s₁ : R) * (v * r₃) = r₂ * u * r₃ := by assoc_rw [← huv] <;> symm <;> apply mul_assoc
_ = r₂ * u₀ * s₃ := by assoc_rw [← h₃] <;> rfl
_ = s₁ * (v₀ * s₃) := by assoc_rw [h₀] <;> apply mul_assoc
rcases ore_left_cancel _ _ _ this with ⟨s₄, hs₄⟩
symm; rw [ore_div_eq_iff]
use s₃ * s₄; use r₃ * s₄; simp only [Submonoid.coe_mul]; constructor
· assoc_rw [← hs₄]
simp only [mul_assoc]
· assoc_rw [h₃]
simp only [mul_assoc]
#align ore_localization.mul'_char ore_localization.mul'_char
#print OreLocalization.mul /-
/-- The multiplication on the Ore localization of monoids. -/
protected def mul : R[S⁻¹] → R[S⁻¹] → R[S⁻¹] :=
lift₂Expand mul' fun r₂ p s₂ hp r₁ r s₁ hr =>
by
have h₁ := ore_eq r₁ s₂
set r₁' := ore_num r₁ s₂
set s₂' := ore_denom r₁ s₂
rcases ore_condition (↑s₂ * r₁') ⟨s₂ * p, hp⟩ with ⟨p', s_star, h₂⟩
dsimp at h₂
rcases ore_condition r (s₂' * s_star) with ⟨p_flat, s_flat, h₃⟩
simp only [S.coe_mul] at h₃
have : r₁ * r * s_flat = s₂ * p * (p' * p_flat) :=
by
rw [← mul_assoc, ← h₂, ← h₁, mul_assoc, h₃]
simp only [mul_assoc]
rw [mul'_char (r₂ * p) (r₁ * r) ⟨↑s₂ * p, hp⟩ ⟨↑s₁ * r, hr⟩ _ _ this]
clear this
have hsssp : ↑s₁ * ↑s₂' * ↑s_star * p_flat ∈ S :=
by
rw [mul_assoc, mul_assoc, ← mul_assoc ↑s₂', ← h₃, ← mul_assoc]
exact S.mul_mem hr (SetLike.coe_mem s_flat)
have : (⟨↑s₁ * r, hr⟩ : S) * s_flat = ⟨s₁ * s₂' * s_star * p_flat, hsssp⟩ :=
by
ext
simp only [[anonymous], Submonoid.coe_mul]
rw [mul_assoc, h₃, ← mul_assoc, ← mul_assoc]
rw [this]
clear this
rcases ore_left_cancel (p * p') (r₁' * ↑s_star) s₂ (by simp [← mul_assoc, h₂]) with ⟨s₂'', h₂''⟩
rw [← mul_assoc, mul_assoc r₂, OreLocalization.eq_of_num_factor_eq h₂'']
norm_cast at hsssp⊢
rw [← OreLocalization.expand _ _ _ hsssp, ← mul_assoc]
apply OreLocalization.expand
#align ore_localization.mul OreLocalization.mul
-/
instance : Mul R[S⁻¹] :=
⟨OreLocalization.mul⟩
/- warning: ore_localization.ore_div_mul_ore_div -> OreLocalization.oreDiv_mul_oreDiv is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] {r₁ : R} {r₂ : R} {s₁ : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S} {s₂ : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S}, Eq.{succ u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (HMul.hMul.{u1, u1, u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.{u1} R _inst_1 S _inst_2) (instHMul.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.hasMul.{u1} R _inst_1 S _inst_2)) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r₁ s₁) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r₂ s₂)) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) r₁ (OreLocalization.oreNum.{u1} R _inst_1 S _inst_2 r₂ s₁)) (HMul.hMul.{u1, u1, u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (instHMul.{u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (Submonoid.mul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S)) s₂ (OreLocalization.oreDenom.{u1} R _inst_1 S _inst_2 r₂ s₁)))
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] {r₁ : R} {r₂ : R} {s₁ : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)} {s₂ : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)}, Eq.{succ u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (HMul.hMul.{u1, u1, u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.{u1} R _inst_1 S _inst_2) (instHMul.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instMulOreLocalization.{u1} R _inst_1 S _inst_2)) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r₁ s₁) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r₂ s₂)) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) r₁ (OreLocalization.oreNum.{u1} R _inst_1 S _inst_2 r₂ s₁)) (HMul.hMul.{u1, u1, u1} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (instHMul.{u1} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (Submonoid.mul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S)) s₂ (OreLocalization.oreDenom.{u1} R _inst_1 S _inst_2 r₂ s₁)))
Case conversion may be inaccurate. Consider using '#align ore_localization.ore_div_mul_ore_div OreLocalization.oreDiv_mul_oreDivₓ'. -/
theorem oreDiv_mul_oreDiv {r₁ r₂ : R} {s₁ s₂ : S} :
r₁ /ₒ s₁ * (r₂ /ₒ s₂) = r₁ * oreNum r₂ s₁ /ₒ (s₂ * oreDenom r₂ s₁) :=
rfl
#align ore_localization.ore_div_mul_ore_div OreLocalization.oreDiv_mul_oreDiv
/- warning: ore_localization.ore_div_mul_char -> OreLocalization.oreDiv_mul_char is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] (r₁ : R) (r₂ : R) (s₁ : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (s₂ : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (r' : R) (s' : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S), (Eq.{succ u1} R (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) r₂ ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S))))) s')) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S))))) s₁) r')) -> (Eq.{succ u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (HMul.hMul.{u1, u1, u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.{u1} R _inst_1 S _inst_2) (instHMul.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.hasMul.{u1} R _inst_1 S _inst_2)) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r₁ s₁) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r₂ s₂)) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) r₁ r') (HMul.hMul.{u1, u1, u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (instHMul.{u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (Submonoid.mul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S)) s₂ s')))
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] (r₁ : R) (r₂ : R) (s₁ : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (s₂ : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (r' : R) (s' : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)), (Eq.{succ u1} R (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) r₂ (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) S)) s')) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) S)) s₁) r')) -> (Eq.{succ u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (HMul.hMul.{u1, u1, u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.{u1} R _inst_1 S _inst_2) (instHMul.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instMulOreLocalization.{u1} R _inst_1 S _inst_2)) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r₁ s₁) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r₂ s₂)) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) r₁ r') (HMul.hMul.{u1, u1, u1} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (instHMul.{u1} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (Submonoid.mul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S)) s₂ s')))
Case conversion may be inaccurate. Consider using '#align ore_localization.ore_div_mul_char OreLocalization.oreDiv_mul_charₓ'. -/
/-- A characterization lemma for the multiplication on the Ore localization, allowing for a choice
of Ore numerator and Ore denominator. -/
theorem oreDiv_mul_char (r₁ r₂ : R) (s₁ s₂ : S) (r' : R) (s' : S) (huv : r₂ * (s' : R) = s₁ * r') :
r₁ /ₒ s₁ * (r₂ /ₒ s₂) = r₁ * r' /ₒ (s₂ * s') :=
mul'_char r₁ r₂ s₁ s₂ s' r' huv
#align ore_localization.ore_div_mul_char OreLocalization.oreDiv_mul_char
/- warning: ore_localization.ore_div_mul_char' -> OreLocalization.oreDivMulChar' is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] (r₁ : R) (r₂ : R) (s₁ : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (s₂ : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S), PSigma.{succ u1, succ u1} R (fun (r' : R) => PSigma.{succ u1, 0} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (fun (s' : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) => And (Eq.{succ u1} R (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) r₂ ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S))))) s')) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S))))) s₁) r')) (Eq.{succ u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (HMul.hMul.{u1, u1, u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.{u1} R _inst_1 S _inst_2) (instHMul.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.hasMul.{u1} R _inst_1 S _inst_2)) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r₁ s₁) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r₂ s₂)) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) r₁ r') (HMul.hMul.{u1, u1, u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (instHMul.{u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (Submonoid.mul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S)) s₂ s')))))
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] (r₁ : R) (r₂ : R) (s₁ : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (s₂ : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)), PSigma.{succ u1, succ u1} R (fun (r' : R) => PSigma.{succ u1, 0} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (fun (s' : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) => And (Eq.{succ u1} R (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) r₂ (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) S)) s')) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) S)) s₁) r')) (Eq.{succ u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (HMul.hMul.{u1, u1, u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.{u1} R _inst_1 S _inst_2) (instHMul.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instMulOreLocalization.{u1} R _inst_1 S _inst_2)) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r₁ s₁) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r₂ s₂)) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) r₁ r') (HMul.hMul.{u1, u1, u1} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (instHMul.{u1} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (Submonoid.mul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S)) s₂ s')))))
Case conversion may be inaccurate. Consider using '#align ore_localization.ore_div_mul_char' OreLocalization.oreDivMulChar'ₓ'. -/
/-- Another characterization lemma for the multiplication on the Ore localizaion delivering
Ore witnesses and conditions bundled in a sigma type. -/
def oreDivMulChar' (r₁ r₂ : R) (s₁ s₂ : S) :
Σ'r' : R, Σ's' : S, r₂ * (s' : R) = s₁ * r' ∧ r₁ /ₒ s₁ * (r₂ /ₒ s₂) = r₁ * r' /ₒ (s₂ * s') :=
⟨oreNum r₂ s₁, oreDenom r₂ s₁, ore_eq r₂ s₁, oreDiv_mul_oreDiv⟩
#align ore_localization.ore_div_mul_char' OreLocalization.oreDivMulChar'
instance : One R[S⁻¹] :=
⟨1 /ₒ 1⟩
/- warning: ore_localization.one_def -> OreLocalization.one_def is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S], Eq.{succ u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OfNat.ofNat.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) 1 (OfNat.mk.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) 1 (One.one.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.hasOne.{u1} R _inst_1 S _inst_2)))) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 (OfNat.ofNat.{u1} R 1 (OfNat.mk.{u1} R 1 (One.one.{u1} R (MulOneClass.toHasOne.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))))) (OfNat.ofNat.{u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) 1 (OfNat.mk.{u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) 1 (One.one.{u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (Submonoid.one.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S)))))
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S], Eq.{succ u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OfNat.ofNat.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) 1 (One.toOfNat1.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instOneOreLocalization.{u1} R _inst_1 S _inst_2))) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 (OfNat.ofNat.{u1} R 1 (One.toOfNat1.{u1} R (Monoid.toOne.{u1} R _inst_1))) (OfNat.ofNat.{u1} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) 1 (One.toOfNat1.{u1} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (Submonoid.one.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S))))
Case conversion may be inaccurate. Consider using '#align ore_localization.one_def OreLocalization.one_defₓ'. -/
protected theorem one_def : (1 : R[S⁻¹]) = 1 /ₒ 1 :=
rfl
#align ore_localization.one_def OreLocalization.one_def
instance : Inhabited R[S⁻¹] :=
⟨1⟩
/- warning: ore_localization.div_eq_one' -> OreLocalization.div_eq_one' is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] {r : R} (hr : Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) r S), Eq.{succ u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r (Subtype.mk.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S) r hr)) (OfNat.ofNat.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) 1 (OfNat.mk.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) 1 (One.one.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.hasOne.{u1} R _inst_1 S _inst_2))))
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] {r : R} (hr : Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) r S), Eq.{succ u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r (Subtype.mk.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S) r hr)) (OfNat.ofNat.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) 1 (One.toOfNat1.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instOneOreLocalization.{u1} R _inst_1 S _inst_2)))
Case conversion may be inaccurate. Consider using '#align ore_localization.div_eq_one' OreLocalization.div_eq_one'ₓ'. -/
@[simp]
protected theorem div_eq_one' {r : R} (hr : r ∈ S) : r /ₒ ⟨r, hr⟩ = 1 :=
by
rw [OreLocalization.one_def, ore_div_eq_iff]
exact ⟨⟨r, hr⟩, 1, by simp, by simp⟩
#align ore_localization.div_eq_one' OreLocalization.div_eq_one'
/- warning: ore_localization.div_eq_one -> OreLocalization.div_eq_one is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] {s : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S}, Eq.{succ u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S))))) s) s) (OfNat.ofNat.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) 1 (OfNat.mk.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) 1 (One.one.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.hasOne.{u1} R _inst_1 S _inst_2))))
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] {s : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)}, Eq.{succ u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) S)) s) s) (OfNat.ofNat.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) 1 (One.toOfNat1.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instOneOreLocalization.{u1} R _inst_1 S _inst_2)))
Case conversion may be inaccurate. Consider using '#align ore_localization.div_eq_one OreLocalization.div_eq_oneₓ'. -/
@[simp]
protected theorem div_eq_one {s : S} : (s : R) /ₒ s = 1 := by
cases s <;> apply OreLocalization.div_eq_one'
#align ore_localization.div_eq_one OreLocalization.div_eq_one
/- warning: ore_localization.one_mul -> OreLocalization.one_mul is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] (x : OreLocalization.{u1} R _inst_1 S _inst_2), Eq.{succ u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (HMul.hMul.{u1, u1, u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.{u1} R _inst_1 S _inst_2) (instHMul.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.hasMul.{u1} R _inst_1 S _inst_2)) (OfNat.ofNat.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) 1 (OfNat.mk.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) 1 (One.one.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.hasOne.{u1} R _inst_1 S _inst_2)))) x) x
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] (x : OreLocalization.{u1} R _inst_1 S _inst_2), Eq.{succ u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (HMul.hMul.{u1, u1, u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.{u1} R _inst_1 S _inst_2) (instHMul.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instMulOreLocalization.{u1} R _inst_1 S _inst_2)) (OfNat.ofNat.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) 1 (One.toOfNat1.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instOneOreLocalization.{u1} R _inst_1 S _inst_2))) x) x
Case conversion may be inaccurate. Consider using '#align ore_localization.one_mul OreLocalization.one_mulₓ'. -/
protected theorem one_mul (x : R[S⁻¹]) : 1 * x = x :=
by
induction' x using OreLocalization.ind with r s
simp [OreLocalization.one_def, ore_div_mul_char (1 : R) r (1 : S) s r 1 (by simp)]
#align ore_localization.one_mul OreLocalization.one_mul
/- warning: ore_localization.mul_one -> OreLocalization.mul_one is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] (x : OreLocalization.{u1} R _inst_1 S _inst_2), Eq.{succ u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (HMul.hMul.{u1, u1, u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.{u1} R _inst_1 S _inst_2) (instHMul.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.hasMul.{u1} R _inst_1 S _inst_2)) x (OfNat.ofNat.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) 1 (OfNat.mk.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) 1 (One.one.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.hasOne.{u1} R _inst_1 S _inst_2))))) x
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] (x : OreLocalization.{u1} R _inst_1 S _inst_2), Eq.{succ u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (HMul.hMul.{u1, u1, u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.{u1} R _inst_1 S _inst_2) (instHMul.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instMulOreLocalization.{u1} R _inst_1 S _inst_2)) x (OfNat.ofNat.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) 1 (One.toOfNat1.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instOneOreLocalization.{u1} R _inst_1 S _inst_2)))) x
Case conversion may be inaccurate. Consider using '#align ore_localization.mul_one OreLocalization.mul_oneₓ'. -/
protected theorem mul_one (x : R[S⁻¹]) : x * 1 = x :=
by
induction' x using OreLocalization.ind with r s
simp [OreLocalization.one_def, ore_div_mul_char r 1 s 1 1 s (by simp)]
#align ore_localization.mul_one OreLocalization.mul_one
#print OreLocalization.mul_assoc /-
protected theorem mul_assoc (x y z : R[S⁻¹]) : x * y * z = x * (y * z) :=
by
induction' x using OreLocalization.ind with r₁ s₁
induction' y using OreLocalization.ind with r₂ s₂
induction' z using OreLocalization.ind with r₃ s₃
rcases ore_div_mul_char' r₁ r₂ s₁ s₂ with ⟨ra, sa, ha, ha'⟩; rw [ha']; clear ha'
rcases ore_div_mul_char' r₂ r₃ s₂ s₃ with ⟨rb, sb, hb, hb'⟩; rw [hb']; clear hb'
rcases ore_condition rb sa with ⟨rc, sc, hc⟩
rw [ore_div_mul_char (r₁ * ra) r₃ (s₂ * sa) s₃ rc (sb * sc)
(by
simp only [Submonoid.coe_mul]
assoc_rw [hb, hc])]
rw [mul_assoc, ← mul_assoc s₃]
symm; apply ore_div_mul_char
assoc_rw [hc, ← ha]; apply mul_assoc
#align ore_localization.mul_assoc OreLocalization.mul_assoc
-/
instance : Monoid R[S⁻¹] :=
{ OreLocalization.hasMul,
OreLocalization.hasOne with
one_mul := OreLocalization.one_mul
mul_one := OreLocalization.mul_one
mul_assoc := OreLocalization.mul_assoc }
/- warning: ore_localization.mul_inv -> OreLocalization.mul_inv is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] (s : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (s' : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S), Eq.{succ u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (HMul.hMul.{u1, u1, u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.{u1} R _inst_1 S _inst_2) (instHMul.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.hasMul.{u1} R _inst_1 S _inst_2)) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S))))) s) s') (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S))))) s') s)) (OfNat.ofNat.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) 1 (OfNat.mk.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) 1 (One.one.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.hasOne.{u1} R _inst_1 S _inst_2))))
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] (s : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (s' : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)), Eq.{succ u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (HMul.hMul.{u1, u1, u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.{u1} R _inst_1 S _inst_2) (instHMul.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instMulOreLocalization.{u1} R _inst_1 S _inst_2)) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) S)) s) s') (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) S)) s') s)) (OfNat.ofNat.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) 1 (One.toOfNat1.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instOneOreLocalization.{u1} R _inst_1 S _inst_2)))
Case conversion may be inaccurate. Consider using '#align ore_localization.mul_inv OreLocalization.mul_invₓ'. -/
protected theorem mul_inv (s s' : S) : (s : R) /ₒ s' * (s' /ₒ s) = 1 := by
simp [ore_div_mul_char (s : R) s' s' s 1 1 (by simp)]
#align ore_localization.mul_inv OreLocalization.mul_inv
/- warning: ore_localization.mul_one_div -> OreLocalization.mul_one_div is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] {r : R} {s : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S} {t : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S}, Eq.{succ u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (HMul.hMul.{u1, u1, u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.{u1} R _inst_1 S _inst_2) (instHMul.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.hasMul.{u1} R _inst_1 S _inst_2)) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r s) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 (OfNat.ofNat.{u1} R 1 (OfNat.mk.{u1} R 1 (One.one.{u1} R (MulOneClass.toHasOne.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))))) t)) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r (HMul.hMul.{u1, u1, u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (instHMul.{u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (Submonoid.mul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S)) t s))
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] {r : R} {s : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)} {t : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)}, Eq.{succ u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (HMul.hMul.{u1, u1, u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.{u1} R _inst_1 S _inst_2) (instHMul.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instMulOreLocalization.{u1} R _inst_1 S _inst_2)) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r s) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 (OfNat.ofNat.{u1} R 1 (One.toOfNat1.{u1} R (Monoid.toOne.{u1} R _inst_1))) t)) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r (HMul.hMul.{u1, u1, u1} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (instHMul.{u1} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (Submonoid.mul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S)) t s))
Case conversion may be inaccurate. Consider using '#align ore_localization.mul_one_div OreLocalization.mul_one_divₓ'. -/
@[simp]
protected theorem mul_one_div {r : R} {s t : S} : r /ₒ s * (1 /ₒ t) = r /ₒ (t * s) := by
simp [ore_div_mul_char r 1 s t 1 s (by simp)]
#align ore_localization.mul_one_div OreLocalization.mul_one_div
/- warning: ore_localization.mul_cancel -> OreLocalization.mul_cancel is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] {r : R} {s : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S} {t : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S}, Eq.{succ u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (HMul.hMul.{u1, u1, u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.{u1} R _inst_1 S _inst_2) (instHMul.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.hasMul.{u1} R _inst_1 S _inst_2)) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r s) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S))))) s) t)) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r t)
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] {r : R} {s : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)} {t : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)}, Eq.{succ u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (HMul.hMul.{u1, u1, u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.{u1} R _inst_1 S _inst_2) (instHMul.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instMulOreLocalization.{u1} R _inst_1 S _inst_2)) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r s) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) S)) s) t)) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r t)
Case conversion may be inaccurate. Consider using '#align ore_localization.mul_cancel OreLocalization.mul_cancelₓ'. -/
@[simp]
protected theorem mul_cancel {r : R} {s t : S} : r /ₒ s * (s /ₒ t) = r /ₒ t := by
simp [ore_div_mul_char r s s t 1 1 (by simp)]
#align ore_localization.mul_cancel OreLocalization.mul_cancel
/- warning: ore_localization.mul_cancel' -> OreLocalization.mul_cancel' is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] {r₁ : R} {r₂ : R} {s : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S} {t : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S}, Eq.{succ u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (HMul.hMul.{u1, u1, u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.{u1} R _inst_1 S _inst_2) (instHMul.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.hasMul.{u1} R _inst_1 S _inst_2)) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r₁ s) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S))))) s) r₂) t)) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) r₁ r₂) t)
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] {r₁ : R} {r₂ : R} {s : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)} {t : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)}, Eq.{succ u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (HMul.hMul.{u1, u1, u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.{u1} R _inst_1 S _inst_2) (instHMul.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instMulOreLocalization.{u1} R _inst_1 S _inst_2)) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r₁ s) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) S)) s) r₂) t)) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) r₁ r₂) t)
Case conversion may be inaccurate. Consider using '#align ore_localization.mul_cancel' OreLocalization.mul_cancel'ₓ'. -/
@[simp]
protected theorem mul_cancel' {r₁ r₂ : R} {s t : S} : r₁ /ₒ s * (s * r₂ /ₒ t) = r₁ * r₂ /ₒ t := by
simp [ore_div_mul_char r₁ (s * r₂) s t r₂ 1 (by simp)]
#align ore_localization.mul_cancel' OreLocalization.mul_cancel'
/- warning: ore_localization.div_one_mul -> OreLocalization.div_one_mul is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] {p : R} {r : R} {s : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S}, Eq.{succ u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (HMul.hMul.{u1, u1, u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.{u1} R _inst_1 S _inst_2) (instHMul.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.hasMul.{u1} R _inst_1 S _inst_2)) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r (OfNat.ofNat.{u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) 1 (OfNat.mk.{u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) 1 (One.one.{u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (Submonoid.one.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S))))) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 p s)) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) r p) s)
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] {p : R} {r : R} {s : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)}, Eq.{succ u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (HMul.hMul.{u1, u1, u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.{u1} R _inst_1 S _inst_2) (instHMul.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instMulOreLocalization.{u1} R _inst_1 S _inst_2)) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r (OfNat.ofNat.{u1} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) 1 (One.toOfNat1.{u1} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (Submonoid.one.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S)))) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 p s)) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) r p) s)
Case conversion may be inaccurate. Consider using '#align ore_localization.div_one_mul OreLocalization.div_one_mulₓ'. -/
@[simp]
theorem div_one_mul {p r : R} {s : S} : r /ₒ 1 * (p /ₒ s) = r * p /ₒ s :=
by--TODO use coercion r ↦ r /ₒ 1
simp [ore_div_mul_char r p 1 s p 1 (by simp)]
#align ore_localization.div_one_mul OreLocalization.div_one_mul
/- warning: ore_localization.numerator_unit -> OreLocalization.numeratorUnit is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S], (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) -> (Units.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.monoid.{u1} R _inst_1 S _inst_2))
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S], (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) -> (Units.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R _inst_1 S _inst_2))
Case conversion may be inaccurate. Consider using '#align ore_localization.numerator_unit OreLocalization.numeratorUnitₓ'. -/
/-- The fraction `s /ₒ 1` as a unit in `R[S⁻¹]`, where `s : S`. -/
def numeratorUnit (s : S) : Units R[S⁻¹]
where
val := (s : R) /ₒ 1
inv := (1 : R) /ₒ s
val_inv := OreLocalization.mul_inv s 1
inv_val := OreLocalization.mul_inv 1 s
#align ore_localization.numerator_unit OreLocalization.numeratorUnit
/- warning: ore_localization.numerator_hom -> OreLocalization.numeratorHom is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S], MonoidHom.{u1, u1} R (OreLocalization.{u1} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.monoid.{u1} R _inst_1 S _inst_2))
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S], MonoidHom.{u1, u1} R (OreLocalization.{u1} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R _inst_1 S _inst_2))
Case conversion may be inaccurate. Consider using '#align ore_localization.numerator_hom OreLocalization.numeratorHomₓ'. -/
/-- The multiplicative homomorphism from `R` to `R[S⁻¹]`, mapping `r : R` to the
fraction `r /ₒ 1`. -/
def numeratorHom : R →* R[S⁻¹] where
toFun r := r /ₒ 1
map_one' := rfl
map_mul' r₁ r₂ := div_one_mul.symm
#align ore_localization.numerator_hom OreLocalization.numeratorHom
/- warning: ore_localization.numerator_hom_apply -> OreLocalization.numeratorHom_apply is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] {r : R}, Eq.{succ u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} R (OreLocalization.{u1} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.monoid.{u1} R _inst_1 S _inst_2))) (fun (_x : MonoidHom.{u1, u1} R (OreLocalization.{u1} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.monoid.{u1} R _inst_1 S _inst_2))) => R -> (OreLocalization.{u1} R _inst_1 S _inst_2)) (MonoidHom.hasCoeToFun.{u1, u1} R (OreLocalization.{u1} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.monoid.{u1} R _inst_1 S _inst_2))) (OreLocalization.numeratorHom.{u1} R _inst_1 S _inst_2) r) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r (OfNat.ofNat.{u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) 1 (OfNat.mk.{u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) 1 (One.one.{u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (Submonoid.one.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S)))))
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] {r : R}, Eq.{succ u1} ((fun ([email protected]._hyg.2391 : R) => OreLocalization.{u1} R _inst_1 S _inst_2) r) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} R (OreLocalization.{u1} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R _inst_1 S _inst_2))) R (fun (_x : R) => (fun ([email protected]._hyg.2391 : R) => OreLocalization.{u1} R _inst_1 S _inst_2) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} R (OreLocalization.{u1} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R _inst_1 S _inst_2))) R (OreLocalization.{u1} R _inst_1 S _inst_2) (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (MulOneClass.toMul.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R _inst_1 S _inst_2))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} R (OreLocalization.{u1} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R _inst_1 S _inst_2))) R (OreLocalization.{u1} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R _inst_1 S _inst_2)) (MonoidHom.monoidHomClass.{u1, u1} R (OreLocalization.{u1} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R _inst_1 S _inst_2))))) (OreLocalization.numeratorHom.{u1} R _inst_1 S _inst_2) r) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r (OfNat.ofNat.{u1} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) 1 (One.toOfNat1.{u1} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (Submonoid.one.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S))))
Case conversion may be inaccurate. Consider using '#align ore_localization.numerator_hom_apply OreLocalization.numeratorHom_applyₓ'. -/
theorem numeratorHom_apply {r : R} : numeratorHom r = r /ₒ (1 : S) :=
rfl
#align ore_localization.numerator_hom_apply OreLocalization.numeratorHom_apply
/- warning: ore_localization.numerator_is_unit -> OreLocalization.numerator_isUnit is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] (s : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S), IsUnit.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.monoid.{u1} R _inst_1 S _inst_2) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} R (OreLocalization.{u1} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.monoid.{u1} R _inst_1 S _inst_2))) (fun (_x : MonoidHom.{u1, u1} R (OreLocalization.{u1} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.monoid.{u1} R _inst_1 S _inst_2))) => R -> (OreLocalization.{u1} R _inst_1 S _inst_2)) (MonoidHom.hasCoeToFun.{u1, u1} R (OreLocalization.{u1} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.monoid.{u1} R _inst_1 S _inst_2))) (OreLocalization.numeratorHom.{u1} R _inst_1 S _inst_2) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S))))) s))
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] (s : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)), IsUnit.{u1} ((fun ([email protected]._hyg.2391 : R) => OreLocalization.{u1} R _inst_1 S _inst_2) (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) S)) s)) (OreLocalization.instMonoidOreLocalization.{u1} R _inst_1 S _inst_2) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} R (OreLocalization.{u1} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R _inst_1 S _inst_2))) R (fun (_x : R) => (fun ([email protected]._hyg.2391 : R) => OreLocalization.{u1} R _inst_1 S _inst_2) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} R (OreLocalization.{u1} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R _inst_1 S _inst_2))) R (OreLocalization.{u1} R _inst_1 S _inst_2) (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (MulOneClass.toMul.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R _inst_1 S _inst_2))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} R (OreLocalization.{u1} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R _inst_1 S _inst_2))) R (OreLocalization.{u1} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R _inst_1 S _inst_2)) (MonoidHom.monoidHomClass.{u1, u1} R (OreLocalization.{u1} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R _inst_1 S _inst_2))))) (OreLocalization.numeratorHom.{u1} R _inst_1 S _inst_2) (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) S)) s))
Case conversion may be inaccurate. Consider using '#align ore_localization.numerator_is_unit OreLocalization.numerator_isUnitₓ'. -/
theorem numerator_isUnit (s : S) : IsUnit (numeratorHom (s : R) : R[S⁻¹]) :=
⟨numeratorUnit s, rfl⟩
#align ore_localization.numerator_is_unit OreLocalization.numerator_isUnit
section UMP
variable {T : Type _} [Monoid T]
variable (f : R →* T) (fS : S →* Units T)
variable (hf : ∀ s : S, f s = fS s)
include f fS hf
/- warning: ore_localization.universal_mul_hom -> OreLocalization.universalMulHom is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] {T : Type.{u2}} [_inst_3 : Monoid.{u2} T] (f : MonoidHom.{u1, u2} R T (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} T _inst_3)) (fS : MonoidHom.{u1, u2} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (Units.{u2} T _inst_3) (Submonoid.toMulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S) (Units.mulOneClass.{u2} T _inst_3)), (forall (s : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S), Eq.{succ u2} T (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} R T (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} T _inst_3)) (fun (_x : MonoidHom.{u1, u2} R T (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} T _inst_3)) => R -> T) (MonoidHom.hasCoeToFun.{u1, u2} R T (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} T _inst_3)) f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S))))) s)) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} T _inst_3) T (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} T _inst_3) T (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} T _inst_3) T (coeBase.{succ u2, succ u2} (Units.{u2} T _inst_3) T (Units.hasCoe.{u2} T _inst_3)))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (Units.{u2} T _inst_3) (Submonoid.toMulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S) (Units.mulOneClass.{u2} T _inst_3)) (fun (_x : MonoidHom.{u1, u2} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (Units.{u2} T _inst_3) (Submonoid.toMulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S) (Units.mulOneClass.{u2} T _inst_3)) => (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) -> (Units.{u2} T _inst_3)) (MonoidHom.hasCoeToFun.{u1, u2} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (Units.{u2} T _inst_3) (Submonoid.toMulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S) (Units.mulOneClass.{u2} T _inst_3)) fS s))) -> (MonoidHom.{u1, u2} (OreLocalization.{u1} R _inst_1 S _inst_2) T (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.monoid.{u1} R _inst_1 S _inst_2)) (Monoid.toMulOneClass.{u2} T _inst_3))
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] {T : Type.{u2}} [_inst_3 : Monoid.{u2} T] (f : MonoidHom.{u1, u2} R T (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} T _inst_3)) (fS : MonoidHom.{u1, u2} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (Units.{u2} T _inst_3) (Submonoid.toMulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S) (Units.instMulOneClassUnits.{u2} T _inst_3)), (forall (s : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)), Eq.{succ u2} ((fun ([email protected]._hyg.2391 : R) => T) (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) S)) s)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} R T (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} T _inst_3)) R (fun (_x : R) => (fun ([email protected]._hyg.2391 : R) => T) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} R T (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} T _inst_3)) R T (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (MulOneClass.toMul.{u2} T (Monoid.toMulOneClass.{u2} T _inst_3)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} R T (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} T _inst_3)) R T (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} T _inst_3) (MonoidHom.monoidHomClass.{u1, u2} R T (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} T _inst_3)))) f (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) S)) s)) (Units.val.{u2} T _inst_3 (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (Units.{u2} T _inst_3) (Submonoid.toMulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S) (Units.instMulOneClassUnits.{u2} T _inst_3)) (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (fun (_x : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) => (fun ([email protected]._hyg.2391 : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) => Units.{u2} T _inst_3) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (Units.{u2} T _inst_3) (Submonoid.toMulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S) (Units.instMulOneClassUnits.{u2} T _inst_3)) (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (Units.{u2} T _inst_3) (MulOneClass.toMul.{u1} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (Submonoid.toMulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S)) (MulOneClass.toMul.{u2} (Units.{u2} T _inst_3) (Units.instMulOneClassUnits.{u2} T _inst_3)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (Units.{u2} T _inst_3) (Submonoid.toMulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S) (Units.instMulOneClassUnits.{u2} T _inst_3)) (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (Units.{u2} T _inst_3) (Submonoid.toMulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S) (Units.instMulOneClassUnits.{u2} T _inst_3) (MonoidHom.monoidHomClass.{u1, u2} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (Units.{u2} T _inst_3) (Submonoid.toMulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S) (Units.instMulOneClassUnits.{u2} T _inst_3)))) fS s))) -> (MonoidHom.{u1, u2} (OreLocalization.{u1} R _inst_1 S _inst_2) T (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R _inst_1 S _inst_2)) (Monoid.toMulOneClass.{u2} T _inst_3))
Case conversion may be inaccurate. Consider using '#align ore_localization.universal_mul_hom OreLocalization.universalMulHomₓ'. -/
/-- The universal lift from a morphism `R →* T`, which maps elements of `S` to units of `T`,
to a morphism `R[S⁻¹] →* T`. -/
def universalMulHom : R[S⁻¹] →* T
where
toFun x :=
x.liftExpand (fun r s => f r * ((fS s)⁻¹ : Units T)) fun r t s ht =>
by
have : (fS ⟨s * t, ht⟩ : T) = fS s * f t := by
simp only [← hf, [anonymous], MonoidHom.map_mul]
conv_rhs =>
rw [MonoidHom.map_mul, ← mul_one (f r), ← Units.val_one, ← mul_left_inv (fS s)]
rw [Units.val_mul, ← mul_assoc, mul_assoc _ ↑(fS s), ← this, mul_assoc]
simp only [mul_one, Units.mul_inv]
map_one' := by rw [OreLocalization.one_def, lift_expand_of] <;> simp
map_mul' x y := by
induction' x using OreLocalization.ind with r₁ s₁
induction' y using OreLocalization.ind with r₂ s₂
rcases ore_div_mul_char' r₁ r₂ s₁ s₂ with ⟨ra, sa, ha, ha'⟩; rw [ha']; clear ha'
rw [lift_expand_of, lift_expand_of, lift_expand_of]
conv_rhs =>
congr
skip
congr
rw [← mul_one (f r₂), ← (fS sa).mul_inv, ← mul_assoc, ← hf, ← f.map_mul, ha, f.map_mul]
rw [mul_assoc, mul_assoc, mul_assoc, ← mul_assoc _ (f s₁), hf s₁, (fS s₁).inv_mul, one_mul,
f.map_mul, mul_assoc, fS.map_mul, ← Units.val_mul]
rfl
#align ore_localization.universal_mul_hom OreLocalization.universalMulHom
/- warning: ore_localization.universal_mul_hom_apply -> OreLocalization.universalMulHom_apply is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] {T : Type.{u2}} [_inst_3 : Monoid.{u2} T] (f : MonoidHom.{u1, u2} R T (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} T _inst_3)) (fS : MonoidHom.{u1, u2} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (Units.{u2} T _inst_3) (Submonoid.toMulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S) (Units.mulOneClass.{u2} T _inst_3)) (hf : forall (s : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S), Eq.{succ u2} T (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} R T (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} T _inst_3)) (fun (_x : MonoidHom.{u1, u2} R T (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} T _inst_3)) => R -> T) (MonoidHom.hasCoeToFun.{u1, u2} R T (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} T _inst_3)) f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S))))) s)) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} T _inst_3) T (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} T _inst_3) T (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} T _inst_3) T (coeBase.{succ u2, succ u2} (Units.{u2} T _inst_3) T (Units.hasCoe.{u2} T _inst_3)))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (Units.{u2} T _inst_3) (Submonoid.toMulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S) (Units.mulOneClass.{u2} T _inst_3)) (fun (_x : MonoidHom.{u1, u2} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (Units.{u2} T _inst_3) (Submonoid.toMulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S) (Units.mulOneClass.{u2} T _inst_3)) => (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) -> (Units.{u2} T _inst_3)) (MonoidHom.hasCoeToFun.{u1, u2} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (Units.{u2} T _inst_3) (Submonoid.toMulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S) (Units.mulOneClass.{u2} T _inst_3)) fS s))) {r : R} {s : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S}, Eq.{succ u2} T (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (OreLocalization.{u1} R _inst_1 S _inst_2) T (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.monoid.{u1} R _inst_1 S _inst_2)) (Monoid.toMulOneClass.{u2} T _inst_3)) (fun (_x : MonoidHom.{u1, u2} (OreLocalization.{u1} R _inst_1 S _inst_2) T (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.monoid.{u1} R _inst_1 S _inst_2)) (Monoid.toMulOneClass.{u2} T _inst_3)) => (OreLocalization.{u1} R _inst_1 S _inst_2) -> T) (MonoidHom.hasCoeToFun.{u1, u2} (OreLocalization.{u1} R _inst_1 S _inst_2) T (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.monoid.{u1} R _inst_1 S _inst_2)) (Monoid.toMulOneClass.{u2} T _inst_3)) (OreLocalization.universalMulHom.{u1, u2} R _inst_1 S _inst_2 T _inst_3 f fS hf) (OreLocalization.oreDiv.{u1} R _inst_1 S _inst_2 r s)) (HMul.hMul.{u2, u2, u2} T T T (instHMul.{u2} T (MulOneClass.toHasMul.{u2} T (Monoid.toMulOneClass.{u2} T _inst_3))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} R T (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} T _inst_3)) (fun (_x : MonoidHom.{u1, u2} R T (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} T _inst_3)) => R -> T) (MonoidHom.hasCoeToFun.{u1, u2} R T (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} T _inst_3)) f r) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} T _inst_3) T (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} T _inst_3) T (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} T _inst_3) T (coeBase.{succ u2, succ u2} (Units.{u2} T _inst_3) T (Units.hasCoe.{u2} T _inst_3)))) (Inv.inv.{u2} (Units.{u2} T _inst_3) (Units.hasInv.{u2} T _inst_3) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (Units.{u2} T _inst_3) (Submonoid.toMulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S) (Units.mulOneClass.{u2} T _inst_3)) (fun (_x : MonoidHom.{u1, u2} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (Units.{u2} T _inst_3) (Submonoid.toMulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S) (Units.mulOneClass.{u2} T _inst_3)) => (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) -> (Units.{u2} T _inst_3)) (MonoidHom.hasCoeToFun.{u1, u2} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (Units.{u2} T _inst_3) (Submonoid.toMulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S) (Units.mulOneClass.{u2} T _inst_3)) fS s))))
but is expected to have type
forall {R : Type.{u2}} [_inst_1 : Monoid.{u2} R] {S : Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u2} R _inst_1 S] {T : Type.{u1}} [_inst_3 : Monoid.{u1} T] (f : MonoidHom.{u2, u1} R T (Monoid.toMulOneClass.{u2} R _inst_1) (Monoid.toMulOneClass.{u1} T _inst_3)) (fS : MonoidHom.{u2, u1} (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1))) x S)) (Units.{u1} T _inst_3) (Submonoid.toMulOneClass.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1) S) (Units.instMulOneClassUnits.{u1} T _inst_3)) (hf : forall (s : Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1))) x S)), Eq.{succ u1} ((fun ([email protected]._hyg.2391 : R) => T) (Subtype.val.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Set.{u2} R) (Set.instMembershipSet.{u2} R) x (SetLike.coe.{u2, u2} (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) S)) s)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} R T (Monoid.toMulOneClass.{u2} R _inst_1) (Monoid.toMulOneClass.{u1} T _inst_3)) R (fun (_x : R) => (fun ([email protected]._hyg.2391 : R) => T) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} R T (Monoid.toMulOneClass.{u2} R _inst_1) (Monoid.toMulOneClass.{u1} T _inst_3)) R T (MulOneClass.toMul.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) (MulOneClass.toMul.{u1} T (Monoid.toMulOneClass.{u1} T _inst_3)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} R T (Monoid.toMulOneClass.{u2} R _inst_1) (Monoid.toMulOneClass.{u1} T _inst_3)) R T (Monoid.toMulOneClass.{u2} R _inst_1) (Monoid.toMulOneClass.{u1} T _inst_3) (MonoidHom.monoidHomClass.{u2, u1} R T (Monoid.toMulOneClass.{u2} R _inst_1) (Monoid.toMulOneClass.{u1} T _inst_3)))) f (Subtype.val.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Set.{u2} R) (Set.instMembershipSet.{u2} R) x (SetLike.coe.{u2, u2} (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) S)) s)) (Units.val.{u1} T _inst_3 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1))) x S)) (Units.{u1} T _inst_3) (Submonoid.toMulOneClass.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1) S) (Units.instMulOneClassUnits.{u1} T _inst_3)) (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1))) x S)) (fun (_x : Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1))) x S)) => (fun ([email protected]._hyg.2391 : Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1))) x S)) => Units.{u1} T _inst_3) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1))) x S)) (Units.{u1} T _inst_3) (Submonoid.toMulOneClass.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1) S) (Units.instMulOneClassUnits.{u1} T _inst_3)) (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1))) x S)) (Units.{u1} T _inst_3) (MulOneClass.toMul.{u2} (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1))) x S)) (Submonoid.toMulOneClass.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1) S)) (MulOneClass.toMul.{u1} (Units.{u1} T _inst_3) (Units.instMulOneClassUnits.{u1} T _inst_3)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1))) x S)) (Units.{u1} T _inst_3) (Submonoid.toMulOneClass.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1) S) (Units.instMulOneClassUnits.{u1} T _inst_3)) (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1))) x S)) (Units.{u1} T _inst_3) (Submonoid.toMulOneClass.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1) S) (Units.instMulOneClassUnits.{u1} T _inst_3) (MonoidHom.monoidHomClass.{u2, u1} (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1))) x S)) (Units.{u1} T _inst_3) (Submonoid.toMulOneClass.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1) S) (Units.instMulOneClassUnits.{u1} T _inst_3)))) fS s))) {r : R} {s : Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1))) x S)}, Eq.{succ u1} ((fun ([email protected]._hyg.2391 : OreLocalization.{u2} R _inst_1 S _inst_2) => T) (OreLocalization.oreDiv.{u2} R _inst_1 S _inst_2 r s)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} (OreLocalization.{u2} R _inst_1 S _inst_2) T (Monoid.toMulOneClass.{u2} (OreLocalization.{u2} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u2} R _inst_1 S _inst_2)) (Monoid.toMulOneClass.{u1} T _inst_3)) (OreLocalization.{u2} R _inst_1 S _inst_2) (fun (_x : OreLocalization.{u2} R _inst_1 S _inst_2) => (fun ([email protected]._hyg.2391 : OreLocalization.{u2} R _inst_1 S _inst_2) => T) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} (OreLocalization.{u2} R _inst_1 S _inst_2) T (Monoid.toMulOneClass.{u2} (OreLocalization.{u2} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u2} R _inst_1 S _inst_2)) (Monoid.toMulOneClass.{u1} T _inst_3)) (OreLocalization.{u2} R _inst_1 S _inst_2) T (MulOneClass.toMul.{u2} (OreLocalization.{u2} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u2} (OreLocalization.{u2} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u2} R _inst_1 S _inst_2))) (MulOneClass.toMul.{u1} T (Monoid.toMulOneClass.{u1} T _inst_3)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} (OreLocalization.{u2} R _inst_1 S _inst_2) T (Monoid.toMulOneClass.{u2} (OreLocalization.{u2} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u2} R _inst_1 S _inst_2)) (Monoid.toMulOneClass.{u1} T _inst_3)) (OreLocalization.{u2} R _inst_1 S _inst_2) T (Monoid.toMulOneClass.{u2} (OreLocalization.{u2} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u2} R _inst_1 S _inst_2)) (Monoid.toMulOneClass.{u1} T _inst_3) (MonoidHom.monoidHomClass.{u2, u1} (OreLocalization.{u2} R _inst_1 S _inst_2) T (Monoid.toMulOneClass.{u2} (OreLocalization.{u2} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u2} R _inst_1 S _inst_2)) (Monoid.toMulOneClass.{u1} T _inst_3)))) (OreLocalization.universalMulHom.{u2, u1} R _inst_1 S _inst_2 T _inst_3 f fS hf) (OreLocalization.oreDiv.{u2} R _inst_1 S _inst_2 r s)) (HMul.hMul.{u1, u1, u1} ((fun ([email protected]._hyg.2391 : R) => T) r) T ((fun ([email protected]._hyg.2391 : R) => T) r) (instHMul.{u1} ((fun ([email protected]._hyg.2391 : R) => T) r) (MulOneClass.toMul.{u1} ((fun ([email protected]._hyg.2391 : R) => T) r) (Monoid.toMulOneClass.{u1} ((fun ([email protected]._hyg.2391 : R) => T) r) _inst_3))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} R T (Monoid.toMulOneClass.{u2} R _inst_1) (Monoid.toMulOneClass.{u1} T _inst_3)) R (fun (_x : R) => (fun ([email protected]._hyg.2391 : R) => T) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} R T (Monoid.toMulOneClass.{u2} R _inst_1) (Monoid.toMulOneClass.{u1} T _inst_3)) R T (MulOneClass.toMul.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) (MulOneClass.toMul.{u1} T (Monoid.toMulOneClass.{u1} T _inst_3)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} R T (Monoid.toMulOneClass.{u2} R _inst_1) (Monoid.toMulOneClass.{u1} T _inst_3)) R T (Monoid.toMulOneClass.{u2} R _inst_1) (Monoid.toMulOneClass.{u1} T _inst_3) (MonoidHom.monoidHomClass.{u2, u1} R T (Monoid.toMulOneClass.{u2} R _inst_1) (Monoid.toMulOneClass.{u1} T _inst_3)))) f r) (Units.val.{u1} T _inst_3 (Inv.inv.{u1} (Units.{u1} T _inst_3) (Units.instInvUnits.{u1} T _inst_3) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1))) x S)) (Units.{u1} T _inst_3) (Submonoid.toMulOneClass.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1) S) (Units.instMulOneClassUnits.{u1} T _inst_3)) (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1))) x S)) (fun (_x : Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1))) x S)) => (fun ([email protected]._hyg.2391 : Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1))) x S)) => Units.{u1} T _inst_3) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1))) x S)) (Units.{u1} T _inst_3) (Submonoid.toMulOneClass.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1) S) (Units.instMulOneClassUnits.{u1} T _inst_3)) (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1))) x S)) (Units.{u1} T _inst_3) (MulOneClass.toMul.{u2} (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1))) x S)) (Submonoid.toMulOneClass.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1) S)) (MulOneClass.toMul.{u1} (Units.{u1} T _inst_3) (Units.instMulOneClassUnits.{u1} T _inst_3)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1))) x S)) (Units.{u1} T _inst_3) (Submonoid.toMulOneClass.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1) S) (Units.instMulOneClassUnits.{u1} T _inst_3)) (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1))) x S)) (Units.{u1} T _inst_3) (Submonoid.toMulOneClass.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1) S) (Units.instMulOneClassUnits.{u1} T _inst_3) (MonoidHom.monoidHomClass.{u2, u1} (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1))) x S)) (Units.{u1} T _inst_3) (Submonoid.toMulOneClass.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1) S) (Units.instMulOneClassUnits.{u1} T _inst_3)))) fS s))))
Case conversion may be inaccurate. Consider using '#align ore_localization.universal_mul_hom_apply OreLocalization.universalMulHom_applyₓ'. -/
theorem universalMulHom_apply {r : R} {s : S} :
universalMulHom f fS hf (r /ₒ s) = f r * ((fS s)⁻¹ : Units T) :=
rfl
#align ore_localization.universal_mul_hom_apply OreLocalization.universalMulHom_apply
/- warning: ore_localization.universal_mul_hom_commutes -> OreLocalization.universalMulHom_commutes is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] {T : Type.{u2}} [_inst_3 : Monoid.{u2} T] (f : MonoidHom.{u1, u2} R T (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} T _inst_3)) (fS : MonoidHom.{u1, u2} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (Units.{u2} T _inst_3) (Submonoid.toMulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S) (Units.mulOneClass.{u2} T _inst_3)) (hf : forall (s : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S), Eq.{succ u2} T (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} R T (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} T _inst_3)) (fun (_x : MonoidHom.{u1, u2} R T (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} T _inst_3)) => R -> T) (MonoidHom.hasCoeToFun.{u1, u2} R T (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} T _inst_3)) f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S))))) s)) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} T _inst_3) T (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} T _inst_3) T (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} T _inst_3) T (coeBase.{succ u2, succ u2} (Units.{u2} T _inst_3) T (Units.hasCoe.{u2} T _inst_3)))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (Units.{u2} T _inst_3) (Submonoid.toMulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S) (Units.mulOneClass.{u2} T _inst_3)) (fun (_x : MonoidHom.{u1, u2} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (Units.{u2} T _inst_3) (Submonoid.toMulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S) (Units.mulOneClass.{u2} T _inst_3)) => (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) -> (Units.{u2} T _inst_3)) (MonoidHom.hasCoeToFun.{u1, u2} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (Units.{u2} T _inst_3) (Submonoid.toMulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S) (Units.mulOneClass.{u2} T _inst_3)) fS s))) {r : R}, Eq.{succ u2} T (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (OreLocalization.{u1} R _inst_1 S _inst_2) T (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.monoid.{u1} R _inst_1 S _inst_2)) (Monoid.toMulOneClass.{u2} T _inst_3)) (fun (_x : MonoidHom.{u1, u2} (OreLocalization.{u1} R _inst_1 S _inst_2) T (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.monoid.{u1} R _inst_1 S _inst_2)) (Monoid.toMulOneClass.{u2} T _inst_3)) => (OreLocalization.{u1} R _inst_1 S _inst_2) -> T) (MonoidHom.hasCoeToFun.{u1, u2} (OreLocalization.{u1} R _inst_1 S _inst_2) T (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.monoid.{u1} R _inst_1 S _inst_2)) (Monoid.toMulOneClass.{u2} T _inst_3)) (OreLocalization.universalMulHom.{u1, u2} R _inst_1 S _inst_2 T _inst_3 f fS hf) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} R (OreLocalization.{u1} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.monoid.{u1} R _inst_1 S _inst_2))) (fun (_x : MonoidHom.{u1, u1} R (OreLocalization.{u1} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.monoid.{u1} R _inst_1 S _inst_2))) => R -> (OreLocalization.{u1} R _inst_1 S _inst_2)) (MonoidHom.hasCoeToFun.{u1, u1} R (OreLocalization.{u1} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.monoid.{u1} R _inst_1 S _inst_2))) (OreLocalization.numeratorHom.{u1} R _inst_1 S _inst_2) r)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} R T (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} T _inst_3)) (fun (_x : MonoidHom.{u1, u2} R T (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} T _inst_3)) => R -> T) (MonoidHom.hasCoeToFun.{u1, u2} R T (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} T _inst_3)) f r)
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] {T : Type.{u2}} [_inst_3 : Monoid.{u2} T] (f : MonoidHom.{u1, u2} R T (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} T _inst_3)) (fS : MonoidHom.{u1, u2} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (Units.{u2} T _inst_3) (Submonoid.toMulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S) (Units.instMulOneClassUnits.{u2} T _inst_3)) (hf : forall (s : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)), Eq.{succ u2} ((fun ([email protected]._hyg.2391 : R) => T) (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) S)) s)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} R T (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} T _inst_3)) R (fun (_x : R) => (fun ([email protected]._hyg.2391 : R) => T) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} R T (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} T _inst_3)) R T (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (MulOneClass.toMul.{u2} T (Monoid.toMulOneClass.{u2} T _inst_3)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} R T (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} T _inst_3)) R T (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} T _inst_3) (MonoidHom.monoidHomClass.{u1, u2} R T (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} T _inst_3)))) f (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) S)) s)) (Units.val.{u2} T _inst_3 (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (Units.{u2} T _inst_3) (Submonoid.toMulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S) (Units.instMulOneClassUnits.{u2} T _inst_3)) (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (fun (_x : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) => (fun ([email protected]._hyg.2391 : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) => Units.{u2} T _inst_3) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (Units.{u2} T _inst_3) (Submonoid.toMulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S) (Units.instMulOneClassUnits.{u2} T _inst_3)) (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (Units.{u2} T _inst_3) (MulOneClass.toMul.{u1} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (Submonoid.toMulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S)) (MulOneClass.toMul.{u2} (Units.{u2} T _inst_3) (Units.instMulOneClassUnits.{u2} T _inst_3)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (Units.{u2} T _inst_3) (Submonoid.toMulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S) (Units.instMulOneClassUnits.{u2} T _inst_3)) (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (Units.{u2} T _inst_3) (Submonoid.toMulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S) (Units.instMulOneClassUnits.{u2} T _inst_3) (MonoidHom.monoidHomClass.{u1, u2} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S)) (Units.{u2} T _inst_3) (Submonoid.toMulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S) (Units.instMulOneClassUnits.{u2} T _inst_3)))) fS s))) {r : R}, Eq.{succ u2} ((fun ([email protected]._hyg.2391 : OreLocalization.{u1} R _inst_1 S _inst_2) => T) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} R (OreLocalization.{u1} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R _inst_1 S _inst_2))) R (fun (a : R) => (fun ([email protected]._hyg.2391 : R) => OreLocalization.{u1} R _inst_1 S _inst_2) a) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} R (OreLocalization.{u1} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R _inst_1 S _inst_2))) R (OreLocalization.{u1} R _inst_1 S _inst_2) (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (MulOneClass.toMul.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R _inst_1 S _inst_2))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} R (OreLocalization.{u1} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R _inst_1 S _inst_2))) R (OreLocalization.{u1} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R _inst_1 S _inst_2)) (MonoidHom.monoidHomClass.{u1, u1} R (OreLocalization.{u1} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R _inst_1 S _inst_2))))) (OreLocalization.numeratorHom.{u1} R _inst_1 S _inst_2) r)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (OreLocalization.{u1} R _inst_1 S _inst_2) T (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R _inst_1 S _inst_2)) (Monoid.toMulOneClass.{u2} T _inst_3)) (OreLocalization.{u1} R _inst_1 S _inst_2) (fun (_x : OreLocalization.{u1} R _inst_1 S _inst_2) => (fun ([email protected]._hyg.2391 : OreLocalization.{u1} R _inst_1 S _inst_2) => T) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (OreLocalization.{u1} R _inst_1 S _inst_2) T (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R _inst_1 S _inst_2)) (Monoid.toMulOneClass.{u2} T _inst_3)) (OreLocalization.{u1} R _inst_1 S _inst_2) T (MulOneClass.toMul.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R _inst_1 S _inst_2))) (MulOneClass.toMul.{u2} T (Monoid.toMulOneClass.{u2} T _inst_3)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (OreLocalization.{u1} R _inst_1 S _inst_2) T (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R _inst_1 S _inst_2)) (Monoid.toMulOneClass.{u2} T _inst_3)) (OreLocalization.{u1} R _inst_1 S _inst_2) T (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R _inst_1 S _inst_2)) (Monoid.toMulOneClass.{u2} T _inst_3) (MonoidHom.monoidHomClass.{u1, u2} (OreLocalization.{u1} R _inst_1 S _inst_2) T (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R _inst_1 S _inst_2)) (Monoid.toMulOneClass.{u2} T _inst_3)))) (OreLocalization.universalMulHom.{u1, u2} R _inst_1 S _inst_2 T _inst_3 f fS hf) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} R (OreLocalization.{u1} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R _inst_1 S _inst_2))) R (fun (_x : R) => (fun ([email protected]._hyg.2391 : R) => OreLocalization.{u1} R _inst_1 S _inst_2) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} R (OreLocalization.{u1} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R _inst_1 S _inst_2))) R (OreLocalization.{u1} R _inst_1 S _inst_2) (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (MulOneClass.toMul.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R _inst_1 S _inst_2))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} R (OreLocalization.{u1} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R _inst_1 S _inst_2))) R (OreLocalization.{u1} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R _inst_1 S _inst_2)) (MonoidHom.monoidHomClass.{u1, u1} R (OreLocalization.{u1} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R _inst_1 S _inst_2))))) (OreLocalization.numeratorHom.{u1} R _inst_1 S _inst_2) r)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} R T (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} T _inst_3)) R (fun (_x : R) => (fun ([email protected]._hyg.2391 : R) => T) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} R T (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} T _inst_3)) R T (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (MulOneClass.toMul.{u2} T (Monoid.toMulOneClass.{u2} T _inst_3)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} R T (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} T _inst_3)) R T (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} T _inst_3) (MonoidHom.monoidHomClass.{u1, u2} R T (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} T _inst_3)))) f r)
Case conversion may be inaccurate. Consider using '#align ore_localization.universal_mul_hom_commutes OreLocalization.universalMulHom_commutesₓ'. -/
theorem universalMulHom_commutes {r : R} : universalMulHom f fS hf (numeratorHom r) = f r := by
simp [numerator_hom_apply, universal_mul_hom_apply]
#align ore_localization.universal_mul_hom_commutes OreLocalization.universalMulHom_commutes
/- warning: ore_localization.universal_mul_hom_unique -> OreLocalization.universalMulHom_unique is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u1} R _inst_1 S] {T : Type.{u2}} [_inst_3 : Monoid.{u2} T] (f : MonoidHom.{u1, u2} R T (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} T _inst_3)) (fS : MonoidHom.{u1, u2} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (Units.{u2} T _inst_3) (Submonoid.toMulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S) (Units.mulOneClass.{u2} T _inst_3)) (hf : forall (s : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S), Eq.{succ u2} T (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} R T (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} T _inst_3)) (fun (_x : MonoidHom.{u1, u2} R T (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} T _inst_3)) => R -> T) (MonoidHom.hasCoeToFun.{u1, u2} R T (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} T _inst_3)) f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) x S))))) s)) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} T _inst_3) T (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} T _inst_3) T (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} T _inst_3) T (coeBase.{succ u2, succ u2} (Units.{u2} T _inst_3) T (Units.hasCoe.{u2} T _inst_3)))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (Units.{u2} T _inst_3) (Submonoid.toMulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S) (Units.mulOneClass.{u2} T _inst_3)) (fun (_x : MonoidHom.{u1, u2} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (Units.{u2} T _inst_3) (Submonoid.toMulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S) (Units.mulOneClass.{u2} T _inst_3)) => (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) -> (Units.{u2} T _inst_3)) (MonoidHom.hasCoeToFun.{u1, u2} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) S) (Units.{u2} T _inst_3) (Submonoid.toMulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1) S) (Units.mulOneClass.{u2} T _inst_3)) fS s))) (φ : MonoidHom.{u1, u2} (OreLocalization.{u1} R _inst_1 S _inst_2) T (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.monoid.{u1} R _inst_1 S _inst_2)) (Monoid.toMulOneClass.{u2} T _inst_3)), (forall (r : R), Eq.{succ u2} T (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (OreLocalization.{u1} R _inst_1 S _inst_2) T (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.monoid.{u1} R _inst_1 S _inst_2)) (Monoid.toMulOneClass.{u2} T _inst_3)) (fun (_x : MonoidHom.{u1, u2} (OreLocalization.{u1} R _inst_1 S _inst_2) T (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.monoid.{u1} R _inst_1 S _inst_2)) (Monoid.toMulOneClass.{u2} T _inst_3)) => (OreLocalization.{u1} R _inst_1 S _inst_2) -> T) (MonoidHom.hasCoeToFun.{u1, u2} (OreLocalization.{u1} R _inst_1 S _inst_2) T (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.monoid.{u1} R _inst_1 S _inst_2)) (Monoid.toMulOneClass.{u2} T _inst_3)) φ (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} R (OreLocalization.{u1} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.monoid.{u1} R _inst_1 S _inst_2))) (fun (_x : MonoidHom.{u1, u1} R (OreLocalization.{u1} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.monoid.{u1} R _inst_1 S _inst_2))) => R -> (OreLocalization.{u1} R _inst_1 S _inst_2)) (MonoidHom.hasCoeToFun.{u1, u1} R (OreLocalization.{u1} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.monoid.{u1} R _inst_1 S _inst_2))) (OreLocalization.numeratorHom.{u1} R _inst_1 S _inst_2) r)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} R T (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} T _inst_3)) (fun (_x : MonoidHom.{u1, u2} R T (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} T _inst_3)) => R -> T) (MonoidHom.hasCoeToFun.{u1, u2} R T (Monoid.toMulOneClass.{u1} R _inst_1) (Monoid.toMulOneClass.{u2} T _inst_3)) f r)) -> (Eq.{max (succ u2) (succ u1)} (MonoidHom.{u1, u2} (OreLocalization.{u1} R _inst_1 S _inst_2) T (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R _inst_1 S _inst_2) (OreLocalization.monoid.{u1} R _inst_1 S _inst_2)) (Monoid.toMulOneClass.{u2} T _inst_3)) φ (OreLocalization.universalMulHom.{u1, u2} R _inst_1 S _inst_2 T _inst_3 f fS hf))
but is expected to have type
forall {R : Type.{u2}} [_inst_1 : Monoid.{u2} R] {S : Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)} [_inst_2 : OreLocalization.OreSet.{u2} R _inst_1 S] {T : Type.{u1}} [_inst_3 : Monoid.{u1} T] (f : MonoidHom.{u2, u1} R T (Monoid.toMulOneClass.{u2} R _inst_1) (Monoid.toMulOneClass.{u1} T _inst_3)) (fS : MonoidHom.{u2, u1} (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1))) x S)) (Units.{u1} T _inst_3) (Submonoid.toMulOneClass.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1) S) (Units.instMulOneClassUnits.{u1} T _inst_3)) (hf : forall (s : Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1))) x S)), Eq.{succ u1} ((fun ([email protected]._hyg.2391 : R) => T) (Subtype.val.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Set.{u2} R) (Set.instMembershipSet.{u2} R) x (SetLike.coe.{u2, u2} (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) S)) s)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} R T (Monoid.toMulOneClass.{u2} R _inst_1) (Monoid.toMulOneClass.{u1} T _inst_3)) R (fun (_x : R) => (fun ([email protected]._hyg.2391 : R) => T) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} R T (Monoid.toMulOneClass.{u2} R _inst_1) (Monoid.toMulOneClass.{u1} T _inst_3)) R T (MulOneClass.toMul.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) (MulOneClass.toMul.{u1} T (Monoid.toMulOneClass.{u1} T _inst_3)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} R T (Monoid.toMulOneClass.{u2} R _inst_1) (Monoid.toMulOneClass.{u1} T _inst_3)) R T (Monoid.toMulOneClass.{u2} R _inst_1) (Monoid.toMulOneClass.{u1} T _inst_3) (MonoidHom.monoidHomClass.{u2, u1} R T (Monoid.toMulOneClass.{u2} R _inst_1) (Monoid.toMulOneClass.{u1} T _inst_3)))) f (Subtype.val.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Set.{u2} R) (Set.instMembershipSet.{u2} R) x (SetLike.coe.{u2, u2} (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) S)) s)) (Units.val.{u1} T _inst_3 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1))) x S)) (Units.{u1} T _inst_3) (Submonoid.toMulOneClass.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1) S) (Units.instMulOneClassUnits.{u1} T _inst_3)) (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1))) x S)) (fun (_x : Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1))) x S)) => (fun ([email protected]._hyg.2391 : Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1))) x S)) => Units.{u1} T _inst_3) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1))) x S)) (Units.{u1} T _inst_3) (Submonoid.toMulOneClass.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1) S) (Units.instMulOneClassUnits.{u1} T _inst_3)) (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1))) x S)) (Units.{u1} T _inst_3) (MulOneClass.toMul.{u2} (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1))) x S)) (Submonoid.toMulOneClass.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1) S)) (MulOneClass.toMul.{u1} (Units.{u1} T _inst_3) (Units.instMulOneClassUnits.{u1} T _inst_3)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1))) x S)) (Units.{u1} T _inst_3) (Submonoid.toMulOneClass.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1) S) (Units.instMulOneClassUnits.{u1} T _inst_3)) (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1))) x S)) (Units.{u1} T _inst_3) (Submonoid.toMulOneClass.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1) S) (Units.instMulOneClassUnits.{u1} T _inst_3) (MonoidHom.monoidHomClass.{u2, u1} (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) R (Submonoid.instSetLikeSubmonoid.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1))) x S)) (Units.{u1} T _inst_3) (Submonoid.toMulOneClass.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1) S) (Units.instMulOneClassUnits.{u1} T _inst_3)))) fS s))) (φ : MonoidHom.{u2, u1} (OreLocalization.{u2} R _inst_1 S _inst_2) T (Monoid.toMulOneClass.{u2} (OreLocalization.{u2} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u2} R _inst_1 S _inst_2)) (Monoid.toMulOneClass.{u1} T _inst_3)), (forall (r : R), Eq.{succ u1} ((fun ([email protected]._hyg.2391 : OreLocalization.{u2} R _inst_1 S _inst_2) => T) (FunLike.coe.{succ u2, succ u2, succ u2} (MonoidHom.{u2, u2} R (OreLocalization.{u2} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u2} R _inst_1) (Monoid.toMulOneClass.{u2} (OreLocalization.{u2} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u2} R _inst_1 S _inst_2))) R (fun (a : R) => (fun ([email protected]._hyg.2391 : R) => OreLocalization.{u2} R _inst_1 S _inst_2) a) (MulHomClass.toFunLike.{u2, u2, u2} (MonoidHom.{u2, u2} R (OreLocalization.{u2} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u2} R _inst_1) (Monoid.toMulOneClass.{u2} (OreLocalization.{u2} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u2} R _inst_1 S _inst_2))) R (OreLocalization.{u2} R _inst_1 S _inst_2) (MulOneClass.toMul.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) (MulOneClass.toMul.{u2} (OreLocalization.{u2} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u2} (OreLocalization.{u2} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u2} R _inst_1 S _inst_2))) (MonoidHomClass.toMulHomClass.{u2, u2, u2} (MonoidHom.{u2, u2} R (OreLocalization.{u2} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u2} R _inst_1) (Monoid.toMulOneClass.{u2} (OreLocalization.{u2} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u2} R _inst_1 S _inst_2))) R (OreLocalization.{u2} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u2} R _inst_1) (Monoid.toMulOneClass.{u2} (OreLocalization.{u2} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u2} R _inst_1 S _inst_2)) (MonoidHom.monoidHomClass.{u2, u2} R (OreLocalization.{u2} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u2} R _inst_1) (Monoid.toMulOneClass.{u2} (OreLocalization.{u2} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u2} R _inst_1 S _inst_2))))) (OreLocalization.numeratorHom.{u2} R _inst_1 S _inst_2) r)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} (OreLocalization.{u2} R _inst_1 S _inst_2) T (Monoid.toMulOneClass.{u2} (OreLocalization.{u2} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u2} R _inst_1 S _inst_2)) (Monoid.toMulOneClass.{u1} T _inst_3)) (OreLocalization.{u2} R _inst_1 S _inst_2) (fun (_x : OreLocalization.{u2} R _inst_1 S _inst_2) => (fun ([email protected]._hyg.2391 : OreLocalization.{u2} R _inst_1 S _inst_2) => T) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} (OreLocalization.{u2} R _inst_1 S _inst_2) T (Monoid.toMulOneClass.{u2} (OreLocalization.{u2} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u2} R _inst_1 S _inst_2)) (Monoid.toMulOneClass.{u1} T _inst_3)) (OreLocalization.{u2} R _inst_1 S _inst_2) T (MulOneClass.toMul.{u2} (OreLocalization.{u2} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u2} (OreLocalization.{u2} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u2} R _inst_1 S _inst_2))) (MulOneClass.toMul.{u1} T (Monoid.toMulOneClass.{u1} T _inst_3)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} (OreLocalization.{u2} R _inst_1 S _inst_2) T (Monoid.toMulOneClass.{u2} (OreLocalization.{u2} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u2} R _inst_1 S _inst_2)) (Monoid.toMulOneClass.{u1} T _inst_3)) (OreLocalization.{u2} R _inst_1 S _inst_2) T (Monoid.toMulOneClass.{u2} (OreLocalization.{u2} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u2} R _inst_1 S _inst_2)) (Monoid.toMulOneClass.{u1} T _inst_3) (MonoidHom.monoidHomClass.{u2, u1} (OreLocalization.{u2} R _inst_1 S _inst_2) T (Monoid.toMulOneClass.{u2} (OreLocalization.{u2} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u2} R _inst_1 S _inst_2)) (Monoid.toMulOneClass.{u1} T _inst_3)))) φ (FunLike.coe.{succ u2, succ u2, succ u2} (MonoidHom.{u2, u2} R (OreLocalization.{u2} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u2} R _inst_1) (Monoid.toMulOneClass.{u2} (OreLocalization.{u2} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u2} R _inst_1 S _inst_2))) R (fun (_x : R) => (fun ([email protected]._hyg.2391 : R) => OreLocalization.{u2} R _inst_1 S _inst_2) _x) (MulHomClass.toFunLike.{u2, u2, u2} (MonoidHom.{u2, u2} R (OreLocalization.{u2} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u2} R _inst_1) (Monoid.toMulOneClass.{u2} (OreLocalization.{u2} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u2} R _inst_1 S _inst_2))) R (OreLocalization.{u2} R _inst_1 S _inst_2) (MulOneClass.toMul.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) (MulOneClass.toMul.{u2} (OreLocalization.{u2} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u2} (OreLocalization.{u2} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u2} R _inst_1 S _inst_2))) (MonoidHomClass.toMulHomClass.{u2, u2, u2} (MonoidHom.{u2, u2} R (OreLocalization.{u2} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u2} R _inst_1) (Monoid.toMulOneClass.{u2} (OreLocalization.{u2} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u2} R _inst_1 S _inst_2))) R (OreLocalization.{u2} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u2} R _inst_1) (Monoid.toMulOneClass.{u2} (OreLocalization.{u2} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u2} R _inst_1 S _inst_2)) (MonoidHom.monoidHomClass.{u2, u2} R (OreLocalization.{u2} R _inst_1 S _inst_2) (Monoid.toMulOneClass.{u2} R _inst_1) (Monoid.toMulOneClass.{u2} (OreLocalization.{u2} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u2} R _inst_1 S _inst_2))))) (OreLocalization.numeratorHom.{u2} R _inst_1 S _inst_2) r)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} R T (Monoid.toMulOneClass.{u2} R _inst_1) (Monoid.toMulOneClass.{u1} T _inst_3)) R (fun (_x : R) => (fun ([email protected]._hyg.2391 : R) => T) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} R T (Monoid.toMulOneClass.{u2} R _inst_1) (Monoid.toMulOneClass.{u1} T _inst_3)) R T (MulOneClass.toMul.{u2} R (Monoid.toMulOneClass.{u2} R _inst_1)) (MulOneClass.toMul.{u1} T (Monoid.toMulOneClass.{u1} T _inst_3)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} R T (Monoid.toMulOneClass.{u2} R _inst_1) (Monoid.toMulOneClass.{u1} T _inst_3)) R T (Monoid.toMulOneClass.{u2} R _inst_1) (Monoid.toMulOneClass.{u1} T _inst_3) (MonoidHom.monoidHomClass.{u2, u1} R T (Monoid.toMulOneClass.{u2} R _inst_1) (Monoid.toMulOneClass.{u1} T _inst_3)))) f r)) -> (Eq.{max (succ u2) (succ u1)} (MonoidHom.{u2, u1} (OreLocalization.{u2} R _inst_1 S _inst_2) T (Monoid.toMulOneClass.{u2} (OreLocalization.{u2} R _inst_1 S _inst_2) (OreLocalization.instMonoidOreLocalization.{u2} R _inst_1 S _inst_2)) (Monoid.toMulOneClass.{u1} T _inst_3)) φ (OreLocalization.universalMulHom.{u2, u1} R _inst_1 S _inst_2 T _inst_3 f fS hf))
Case conversion may be inaccurate. Consider using '#align ore_localization.universal_mul_hom_unique OreLocalization.universalMulHom_uniqueₓ'. -/
/-- The universal morphism `universal_mul_hom` is unique. -/
theorem universalMulHom_unique (φ : R[S⁻¹] →* T) (huniv : ∀ r : R, φ (numeratorHom r) = f r) :
φ = universalMulHom f fS hf := by
ext; induction' x using OreLocalization.ind with r s
rw [universal_mul_hom_apply, ← huniv r, numerator_hom_apply, ← mul_one (φ (r /ₒ s)), ←
Units.val_one, ← mul_right_inv (fS s), Units.val_mul, ← mul_assoc, ← hf, ← huniv, ← φ.map_mul,
numerator_hom_apply, OreLocalization.mul_cancel]
#align ore_localization.universal_mul_hom_unique OreLocalization.universalMulHom_unique
end UMP
end Monoid
section CommMonoid
variable {R : Type _} [CommMonoid R] {S : Submonoid R} [OreSet S]
/- warning: ore_localization.ore_div_mul_ore_div_comm -> OreLocalization.oreDiv_mul_oreDiv_comm is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : CommMonoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1))} [_inst_2 : OreLocalization.OreSet.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1) S] {r₁ : R} {r₂ : R} {s₁ : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1))) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1)))) S} {s₂ : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1))) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1)))) S}, Eq.{succ u1} (OreLocalization.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1) S _inst_2) (HMul.hMul.{u1, u1, u1} (OreLocalization.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1) S _inst_2) (OreLocalization.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1) S _inst_2) (OreLocalization.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1) S _inst_2) (instHMul.{u1} (OreLocalization.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1) S _inst_2) (OreLocalization.hasMul.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1) S _inst_2)) (OreLocalization.oreDiv.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1) S _inst_2 r₁ s₁) (OreLocalization.oreDiv.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1) S _inst_2 r₂ s₂)) (OreLocalization.oreDiv.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1) S _inst_2 (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toHasMul.{u1} R (Monoid.toMulOneClass.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1)))) r₁ r₂) (HMul.hMul.{u1, u1, u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1))) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1)))) S) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1))) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1)))) S) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1))) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1)))) S) (instHMul.{u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1))) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1)))) S) (Submonoid.mul.{u1} R (Monoid.toMulOneClass.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1)) S)) s₁ s₂))
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : CommMonoid.{u1} R] {S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1))} [_inst_2 : OreLocalization.OreSet.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1) S] {r₁ : R} {r₂ : R} {s₁ : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1))) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1)))) x S)} {s₂ : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1))) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1)))) x S)}, Eq.{succ u1} (OreLocalization.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1) S _inst_2) (HMul.hMul.{u1, u1, u1} (OreLocalization.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1) S _inst_2) (OreLocalization.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1) S _inst_2) (OreLocalization.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1) S _inst_2) (instHMul.{u1} (OreLocalization.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1) S _inst_2) (OreLocalization.instMulOreLocalization.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1) S _inst_2)) (OreLocalization.oreDiv.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1) S _inst_2 r₁ s₁) (OreLocalization.oreDiv.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1) S _inst_2 r₂ s₂)) (OreLocalization.oreDiv.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1) S _inst_2 (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1)))) r₁ r₂) (HMul.hMul.{u1, u1, u1} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1))) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1)))) x S)) (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1))) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1)))) x S)) (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1))) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1)))) x S)) (instHMul.{u1} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1))) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1)))) x S)) (Submonoid.mul.{u1} R (Monoid.toMulOneClass.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1)) S)) s₁ s₂))
Case conversion may be inaccurate. Consider using '#align ore_localization.ore_div_mul_ore_div_comm OreLocalization.oreDiv_mul_oreDiv_commₓ'. -/
theorem oreDiv_mul_oreDiv_comm {r₁ r₂ : R} {s₁ s₂ : S} :
r₁ /ₒ s₁ * (r₂ /ₒ s₂) = r₁ * r₂ /ₒ (s₁ * s₂) := by
rw [ore_div_mul_char r₁ r₂ s₁ s₂ r₂ s₁ (by simp [mul_comm]), mul_comm s₂]
#align ore_localization.ore_div_mul_ore_div_comm OreLocalization.oreDiv_mul_oreDiv_comm
instance : CommMonoid R[S⁻¹] :=
{ OreLocalization.monoid with
mul_comm := fun x y => by
induction' x using OreLocalization.ind with r₁ s₁
induction' y using OreLocalization.ind with r₂ s₂
rw [ore_div_mul_ore_div_comm, ore_div_mul_ore_div_comm, mul_comm r₁, mul_comm s₁] }
variable (R S)
/- warning: ore_localization.localization_map -> OreLocalization.localizationMap is a dubious translation:
lean 3 declaration is
forall (R : Type.{u1}) [_inst_1 : CommMonoid.{u1} R] (S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1))) [_inst_2 : OreLocalization.OreSet.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1) S], Submonoid.LocalizationMap.{u1, u1} R _inst_1 S (OreLocalization.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1) S _inst_2) (OreLocalization.commMonoid.{u1} R _inst_1 S _inst_2)
but is expected to have type
forall (R : Type.{u1}) [_inst_1 : CommMonoid.{u1} R] (S : Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1))) [_inst_2 : OreLocalization.OreSet.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1) S], Submonoid.LocalizationMap.{u1, u1} R _inst_1 S (OreLocalization.{u1} R (CommMonoid.toMonoid.{u1} R _inst_1) S _inst_2) (OreLocalization.instCommMonoidOreLocalizationToMonoid.{u1} R _inst_1 S _inst_2)
Case conversion may be inaccurate. Consider using '#align ore_localization.localization_map OreLocalization.localizationMapₓ'. -/
/-- The morphism `numerator_hom` is a monoid localization map in the case of commutative `R`. -/
protected def localizationMap : S.LocalizationMap R[S⁻¹]
where
toFun := numeratorHom
map_one' := rfl
map_mul' r₁ r₂ := by simp
map_units' := numerator_isUnit
surj' z := by
induction' z using OreLocalization.ind with r s
use (r, s); dsimp
rw [numerator_hom_apply, numerator_hom_apply]; simp
eq_iff_exists' r₁ r₂ := by
dsimp; constructor
· intro h
rw [numerator_hom_apply, numerator_hom_apply, ore_div_eq_iff] at h
rcases h with ⟨u, v, h₁, h₂⟩
dsimp at h₂
rw [one_mul, one_mul] at h₂
subst h₂
use u
simpa only [mul_comm] using h₁.symm
· rintro ⟨s, h⟩
rw [numerator_hom_apply, numerator_hom_apply, ore_div_eq_iff]
refine' ⟨s, s, _, _⟩
· simpa [mul_comm] using h.symm
· simp [one_mul]
#align ore_localization.localization_map OreLocalization.localizationMap
#print OreLocalization.equivMonoidLocalization /-
/-- If `R` is commutative, Ore localization and monoid localization are isomorphic. -/
protected noncomputable def equivMonoidLocalization : Localization S ≃* R[S⁻¹] :=
Localization.mulEquivOfQuotient (OreLocalization.localizationMap R S)
#align ore_localization.equiv_monoid_localization OreLocalization.equivMonoidLocalization
-/
end CommMonoid
section Semiring
variable {R : Type _} [Semiring R] {S : Submonoid R} [OreSet S]
private def add'' (r₁ : R) (s₁ : S) (r₂ : R) (s₂ : S) : R[S⁻¹] :=
(r₁ * oreDenom (s₁ : R) s₂ + r₂ * oreNum s₁ s₂) /ₒ (s₁ * oreDenom s₁ s₂)
#align ore_localization.add'' ore_localization.add''
private theorem add''_char (r₁ : R) (s₁ : S) (r₂ : R) (s₂ : S) (rb : R) (sb : S)
(hb : (s₁ : R) * sb = (s₂ : R) * rb) : add'' r₁ s₁ r₂ s₂ = (r₁ * sb + r₂ * rb) /ₒ (s₁ * sb) :=
by
simp only [add'']
have ha := ore_eq (s₁ : R) s₂
set! ra := ore_num (s₁ : R) s₂ with h
rw [← h] at *
clear h
-- r tilde
set! sa := ore_denom (s₁ : R) s₂ with h
rw [← h] at *
clear h
-- s tilde
rcases ore_condition (sa : R) sb with ⟨rc, sc, hc⟩
-- s*, r*
have : (s₂ : R) * (rb * rc) = s₂ * (ra * sc) := by
rw [← mul_assoc, ← hb, mul_assoc, ← hc, ← mul_assoc, ← mul_assoc, ha]
rcases ore_left_cancel _ _ s₂ this with ⟨sd, hd⟩
-- s#
symm
rw [ore_div_eq_iff]
use sc * sd
use rc * sd
constructor <;> simp only [Submonoid.coe_mul]
· noncomm_ring
assoc_rw [hd, hc]
noncomm_ring
· assoc_rw [hc]
noncomm_ring
#align ore_localization.add''_char ore_localization.add''_char
attribute [local instance] OreLocalization.oreEqv
private def add' (r₂ : R) (s₂ : S) : R[S⁻¹] → R[S⁻¹] :=
(--plus tilde
Quotient.lift
fun r₁s₁ : R × S => add'' r₁s₁.1 r₁s₁.2 r₂ s₂) <|
by
rintro ⟨r₁', s₁'⟩ ⟨r₁, s₁⟩ ⟨sb, rb, hb, hb'⟩
-- s*, r*
rcases ore_condition (s₁' : R) s₂ with ⟨rc, sc, hc⟩
--s~~, r~~
rcases ore_condition rb sc with ⟨rd, sd, hd⟩
-- s#, r#
dsimp at *
rw [add''_char _ _ _ _ rc sc hc]
have : ↑s₁ * ↑(sb * sd) = ↑s₂ * (rc * rd) :=
by
simp only [Submonoid.coe_mul]
assoc_rw [hb', hd, hc]
noncomm_ring
rw [add''_char _ _ _ _ (rc * rd : R) (sb * sd : S) this]
simp only [Submonoid.coe_mul]
assoc_rw [hb, hd]
rw [← mul_assoc, ← add_mul, ore_div_eq_iff]
use 1
use rd
constructor
· simp
· simp only [mul_one, Submonoid.coe_one, Submonoid.coe_mul] at this⊢
assoc_rw [hc, this]
#align ore_localization.add' ore_localization.add'
private theorem add'_comm (r₁ r₂ : R) (s₁ s₂ : S) : add' r₁ s₁ (r₂ /ₒ s₂) = add' r₂ s₂ (r₁ /ₒ s₁) :=
by
simp only [add', ore_div, add'', Quotient.lift_mk, Quotient.eq']
have hb := ore_eq (↑s₂) s₁
set rb := ore_num (↑s₂) s₁ with h
-- r~~
rw [← h]
clear h
set sb := ore_denom (↑s₂) s₁ with h
rw [← h]
clear h
-- s~~
have ha := ore_eq (↑s₁) s₂
set ra := ore_num (↑s₁) s₂ with h
-- r~
rw [← h]
clear h
set sa := ore_denom (↑s₁) s₂ with h
rw [← h]
clear h
-- s~
rcases ore_condition ra sb with ⟨rc, sc, hc⟩
-- r#, s#
have : (s₁ : R) * (rb * rc) = s₁ * (sa * sc) := by
rw [← mul_assoc, ← hb, mul_assoc, ← hc, ← mul_assoc, ← ha, mul_assoc]
rcases ore_left_cancel _ _ s₁ this with ⟨sd, hd⟩
-- s+
use sc * sd
use rc * sd
dsimp
constructor
· rw [add_mul, add_mul, add_comm]
assoc_rw [← hd, hc]
noncomm_ring
· rw [mul_assoc, ← mul_assoc ↑sa, ← hd, hb]
noncomm_ring
#align ore_localization.add'_comm ore_localization.add'_comm
/-- The addition on the Ore localization. -/
private def add : R[S⁻¹] → R[S⁻¹] → R[S⁻¹] := fun x =>
Quotient.lift (fun rs : R × S => add' rs.1 rs.2 x)
(by
rintro ⟨r₁, s₁⟩ ⟨r₂, s₂⟩ hyz
induction' x using OreLocalization.ind with r₃ s₃
dsimp; rw [add'_comm, add'_comm r₂]
simp [(· /ₒ ·), Quotient.sound hyz])
#align ore_localization.add ore_localization.add
instance : Add R[S⁻¹] :=
⟨add⟩
/- warning: ore_localization.ore_div_add_ore_div -> OreLocalization.oreDiv_add_oreDiv is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] {S : Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))} [_inst_2 : OreLocalization.OreSet.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S] {r : R} {r' : R} {s : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S} {s' : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S}, Eq.{succ u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (HAdd.hAdd.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHAdd.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.hasAdd.{u1} R _inst_1 S _inst_2)) (OreLocalization.oreDiv.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2 r s) (OreLocalization.oreDiv.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2 r' s')) (OreLocalization.oreDiv.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2 (HAdd.hAdd.{u1, u1, u1} R R R (instHAdd.{u1} R (Distrib.toHasAdd.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) r ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1))))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1))))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1))))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1))))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1))))) x S))))) (OreLocalization.oreDenom.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2 ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S))))) s) s'))) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) r' (OreLocalization.oreNum.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2 ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S))))) s) s'))) (HMul.hMul.{u1, u1, u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1))))) S) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1))))) S) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1))))) S) (instHMul.{u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1))))) S) (Submonoid.mul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) S)) s (OreLocalization.oreDenom.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2 ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S))))) s) s')))
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] {S : Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))} [_inst_2 : OreLocalization.OreSet.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S] {r : R} {r' : R} {s : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)} {s' : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)}, Eq.{succ u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (HAdd.hAdd.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHAdd.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instAddOreLocalizationToMonoidToMonoidWithZero.{u1} R _inst_1 S _inst_2)) (OreLocalization.oreDiv.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2 r s) (OreLocalization.oreDiv.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2 r' s')) (OreLocalization.oreDiv.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2 (HAdd.hAdd.{u1, u1, u1} R R R (instHAdd.{u1} R (Distrib.toAdd.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) r (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) S)) (OreLocalization.oreDenom.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2 (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) S)) s) s'))) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) r' (OreLocalization.oreNum.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2 (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) S)) s) s'))) (HMul.hMul.{u1, u1, u1} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)) (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1))))) x S)) (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)) (instHMul.{u1} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)) (Submonoid.mul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) S)) s (OreLocalization.oreDenom.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2 (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) S)) s) s')))
Case conversion may be inaccurate. Consider using '#align ore_localization.ore_div_add_ore_div OreLocalization.oreDiv_add_oreDivₓ'. -/
theorem oreDiv_add_oreDiv {r r' : R} {s s' : S} :
r /ₒ s + r' /ₒ s' = (r * oreDenom (s : R) s' + r' * oreNum s s') /ₒ (s * oreDenom s s') :=
rfl
#align ore_localization.ore_div_add_ore_div OreLocalization.oreDiv_add_oreDiv
/- warning: ore_localization.ore_div_add_char -> OreLocalization.oreDiv_add_char is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] {S : Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))} [_inst_2 : OreLocalization.OreSet.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S] {r : R} {r' : R} (s : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) (s' : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) (rb : R) (sb : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S), (Eq.{succ u1} R (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S))))) s) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S))))) sb)) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S))))) s') rb)) -> (Eq.{succ u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (HAdd.hAdd.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHAdd.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.hasAdd.{u1} R _inst_1 S _inst_2)) (OreLocalization.oreDiv.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2 r s) (OreLocalization.oreDiv.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2 r' s')) (OreLocalization.oreDiv.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2 (HAdd.hAdd.{u1, u1, u1} R R R (instHAdd.{u1} R (Distrib.toHasAdd.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) r ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S))))) sb)) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) r' rb)) (HMul.hMul.{u1, u1, u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1))))) S) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1))))) S) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1))))) S) (instHMul.{u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1))))) S) (Submonoid.mul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) S)) s sb)))
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] {S : Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))} [_inst_2 : OreLocalization.OreSet.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S] {r : R} {r' : R} (s : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)) (s' : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)) (rb : R) (sb : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)), (Eq.{succ u1} R (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) S)) s) (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) S)) sb)) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) S)) s') rb)) -> (Eq.{succ u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (HAdd.hAdd.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHAdd.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instAddOreLocalizationToMonoidToMonoidWithZero.{u1} R _inst_1 S _inst_2)) (OreLocalization.oreDiv.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2 r s) (OreLocalization.oreDiv.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2 r' s')) (OreLocalization.oreDiv.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2 (HAdd.hAdd.{u1, u1, u1} R R R (instHAdd.{u1} R (Distrib.toAdd.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) r (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) S)) sb)) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) r' rb)) (HMul.hMul.{u1, u1, u1} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)) (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)) (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)) (instHMul.{u1} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)) (Submonoid.mul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) S)) s sb)))
Case conversion may be inaccurate. Consider using '#align ore_localization.ore_div_add_char OreLocalization.oreDiv_add_charₓ'. -/
/-- A characterization of the addition on the Ore localizaion, allowing for arbitrary Ore
numerator and Ore denominator. -/
theorem oreDiv_add_char {r r' : R} (s s' : S) (rb : R) (sb : S) (h : (s : R) * sb = s' * rb) :
r /ₒ s + r' /ₒ s' = (r * sb + r' * rb) /ₒ (s * sb) :=
add''_char r s r' s' rb sb h
#align ore_localization.ore_div_add_char OreLocalization.oreDiv_add_char
/- warning: ore_localization.ore_div_add_char' -> OreLocalization.oreDivAddChar' is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] {S : Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))} [_inst_2 : OreLocalization.OreSet.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S] (r : R) (r' : R) (s : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) (s' : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S), PSigma.{succ u1, succ u1} R (fun (r'' : R) => PSigma.{succ u1, 0} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) (fun (s'' : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) => And (Eq.{succ u1} R (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S))))) s) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S))))) s'')) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S))))) s') r'')) (Eq.{succ u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (HAdd.hAdd.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHAdd.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.hasAdd.{u1} R _inst_1 S _inst_2)) (OreLocalization.oreDiv.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2 r s) (OreLocalization.oreDiv.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2 r' s')) (OreLocalization.oreDiv.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2 (HAdd.hAdd.{u1, u1, u1} R R R (instHAdd.{u1} R (Distrib.toHasAdd.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) r ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S))))) s'')) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) r' r'')) (HMul.hMul.{u1, u1, u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1))))) S) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1))))) S) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1))))) S) (instHMul.{u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1))))) S) (Submonoid.mul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) S)) s s'')))))
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] {S : Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))} [_inst_2 : OreLocalization.OreSet.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S] (r : R) (r' : R) (s : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)) (s' : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)), PSigma.{succ u1, succ u1} R (fun (r'' : R) => PSigma.{succ u1, 0} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)) (fun (s'' : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)) => And (Eq.{succ u1} R (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) S)) s) (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) S)) s'')) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) S)) s') r'')) (Eq.{succ u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (HAdd.hAdd.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHAdd.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instAddOreLocalizationToMonoidToMonoidWithZero.{u1} R _inst_1 S _inst_2)) (OreLocalization.oreDiv.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2 r s) (OreLocalization.oreDiv.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2 r' s')) (OreLocalization.oreDiv.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2 (HAdd.hAdd.{u1, u1, u1} R R R (instHAdd.{u1} R (Distrib.toAdd.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) r (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) S)) s'')) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) r' r'')) (HMul.hMul.{u1, u1, u1} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)) (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)) (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)) (instHMul.{u1} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)) (Submonoid.mul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) S)) s s'')))))
Case conversion may be inaccurate. Consider using '#align ore_localization.ore_div_add_char' OreLocalization.oreDivAddChar'ₓ'. -/
/-- Another characterization of the addition on the Ore localization, bundling up all witnesses
and conditions into a sigma type. -/
def oreDivAddChar' (r r' : R) (s s' : S) :
Σ'r'' : R,
Σ's'' : S, (s : R) * s'' = s' * r'' ∧ r /ₒ s + r' /ₒ s' = (r * s'' + r' * r'') /ₒ (s * s'') :=
⟨oreNum s s', oreDenom s s', ore_eq s s', oreDiv_add_oreDiv⟩
#align ore_localization.ore_div_add_char' OreLocalization.oreDivAddChar'
/- warning: ore_localization.add_ore_div -> OreLocalization.add_oreDiv is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] {S : Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))} [_inst_2 : OreLocalization.OreSet.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S] {r : R} {r' : R} {s : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S}, Eq.{succ u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (HAdd.hAdd.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHAdd.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.hasAdd.{u1} R _inst_1 S _inst_2)) (OreLocalization.oreDiv.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2 r s) (OreLocalization.oreDiv.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2 r' s)) (OreLocalization.oreDiv.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2 (HAdd.hAdd.{u1, u1, u1} R R R (instHAdd.{u1} R (Distrib.toHasAdd.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) r r') s)
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] {S : Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))} [_inst_2 : OreLocalization.OreSet.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S] {r : R} {r' : R} {s : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)}, Eq.{succ u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (HAdd.hAdd.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHAdd.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instAddOreLocalizationToMonoidToMonoidWithZero.{u1} R _inst_1 S _inst_2)) (OreLocalization.oreDiv.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2 r s) (OreLocalization.oreDiv.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2 r' s)) (OreLocalization.oreDiv.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2 (HAdd.hAdd.{u1, u1, u1} R R R (instHAdd.{u1} R (Distrib.toAdd.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) r r') s)
Case conversion may be inaccurate. Consider using '#align ore_localization.add_ore_div OreLocalization.add_oreDivₓ'. -/
@[simp]
theorem add_oreDiv {r r' : R} {s : S} : r /ₒ s + r' /ₒ s = (r + r') /ₒ s := by
simp [ore_div_add_char s s 1 1 (by simp)]
#align ore_localization.add_ore_div OreLocalization.add_oreDiv
/- warning: ore_localization.add_assoc -> OreLocalization.add_assoc is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] {S : Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))} [_inst_2 : OreLocalization.OreSet.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S] (x : OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (y : OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (z : OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2), Eq.{succ u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (HAdd.hAdd.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHAdd.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.hasAdd.{u1} R _inst_1 S _inst_2)) (HAdd.hAdd.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHAdd.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.hasAdd.{u1} R _inst_1 S _inst_2)) x y) z) (HAdd.hAdd.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHAdd.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.hasAdd.{u1} R _inst_1 S _inst_2)) x (HAdd.hAdd.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHAdd.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.hasAdd.{u1} R _inst_1 S _inst_2)) y z))
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] {S : Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))} [_inst_2 : OreLocalization.OreSet.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S] (x : OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (y : OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (z : OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2), Eq.{succ u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (HAdd.hAdd.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHAdd.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instAddOreLocalizationToMonoidToMonoidWithZero.{u1} R _inst_1 S _inst_2)) (HAdd.hAdd.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHAdd.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instAddOreLocalizationToMonoidToMonoidWithZero.{u1} R _inst_1 S _inst_2)) x y) z) (HAdd.hAdd.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHAdd.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instAddOreLocalizationToMonoidToMonoidWithZero.{u1} R _inst_1 S _inst_2)) x (HAdd.hAdd.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHAdd.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instAddOreLocalizationToMonoidToMonoidWithZero.{u1} R _inst_1 S _inst_2)) y z))
Case conversion may be inaccurate. Consider using '#align ore_localization.add_assoc OreLocalization.add_assocₓ'. -/
protected theorem add_assoc (x y z : R[S⁻¹]) : x + y + z = x + (y + z) :=
by
induction' x using OreLocalization.ind with r₁ s₁
induction' y using OreLocalization.ind with r₂ s₂
induction' z using OreLocalization.ind with r₃ s₃
rcases ore_div_add_char' r₁ r₂ s₁ s₂ with ⟨ra, sa, ha, ha'⟩; rw [ha']; clear ha'
rcases ore_div_add_char' r₂ r₃ s₂ s₃ with ⟨rb, sb, hb, hb'⟩; rw [hb']; clear hb'
rcases ore_div_add_char' (r₁ * sa + r₂ * ra) r₃ (s₁ * sa) s₃ with ⟨rc, sc, hc, q⟩; rw [q]; clear q
rcases ore_div_add_char' r₁ (r₂ * sb + r₃ * rb) s₁ (s₂ * sb) with ⟨rd, sd, hd, q⟩; rw [q]; clear q
noncomm_ring; rw [add_comm (r₂ * _)]
repeat' rw [← add_ore_div]
congr 1
· rcases ore_condition (sd : R) (sa * sc) with ⟨re, se, he⟩
· simp_rw [← Submonoid.coe_mul] at hb hc hd
assoc_rw [Subtype.coe_eq_of_eq_mk hc]
rw [← OreLocalization.expand, Subtype.coe_eq_of_eq_mk hd, ← mul_assoc, ←
OreLocalization.expand, Subtype.coe_eq_of_eq_mk hb]
apply OreLocalization.expand
congr 1
·
rw [← OreLocalization.expand', ← mul_assoc, ← mul_assoc, ← OreLocalization.expand', ←
OreLocalization.expand']
· simp_rw [← Submonoid.coe_mul] at ha hd
rw [Subtype.coe_eq_of_eq_mk hd, ← mul_assoc, ← mul_assoc, ← mul_assoc, ← OreLocalization.expand,
← OreLocalization.expand', Subtype.coe_eq_of_eq_mk ha, ← OreLocalization.expand]
apply OreLocalization.expand'
#align ore_localization.add_assoc OreLocalization.add_assoc
private def zero : R[S⁻¹] :=
0 /ₒ 1
#align ore_localization.zero ore_localization.zero
instance : Zero R[S⁻¹] :=
⟨zero⟩
/- warning: ore_localization.zero_def -> OreLocalization.zero_def is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] {S : Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))} [_inst_2 : OreLocalization.OreSet.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S], Eq.{succ u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OfNat.ofNat.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) 0 (OfNat.mk.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) 0 (Zero.zero.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.hasZero.{u1} R _inst_1 S _inst_2)))) (OreLocalization.oreDiv.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2 (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))))) (OfNat.ofNat.{u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1))))) S) 1 (OfNat.mk.{u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1))))) S) 1 (One.one.{u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1))))) S) (Submonoid.one.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) S)))))
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] {S : Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))} [_inst_2 : OreLocalization.OreSet.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S], Eq.{succ u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OfNat.ofNat.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) 0 (Zero.toOfNat0.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instZeroOreLocalizationToMonoidToMonoidWithZero.{u1} R _inst_1 S _inst_2))) (OreLocalization.oreDiv.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2 (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) (OfNat.ofNat.{u1} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1))))) x S)) 1 (One.toOfNat1.{u1} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1))))) x S)) (Submonoid.one.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1))) S))))
Case conversion may be inaccurate. Consider using '#align ore_localization.zero_def OreLocalization.zero_defₓ'. -/
protected theorem zero_def : (0 : R[S⁻¹]) = 0 /ₒ 1 :=
rfl
#align ore_localization.zero_def OreLocalization.zero_def
/- warning: ore_localization.zero_div_eq_zero -> OreLocalization.zero_div_eq_zero is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] {S : Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))} [_inst_2 : OreLocalization.OreSet.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S] (s : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S), Eq.{succ u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.oreDiv.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2 (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))))) s) (OfNat.ofNat.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) 0 (OfNat.mk.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) 0 (Zero.zero.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.hasZero.{u1} R _inst_1 S _inst_2))))
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] {S : Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))} [_inst_2 : OreLocalization.OreSet.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S] (s : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)), Eq.{succ u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.oreDiv.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2 (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) s) (OfNat.ofNat.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) 0 (Zero.toOfNat0.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instZeroOreLocalizationToMonoidToMonoidWithZero.{u1} R _inst_1 S _inst_2)))
Case conversion may be inaccurate. Consider using '#align ore_localization.zero_div_eq_zero OreLocalization.zero_div_eq_zeroₓ'. -/
@[simp]
theorem zero_div_eq_zero (s : S) : 0 /ₒ s = 0 :=
by
rw [OreLocalization.zero_def, ore_div_eq_iff]
exact ⟨s, 1, by simp⟩
#align ore_localization.zero_div_eq_zero OreLocalization.zero_div_eq_zero
/- warning: ore_localization.zero_add -> OreLocalization.zero_add is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] {S : Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))} [_inst_2 : OreLocalization.OreSet.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S] (x : OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2), Eq.{succ u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (HAdd.hAdd.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHAdd.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.hasAdd.{u1} R _inst_1 S _inst_2)) (OfNat.ofNat.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) 0 (OfNat.mk.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) 0 (Zero.zero.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.hasZero.{u1} R _inst_1 S _inst_2)))) x) x
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] {S : Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))} [_inst_2 : OreLocalization.OreSet.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S] (x : OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2), Eq.{succ u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (HAdd.hAdd.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHAdd.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instAddOreLocalizationToMonoidToMonoidWithZero.{u1} R _inst_1 S _inst_2)) (OfNat.ofNat.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) 0 (Zero.toOfNat0.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instZeroOreLocalizationToMonoidToMonoidWithZero.{u1} R _inst_1 S _inst_2))) x) x
Case conversion may be inaccurate. Consider using '#align ore_localization.zero_add OreLocalization.zero_addₓ'. -/
protected theorem zero_add (x : R[S⁻¹]) : 0 + x = x :=
by
induction x using OreLocalization.ind
rw [← zero_div_eq_zero, add_ore_div]; simp
#align ore_localization.zero_add OreLocalization.zero_add
/- warning: ore_localization.add_comm -> OreLocalization.add_comm is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] {S : Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))} [_inst_2 : OreLocalization.OreSet.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S] (x : OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (y : OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2), Eq.{succ u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (HAdd.hAdd.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHAdd.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.hasAdd.{u1} R _inst_1 S _inst_2)) x y) (HAdd.hAdd.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHAdd.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.hasAdd.{u1} R _inst_1 S _inst_2)) y x)
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] {S : Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))} [_inst_2 : OreLocalization.OreSet.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S] (x : OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (y : OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2), Eq.{succ u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (HAdd.hAdd.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHAdd.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instAddOreLocalizationToMonoidToMonoidWithZero.{u1} R _inst_1 S _inst_2)) x y) (HAdd.hAdd.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHAdd.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instAddOreLocalizationToMonoidToMonoidWithZero.{u1} R _inst_1 S _inst_2)) y x)
Case conversion may be inaccurate. Consider using '#align ore_localization.add_comm OreLocalization.add_commₓ'. -/
protected theorem add_comm (x y : R[S⁻¹]) : x + y = y + x :=
by
induction x using OreLocalization.ind
induction y using OreLocalization.ind
change add' _ _ (_ /ₒ _) = _; apply add'_comm
#align ore_localization.add_comm OreLocalization.add_comm
instance : AddCommMonoid R[S⁻¹] :=
{ OreLocalization.hasAdd with
add_comm := OreLocalization.add_comm
add_assoc := OreLocalization.add_assoc
zero := zero
zero_add := OreLocalization.zero_add
add_zero := fun x => by rw [OreLocalization.add_comm, OreLocalization.zero_add] }
/- warning: ore_localization.zero_mul -> OreLocalization.zero_mul is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] {S : Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))} [_inst_2 : OreLocalization.OreSet.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S] (x : OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2), Eq.{succ u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (HMul.hMul.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHMul.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.hasMul.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2)) (OfNat.ofNat.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) 0 (OfNat.mk.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) 0 (Zero.zero.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.hasZero.{u1} R _inst_1 S _inst_2)))) x) (OfNat.ofNat.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) 0 (OfNat.mk.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) 0 (Zero.zero.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.hasZero.{u1} R _inst_1 S _inst_2))))
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] {S : Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))} [_inst_2 : OreLocalization.OreSet.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S] (x : OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2), Eq.{succ u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (HMul.hMul.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHMul.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instMulOreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2)) (OfNat.ofNat.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) 0 (Zero.toOfNat0.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instZeroOreLocalizationToMonoidToMonoidWithZero.{u1} R _inst_1 S _inst_2))) x) (OfNat.ofNat.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) 0 (Zero.toOfNat0.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instZeroOreLocalizationToMonoidToMonoidWithZero.{u1} R _inst_1 S _inst_2)))
Case conversion may be inaccurate. Consider using '#align ore_localization.zero_mul OreLocalization.zero_mulₓ'. -/
protected theorem zero_mul (x : R[S⁻¹]) : 0 * x = 0 :=
by
induction' x using OreLocalization.ind with r s
rw [OreLocalization.zero_def, ore_div_mul_char 0 r 1 s r 1 (by simp)]; simp
#align ore_localization.zero_mul OreLocalization.zero_mul
/- warning: ore_localization.mul_zero -> OreLocalization.mul_zero is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] {S : Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))} [_inst_2 : OreLocalization.OreSet.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S] (x : OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2), Eq.{succ u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (HMul.hMul.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHMul.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.hasMul.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2)) x (OfNat.ofNat.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) 0 (OfNat.mk.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) 0 (Zero.zero.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.hasZero.{u1} R _inst_1 S _inst_2))))) (OfNat.ofNat.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) 0 (OfNat.mk.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) 0 (Zero.zero.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.hasZero.{u1} R _inst_1 S _inst_2))))
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] {S : Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))} [_inst_2 : OreLocalization.OreSet.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S] (x : OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2), Eq.{succ u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (HMul.hMul.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHMul.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instMulOreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2)) x (OfNat.ofNat.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) 0 (Zero.toOfNat0.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instZeroOreLocalizationToMonoidToMonoidWithZero.{u1} R _inst_1 S _inst_2)))) (OfNat.ofNat.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) 0 (Zero.toOfNat0.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instZeroOreLocalizationToMonoidToMonoidWithZero.{u1} R _inst_1 S _inst_2)))
Case conversion may be inaccurate. Consider using '#align ore_localization.mul_zero OreLocalization.mul_zeroₓ'. -/
protected theorem mul_zero (x : R[S⁻¹]) : x * 0 = 0 :=
by
induction' x using OreLocalization.ind with r s
rw [OreLocalization.zero_def, ore_div_mul_char r 0 s 1 0 1 (by simp)]; simp
#align ore_localization.mul_zero OreLocalization.mul_zero
/- warning: ore_localization.left_distrib -> OreLocalization.left_distrib is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] {S : Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))} [_inst_2 : OreLocalization.OreSet.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S] (x : OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (y : OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (z : OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2), Eq.{succ u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (HMul.hMul.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHMul.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.hasMul.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2)) x (HAdd.hAdd.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHAdd.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.hasAdd.{u1} R _inst_1 S _inst_2)) y z)) (HAdd.hAdd.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHAdd.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.hasAdd.{u1} R _inst_1 S _inst_2)) (HMul.hMul.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHMul.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.hasMul.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2)) x y) (HMul.hMul.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHMul.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.hasMul.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2)) x z))
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] {S : Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))} [_inst_2 : OreLocalization.OreSet.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S] (x : OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (y : OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (z : OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2), Eq.{succ u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (HMul.hMul.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHMul.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instMulOreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2)) x (HAdd.hAdd.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHAdd.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instAddOreLocalizationToMonoidToMonoidWithZero.{u1} R _inst_1 S _inst_2)) y z)) (HAdd.hAdd.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHAdd.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instAddOreLocalizationToMonoidToMonoidWithZero.{u1} R _inst_1 S _inst_2)) (HMul.hMul.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHMul.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instMulOreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2)) x y) (HMul.hMul.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHMul.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instMulOreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2)) x z))
Case conversion may be inaccurate. Consider using '#align ore_localization.left_distrib OreLocalization.left_distribₓ'. -/
protected theorem left_distrib (x y z : R[S⁻¹]) : x * (y + z) = x * y + x * z :=
by
induction' x using OreLocalization.ind with r₁ s₁
induction' y using OreLocalization.ind with r₂ s₂
induction' z using OreLocalization.ind with r₃ s₃
rcases ore_div_add_char' r₂ r₃ s₂ s₃ with ⟨ra, sa, ha, q⟩
rw [q]
clear q
rw [OreLocalization.expand' r₂ s₂ sa]
rcases ore_div_mul_char' r₁ (r₂ * sa) s₁ (s₂ * sa) with ⟨rb, sb, hb, q⟩
rw [q]
clear q
have hs₃rasb : ↑s₃ * (ra * sb) ∈ S :=
by
rw [← mul_assoc, ← ha]
norm_cast
apply SetLike.coe_mem
rw [OreLocalization.expand _ _ _ hs₃rasb]
have ha' : ↑(s₂ * sa * sb) = ↑s₃ * (ra * sb) := by simp [ha, ← mul_assoc]
rw [← Subtype.coe_eq_of_eq_mk ha']
rcases ore_div_mul_char' r₁ (r₃ * (ra * sb)) s₁ (s₂ * sa * sb) with ⟨rc, sc, hc, hc'⟩
rw [hc']
rw [ore_div_add_char (s₂ * sa * sb) (s₂ * sa * sb * sc) 1 sc (by simp)]
rw [OreLocalization.expand' (r₂ * ↑sa + r₃ * ra) (s₂ * sa) (sb * sc)]
conv_lhs =>
congr
skip
congr
rw [add_mul, S.coe_mul, ← mul_assoc, hb, ← mul_assoc, mul_assoc r₃, hc, mul_assoc, ← mul_add]
rw [OreLocalization.mul_cancel']
simp only [mul_one, Submonoid.coe_mul, mul_add, ← mul_assoc]
#align ore_localization.left_distrib OreLocalization.left_distrib
/- warning: ore_localization.right_distrib -> OreLocalization.right_distrib is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] {S : Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))} [_inst_2 : OreLocalization.OreSet.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S] (x : OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (y : OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (z : OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2), Eq.{succ u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (HMul.hMul.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHMul.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.hasMul.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2)) (HAdd.hAdd.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHAdd.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.hasAdd.{u1} R _inst_1 S _inst_2)) x y) z) (HAdd.hAdd.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHAdd.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.hasAdd.{u1} R _inst_1 S _inst_2)) (HMul.hMul.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHMul.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.hasMul.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2)) x z) (HMul.hMul.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHMul.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.hasMul.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2)) y z))
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] {S : Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))} [_inst_2 : OreLocalization.OreSet.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S] (x : OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (y : OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (z : OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2), Eq.{succ u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (HMul.hMul.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHMul.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instMulOreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2)) (HAdd.hAdd.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHAdd.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instAddOreLocalizationToMonoidToMonoidWithZero.{u1} R _inst_1 S _inst_2)) x y) z) (HAdd.hAdd.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHAdd.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instAddOreLocalizationToMonoidToMonoidWithZero.{u1} R _inst_1 S _inst_2)) (HMul.hMul.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHMul.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instMulOreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2)) x z) (HMul.hMul.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (instHMul.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instMulOreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2)) y z))
Case conversion may be inaccurate. Consider using '#align ore_localization.right_distrib OreLocalization.right_distribₓ'. -/
theorem right_distrib (x y z : R[S⁻¹]) : (x + y) * z = x * z + y * z :=
by
induction' x using OreLocalization.ind with r₁ s₁
induction' y using OreLocalization.ind with r₂ s₂
induction' z using OreLocalization.ind with r₃ s₃
rcases ore_div_add_char' r₁ r₂ s₁ s₂ with ⟨ra, sa, ha, ha'⟩; rw [ha']; clear ha'; norm_cast at ha
rw [OreLocalization.expand' r₁ s₁ sa]
rw [OreLocalization.expand r₂ s₂ ra (by rw [← ha] <;> apply SetLike.coe_mem)]
rw [← Subtype.coe_eq_of_eq_mk ha]
repeat' rw [ore_div_mul_ore_div]; simp only [add_mul, add_ore_div]
#align ore_localization.right_distrib OreLocalization.right_distrib
instance : Semiring R[S⁻¹] :=
{ OreLocalization.addCommMonoid,
OreLocalization.monoid with
zero_mul := OreLocalization.zero_mul
mul_zero := OreLocalization.mul_zero
left_distrib := OreLocalization.left_distrib
right_distrib := right_distrib }
section UMP
variable {T : Type _} [Semiring T]
variable (f : R →+* T) (fS : S →* Units T)
variable (hf : ∀ s : S, f s = fS s)
include f fS hf
/- warning: ore_localization.universal_hom -> OreLocalization.universalHom is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] {S : Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))} [_inst_2 : OreLocalization.OreSet.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S] {T : Type.{u2}} [_inst_3 : Semiring.{u2} T] (f : RingHom.{u1, u2} R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) (fS : MonoidHom.{u1, u2} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) (Submonoid.toMulOneClass.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) S) (Units.mulOneClass.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3)))), (forall (s : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S), Eq.{succ u2} T (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u1, u2} R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) (fun (_x : RingHom.{u1, u2} R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) => R -> T) (RingHom.hasCoeToFun.{u1, u2} R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S))))) s)) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) T (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) T (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) T (coeBase.{succ u2, succ u2} (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) T (Units.hasCoe.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3)))))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) (Submonoid.toMulOneClass.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) S) (Units.mulOneClass.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3)))) (fun (_x : MonoidHom.{u1, u2} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) (Submonoid.toMulOneClass.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) S) (Units.mulOneClass.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3)))) => (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) -> (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3)))) (MonoidHom.hasCoeToFun.{u1, u2} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) (Submonoid.toMulOneClass.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) S) (Units.mulOneClass.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3)))) fS s))) -> (RingHom.{u1, u2} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) T (Semiring.toNonAssocSemiring.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.semiring.{u1} R _inst_1 S _inst_2)) (Semiring.toNonAssocSemiring.{u2} T _inst_3))
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] {S : Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))} [_inst_2 : OreLocalization.OreSet.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S] {T : Type.{u2}} [_inst_3 : Semiring.{u2} T] (f : RingHom.{u1, u2} R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) (fS : MonoidHom.{u1, u2} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)) (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) (Submonoid.toMulOneClass.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) S) (Units.instMulOneClassUnits.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3)))), (forall (s : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)), Eq.{succ u2} ((fun ([email protected]._hyg.2391 : R) => T) (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) S)) s)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RingHom.{u1, u2} R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) R (fun (_x : R) => (fun ([email protected]._hyg.2391 : R) => T) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (RingHom.{u1, u2} R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) R T (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (NonUnitalNonAssocSemiring.toMul.{u2} T (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} T (Semiring.toNonAssocSemiring.{u2} T _inst_3))) (NonUnitalRingHomClass.toMulHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) R T (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} T (Semiring.toNonAssocSemiring.{u2} T _inst_3)) (RingHomClass.toNonUnitalRingHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3) (RingHom.instRingHomClassRingHom.{u1, u2} R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3))))) f (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) S)) s)) (Units.val.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)) (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) (Submonoid.toMulOneClass.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) S) (Units.instMulOneClassUnits.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3)))) (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)) (fun (_x : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)) => (fun ([email protected]._hyg.2391 : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)) => Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)) (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) (Submonoid.toMulOneClass.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) S) (Units.instMulOneClassUnits.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3)))) (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)) (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) (MulOneClass.toMul.{u1} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)) (Submonoid.toMulOneClass.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) S)) (MulOneClass.toMul.{u2} (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) (Units.instMulOneClassUnits.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)) (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) (Submonoid.toMulOneClass.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) S) (Units.instMulOneClassUnits.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3)))) (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)) (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) (Submonoid.toMulOneClass.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) S) (Units.instMulOneClassUnits.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) (MonoidHom.monoidHomClass.{u1, u2} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)) (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) (Submonoid.toMulOneClass.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) S) (Units.instMulOneClassUnits.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3)))))) fS s))) -> (RingHom.{u1, u2} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) T (Semiring.toNonAssocSemiring.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instSemiringOreLocalizationToMonoidToMonoidWithZero.{u1} R _inst_1 S _inst_2)) (Semiring.toNonAssocSemiring.{u2} T _inst_3))
Case conversion may be inaccurate. Consider using '#align ore_localization.universal_hom OreLocalization.universalHomₓ'. -/
/-- The universal lift from a ring homomorphism `f : R →+* T`, which maps elements in `S` to
units of `T`, to a ring homomorphism `R[S⁻¹] →+* T`. This extends the construction on
monoids. -/
def universalHom : R[S⁻¹] →+* T :=
{
universalMulHom f.toMonoidHom fS
hf with
map_zero' :=
by
rw [MonoidHom.toFun_eq_coe, OreLocalization.zero_def, universal_mul_hom_apply]
simp
map_add' := fun x y => by
induction' x using OreLocalization.ind with r₁ s₁
induction' y using OreLocalization.ind with r₂ s₂
rcases ore_div_add_char' r₁ r₂ s₁ s₂ with ⟨r₃, s₃, h₃, h₃'⟩
rw [h₃']
clear h₃'
simp only [universal_mul_hom_apply, [anonymous], RingHom.toMonoidHom_eq_coe,
MonoidHom.toFun_eq_coe]
simp only [mul_inv_rev, MonoidHom.map_mul, RingHom.map_add, RingHom.map_mul, Units.val_mul]
rw [add_mul, ← mul_assoc, mul_assoc (f r₁), hf, ← Units.val_mul]
simp only [mul_one, mul_right_inv, Units.val_one]
congr 1
rw [mul_assoc]
congr 1
norm_cast at h₃
have h₃' := Subtype.coe_eq_of_eq_mk h₃
rw [← Units.val_mul, ← mul_inv_rev, ← fS.map_mul, h₃']
have hs₂r₃ : ↑s₂ * r₃ ∈ S := by
rw [← h₃]
exact SetLike.coe_mem (s₁ * s₃)
apply (Units.inv_mul_cancel_left (fS s₂) _).symm.trans
conv_lhs =>
congr
skip
rw [← Units.mul_inv_cancel_left (fS ⟨s₂ * r₃, hs₂r₃⟩) (fS s₂), mul_assoc, mul_assoc]
congr
skip
rw [← hf, ← mul_assoc (f s₂), ← f.map_mul]
conv =>
congr
skip
congr
rw [← h₃]
rw [hf, ← mul_assoc, ← h₃', Units.inv_mul]
rw [one_mul, ← h₃', Units.mul_inv, mul_one] }
#align ore_localization.universal_hom OreLocalization.universalHom
/- warning: ore_localization.universal_hom_apply -> OreLocalization.universalHom_apply is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] {S : Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))} [_inst_2 : OreLocalization.OreSet.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S] {T : Type.{u2}} [_inst_3 : Semiring.{u2} T] (f : RingHom.{u1, u2} R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) (fS : MonoidHom.{u1, u2} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) (Submonoid.toMulOneClass.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) S) (Units.mulOneClass.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3)))) (hf : forall (s : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S), Eq.{succ u2} T (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u1, u2} R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) (fun (_x : RingHom.{u1, u2} R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) => R -> T) (RingHom.hasCoeToFun.{u1, u2} R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S))))) s)) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) T (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) T (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) T (coeBase.{succ u2, succ u2} (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) T (Units.hasCoe.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3)))))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) (Submonoid.toMulOneClass.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) S) (Units.mulOneClass.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3)))) (fun (_x : MonoidHom.{u1, u2} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) (Submonoid.toMulOneClass.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) S) (Units.mulOneClass.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3)))) => (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) -> (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3)))) (MonoidHom.hasCoeToFun.{u1, u2} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) (Submonoid.toMulOneClass.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) S) (Units.mulOneClass.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3)))) fS s))) {r : R} {s : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S}, Eq.{succ u2} T (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u1, u2} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) T (Semiring.toNonAssocSemiring.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.semiring.{u1} R _inst_1 S _inst_2)) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) (fun (_x : RingHom.{u1, u2} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) T (Semiring.toNonAssocSemiring.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.semiring.{u1} R _inst_1 S _inst_2)) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) => (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) -> T) (RingHom.hasCoeToFun.{u1, u2} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) T (Semiring.toNonAssocSemiring.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.semiring.{u1} R _inst_1 S _inst_2)) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) (OreLocalization.universalHom.{u1, u2} R _inst_1 S _inst_2 T _inst_3 f fS hf) (OreLocalization.oreDiv.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2 r s)) (HMul.hMul.{u2, u2, u2} T T T (instHMul.{u2} T (Distrib.toHasMul.{u2} T (NonUnitalNonAssocSemiring.toDistrib.{u2} T (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} T (Semiring.toNonAssocSemiring.{u2} T _inst_3))))) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u1, u2} R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) (fun (_x : RingHom.{u1, u2} R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) => R -> T) (RingHom.hasCoeToFun.{u1, u2} R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) f r) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) T (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) T (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) T (coeBase.{succ u2, succ u2} (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) T (Units.hasCoe.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3)))))) (Inv.inv.{u2} (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) (Units.hasInv.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) (Submonoid.toMulOneClass.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) S) (Units.mulOneClass.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3)))) (fun (_x : MonoidHom.{u1, u2} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) (Submonoid.toMulOneClass.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) S) (Units.mulOneClass.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3)))) => (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) -> (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3)))) (MonoidHom.hasCoeToFun.{u1, u2} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) (Submonoid.toMulOneClass.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) S) (Units.mulOneClass.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3)))) fS s))))
but is expected to have type
forall {R : Type.{u2}} [_inst_1 : Semiring.{u2} R] {S : Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))} [_inst_2 : OreLocalization.OreSet.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S] {T : Type.{u1}} [_inst_3 : Semiring.{u1} T] (f : RingHom.{u2, u1} R T (Semiring.toNonAssocSemiring.{u2} R _inst_1) (Semiring.toNonAssocSemiring.{u1} T _inst_3)) (fS : MonoidHom.{u2, u1} (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))))) x S)) (Units.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3))) (Submonoid.toMulOneClass.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))) S) (Units.instMulOneClassUnits.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3)))) (hf : forall (s : Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))))) x S)), Eq.{succ u1} ((fun ([email protected]._hyg.2391 : R) => T) (Subtype.val.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Set.{u2} R) (Set.instMembershipSet.{u2} R) x (SetLike.coe.{u2, u2} (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) S)) s)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (RingHom.{u2, u1} R T (Semiring.toNonAssocSemiring.{u2} R _inst_1) (Semiring.toNonAssocSemiring.{u1} T _inst_3)) R (fun (_x : R) => (fun ([email protected]._hyg.2391 : R) => T) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (RingHom.{u2, u1} R T (Semiring.toNonAssocSemiring.{u2} R _inst_1) (Semiring.toNonAssocSemiring.{u1} T _inst_3)) R T (NonUnitalNonAssocSemiring.toMul.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))) (NonUnitalNonAssocSemiring.toMul.{u1} T (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} T (Semiring.toNonAssocSemiring.{u1} T _inst_3))) (NonUnitalRingHomClass.toMulHomClass.{max u2 u1, u2, u1} (RingHom.{u2, u1} R T (Semiring.toNonAssocSemiring.{u2} R _inst_1) (Semiring.toNonAssocSemiring.{u1} T _inst_3)) R T (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} T (Semiring.toNonAssocSemiring.{u1} T _inst_3)) (RingHomClass.toNonUnitalRingHomClass.{max u2 u1, u2, u1} (RingHom.{u2, u1} R T (Semiring.toNonAssocSemiring.{u2} R _inst_1) (Semiring.toNonAssocSemiring.{u1} T _inst_3)) R T (Semiring.toNonAssocSemiring.{u2} R _inst_1) (Semiring.toNonAssocSemiring.{u1} T _inst_3) (RingHom.instRingHomClassRingHom.{u2, u1} R T (Semiring.toNonAssocSemiring.{u2} R _inst_1) (Semiring.toNonAssocSemiring.{u1} T _inst_3))))) f (Subtype.val.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Set.{u2} R) (Set.instMembershipSet.{u2} R) x (SetLike.coe.{u2, u2} (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) S)) s)) (Units.val.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))))) x S)) (Units.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3))) (Submonoid.toMulOneClass.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))) S) (Units.instMulOneClassUnits.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3)))) (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))))) x S)) (fun (_x : Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))))) x S)) => (fun ([email protected]._hyg.2391 : Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))))) x S)) => Units.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3))) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))))) x S)) (Units.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3))) (Submonoid.toMulOneClass.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))) S) (Units.instMulOneClassUnits.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3)))) (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))))) x S)) (Units.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3))) (MulOneClass.toMul.{u2} (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))))) x S)) (Submonoid.toMulOneClass.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))) S)) (MulOneClass.toMul.{u1} (Units.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3))) (Units.instMulOneClassUnits.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3)))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))))) x S)) (Units.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3))) (Submonoid.toMulOneClass.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))) S) (Units.instMulOneClassUnits.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3)))) (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))))) x S)) (Units.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3))) (Submonoid.toMulOneClass.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))) S) (Units.instMulOneClassUnits.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3))) (MonoidHom.monoidHomClass.{u2, u1} (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))))) x S)) (Units.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3))) (Submonoid.toMulOneClass.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))) S) (Units.instMulOneClassUnits.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3)))))) fS s))) {r : R} {s : Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))))) x S)}, Eq.{succ u1} ((fun ([email protected]._hyg.2391 : OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) => T) (OreLocalization.oreDiv.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2 r s)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (RingHom.{u2, u1} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) T (Semiring.toNonAssocSemiring.{u2} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (OreLocalization.instSemiringOreLocalizationToMonoidToMonoidWithZero.{u2} R _inst_1 S _inst_2)) (Semiring.toNonAssocSemiring.{u1} T _inst_3)) (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (fun (_x : OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) => (fun ([email protected]._hyg.2391 : OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) => T) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (RingHom.{u2, u1} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) T (Semiring.toNonAssocSemiring.{u2} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (OreLocalization.instSemiringOreLocalizationToMonoidToMonoidWithZero.{u2} R _inst_1 S _inst_2)) (Semiring.toNonAssocSemiring.{u1} T _inst_3)) (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) T (NonUnitalNonAssocSemiring.toMul.{u2} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (Semiring.toNonAssocSemiring.{u2} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (OreLocalization.instSemiringOreLocalizationToMonoidToMonoidWithZero.{u2} R _inst_1 S _inst_2)))) (NonUnitalNonAssocSemiring.toMul.{u1} T (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} T (Semiring.toNonAssocSemiring.{u1} T _inst_3))) (NonUnitalRingHomClass.toMulHomClass.{max u2 u1, u2, u1} (RingHom.{u2, u1} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) T (Semiring.toNonAssocSemiring.{u2} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (OreLocalization.instSemiringOreLocalizationToMonoidToMonoidWithZero.{u2} R _inst_1 S _inst_2)) (Semiring.toNonAssocSemiring.{u1} T _inst_3)) (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) T (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (Semiring.toNonAssocSemiring.{u2} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (OreLocalization.instSemiringOreLocalizationToMonoidToMonoidWithZero.{u2} R _inst_1 S _inst_2))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} T (Semiring.toNonAssocSemiring.{u1} T _inst_3)) (RingHomClass.toNonUnitalRingHomClass.{max u2 u1, u2, u1} (RingHom.{u2, u1} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) T (Semiring.toNonAssocSemiring.{u2} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (OreLocalization.instSemiringOreLocalizationToMonoidToMonoidWithZero.{u2} R _inst_1 S _inst_2)) (Semiring.toNonAssocSemiring.{u1} T _inst_3)) (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) T (Semiring.toNonAssocSemiring.{u2} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (OreLocalization.instSemiringOreLocalizationToMonoidToMonoidWithZero.{u2} R _inst_1 S _inst_2)) (Semiring.toNonAssocSemiring.{u1} T _inst_3) (RingHom.instRingHomClassRingHom.{u2, u1} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) T (Semiring.toNonAssocSemiring.{u2} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (OreLocalization.instSemiringOreLocalizationToMonoidToMonoidWithZero.{u2} R _inst_1 S _inst_2)) (Semiring.toNonAssocSemiring.{u1} T _inst_3))))) (OreLocalization.universalHom.{u2, u1} R _inst_1 S _inst_2 T _inst_3 f fS hf) (OreLocalization.oreDiv.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2 r s)) (HMul.hMul.{u1, u1, u1} ((fun ([email protected]._hyg.2391 : R) => T) r) T ((fun ([email protected]._hyg.2391 : R) => T) r) (instHMul.{u1} ((fun ([email protected]._hyg.2391 : R) => T) r) (NonUnitalNonAssocSemiring.toMul.{u1} ((fun ([email protected]._hyg.2391 : R) => T) r) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} ((fun ([email protected]._hyg.2391 : R) => T) r) (Semiring.toNonAssocSemiring.{u1} ((fun ([email protected]._hyg.2391 : R) => T) r) _inst_3)))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (RingHom.{u2, u1} R T (Semiring.toNonAssocSemiring.{u2} R _inst_1) (Semiring.toNonAssocSemiring.{u1} T _inst_3)) R (fun (_x : R) => (fun ([email protected]._hyg.2391 : R) => T) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (RingHom.{u2, u1} R T (Semiring.toNonAssocSemiring.{u2} R _inst_1) (Semiring.toNonAssocSemiring.{u1} T _inst_3)) R T (NonUnitalNonAssocSemiring.toMul.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))) (NonUnitalNonAssocSemiring.toMul.{u1} T (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} T (Semiring.toNonAssocSemiring.{u1} T _inst_3))) (NonUnitalRingHomClass.toMulHomClass.{max u2 u1, u2, u1} (RingHom.{u2, u1} R T (Semiring.toNonAssocSemiring.{u2} R _inst_1) (Semiring.toNonAssocSemiring.{u1} T _inst_3)) R T (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} T (Semiring.toNonAssocSemiring.{u1} T _inst_3)) (RingHomClass.toNonUnitalRingHomClass.{max u2 u1, u2, u1} (RingHom.{u2, u1} R T (Semiring.toNonAssocSemiring.{u2} R _inst_1) (Semiring.toNonAssocSemiring.{u1} T _inst_3)) R T (Semiring.toNonAssocSemiring.{u2} R _inst_1) (Semiring.toNonAssocSemiring.{u1} T _inst_3) (RingHom.instRingHomClassRingHom.{u2, u1} R T (Semiring.toNonAssocSemiring.{u2} R _inst_1) (Semiring.toNonAssocSemiring.{u1} T _inst_3))))) f r) (Units.val.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3)) (Inv.inv.{u1} (Units.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3))) (Units.instInvUnits.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))))) x S)) (Units.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3))) (Submonoid.toMulOneClass.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))) S) (Units.instMulOneClassUnits.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3)))) (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))))) x S)) (fun (_x : Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))))) x S)) => (fun ([email protected]._hyg.2391 : Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))))) x S)) => Units.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3))) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))))) x S)) (Units.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3))) (Submonoid.toMulOneClass.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))) S) (Units.instMulOneClassUnits.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3)))) (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))))) x S)) (Units.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3))) (MulOneClass.toMul.{u2} (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))))) x S)) (Submonoid.toMulOneClass.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))) S)) (MulOneClass.toMul.{u1} (Units.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3))) (Units.instMulOneClassUnits.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3)))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))))) x S)) (Units.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3))) (Submonoid.toMulOneClass.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))) S) (Units.instMulOneClassUnits.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3)))) (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))))) x S)) (Units.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3))) (Submonoid.toMulOneClass.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))) S) (Units.instMulOneClassUnits.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3))) (MonoidHom.monoidHomClass.{u2, u1} (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))))) x S)) (Units.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3))) (Submonoid.toMulOneClass.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))) S) (Units.instMulOneClassUnits.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3)))))) fS s))))
Case conversion may be inaccurate. Consider using '#align ore_localization.universal_hom_apply OreLocalization.universalHom_applyₓ'. -/
theorem universalHom_apply {r : R} {s : S} :
universalHom f fS hf (r /ₒ s) = f r * ((fS s)⁻¹ : Units T) :=
rfl
#align ore_localization.universal_hom_apply OreLocalization.universalHom_apply
/- warning: ore_localization.universal_hom_commutes -> OreLocalization.universalHom_commutes is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] {S : Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))} [_inst_2 : OreLocalization.OreSet.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S] {T : Type.{u2}} [_inst_3 : Semiring.{u2} T] (f : RingHom.{u1, u2} R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) (fS : MonoidHom.{u1, u2} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) (Submonoid.toMulOneClass.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) S) (Units.mulOneClass.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3)))) (hf : forall (s : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S), Eq.{succ u2} T (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u1, u2} R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) (fun (_x : RingHom.{u1, u2} R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) => R -> T) (RingHom.hasCoeToFun.{u1, u2} R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S))))) s)) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) T (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) T (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) T (coeBase.{succ u2, succ u2} (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) T (Units.hasCoe.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3)))))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) (Submonoid.toMulOneClass.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) S) (Units.mulOneClass.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3)))) (fun (_x : MonoidHom.{u1, u2} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) (Submonoid.toMulOneClass.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) S) (Units.mulOneClass.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3)))) => (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) -> (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3)))) (MonoidHom.hasCoeToFun.{u1, u2} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) (Submonoid.toMulOneClass.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) S) (Units.mulOneClass.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3)))) fS s))) {r : R}, Eq.{succ u2} T (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u1, u2} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) T (Semiring.toNonAssocSemiring.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.semiring.{u1} R _inst_1 S _inst_2)) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) (fun (_x : RingHom.{u1, u2} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) T (Semiring.toNonAssocSemiring.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.semiring.{u1} R _inst_1 S _inst_2)) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) => (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) -> T) (RingHom.hasCoeToFun.{u1, u2} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) T (Semiring.toNonAssocSemiring.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.semiring.{u1} R _inst_1 S _inst_2)) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) (OreLocalization.universalHom.{u1, u2} R _inst_1 S _inst_2 T _inst_3 f fS hf) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} R (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1))) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.monoid.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2))) (fun (_x : MonoidHom.{u1, u1} R (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1))) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.monoid.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2))) => R -> (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2)) (MonoidHom.hasCoeToFun.{u1, u1} R (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1))) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.monoid.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2))) (OreLocalization.numeratorHom.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) r)) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u1, u2} R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) (fun (_x : RingHom.{u1, u2} R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) => R -> T) (RingHom.hasCoeToFun.{u1, u2} R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) f r)
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] {S : Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))} [_inst_2 : OreLocalization.OreSet.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S] {T : Type.{u2}} [_inst_3 : Semiring.{u2} T] (f : RingHom.{u1, u2} R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) (fS : MonoidHom.{u1, u2} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)) (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) (Submonoid.toMulOneClass.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) S) (Units.instMulOneClassUnits.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3)))) (hf : forall (s : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)), Eq.{succ u2} ((fun ([email protected]._hyg.2391 : R) => T) (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) S)) s)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RingHom.{u1, u2} R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) R (fun (_x : R) => (fun ([email protected]._hyg.2391 : R) => T) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (RingHom.{u1, u2} R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) R T (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (NonUnitalNonAssocSemiring.toMul.{u2} T (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} T (Semiring.toNonAssocSemiring.{u2} T _inst_3))) (NonUnitalRingHomClass.toMulHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) R T (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} T (Semiring.toNonAssocSemiring.{u2} T _inst_3)) (RingHomClass.toNonUnitalRingHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3) (RingHom.instRingHomClassRingHom.{u1, u2} R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3))))) f (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) S)) s)) (Units.val.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)) (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) (Submonoid.toMulOneClass.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) S) (Units.instMulOneClassUnits.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3)))) (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)) (fun (_x : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)) => (fun ([email protected]._hyg.2391 : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)) => Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)) (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) (Submonoid.toMulOneClass.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) S) (Units.instMulOneClassUnits.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3)))) (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)) (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) (MulOneClass.toMul.{u1} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)) (Submonoid.toMulOneClass.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) S)) (MulOneClass.toMul.{u2} (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) (Units.instMulOneClassUnits.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)) (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) (Submonoid.toMulOneClass.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) S) (Units.instMulOneClassUnits.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3)))) (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)) (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) (Submonoid.toMulOneClass.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) S) (Units.instMulOneClassUnits.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) (MonoidHom.monoidHomClass.{u1, u2} (Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S)) (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) (Submonoid.toMulOneClass.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) S) (Units.instMulOneClassUnits.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3)))))) fS s))) {r : R}, Eq.{succ u2} ((fun ([email protected]._hyg.2391 : OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) => T) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} R (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1))) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2))) R (fun (a : R) => (fun ([email protected]._hyg.2391 : R) => OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) a) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} R (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1))) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2))) R (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) (MulOneClass.toMul.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} R (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1))) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2))) R (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1))) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2)) (MonoidHom.monoidHomClass.{u1, u1} R (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1))) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2))))) (OreLocalization.numeratorHom.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) r)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RingHom.{u1, u2} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) T (Semiring.toNonAssocSemiring.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instSemiringOreLocalizationToMonoidToMonoidWithZero.{u1} R _inst_1 S _inst_2)) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (fun (_x : OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) => (fun ([email protected]._hyg.2391 : OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) => T) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (RingHom.{u1, u2} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) T (Semiring.toNonAssocSemiring.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instSemiringOreLocalizationToMonoidToMonoidWithZero.{u1} R _inst_1 S _inst_2)) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) T (NonUnitalNonAssocSemiring.toMul.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (Semiring.toNonAssocSemiring.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instSemiringOreLocalizationToMonoidToMonoidWithZero.{u1} R _inst_1 S _inst_2)))) (NonUnitalNonAssocSemiring.toMul.{u2} T (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} T (Semiring.toNonAssocSemiring.{u2} T _inst_3))) (NonUnitalRingHomClass.toMulHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) T (Semiring.toNonAssocSemiring.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instSemiringOreLocalizationToMonoidToMonoidWithZero.{u1} R _inst_1 S _inst_2)) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) T (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (Semiring.toNonAssocSemiring.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instSemiringOreLocalizationToMonoidToMonoidWithZero.{u1} R _inst_1 S _inst_2))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} T (Semiring.toNonAssocSemiring.{u2} T _inst_3)) (RingHomClass.toNonUnitalRingHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) T (Semiring.toNonAssocSemiring.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instSemiringOreLocalizationToMonoidToMonoidWithZero.{u1} R _inst_1 S _inst_2)) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) T (Semiring.toNonAssocSemiring.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instSemiringOreLocalizationToMonoidToMonoidWithZero.{u1} R _inst_1 S _inst_2)) (Semiring.toNonAssocSemiring.{u2} T _inst_3) (RingHom.instRingHomClassRingHom.{u1, u2} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) T (Semiring.toNonAssocSemiring.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instSemiringOreLocalizationToMonoidToMonoidWithZero.{u1} R _inst_1 S _inst_2)) (Semiring.toNonAssocSemiring.{u2} T _inst_3))))) (OreLocalization.universalHom.{u1, u2} R _inst_1 S _inst_2 T _inst_3 f fS hf) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} R (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1))) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2))) R (fun (_x : R) => (fun ([email protected]._hyg.2391 : R) => OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} R (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1))) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2))) R (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) (MulOneClass.toMul.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} R (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1))) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2))) R (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1))) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2)) (MonoidHom.monoidHomClass.{u1, u1} R (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1))) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2))))) (OreLocalization.numeratorHom.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) r)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RingHom.{u1, u2} R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) R (fun (_x : R) => (fun ([email protected]._hyg.2391 : R) => T) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (RingHom.{u1, u2} R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) R T (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) (NonUnitalNonAssocSemiring.toMul.{u2} T (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} T (Semiring.toNonAssocSemiring.{u2} T _inst_3))) (NonUnitalRingHomClass.toMulHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) R T (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} T (Semiring.toNonAssocSemiring.{u2} T _inst_3)) (RingHomClass.toNonUnitalRingHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3) (RingHom.instRingHomClassRingHom.{u1, u2} R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3))))) f r)
Case conversion may be inaccurate. Consider using '#align ore_localization.universal_hom_commutes OreLocalization.universalHom_commutesₓ'. -/
theorem universalHom_commutes {r : R} : universalHom f fS hf (numeratorHom r) = f r := by
simp [numerator_hom_apply, universal_hom_apply]
#align ore_localization.universal_hom_commutes OreLocalization.universalHom_commutes
/- warning: ore_localization.universal_hom_unique -> OreLocalization.universalHom_unique is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R] {S : Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))} [_inst_2 : OreLocalization.OreSet.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S] {T : Type.{u2}} [_inst_3 : Semiring.{u2} T] (f : RingHom.{u1, u2} R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) (fS : MonoidHom.{u1, u2} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) (Submonoid.toMulOneClass.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) S) (Units.mulOneClass.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3)))) (hf : forall (s : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S), Eq.{succ u2} T (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u1, u2} R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) (fun (_x : RingHom.{u1, u2} R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) => R -> T) (RingHom.hasCoeToFun.{u1, u2} R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) x S))))) s)) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) T (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) T (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) T (coeBase.{succ u2, succ u2} (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) T (Units.hasCoe.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3)))))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) (Submonoid.toMulOneClass.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) S) (Units.mulOneClass.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3)))) (fun (_x : MonoidHom.{u1, u2} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) (Submonoid.toMulOneClass.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) S) (Units.mulOneClass.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3)))) => (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) -> (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3)))) (MonoidHom.hasCoeToFun.{u1, u2} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1)))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))))) S) (Units.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3))) (Submonoid.toMulOneClass.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_1))) S) (Units.mulOneClass.{u2} T (MonoidWithZero.toMonoid.{u2} T (Semiring.toMonoidWithZero.{u2} T _inst_3)))) fS s))) (φ : RingHom.{u1, u2} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) T (Semiring.toNonAssocSemiring.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.semiring.{u1} R _inst_1 S _inst_2)) (Semiring.toNonAssocSemiring.{u2} T _inst_3)), (forall (r : R), Eq.{succ u2} T (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u1, u2} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) T (Semiring.toNonAssocSemiring.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.semiring.{u1} R _inst_1 S _inst_2)) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) (fun (_x : RingHom.{u1, u2} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) T (Semiring.toNonAssocSemiring.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.semiring.{u1} R _inst_1 S _inst_2)) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) => (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) -> T) (RingHom.hasCoeToFun.{u1, u2} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) T (Semiring.toNonAssocSemiring.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.semiring.{u1} R _inst_1 S _inst_2)) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) φ (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} R (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1))) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.monoid.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2))) (fun (_x : MonoidHom.{u1, u1} R (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1))) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.monoid.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2))) => R -> (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2)) (MonoidHom.hasCoeToFun.{u1, u1} R (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1))) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.monoid.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2))) (OreLocalization.numeratorHom.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) r)) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u1, u2} R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) (fun (_x : RingHom.{u1, u2} R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) => R -> T) (RingHom.hasCoeToFun.{u1, u2} R T (Semiring.toNonAssocSemiring.{u1} R _inst_1) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) f r)) -> (Eq.{max (succ u1) (succ u2)} (RingHom.{u1, u2} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) T (Semiring.toNonAssocSemiring.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)) S _inst_2) (OreLocalization.semiring.{u1} R _inst_1 S _inst_2)) (Semiring.toNonAssocSemiring.{u2} T _inst_3)) φ (OreLocalization.universalHom.{u1, u2} R _inst_1 S _inst_2 T _inst_3 f fS hf))
but is expected to have type
forall {R : Type.{u2}} [_inst_1 : Semiring.{u2} R] {S : Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))} [_inst_2 : OreLocalization.OreSet.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S] {T : Type.{u1}} [_inst_3 : Semiring.{u1} T] (f : RingHom.{u2, u1} R T (Semiring.toNonAssocSemiring.{u2} R _inst_1) (Semiring.toNonAssocSemiring.{u1} T _inst_3)) (fS : MonoidHom.{u2, u1} (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))))) x S)) (Units.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3))) (Submonoid.toMulOneClass.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))) S) (Units.instMulOneClassUnits.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3)))) (hf : forall (s : Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))))) x S)), Eq.{succ u1} ((fun ([email protected]._hyg.2391 : R) => T) (Subtype.val.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Set.{u2} R) (Set.instMembershipSet.{u2} R) x (SetLike.coe.{u2, u2} (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) S)) s)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (RingHom.{u2, u1} R T (Semiring.toNonAssocSemiring.{u2} R _inst_1) (Semiring.toNonAssocSemiring.{u1} T _inst_3)) R (fun (_x : R) => (fun ([email protected]._hyg.2391 : R) => T) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (RingHom.{u2, u1} R T (Semiring.toNonAssocSemiring.{u2} R _inst_1) (Semiring.toNonAssocSemiring.{u1} T _inst_3)) R T (NonUnitalNonAssocSemiring.toMul.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))) (NonUnitalNonAssocSemiring.toMul.{u1} T (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} T (Semiring.toNonAssocSemiring.{u1} T _inst_3))) (NonUnitalRingHomClass.toMulHomClass.{max u2 u1, u2, u1} (RingHom.{u2, u1} R T (Semiring.toNonAssocSemiring.{u2} R _inst_1) (Semiring.toNonAssocSemiring.{u1} T _inst_3)) R T (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} T (Semiring.toNonAssocSemiring.{u1} T _inst_3)) (RingHomClass.toNonUnitalRingHomClass.{max u2 u1, u2, u1} (RingHom.{u2, u1} R T (Semiring.toNonAssocSemiring.{u2} R _inst_1) (Semiring.toNonAssocSemiring.{u1} T _inst_3)) R T (Semiring.toNonAssocSemiring.{u2} R _inst_1) (Semiring.toNonAssocSemiring.{u1} T _inst_3) (RingHom.instRingHomClassRingHom.{u2, u1} R T (Semiring.toNonAssocSemiring.{u2} R _inst_1) (Semiring.toNonAssocSemiring.{u1} T _inst_3))))) f (Subtype.val.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Set.{u2} R) (Set.instMembershipSet.{u2} R) x (SetLike.coe.{u2, u2} (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) S)) s)) (Units.val.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))))) x S)) (Units.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3))) (Submonoid.toMulOneClass.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))) S) (Units.instMulOneClassUnits.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3)))) (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))))) x S)) (fun (_x : Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))))) x S)) => (fun ([email protected]._hyg.2391 : Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))))) x S)) => Units.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3))) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))))) x S)) (Units.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3))) (Submonoid.toMulOneClass.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))) S) (Units.instMulOneClassUnits.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3)))) (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))))) x S)) (Units.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3))) (MulOneClass.toMul.{u2} (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))))) x S)) (Submonoid.toMulOneClass.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))) S)) (MulOneClass.toMul.{u1} (Units.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3))) (Units.instMulOneClassUnits.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3)))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))))) x S)) (Units.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3))) (Submonoid.toMulOneClass.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))) S) (Units.instMulOneClassUnits.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3)))) (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))))) x S)) (Units.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3))) (Submonoid.toMulOneClass.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))) S) (Units.instMulOneClassUnits.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3))) (MonoidHom.monoidHomClass.{u2, u1} (Subtype.{succ u2} R (fun (x : R) => Membership.mem.{u2, u2} R (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)))) R (Submonoid.instSetLikeSubmonoid.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))))) x S)) (Units.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3))) (Submonoid.toMulOneClass.{u2} R (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))) S) (Units.instMulOneClassUnits.{u1} T (MonoidWithZero.toMonoid.{u1} T (Semiring.toMonoidWithZero.{u1} T _inst_3)))))) fS s))) (φ : RingHom.{u2, u1} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) T (Semiring.toNonAssocSemiring.{u2} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (OreLocalization.instSemiringOreLocalizationToMonoidToMonoidWithZero.{u2} R _inst_1 S _inst_2)) (Semiring.toNonAssocSemiring.{u1} T _inst_3)), (forall (r : R), Eq.{succ u1} ((fun ([email protected]._hyg.2391 : OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) => T) (FunLike.coe.{succ u2, succ u2, succ u2} (MonoidHom.{u2, u2} R (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (Monoid.toMulOneClass.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1))) (Monoid.toMulOneClass.{u2} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (OreLocalization.instMonoidOreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2))) R (fun (a : R) => (fun ([email protected]._hyg.2391 : R) => OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) a) (MulHomClass.toFunLike.{u2, u2, u2} (MonoidHom.{u2, u2} R (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (Monoid.toMulOneClass.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1))) (Monoid.toMulOneClass.{u2} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (OreLocalization.instMonoidOreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2))) R (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (MulOneClass.toMul.{u2} R (Monoid.toMulOneClass.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)))) (MulOneClass.toMul.{u2} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (Monoid.toMulOneClass.{u2} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (OreLocalization.instMonoidOreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2))) (MonoidHomClass.toMulHomClass.{u2, u2, u2} (MonoidHom.{u2, u2} R (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (Monoid.toMulOneClass.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1))) (Monoid.toMulOneClass.{u2} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (OreLocalization.instMonoidOreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2))) R (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (Monoid.toMulOneClass.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1))) (Monoid.toMulOneClass.{u2} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (OreLocalization.instMonoidOreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2)) (MonoidHom.monoidHomClass.{u2, u2} R (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (Monoid.toMulOneClass.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1))) (Monoid.toMulOneClass.{u2} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (OreLocalization.instMonoidOreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2))))) (OreLocalization.numeratorHom.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) r)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (RingHom.{u2, u1} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) T (Semiring.toNonAssocSemiring.{u2} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (OreLocalization.instSemiringOreLocalizationToMonoidToMonoidWithZero.{u2} R _inst_1 S _inst_2)) (Semiring.toNonAssocSemiring.{u1} T _inst_3)) (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (fun (_x : OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) => (fun ([email protected]._hyg.2391 : OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) => T) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (RingHom.{u2, u1} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) T (Semiring.toNonAssocSemiring.{u2} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (OreLocalization.instSemiringOreLocalizationToMonoidToMonoidWithZero.{u2} R _inst_1 S _inst_2)) (Semiring.toNonAssocSemiring.{u1} T _inst_3)) (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) T (NonUnitalNonAssocSemiring.toMul.{u2} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (Semiring.toNonAssocSemiring.{u2} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (OreLocalization.instSemiringOreLocalizationToMonoidToMonoidWithZero.{u2} R _inst_1 S _inst_2)))) (NonUnitalNonAssocSemiring.toMul.{u1} T (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} T (Semiring.toNonAssocSemiring.{u1} T _inst_3))) (NonUnitalRingHomClass.toMulHomClass.{max u2 u1, u2, u1} (RingHom.{u2, u1} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) T (Semiring.toNonAssocSemiring.{u2} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (OreLocalization.instSemiringOreLocalizationToMonoidToMonoidWithZero.{u2} R _inst_1 S _inst_2)) (Semiring.toNonAssocSemiring.{u1} T _inst_3)) (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) T (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (Semiring.toNonAssocSemiring.{u2} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (OreLocalization.instSemiringOreLocalizationToMonoidToMonoidWithZero.{u2} R _inst_1 S _inst_2))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} T (Semiring.toNonAssocSemiring.{u1} T _inst_3)) (RingHomClass.toNonUnitalRingHomClass.{max u2 u1, u2, u1} (RingHom.{u2, u1} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) T (Semiring.toNonAssocSemiring.{u2} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (OreLocalization.instSemiringOreLocalizationToMonoidToMonoidWithZero.{u2} R _inst_1 S _inst_2)) (Semiring.toNonAssocSemiring.{u1} T _inst_3)) (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) T (Semiring.toNonAssocSemiring.{u2} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (OreLocalization.instSemiringOreLocalizationToMonoidToMonoidWithZero.{u2} R _inst_1 S _inst_2)) (Semiring.toNonAssocSemiring.{u1} T _inst_3) (RingHom.instRingHomClassRingHom.{u2, u1} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) T (Semiring.toNonAssocSemiring.{u2} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (OreLocalization.instSemiringOreLocalizationToMonoidToMonoidWithZero.{u2} R _inst_1 S _inst_2)) (Semiring.toNonAssocSemiring.{u1} T _inst_3))))) φ (FunLike.coe.{succ u2, succ u2, succ u2} (MonoidHom.{u2, u2} R (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (Monoid.toMulOneClass.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1))) (Monoid.toMulOneClass.{u2} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (OreLocalization.instMonoidOreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2))) R (fun (_x : R) => (fun ([email protected]._hyg.2391 : R) => OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) _x) (MulHomClass.toFunLike.{u2, u2, u2} (MonoidHom.{u2, u2} R (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (Monoid.toMulOneClass.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1))) (Monoid.toMulOneClass.{u2} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (OreLocalization.instMonoidOreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2))) R (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (MulOneClass.toMul.{u2} R (Monoid.toMulOneClass.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)))) (MulOneClass.toMul.{u2} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (Monoid.toMulOneClass.{u2} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (OreLocalization.instMonoidOreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2))) (MonoidHomClass.toMulHomClass.{u2, u2, u2} (MonoidHom.{u2, u2} R (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (Monoid.toMulOneClass.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1))) (Monoid.toMulOneClass.{u2} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (OreLocalization.instMonoidOreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2))) R (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (Monoid.toMulOneClass.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1))) (Monoid.toMulOneClass.{u2} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (OreLocalization.instMonoidOreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2)) (MonoidHom.monoidHomClass.{u2, u2} R (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (Monoid.toMulOneClass.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1))) (Monoid.toMulOneClass.{u2} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (OreLocalization.instMonoidOreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2))))) (OreLocalization.numeratorHom.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) r)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (RingHom.{u2, u1} R T (Semiring.toNonAssocSemiring.{u2} R _inst_1) (Semiring.toNonAssocSemiring.{u1} T _inst_3)) R (fun (_x : R) => (fun ([email protected]._hyg.2391 : R) => T) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (RingHom.{u2, u1} R T (Semiring.toNonAssocSemiring.{u2} R _inst_1) (Semiring.toNonAssocSemiring.{u1} T _inst_3)) R T (NonUnitalNonAssocSemiring.toMul.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1))) (NonUnitalNonAssocSemiring.toMul.{u1} T (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} T (Semiring.toNonAssocSemiring.{u1} T _inst_3))) (NonUnitalRingHomClass.toMulHomClass.{max u2 u1, u2, u1} (RingHom.{u2, u1} R T (Semiring.toNonAssocSemiring.{u2} R _inst_1) (Semiring.toNonAssocSemiring.{u1} T _inst_3)) R T (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R _inst_1)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} T (Semiring.toNonAssocSemiring.{u1} T _inst_3)) (RingHomClass.toNonUnitalRingHomClass.{max u2 u1, u2, u1} (RingHom.{u2, u1} R T (Semiring.toNonAssocSemiring.{u2} R _inst_1) (Semiring.toNonAssocSemiring.{u1} T _inst_3)) R T (Semiring.toNonAssocSemiring.{u2} R _inst_1) (Semiring.toNonAssocSemiring.{u1} T _inst_3) (RingHom.instRingHomClassRingHom.{u2, u1} R T (Semiring.toNonAssocSemiring.{u2} R _inst_1) (Semiring.toNonAssocSemiring.{u1} T _inst_3))))) f r)) -> (Eq.{max (succ u2) (succ u1)} (RingHom.{u2, u1} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) T (Semiring.toNonAssocSemiring.{u2} (OreLocalization.{u2} R (MonoidWithZero.toMonoid.{u2} R (Semiring.toMonoidWithZero.{u2} R _inst_1)) S _inst_2) (OreLocalization.instSemiringOreLocalizationToMonoidToMonoidWithZero.{u2} R _inst_1 S _inst_2)) (Semiring.toNonAssocSemiring.{u1} T _inst_3)) φ (OreLocalization.universalHom.{u2, u1} R _inst_1 S _inst_2 T _inst_3 f fS hf))
Case conversion may be inaccurate. Consider using '#align ore_localization.universal_hom_unique OreLocalization.universalHom_uniqueₓ'. -/
theorem universalHom_unique (φ : R[S⁻¹] →+* T) (huniv : ∀ r : R, φ (numeratorHom r) = f r) :
φ = universalHom f fS hf :=
RingHom.coe_monoidHom_injective <| universalMulHom_unique (RingHom.toMonoidHom f) fS hf (↑φ) huniv
#align ore_localization.universal_hom_unique OreLocalization.universalHom_unique
end UMP
end Semiring
section Ring
variable {R : Type _} [Ring R] {S : Submonoid R} [OreSet S]
/- warning: ore_localization.neg -> OreLocalization.neg is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Ring.{u1} R] {S : Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1))))} [_inst_2 : OreLocalization.OreSet.{u1} R (Ring.toMonoid.{u1} R _inst_1) S], (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) S _inst_2) -> (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) S _inst_2)
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Ring.{u1} R] {S : Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1))))} [_inst_2 : OreLocalization.OreSet.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) S], (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) S _inst_2) -> (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) S _inst_2)
Case conversion may be inaccurate. Consider using '#align ore_localization.neg OreLocalization.negₓ'. -/
/-- Negation on the Ore localization is defined via negation on the numerator. -/
protected def neg : R[S⁻¹] → R[S⁻¹] :=
liftExpand (fun (r : R) (s : S) => -r /ₒ s) fun r t s ht => by
rw [neg_mul_eq_neg_mul, ← OreLocalization.expand]
#align ore_localization.neg OreLocalization.neg
instance : Neg R[S⁻¹] :=
⟨OreLocalization.neg⟩
/- warning: ore_localization.neg_def -> OreLocalization.neg_def is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Ring.{u1} R] {S : Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1))))} [_inst_2 : OreLocalization.OreSet.{u1} R (Ring.toMonoid.{u1} R _inst_1) S] (r : R) (s : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1))))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1))))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1)))))) S), Eq.{succ u1} (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) S _inst_2) (Neg.neg.{u1} (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) S _inst_2) (OreLocalization.hasNeg.{u1} R _inst_1 S _inst_2) (OreLocalization.oreDiv.{u1} R (Ring.toMonoid.{u1} R _inst_1) S _inst_2 r s)) (OreLocalization.oreDiv.{u1} R (Ring.toMonoid.{u1} R _inst_1) S _inst_2 (Neg.neg.{u1} R (SubNegMonoid.toHasNeg.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R _inst_1))))) r) s)
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Ring.{u1} R] {S : Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1))))} [_inst_2 : OreLocalization.OreSet.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) S] (r : R) (s : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1))))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1))))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1)))))) x S)), Eq.{succ u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) S _inst_2) (Neg.neg.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) S _inst_2) (OreLocalization.instNegOreLocalizationToMonoidToMonoidWithZeroToSemiring.{u1} R _inst_1 S _inst_2) (OreLocalization.oreDiv.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) S _inst_2 r s)) (OreLocalization.oreDiv.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) S _inst_2 (Neg.neg.{u1} R (Ring.toNeg.{u1} R _inst_1) r) s)
Case conversion may be inaccurate. Consider using '#align ore_localization.neg_def OreLocalization.neg_defₓ'. -/
@[simp]
protected theorem neg_def (r : R) (s : S) : -(r /ₒ s) = -r /ₒ s :=
rfl
#align ore_localization.neg_def OreLocalization.neg_def
/- warning: ore_localization.add_left_neg -> OreLocalization.add_left_neg is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Ring.{u1} R] {S : Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1))))} [_inst_2 : OreLocalization.OreSet.{u1} R (Ring.toMonoid.{u1} R _inst_1) S] (x : OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) S _inst_2), Eq.{succ u1} (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) S _inst_2) (HAdd.hAdd.{u1, u1, u1} (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) S _inst_2) (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) S _inst_2) (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) S _inst_2) (instHAdd.{u1} (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) S _inst_2) (OreLocalization.hasAdd.{u1} R (Ring.toSemiring.{u1} R _inst_1) S _inst_2)) (Neg.neg.{u1} (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) S _inst_2) (OreLocalization.hasNeg.{u1} R _inst_1 S _inst_2) x) x) (OfNat.ofNat.{u1} (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) S _inst_2) 0 (OfNat.mk.{u1} (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) S _inst_2) 0 (Zero.zero.{u1} (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) S _inst_2) (OreLocalization.hasZero.{u1} R (Ring.toSemiring.{u1} R _inst_1) S _inst_2))))
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Ring.{u1} R] {S : Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1))))} [_inst_2 : OreLocalization.OreSet.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) S] (x : OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) S _inst_2), Eq.{succ u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) S _inst_2) (HAdd.hAdd.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) S _inst_2) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) S _inst_2) (instHAdd.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) S _inst_2) (OreLocalization.instAddOreLocalizationToMonoidToMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1) S _inst_2)) (Neg.neg.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) S _inst_2) (OreLocalization.instNegOreLocalizationToMonoidToMonoidWithZeroToSemiring.{u1} R _inst_1 S _inst_2) x) x) (OfNat.ofNat.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) S _inst_2) 0 (Zero.toOfNat0.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) S _inst_2) (OreLocalization.instZeroOreLocalizationToMonoidToMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1) S _inst_2)))
Case conversion may be inaccurate. Consider using '#align ore_localization.add_left_neg OreLocalization.add_left_negₓ'. -/
protected theorem add_left_neg (x : R[S⁻¹]) : -x + x = 0 := by
induction' x using OreLocalization.ind with r s <;> simp
#align ore_localization.add_left_neg OreLocalization.add_left_neg
instance : Ring R[S⁻¹] :=
{ OreLocalization.semiring, OreLocalization.hasNeg with
add_left_neg := OreLocalization.add_left_neg }
open nonZeroDivisors
/- warning: ore_localization.numerator_hom_inj -> OreLocalization.numeratorHom_inj is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Ring.{u1} R] {S : Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1))))} [_inst_2 : OreLocalization.OreSet.{u1} R (Ring.toMonoid.{u1} R _inst_1) S], (LE.le.{u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1))))) (Preorder.toLE.{u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1))))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1))))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1))))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1)))))))) S (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1)))) -> (Function.Injective.{succ u1, succ u1} R (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) S _inst_2) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} R (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) S _inst_2) (Monoid.toMulOneClass.{u1} R (Ring.toMonoid.{u1} R _inst_1)) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) S _inst_2) (OreLocalization.monoid.{u1} R (Ring.toMonoid.{u1} R _inst_1) S _inst_2))) (fun (_x : MonoidHom.{u1, u1} R (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) S _inst_2) (Monoid.toMulOneClass.{u1} R (Ring.toMonoid.{u1} R _inst_1)) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) S _inst_2) (OreLocalization.monoid.{u1} R (Ring.toMonoid.{u1} R _inst_1) S _inst_2))) => R -> (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) S _inst_2)) (MonoidHom.hasCoeToFun.{u1, u1} R (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) S _inst_2) (Monoid.toMulOneClass.{u1} R (Ring.toMonoid.{u1} R _inst_1)) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) S _inst_2) (OreLocalization.monoid.{u1} R (Ring.toMonoid.{u1} R _inst_1) S _inst_2))) (OreLocalization.numeratorHom.{u1} R (Ring.toMonoid.{u1} R _inst_1) S _inst_2)))
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Ring.{u1} R] {S : Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1))))} [_inst_2 : OreLocalization.OreSet.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) S], (LE.le.{u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1))))) (Preorder.toLE.{u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1))))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1))))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1))))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1))))) (Submonoid.instCompleteLatticeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1))))))))) S (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1)))) -> (Function.Injective.{succ u1, succ u1} R (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) S _inst_2) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} R (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) S _inst_2) (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1)))) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) S _inst_2))) R (fun (_x : R) => (fun ([email protected]._hyg.2391 : R) => OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) S _inst_2) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} R (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) S _inst_2) (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1)))) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) S _inst_2))) R (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) S _inst_2) (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))))) (MulOneClass.toMul.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) S _inst_2) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) S _inst_2))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} R (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) S _inst_2) (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1)))) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) S _inst_2))) R (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) S _inst_2) (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1)))) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) S _inst_2)) (MonoidHom.monoidHomClass.{u1, u1} R (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) S _inst_2) (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1)))) (Monoid.toMulOneClass.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) S _inst_2) (OreLocalization.instMonoidOreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) S _inst_2))))) (OreLocalization.numeratorHom.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) S _inst_2)))
Case conversion may be inaccurate. Consider using '#align ore_localization.numerator_hom_inj OreLocalization.numeratorHom_injₓ'. -/
theorem numeratorHom_inj (hS : S ≤ R⁰) : Function.Injective (numeratorHom : R → R[S⁻¹]) :=
fun r₁ r₂ h =>
by
rw [numerator_hom_apply, numerator_hom_apply, ore_div_eq_iff] at h
rcases h with ⟨u, v, h₁, h₂⟩
simp only [S.coe_one, one_mul] at h₂
rwa [← h₂, mul_cancel_right_mem_nonZeroDivisors (hS (SetLike.coe_mem u)), eq_comm] at h₁
#align ore_localization.numerator_hom_inj OreLocalization.numeratorHom_inj
/- warning: ore_localization.nontrivial_of_non_zero_divisors -> OreLocalization.nontrivial_of_nonZeroDivisors is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Ring.{u1} R] {S : Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1))))} [_inst_2 : OreLocalization.OreSet.{u1} R (Ring.toMonoid.{u1} R _inst_1) S] [_inst_3 : Nontrivial.{u1} R], (LE.le.{u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1))))) (Preorder.toLE.{u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1))))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1))))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1))))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1)))))))) S (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1)))) -> (Nontrivial.{u1} (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) S _inst_2))
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Ring.{u1} R] {S : Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1))))} [_inst_2 : OreLocalization.OreSet.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) S] [_inst_3 : Nontrivial.{u1} R], (LE.le.{u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1))))) (Preorder.toLE.{u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1))))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1))))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1))))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1))))) (Submonoid.instCompleteLatticeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1))))))))) S (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1)))) -> (Nontrivial.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) S _inst_2))
Case conversion may be inaccurate. Consider using '#align ore_localization.nontrivial_of_non_zero_divisors OreLocalization.nontrivial_of_nonZeroDivisorsₓ'. -/
theorem nontrivial_of_nonZeroDivisors [Nontrivial R] (hS : S ≤ R⁰) : Nontrivial R[S⁻¹] :=
⟨⟨0, 1, fun h => by
rw [OreLocalization.one_def, OreLocalization.zero_def] at h
apply nonZeroDivisors.coe_ne_zero 1 (numerator_hom_inj hS h).symm⟩⟩
#align ore_localization.nontrivial_of_non_zero_divisors OreLocalization.nontrivial_of_nonZeroDivisors
end Ring
section DivisionRing
open nonZeroDivisors
open Classical
variable {R : Type _} [Ring R] [Nontrivial R] [OreSet R⁰]
instance : Nontrivial R[R⁰⁻¹] :=
nontrivial_of_nonZeroDivisors (refl R⁰)
variable [NoZeroDivisors R]
noncomputable section
/- warning: ore_localization.inv -> OreLocalization.inv is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Ring.{u1} R] [_inst_2 : Nontrivial.{u1} R] [_inst_3 : OreLocalization.OreSet.{u1} R (Ring.toMonoid.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1)))] [_inst_4 : NoZeroDivisors.{u1} R (Distrib.toHasMul.{u1} R (Ring.toDistrib.{u1} R _inst_1)) (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1)))))], (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) -> (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3)
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Ring.{u1} R] [_inst_2 : Nontrivial.{u1} R] [_inst_3 : OreLocalization.OreSet.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1)))] [_inst_4 : NoZeroDivisors.{u1} R (NonUnitalNonAssocRing.toMul.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1))) (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1)))], (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) -> (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3)
Case conversion may be inaccurate. Consider using '#align ore_localization.inv OreLocalization.invₓ'. -/
/-- The inversion of Ore fractions for a ring without zero divisors, satisying `0⁻¹ = 0` and
`(r /ₒ r')⁻¹ = r' /ₒ r` for `r ≠ 0`. -/
protected def inv : R[R⁰⁻¹] → R[R⁰⁻¹] :=
liftExpand
(fun r s =>
if hr : r = (0 : R) then (0 : R[R⁰⁻¹])
else s /ₒ ⟨r, fun _ => eq_zero_of_ne_zero_of_mul_right_eq_zero hr⟩)
(by
intro r t s hst
by_cases hr : r = 0
· simp [hr]
· by_cases ht : t = 0
· exfalso
apply nonZeroDivisors.coe_ne_zero ⟨_, hst⟩
simp [ht, MulZeroClass.mul_zero]
· simp only [hr, ht, [anonymous], dif_neg, not_false_iff, or_self_iff, mul_eq_zero]
apply OreLocalization.expand)
#align ore_localization.inv OreLocalization.inv
instance : Inv R[R⁰⁻¹] :=
⟨OreLocalization.inv⟩
/- warning: ore_localization.inv_def -> OreLocalization.inv_def is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Ring.{u1} R] [_inst_2 : Nontrivial.{u1} R] [_inst_3 : OreLocalization.OreSet.{u1} R (Ring.toMonoid.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1)))] [_inst_4 : NoZeroDivisors.{u1} R (Distrib.toHasMul.{u1} R (Ring.toDistrib.{u1} R _inst_1)) (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1)))))] {r : R} {s : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1)))))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1)))}, Eq.{succ u1} (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) (Inv.inv.{u1} (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) (OreLocalization.hasInv.{u1} R _inst_1 _inst_2 _inst_3 _inst_4) (OreLocalization.oreDiv.{u1} R (Ring.toMonoid.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3 r s)) (dite.{succ u1} (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) (Eq.{succ u1} R r (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1))))))))) (Classical.propDecidable (Eq.{succ u1} R r (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1)))))))))) (fun (hr : Eq.{succ u1} R r (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1))))))))) => OfNat.ofNat.{u1} (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) 0 (OfNat.mk.{u1} (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) 0 (Zero.zero.{u1} (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) (OreLocalization.hasZero.{u1} R (Ring.toSemiring.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3)))) (fun (hr : Not (Eq.{succ u1} R r (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1)))))))))) => OreLocalization.oreDiv.{u1} R (Ring.toMonoid.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3 ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1)))))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1)))) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1)))))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1)))) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1)))))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1)))) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1)))))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1)))) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1)))))) x (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1)))))))) s) (Subtype.mk.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (Ring.toMonoid.{u1} R _inst_1))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (Ring.toMonoid.{u1} R _inst_1))) R (Submonoid.setLike.{u1} R (Monoid.toMulOneClass.{u1} R (Ring.toMonoid.{u1} R _inst_1)))) x (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1)))) r (fun (_x : R) => eq_zero_of_ne_zero_of_mul_right_eq_zero.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1)) _inst_4 r _x hr))))
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Ring.{u1} R] [_inst_2 : Nontrivial.{u1} R] [_inst_3 : OreLocalization.OreSet.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1)))] [_inst_4 : NoZeroDivisors.{u1} R (NonUnitalNonAssocRing.toMul.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1))) (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1)))] {r : R} {s : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1)))))) x (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))))}, Eq.{succ u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) (Inv.inv.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) (OreLocalization.inv'.{u1} R _inst_1 _inst_2 _inst_3 _inst_4) (OreLocalization.oreDiv.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3 r s)) (dite.{succ u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) (Eq.{succ u1} R r (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1)))))) (Classical.propDecidable (Eq.{succ u1} R r (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))))))) (fun (hr : Eq.{succ u1} R r (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1)))))) => OfNat.ofNat.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) 0 (Zero.toOfNat0.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) (OreLocalization.instZeroOreLocalizationToMonoidToMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3))) (fun (hr : Not (Eq.{succ u1} R r (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))))))) => OreLocalization.oreDiv.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3 (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))))) s) (Subtype.mk.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))))) R (Submonoid.instSetLikeSubmonoid.{u1} R (Monoid.toMulOneClass.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1)))))) x (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1)))) r (fun (_x : R) => eq_zero_of_ne_zero_of_mul_right_eq_zero.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1)) _inst_4 r _x hr))))
Case conversion may be inaccurate. Consider using '#align ore_localization.inv_def OreLocalization.inv_defₓ'. -/
protected theorem inv_def {r : R} {s : R⁰} :
(r /ₒ s)⁻¹ =
if hr : r = (0 : R) then (0 : R[R⁰⁻¹])
else s /ₒ ⟨r, fun _ => eq_zero_of_ne_zero_of_mul_right_eq_zero hr⟩ :=
rfl
#align ore_localization.inv_def OreLocalization.inv_def
/- warning: ore_localization.mul_inv_cancel -> OreLocalization.mul_inv_cancel is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Ring.{u1} R] [_inst_2 : Nontrivial.{u1} R] [_inst_3 : OreLocalization.OreSet.{u1} R (Ring.toMonoid.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1)))] [_inst_4 : NoZeroDivisors.{u1} R (Distrib.toHasMul.{u1} R (Ring.toDistrib.{u1} R _inst_1)) (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1)))))] (x : OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3), (Ne.{succ u1} (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) x (OfNat.ofNat.{u1} (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) 0 (OfNat.mk.{u1} (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) 0 (Zero.zero.{u1} (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) (OreLocalization.hasZero.{u1} R (Ring.toSemiring.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3))))) -> (Eq.{succ u1} (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) (HMul.hMul.{u1, u1, u1} (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) (instHMul.{u1} (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) (OreLocalization.hasMul.{u1} R (Ring.toMonoid.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3)) x (Inv.inv.{u1} (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) (OreLocalization.hasInv.{u1} R _inst_1 _inst_2 _inst_3 _inst_4) x)) (OfNat.ofNat.{u1} (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) 1 (OfNat.mk.{u1} (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) 1 (One.one.{u1} (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) (OreLocalization.hasOne.{u1} R (Ring.toMonoid.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3)))))
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Ring.{u1} R] [_inst_2 : Nontrivial.{u1} R] [_inst_3 : OreLocalization.OreSet.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1)))] [_inst_4 : NoZeroDivisors.{u1} R (NonUnitalNonAssocRing.toMul.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1))) (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1)))] (x : OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3), (Ne.{succ u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) x (OfNat.ofNat.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) 0 (Zero.toOfNat0.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) (OreLocalization.instZeroOreLocalizationToMonoidToMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3)))) -> (Eq.{succ u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) (HMul.hMul.{u1, u1, u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) (instHMul.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) (OreLocalization.instMulOreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3)) x (Inv.inv.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) (OreLocalization.inv'.{u1} R _inst_1 _inst_2 _inst_3 _inst_4) x)) (OfNat.ofNat.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) 1 (One.toOfNat1.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) (OreLocalization.instOneOreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3))))
Case conversion may be inaccurate. Consider using '#align ore_localization.mul_inv_cancel OreLocalization.mul_inv_cancelₓ'. -/
protected theorem mul_inv_cancel (x : R[R⁰⁻¹]) (h : x ≠ 0) : x * x⁻¹ = 1 :=
by
induction' x using OreLocalization.ind with r s
rw [OreLocalization.inv_def, OreLocalization.one_def]
by_cases hr : r = 0
· exfalso
apply h
simp [hr]
· simp [hr]
apply OreLocalization.div_eq_one'
#align ore_localization.mul_inv_cancel OreLocalization.mul_inv_cancel
/- warning: ore_localization.inv_zero -> OreLocalization.inv_zero is a dubious translation:
lean 3 declaration is
forall {R : Type.{u1}} [_inst_1 : Ring.{u1} R] [_inst_2 : Nontrivial.{u1} R] [_inst_3 : OreLocalization.OreSet.{u1} R (Ring.toMonoid.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1)))] [_inst_4 : NoZeroDivisors.{u1} R (Distrib.toHasMul.{u1} R (Ring.toDistrib.{u1} R _inst_1)) (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1)))))], Eq.{succ u1} (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) (Inv.inv.{u1} (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) (OreLocalization.hasInv.{u1} R _inst_1 _inst_2 _inst_3 _inst_4) (OfNat.ofNat.{u1} (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) 0 (OfNat.mk.{u1} (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) 0 (Zero.zero.{u1} (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) (OreLocalization.hasZero.{u1} R (Ring.toSemiring.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3))))) (OfNat.ofNat.{u1} (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) 0 (OfNat.mk.{u1} (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) 0 (Zero.zero.{u1} (OreLocalization.{u1} R (Ring.toMonoid.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) (OreLocalization.hasZero.{u1} R (Ring.toSemiring.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3))))
but is expected to have type
forall {R : Type.{u1}} [_inst_1 : Ring.{u1} R] [_inst_2 : Nontrivial.{u1} R] [_inst_3 : OreLocalization.OreSet.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1)))] [_inst_4 : NoZeroDivisors.{u1} R (NonUnitalNonAssocRing.toMul.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R _inst_1))) (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1)))], Eq.{succ u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) (Inv.inv.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) (OreLocalization.inv'.{u1} R _inst_1 _inst_2 _inst_3 _inst_4) (OfNat.ofNat.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) 0 (Zero.toOfNat0.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) (OreLocalization.instZeroOreLocalizationToMonoidToMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3)))) (OfNat.ofNat.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) 0 (Zero.toOfNat0.{u1} (OreLocalization.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3) (OreLocalization.instZeroOreLocalizationToMonoidToMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_1))) _inst_3)))
Case conversion may be inaccurate. Consider using '#align ore_localization.inv_zero OreLocalization.inv_zeroₓ'. -/
protected theorem inv_zero : (0 : R[R⁰⁻¹])⁻¹ = 0 :=
by
rw [OreLocalization.zero_def, OreLocalization.inv_def]
simp
#align ore_localization.inv_zero OreLocalization.inv_zero
instance : DivisionRing R[R⁰⁻¹] :=
{ OreLocalization.nontrivial, OreLocalization.hasInv,
OreLocalization.ring with
mul_inv_cancel := OreLocalization.mul_inv_cancel
inv_zero := OreLocalization.inv_zero }
end DivisionRing
end OreLocalization
|
[GOAL]
X Y : MonCat
⊢ FunLike (↑X →* ↑Y) ↑X fun x => ↑Y
[PROOFSTEP]
infer_instance
-- porting note: added
[GOAL]
G : Type u_1
inst✝ : Group G
⊢ Group ↑(of G)
[PROOFSTEP]
assumption
[GOAL]
⊢ ConcreteCategory CommMonCat
[PROOFSTEP]
dsimp only [CommMonCat]
[GOAL]
⊢ ConcreteCategory (Bundled CommMonoid)
[PROOFSTEP]
infer_instance
[GOAL]
X Y : CommMonCat
⊢ FunLike (↑X →* ↑Y) ↑X fun x => ↑Y
[PROOFSTEP]
infer_instance
-- porting note: added
[GOAL]
R S : MonCat
i : R ⟶ S
r : ↑R
h : r = 1
⊢ ↑i r = 1
[PROOFSTEP]
simp [h]
[GOAL]
R S : CommMonCat
i : R ⟶ S
r : ↑R
h : r = 1
⊢ ↑i r = 1
[PROOFSTEP]
simp [h]
-- We verify that when constructing a morphism in `CommMonCat`,
-- when we construct the `toFun` field, the types are presented as `↑R`.
[GOAL]
R : CommMonCat
x : ↑R
⊢ ↑R
[PROOFSTEP]
match_target (R : Type u)
[GOAL]
R : CommMonCat
x : ↑R
⊢ ↑R
[PROOFSTEP]
guard_hyp x : (R : Type u)
[GOAL]
R : CommMonCat
x : ↑R
⊢ ↑R
[PROOFSTEP]
exact x * x
[GOAL]
R : CommMonCat
⊢ (fun x => x * x) 1 = 1
[PROOFSTEP]
simp
[GOAL]
R : CommMonCat
x y : ↑R
⊢ OneHom.toFun { toFun := fun x => x * x, map_one' := (_ : 1 * 1 = 1) } (x * y) =
OneHom.toFun { toFun := fun x => x * x, map_one' := (_ : 1 * 1 = 1) } x *
OneHom.toFun { toFun := fun x => x * x, map_one' := (_ : 1 * 1 = 1) } y
[PROOFSTEP]
dsimp
[GOAL]
R : CommMonCat
x y : ↑R
⊢ x * y * (x * y) = x * x * (y * y)
[PROOFSTEP]
rw [mul_assoc x y (x * y), ← mul_assoc y x y, mul_comm y x, mul_assoc, mul_assoc]
[GOAL]
X✝ Y✝ : Type u
X Y : MonCat
f : X ⟶ Y
x✝ : IsIso ((forget MonCat).map f)
⊢ IsIso f
[PROOFSTEP]
let i := asIso ((forget MonCat).map f)
[GOAL]
X✝ Y✝ : Type u
X Y : MonCat
f : X ⟶ Y
x✝ : IsIso ((forget MonCat).map f)
i : (forget MonCat).obj X ≅ (forget MonCat).obj Y := asIso ((forget MonCat).map f)
⊢ IsIso f
[PROOFSTEP]
let e : X ≃* Y := MulEquiv.mk i.toEquiv (by aesop)
[GOAL]
X✝ Y✝ : Type u
X Y : MonCat
f : X ⟶ Y
x✝ : IsIso ((forget MonCat).map f)
i : (forget MonCat).obj X ≅ (forget MonCat).obj Y := asIso ((forget MonCat).map f)
⊢ ∀ (x y : ↑X), Equiv.toFun i.toEquiv (x * y) = Equiv.toFun i.toEquiv x * Equiv.toFun i.toEquiv y
[PROOFSTEP]
aesop
[GOAL]
X✝ Y✝ : Type u
X Y : MonCat
f : X ⟶ Y
x✝ : IsIso ((forget MonCat).map f)
i : (forget MonCat).obj X ≅ (forget MonCat).obj Y := asIso ((forget MonCat).map f)
e : ↑X ≃* ↑Y := { toEquiv := i.toEquiv, map_mul' := (_ : ∀ (x_1 y : ↑X), ↑f (x_1 * y) = ↑f x_1 * ↑f y) }
⊢ IsIso f
[PROOFSTEP]
exact IsIso.of_iso e.toMonCatIso
[GOAL]
X✝ Y✝ : Type u
X Y : CommMonCat
f : X ⟶ Y
x✝ : IsIso ((forget CommMonCat).map f)
⊢ IsIso f
[PROOFSTEP]
let i := asIso ((forget CommMonCat).map f)
[GOAL]
X✝ Y✝ : Type u
X Y : CommMonCat
f : X ⟶ Y
x✝ : IsIso ((forget CommMonCat).map f)
i : (forget CommMonCat).obj X ≅ (forget CommMonCat).obj Y := asIso ((forget CommMonCat).map f)
⊢ IsIso f
[PROOFSTEP]
let e : X ≃* Y := MulEquiv.mk i.toEquiv (MonoidHom.map_mul (show MonoidHom X Y from f))
[GOAL]
X✝ Y✝ : Type u
X Y : CommMonCat
f : X ⟶ Y
x✝ : IsIso ((forget CommMonCat).map f)
i : (forget CommMonCat).obj X ≅ (forget CommMonCat).obj Y := asIso ((forget CommMonCat).map f)
e : ↑X ≃* ↑Y :=
{ toEquiv := i.toEquiv,
map_mul' :=
(_ :
∀ (a b : ↑X),
↑(let_fun this := f;
this)
(a * b) =
↑(let_fun this := f;
this)
a *
↑(let_fun this := f;
this)
b) }
⊢ IsIso f
[PROOFSTEP]
exact IsIso.of_iso e.toCommMonCatIso
|
//
// @author [email protected]
//
#include <iostream>
#include <hot/singlethreaded/MemoryPool.hpp>
#include <boost/test/unit_test.hpp>
namespace hot { namespace singlethreaded {
struct DummyElement {
uint64_t mMember;
static size_t sNumberContructorCalls;
static size_t sNumberDestructorCalls;
DummyElement() : mMember(0u) {
++sNumberContructorCalls;
}
~DummyElement() {
++sNumberDestructorCalls;
}
static void reset() {
sNumberContructorCalls = 0;
sNumberDestructorCalls = 0;
}
};
class MemoryPoolTestFixture {
public:
//before test
MemoryPoolTestFixture() {
DummyElement::reset();
}
//after test
~MemoryPoolTestFixture() {
DummyElement::reset();
}
};
size_t DummyElement::sNumberContructorCalls = 0u;
size_t DummyElement::sNumberDestructorCalls = 0u;
BOOST_FIXTURE_TEST_SUITE(MemoryPoolTest, MemoryPoolTestFixture)
BOOST_AUTO_TEST_CASE(testAllocAndDestruction)
{
MemoryPool<DummyElement, 10>* pool = new MemoryPool<DummyElement, 10>();
size_t numberConstructorCalls = 0u;
for(size_t i=1u; i < 10u; ++i) {
void* rawMemory = pool->alloc(i);
numberConstructorCalls+=i;
BOOST_REQUIRE_EQUAL(pool->getNumberAllocations(), i);
pool->returnToPool(i, rawMemory);
void* rawMemory2 = pool->alloc(i);
pool->returnToPool(i, rawMemory2);
BOOST_REQUIRE_EQUAL(pool->getNumberAllocations(), i);
}
BOOST_REQUIRE_EQUAL(pool->getNumberFrees(), 0u);
delete pool;
BOOST_REQUIRE_EQUAL(pool->getNumberFrees(), pool->getNumberAllocations());
BOOST_REQUIRE_EQUAL(pool->getNumberFrees(), 9u);
}
BOOST_AUTO_TEST_CASE(testEviction) {
MemoryPool<DummyElement, 10, 20, 8>* pool = new MemoryPool<DummyElement, 10, 20, 8>();
size_t numberConstructorCalls = 0u;
for(size_t i=1u; i < 10u; ++i) {
void* rawMemory = pool->alloc(i);
BOOST_REQUIRE_EQUAL(pool->getNumberAllocations(), i);
pool->returnToPool(i, rawMemory);
void* rawMemory2 = pool->alloc(i);
pool->returnToPool(i, rawMemory2);
BOOST_REQUIRE_EQUAL(rawMemory2, rawMemory);
BOOST_REQUIRE_EQUAL(pool->getNumberAllocations(), i);
}
std::array<void*, 20> intermediateMemory;
intermediateMemory[0] = pool->alloc(4);
for(size_t i=1u; i < 20u; ++i) {
intermediateMemory[i] = pool->alloc(4);
numberConstructorCalls += 4;
}
BOOST_REQUIRE_EQUAL(pool->getNumberAllocations(), 28u);
BOOST_REQUIRE_EQUAL(pool->getNumberFrees(), 0u);
for(size_t i=0u; i < 19u; ++i) {
pool->returnToPool(4, intermediateMemory[i]);
}
BOOST_REQUIRE_EQUAL(pool->getNumberAllocations(), 28u);
BOOST_REQUIRE_EQUAL(pool->getNumberFrees(), 0u);
pool->returnToPool(4, intermediateMemory[19]);
BOOST_REQUIRE_EQUAL(pool->getNumberAllocations(), 28u);
BOOST_REQUIRE_EQUAL(pool->getNumberFrees(), 12u);
delete pool;
BOOST_REQUIRE_EQUAL(pool->getNumberAllocations(), 28u);
BOOST_REQUIRE_EQUAL(pool->getNumberFrees(), 28u);
}
BOOST_AUTO_TEST_SUITE_END()
}}
|
#' rancovr: Cluster detection in R with RAndom Neighbourhood COVeRing
#'
#' rancovr detects statio-temporal clusters against a baseline of
#' sparse Poisson point events using
#' the random neighbourhood covering algorithm.
#'
#' @section Foo functions:
#' The foo functions ...
#'
#' @docType package
#' @name foo
NULL
#> NULL |
Formal statement is: lemma complex_Im_fact [simp]: "Im (fact n) = 0" Informal statement is: The imaginary part of the factorial of any natural number is zero. |
! ##################################################################################################################################
! Begin MIT license text.
! _______________________________________________________________________________________________________
! Copyright 2019 Dr William R Case, Jr ([email protected])
! Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
! associated documentation files (the "Software"), to deal in the Software without restriction, including
! without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
! copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to
! the following conditions:
! The above copyright notice and this permission notice shall be included in all copies or substantial
! portions of the Software and documentation.
! THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
! OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
! FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
! AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
! LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
! OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
! THE SOFTWARE.
! _______________________________________________________________________________________________________
! End MIT license text.
SUBROUTINE CALC_PHI_SQ ( IERROR )
! Calculates the PHI_SQ shear correction factor used in the MIN3 and MIN4 elements (TRIA3, QUAD4 Mindlin elements) in subrs
! TRPLT2, QPLT2. PHI_SQ is used as a multiplier of the shear stiffness and the element stresses
! PHI_SQ = CBMIN*PSI_HAT/(1 + CBMIN*PSI_HAT) where
! PSI_HAT = BENSUM/SHRSUM
! (1) CBMIN is a constant from the published papers by Alexander TEssler (see refs in the MYSTRAN User's Manual) for the MIN3
! triangular element (TRIA3) and MIN4 quadrilateral element (QUAD4)
! (2) BENSUM is the sum of the diagonal terms for rotation DOF's from the bending portion of the element stiffness matrix
! (3) SHRSUM is the sum of the diagonal terms from the transverse shear portion of the element stiffness matrix
! BENSUM and SHRSUM are determined in subrs TPLT2 (for the MIN3 TRIA3 elem) and QPLT2 (for the MIN4 QUAD4 elem) prior to calling
! this subr.
! For composite elements (PCOMP properties), a correction to PHI_SQ has to be made when PHI_SQ is calculated during stress recovery
! of individual plies. In these cases, the PHI_SQ calculated when the stiffness and stress recovery matrices is based on the
! individual ply thicknesses (bending and transverse shear) but should really be based on the whole element - i.e. the integrated
! effect of all plies. It is known that BENSUM is proportional to the bending inertia of the element and SHRSUM is proportional to
! the transverse shear thickness of the element. Thus, for composite elements, the BENSUM and SHRSUM calculated for 1 ply are
! adjusted by the ratio of these quantities between 1 ply and the composite layup
USE PENTIUM_II_KIND, ONLY : BYTE, LONG, DOUBLE
USE SCONTR, ONLY : BLNK_SUB_NAM, FATAL_ERR, MEFE
USE IOUNT1, ONLY : ERR, F04, F06, WRT_ERR, WRT_LOG
USE TIMDAT, ONLY : TSEC
USE SUBR_BEGEND_LEVELS, ONLY : CALC_PHI_SQ_BEGEND
USE CONSTANTS_1, ONLY : ZERO, ONE, TWELVE
USE PARAMS, ONLY : CBMIN3, CBMIN4, CBMIN4T, EPSIL, PCMPTSTM, QUAD4TYP
USE MODEL_STUF, ONLY : BENSUM, EID, EMG_IFE, EMG_RFE, ERR_SUB_NAM, NUM_EMG_FATAL_ERRS, INTL_MID, PHI_SQ, &
PCOMP_PROPS, PLY_NUM, PSI_HAT, SHRSUM, TPLY, TYPE
USE CALC_PHI_SQ_USE_IFs
IMPLICIT NONE
CHARACTER(LEN=LEN(BLNK_SUB_NAM)):: SUBR_NAME = 'CALC_PHI_SQ'
INTEGER(LONG), INTENT(OUT) :: IERROR ! Local error indicator
INTEGER(LONG), PARAMETER :: SUBR_BEGEND = CALC_PHI_SQ_BEGEND
REAL(DOUBLE) :: CBMIN = ZERO ! Either CBMIN3 or CBMIN4
REAL(DOUBLE) :: DEN ! Denominator term in calculating PHI_SQ
REAL(DOUBLE) :: EPS1 ! A small number to compare to real zero
REAL(DOUBLE) :: PCOMP_TM ! Membrane thick of PCOMP for equiv PSHELL (see subr SHELL_ABD_MATRICES)
REAL(DOUBLE) :: PCOMP_IB ! Bending MOI of PCOMP for equiv PSHELL (see subr SHELL_ABD_MATRICES)
REAL(DOUBLE) :: PCOMP_TS ! Transv shear thick of PCOMP for equiv PSHELL (subr SHELL_ABD_MATRICES)
REAL(DOUBLE) :: PLY_IB ! Bending MOI of a ply
REAL(DOUBLE) :: PLY_TS ! Transv shear thick of a ply
! **********************************************************************************************************************************
IF (WRT_LOG >= SUBR_BEGEND) THEN
CALL OURTIM
WRITE(F04,9001) SUBR_NAME,TSEC
9001 FORMAT(1X,A,' BEGN ',F10.3)
ENDIF
! **********************************************************************************************************************************
IERROR = 0
EPS1 = EPSIL(1)
! For composite elements, adjust BENSUM and SHRSUM to be based on the whole composite element properties since they were calculated
! based on only 1 ply
IF (PCOMP_PROPS == 'Y') THEN
IF (PLY_NUM /= 0) THEN
CALL GET_PCOMP_SECT_PROPS ( PCOMP_TM, PCOMP_IB, PCOMP_TS )
PLY_IB = TPLY*TPLY*TPLY/TWELVE
PLY_TS = TPLY*PCMPTSTM
BENSUM = (PCOMP_IB/PLY_IB)*BENSUM
SHRSUM = (PCOMP_TS/PLY_TS)*SHRSUM
ENDIF
ENDIF
! Now calculate PHI_SQ (but only if the element has transverse shear flexibility)
IF (TYPE(1:5) == 'QUAD4') THEN ! Regardless of who calls this subr, TYPE will det which CBMIN to use
IF (QUAD4TYP == 'MIN4T') THEN ! quad TYPE's will use either CBMIN4 or CBMIN4T
CBMIN = CBMIN4T
ELSE
CBMIN = CBMIN4
ENDIF
ELSE IF (TYPE(1:5) == 'TRIA3') THEN ! tria TYPE's will use CBMIN3 (NOTE: MIN4T quads will use CBMIN4T, above)
CBMIN = CBMIN3
ELSE
NUM_EMG_FATAL_ERRS = NUM_EMG_FATAL_ERRS + 1
FATAL_ERR = FATAL_ERR + 1
IERROR = IERROR + 1
IF (WRT_ERR > 0) THEN
WRITE(ERR,1943) TYPE, EID
WRITE(F06,1943) TYPE, EID
ELSE
IF (NUM_EMG_FATAL_ERRS <= MEFE) THEN
ERR_SUB_NAM(NUM_EMG_FATAL_ERRS) = SUBR_NAME
EMG_IFE(NUM_EMG_FATAL_ERRS,1) = 1943
ENDIF
ENDIF
ENDIF
IERROR = 0
PSI_HAT = ZERO
IF (DABS(SHRSUM) > EPS1) THEN
PSI_HAT = BENSUM/SHRSUM
ELSE
NUM_EMG_FATAL_ERRS = NUM_EMG_FATAL_ERRS + 1
FATAL_ERR = FATAL_ERR + 1
IERROR = IERROR + 1
IF (WRT_ERR > 0) THEN
WRITE(ERR,1923) SHRSUM, TYPE, EID
WRITE(F06,1923) SHRSUM, TYPE, EID
ELSE
IF (NUM_EMG_FATAL_ERRS <= MEFE) THEN
ERR_SUB_NAM(NUM_EMG_FATAL_ERRS) = SUBR_NAME
EMG_IFE(NUM_EMG_FATAL_ERRS,1) = 1923
EMG_RFE(NUM_EMG_FATAL_ERRS,1) = SHRSUM
ENDIF
ENDIF
ENDIF
DEN = ONE + CBMIN*PSI_HAT
IF (DABS(DEN) > EPS1) THEN
PHI_SQ = CBMIN*PSI_HAT/DEN
ELSE
NUM_EMG_FATAL_ERRS = NUM_EMG_FATAL_ERRS + 1
FATAL_ERR = FATAL_ERR + 1
IERROR = IERROR + 1
IF (WRT_ERR > 0) THEN
WRITE(ERR,1942) DEN, TYPE, EID
WRITE(F06,1942) DEN, TYPE, EID
ELSE
IF (NUM_EMG_FATAL_ERRS <= MEFE) THEN
ERR_SUB_NAM(NUM_EMG_FATAL_ERRS) = SUBR_NAME
EMG_IFE(NUM_EMG_FATAL_ERRS,1) = 1942
EMG_RFE(NUM_EMG_FATAL_ERRS,1) = DEN
ENDIF
ENDIF
ENDIF
! **********************************************************************************************************************************
IF (WRT_LOG >= SUBR_BEGEND) THEN
CALL OURTIM
WRITE(F04,9002) SUBR_NAME,TSEC
9002 FORMAT(1X,A,' END ',F10.3)
ENDIF
RETURN
! **********************************************************************************************************************************
1923 FORMAT(' *ERROR 1923: SHRSUM PARAMETER = ',1ES9.2,' IS TOO CLOSE TO ZERO FOR ',A,' ELEMENT ',I8 &
,/,14X,' CANNOT CALCULATE PSI_HAT FACTOR NEEDED FOR TRANSVERSE SHEAR STIFFNESS CALCULATION')
1942 FORMAT(' *ERROR 1942: 1 + CBMIN*PSI_HAT = ',1ES9.2,' IS TOO CLOSE TO ZERO FOR ',A,' ELEMENT ',I8 &
,/,14X,' CANNOT CALCULATE PHI_SQ FACTOR NEEDED FOR TRANSVERSE SHEAR STIFFNESS CALCULATION')
1943 FORMAT(' *ERROR 1943: PROGRAMMING ERROR IN SUBROUTINE ',A &
,/,15X, A, 'ELEMENT ',I8,' IS NOT A VALID ELEMENT FOR THIS SUBR')
! **********************************************************************************************************************************
END SUBROUTINE CALC_PHI_SQ |
(* Title: CartesianMonoidalCategory
Author: Eugene W. Stark <[email protected]>, 2020
Maintainer: Eugene W. Stark <[email protected]>
*)
chapter "Cartesian Monoidal Category"
theory CartesianMonoidalCategory
imports MonoidalCategory Category3.CartesianCategory
begin
locale symmetric_monoidal_category =
monoidal_category C T \<alpha> \<iota> +
S: symmetry_functor C C +
ToS: composite_functor CC.comp CC.comp C S.map T +
\<sigma>: natural_isomorphism CC.comp C T ToS.map \<sigma>
for C :: "'a comp" (infixr "\<cdot>" 55)
and T :: "'a * 'a \<Rightarrow> 'a"
and \<alpha> :: "'a * 'a * 'a \<Rightarrow> 'a"
and \<iota> :: 'a
and \<sigma> :: "'a * 'a \<Rightarrow> 'a" +
assumes sym_inverse: "\<lbrakk> ide a; ide b \<rbrakk> \<Longrightarrow> inverse_arrows (\<sigma> (a, b)) (\<sigma> (b, a))"
and unitor_coherence: "ide a \<Longrightarrow> \<l>[a] \<cdot> \<sigma> (a, \<I>) = \<r>[a]"
and assoc_coherence: "\<lbrakk> ide a; ide b; ide c \<rbrakk> \<Longrightarrow>
\<alpha> (b, c, a) \<cdot> \<sigma> (a, b \<otimes> c) \<cdot> \<alpha> (a, b, c)
= (b \<otimes> \<sigma> (a, c)) \<cdot> \<alpha> (b, a, c) \<cdot> (\<sigma> (a, b) \<otimes> c)"
begin
abbreviation sym ("\<s>[_, _]")
where "sym a b \<equiv> \<sigma> (a, b)"
end
locale elementary_symmetric_monoidal_category =
elementary_monoidal_category C tensor unity lunit runit assoc
for C :: "'a comp" (infixr "\<cdot>" 55)
and tensor :: "'a \<Rightarrow> 'a \<Rightarrow> 'a" (infixr "\<otimes>" 53)
and unity :: 'a ("\<I>")
and lunit :: "'a \<Rightarrow> 'a" ("\<l>[_]")
and runit :: "'a \<Rightarrow> 'a" ("\<r>[_]")
and assoc :: "'a \<Rightarrow> 'a \<Rightarrow> 'a \<Rightarrow> 'a" ("\<a>[_, _, _]")
and sym :: "'a \<Rightarrow> 'a \<Rightarrow> 'a" ("\<s>[_, _]") +
assumes sym_in_hom: "\<lbrakk> ide a; ide b \<rbrakk> \<Longrightarrow> \<guillemotleft>\<s>[a, b] : a \<otimes> b \<rightarrow> b \<otimes> a\<guillemotright>"
and sym_naturality: "\<lbrakk> arr f; arr g \<rbrakk> \<Longrightarrow> \<s>[cod f, cod g] \<cdot> (f \<otimes> g) = (g \<otimes> f) \<cdot> \<s>[dom f, dom g]"
and sym_inverse: "\<lbrakk> ide a; ide b \<rbrakk> \<Longrightarrow> inverse_arrows \<s>[a, b] \<s>[b, a]"
and unitor_coherence: "ide a \<Longrightarrow> \<l>[a] \<cdot> \<s>[a, \<I>] = \<r>[a]"
and assoc_coherence: "\<lbrakk> ide a; ide b; ide c \<rbrakk> \<Longrightarrow>
\<a>[b, c, a] \<cdot> \<s>[a, b \<otimes> c] \<cdot> \<a>[a, b, c]
= (b \<otimes> \<s>[a, c]) \<cdot> \<a>[b, a, c] \<cdot> (\<s>[a, b] \<otimes> c)"
begin
lemma sym_simps [simp]:
assumes "ide a" and "ide b"
shows "arr \<s>[a, b]"
and "dom \<s>[a, b] = a \<otimes> b"
and "cod \<s>[a, b] = b \<otimes> a"
using assms sym_in_hom by auto
interpretation monoidal_category C T \<alpha> \<iota>
using induces_monoidal_category by simp
interpretation CC: product_category C C ..
interpretation S: symmetry_functor C C ..
interpretation ToS: composite_functor CC.comp CC.comp C S.map T ..
definition \<sigma> :: "'a * 'a \<Rightarrow> 'a"
where "\<sigma> f \<equiv> if CC.arr f then \<s>[cod (fst f), cod (snd f)] \<cdot> (fst f \<otimes> snd f) else null"
interpretation \<sigma>: natural_isomorphism CC.comp C T ToS.map \<sigma>
proof -
interpret \<sigma>: transformation_by_components CC.comp C T ToS.map "\<lambda>a. \<s>[fst a, snd a]"
apply unfold_locales
using sym_in_hom sym_naturality by auto
interpret \<sigma>: natural_isomorphism CC.comp C T ToS.map \<sigma>.map
apply unfold_locales
using sym_inverse \<sigma>.map_simp_ide by auto
have "\<sigma> = \<sigma>.map"
using \<sigma>_def \<sigma>.map_def sym_naturality by fastforce
thus "natural_isomorphism CC.comp C T ToS.map \<sigma>"
using \<sigma>.natural_isomorphism_axioms by presburger
qed
interpretation symmetric_monoidal_category C T \<alpha> \<iota> \<sigma>
proof
show "\<And>a b. \<lbrakk> ide a; ide b \<rbrakk> \<Longrightarrow> inverse_arrows (\<sigma> (a, b)) (\<sigma> (b, a))"
proof -
fix a b
assume a: "ide a" and b: "ide b"
show "inverse_arrows (\<sigma> (a, b)) (\<sigma> (b, a))"
using a b sym_inverse comp_arr_dom \<sigma>_def by auto
qed
(*
* TODO: Here just using "lunit" refers to the locale parameter, rather than
* the constant introduced by the interpretation above of monoidal_category.
* This is slightly mysterious.
*)
show "\<And>a. ide a \<Longrightarrow> local.lunit a \<cdot> \<sigma> (a, local.unity) = local.runit a"
proof -
fix a
assume a: "ide a"
show "local.lunit a \<cdot> \<sigma> (a, local.unity) = local.runit a"
using a lunit_agreement \<I>_agreement sym_in_hom comp_arr_dom [of "\<s>[a, \<I>]"]
unitor_coherence runit_agreement \<sigma>_def
by simp
qed
show "\<And>a b c. \<lbrakk> ide a; ide b; ide c \<rbrakk> \<Longrightarrow>
local.assoc b c a \<cdot> \<sigma> (a, local.tensor b c) \<cdot> local.assoc a b c
= local.tensor b (\<sigma> (a, c)) \<cdot> local.assoc b a c \<cdot> local.tensor (\<sigma> (a, b)) c"
proof -
fix a b c
assume a: "ide a" and b: "ide b" and c: "ide c"
show "local.assoc b c a \<cdot> \<sigma> (a, local.tensor b c) \<cdot> local.assoc a b c
= local.tensor b (\<sigma> (a, c)) \<cdot> local.assoc b a c \<cdot> local.tensor (\<sigma> (a, b)) c"
using a b c sym_in_hom tensor_preserves_ide \<sigma>_def assoc_coherence
comp_arr_dom comp_cod_arr
by simp
qed
qed
lemma induces_symmetric_monoidal_category:
shows "symmetric_monoidal_category C T \<alpha> \<iota> \<sigma>"
..
end
context symmetric_monoidal_category
begin
interpretation elementary_monoidal_category C tensor unity lunit runit assoc
using induces_elementary_monoidal_category by auto
lemma induces_elementary_symmetric_monoidal_category:
shows "elementary_symmetric_monoidal_category
C tensor unity lunit runit assoc (\<lambda>a b. \<sigma> (a, b))"
using \<sigma>.naturality unitor_coherence assoc_coherence sym_inverse
by unfold_locales auto
end
(* TODO: This definition of "diagonal_functor" conflicts with the one in Category3.Limit. *)
locale diagonal_functor =
C: category C +
CC: product_category C C
for C :: "'a comp"
begin
abbreviation map
where "map f \<equiv> if C.arr f then (f, f) else CC.null"
lemma is_functor:
shows "functor C CC.comp map"
using map_def by unfold_locales auto
sublocale "functor" C CC.comp map
using is_functor by simp
end
locale cartesian_monoidal_category =
monoidal_category C T \<alpha> \<iota> +
\<Omega>: constant_functor C C \<I> +
\<Delta>: diagonal_functor C +
\<tau>: natural_transformation C C map \<Omega>.map \<tau> +
\<delta>: natural_transformation C C map \<open>T o \<Delta>.map\<close> \<delta>
for C :: "'a comp" (infixr "\<cdot>" 55)
and T :: "'a * 'a \<Rightarrow> 'a"
and \<alpha> :: "'a * 'a * 'a \<Rightarrow> 'a"
and \<iota> :: 'a
and \<delta> :: "'a \<Rightarrow> 'a" ("\<d>[_]")
and \<tau> :: "'a \<Rightarrow> 'a" ("\<t>[_]") +
assumes trm_unity: "\<t>[\<I>] = \<I>"
and pr0_dup: "ide a \<Longrightarrow> \<r>[a] \<cdot> (a \<otimes> \<t>[a]) \<cdot> \<delta> a = a"
and pr1_dup: "ide a \<Longrightarrow> \<l>[a] \<cdot> (\<t>[a] \<otimes> a) \<cdot> \<delta> a = a"
and tuple_pr: "\<lbrakk> ide a; ide b \<rbrakk> \<Longrightarrow> (\<r>[a] \<cdot> (a \<otimes> \<t>[b]) \<otimes> \<l>[b] \<cdot> (\<t>[a] \<otimes> b)) \<cdot> \<d>[a \<otimes> b] = a \<otimes> b"
locale elementary_cartesian_monoidal_category =
elementary_monoidal_category C tensor unity lunit runit assoc
for C :: "'a comp" (infixr "\<cdot>" 55)
and tensor :: "'a \<Rightarrow> 'a \<Rightarrow> 'a" (infixr "\<otimes>" 53)
and unity :: 'a ("\<I>")
and lunit :: "'a \<Rightarrow> 'a" ("\<l>[_]")
and runit :: "'a \<Rightarrow> 'a" ("\<r>[_]")
and assoc :: "'a \<Rightarrow> 'a \<Rightarrow> 'a \<Rightarrow> 'a" ("\<a>[_, _, _]")
and trm :: "'a \<Rightarrow> 'a" ("\<t>[_]")
and dup :: "'a \<Rightarrow> 'a" ("\<d>[_]") +
assumes trm_in_hom [intro]: "ide a \<Longrightarrow> \<guillemotleft>\<t>[a] : a \<rightarrow> \<I>\<guillemotright>"
and trm_unity: "\<t>[\<I>] = \<I>"
and trm_naturality: "arr f \<Longrightarrow> \<t>[cod f] \<cdot> f = \<t>[dom f]"
and dup_in_hom [intro]: "ide a \<Longrightarrow> \<guillemotleft>\<d>[a] : a \<rightarrow> a \<otimes> a\<guillemotright>"
and dup_naturality: "arr f \<Longrightarrow> \<d>[cod f] \<cdot> f = (f \<otimes> f) \<cdot> \<d>[dom f]"
and prj0_dup: "ide a \<Longrightarrow> \<r>[a] \<cdot> (a \<otimes> \<t>[a]) \<cdot> \<d>[a] = a"
and prj1_dup: "ide a \<Longrightarrow> \<l>[a] \<cdot> (\<t>[a] \<otimes> a) \<cdot> \<d>[a] = a"
and tuple_prj: "\<lbrakk> ide a; ide b \<rbrakk> \<Longrightarrow> (\<r>[a] \<cdot> (a \<otimes> \<t>[b]) \<otimes> \<l>[b] \<cdot> (\<t>[a] \<otimes> b)) \<cdot> \<d>[a \<otimes> b] = a \<otimes> b"
context cartesian_monoidal_category
begin
lemma terminal_unity:
shows "terminal \<I>"
proof
show "ide \<I>" by simp
show "\<And>a. ide a \<Longrightarrow> \<exists>!f. \<guillemotleft>f : a \<rightarrow> \<I>\<guillemotright>"
proof
fix a
assume a: "ide a"
show "\<guillemotleft>\<tau> a : a \<rightarrow> \<I>\<guillemotright>" using a by auto
show "\<And>f. \<guillemotleft>f : a \<rightarrow> \<I>\<guillemotright> \<Longrightarrow> f = \<tau> a"
using trm_unity \<tau>.naturality comp_cod_arr by fastforce
qed
qed
lemma trm_is_terminal_arr:
assumes "ide a"
shows "terminal_arr \<t>[a]"
using assms terminal_unity by simp
interpretation elementary_monoidal_category C tensor unity lunit runit assoc
using induces_elementary_monoidal_category by simp
interpretation elementary_cartesian_monoidal_category C tensor unity lunit runit assoc \<tau> \<delta>
proof
show "\<And>a. ide a \<Longrightarrow> \<guillemotleft>\<t>[a] : a \<rightarrow> \<I>\<guillemotright>"
using \<iota>_in_hom by force
show "\<t>[\<I>] = \<I>"
using \<tau>.preserves_hom \<iota>_in_hom ide_unity trm_is_terminal_arr terminal_unity
by (intro terminal_arr_unique) auto
show "\<And>f. arr f \<Longrightarrow> \<t>[cod f] \<cdot> f = \<t>[dom f]"
using \<tau>.naturality comp_cod_arr by simp
show "\<And>a. ide a \<Longrightarrow> \<guillemotleft>\<d>[a] : a \<rightarrow> a \<otimes> a\<guillemotright>"
by auto
show "\<And>f. arr f \<Longrightarrow> \<d>[cod f] \<cdot> f = (f \<otimes> f) \<cdot> \<d>[dom f]"
using \<delta>.naturality by simp
show "\<And>a. ide a \<Longrightarrow> \<l>[a] \<cdot> (\<t>[a] \<otimes> a) \<cdot> \<d>[a] = a"
using pr1_dup lunit_in_hom by simp
show "\<And>a. ide a \<Longrightarrow> \<r>[a] \<cdot> (a \<otimes> \<t>[a]) \<cdot> \<d>[a] = a"
using pr0_dup runit_in_hom by simp
show "\<And>a0 a1. \<lbrakk> ide a0; ide a1 \<rbrakk> \<Longrightarrow>
(\<r>[a0] \<cdot> (a0 \<otimes> \<t>[a1]) \<otimes> \<l>[a1] \<cdot> (\<t>[a0] \<otimes> a1)) \<cdot> \<d>[a0 \<otimes> a1]
= a0 \<otimes> a1"
using tuple_pr by simp
qed
lemma induces_elementary_cartesian_monoidal_category:
shows "elementary_cartesian_monoidal_category C tensor \<I> lunit runit assoc \<tau> \<delta>"
..
end
context elementary_cartesian_monoidal_category
begin
lemma trm_simps [simp]:
assumes "ide a"
shows "arr \<t>[a]" and "dom \<t>[a] = a" and "cod \<t>[a] = \<I>"
using assms trm_in_hom by auto
lemma dup_simps [simp]:
assumes "ide a"
shows "arr \<d>[a]" and "dom \<d>[a] = a" and "cod \<d>[a] = a \<otimes> a"
using assms dup_in_hom by auto
definition \<tau> :: "'a \<Rightarrow> 'a"
where "\<tau> f \<equiv> if arr f then \<t>[dom f] else null"
definition \<delta> :: "'a \<Rightarrow> 'a"
where "\<delta> f \<equiv> if arr f then \<d>[cod f] \<cdot> f else null"
interpretation CC: product_category C C ..
interpretation MC: monoidal_category C T \<alpha> \<iota>
using induces_monoidal_category by auto
interpretation I: constant_functor C C MC.unity
by unfold_locales auto
interpretation \<Delta>: diagonal_functor C ..
interpretation D: composite_functor C CC.comp C \<Delta>.map T ..
interpretation \<tau>: natural_transformation C C map I.map \<tau>
using trm_naturality I.map_def \<tau>_def \<I>_agreement comp_cod_arr
by unfold_locales auto
interpretation \<delta>: natural_transformation C C map D.map \<delta>
using dup_naturality \<delta>_def comp_arr_dom
by unfold_locales auto
interpretation MC: cartesian_monoidal_category C T \<alpha> \<iota> \<delta> \<tau>
proof
show "\<tau> MC.unity = MC.unity"
using \<I>_agreement trm_unity \<tau>_def by simp
show "\<And>a. ide a \<Longrightarrow> MC.runit a \<cdot> MC.tensor a (\<tau> a) \<cdot> \<delta> a = a"
using runit_agreement \<tau>_def \<delta>_def prj0_dup comp_arr_dom by auto
show "\<And>a. ide a \<Longrightarrow> MC.lunit a \<cdot> MC.tensor (\<tau> a) a \<cdot> \<delta> a = a"
using lunit_agreement \<tau>_def \<delta>_def prj1_dup comp_arr_dom by auto
show "\<And>a b. \<lbrakk> ide a; ide b \<rbrakk> \<Longrightarrow>
MC.tensor (MC.runit a \<cdot> MC.tensor a (\<tau> b)) (MC.lunit b \<cdot> MC.tensor (\<tau> a) b) \<cdot>
\<delta> (MC.tensor a b) = MC.tensor a b"
proof -
fix a b
assume a: "ide a" and b: "ide b"
have "seq \<r>[a] (a \<otimes> \<t>[b])"
by (metis a b arr_tensor cod_tensor ide_char in_homE runit_in_hom seqI trm_simps(1,3))
moreover have "seq \<l>[b] (\<t>[a] \<otimes> b)"
by (metis a b arr_tensor cod_tensor ide_char in_homE lunit_in_hom seqI trm_simps(1,3))
ultimately show "MC.tensor (MC.runit a \<cdot> MC.tensor a (\<tau> b))
(MC.lunit b \<cdot> MC.tensor (\<tau> a) b) \<cdot> \<delta> (MC.tensor a b) =
MC.tensor a b"
using a b lunit_agreement runit_agreement unitor_coincidence \<tau>_def \<delta>_def comp_arr_dom
tensor_preserves_ide tuple_prj T_def
by auto
qed
qed
lemma induces_cartesian_monoidal_category:
shows "cartesian_monoidal_category C T \<alpha> \<iota> \<delta> \<tau>"
..
end
text \<open>
A cartesian category extends to a a cartesian monoidal category by using the product
structure to obtain the various canonical maps.
\<close>
context cartesian_category
begin
interpretation C: elementary_cartesian_category C pr0 pr1 \<one> trm
using extends_to_elementary_cartesian_category by simp
interpretation CC: product_category C C ..
interpretation CCC: product_category C CC.comp ..
interpretation T: binary_functor C C C Prod
using binary_functor_Prod by simp
interpretation T: binary_endofunctor C Prod ..
interpretation ToTC: "functor" CCC.comp C T.ToTC
using T.functor_ToTC by auto
interpretation ToCT: "functor" CCC.comp C T.ToCT
using T.functor_ToCT by auto
interpretation \<alpha>: transformation_by_components CCC.comp C T.ToTC T.ToCT
\<open>\<lambda>abc. assoc (fst abc) (fst (snd abc)) (snd (snd abc))\<close>
proof
show "\<And>abc. CCC.ide abc \<Longrightarrow>
\<guillemotleft>assoc (fst abc) (fst (snd abc)) (snd (snd abc)) : T.ToTC abc \<rightarrow> T.ToCT abc\<guillemotright>"
using CCC.ide_char CC.ide_char CCC.arr_char CC.arr_char T.ToTC_def T.ToCT_def
by auto
show "\<And>f. CCC.arr f \<Longrightarrow>
assoc (fst (CCC.cod f)) (fst (snd (CCC.cod f))) (snd (snd (CCC.cod f)))
\<cdot> T.ToTC f =
T.ToCT f
\<cdot> assoc (fst (CCC.dom f)) (fst (snd (CCC.dom f))) (snd (snd (CCC.dom f)))"
using CCC.arr_char CC.arr_char CCC.dom_char CCC.cod_char T.ToTC_def T.ToCT_def
assoc_naturality
by simp blast
qed
abbreviation \<alpha>
where "\<alpha> \<equiv> \<alpha>.map"
interpretation \<alpha>: natural_isomorphism CCC.comp C T.ToTC T.ToCT \<alpha>.map
proof
show "\<And>a. CCC.ide a \<Longrightarrow> iso (\<alpha>.map a)"
using CCC.ide_char CC.ide_char \<alpha>.map_simp_ide inverse_arrows_assoc by auto
qed
interpretation L: "functor" C C \<open>\<lambda>f. Prod (cod \<iota>, f)\<close>
using \<iota>_is_terminal_arr T.fixing_ide_gives_functor_1 by simp
interpretation L: endofunctor C \<open>\<lambda>f. Prod (cod \<iota>, f)\<close> ..
interpretation \<l>: transformation_by_components C C
\<open>\<lambda>f. Prod (cod \<iota>, f)\<close> map \<open>\<lambda>a. pr0 (cod \<iota>) a\<close>
using \<iota>_is_terminal_arr
by unfold_locales auto
interpretation \<l>: natural_isomorphism C C \<open>\<lambda>f. Prod (cod \<iota>, f)\<close> map \<l>.map
using \<l>.map_simp_ide inverse_arrows_lunit ide_some_terminal
by unfold_locales auto
interpretation L: equivalence_functor C C \<open>\<lambda>f. Prod (cod \<iota>, f)\<close>
using \<l>.natural_isomorphism_axioms naturally_isomorphic_def
L.isomorphic_to_identity_is_equivalence
by blast
interpretation R: "functor" C C \<open>\<lambda>f. Prod (f, cod \<iota>)\<close>
using \<iota>_is_terminal_arr T.fixing_ide_gives_functor_2 by simp
interpretation R: endofunctor C\<open>\<lambda>f. Prod (f, cod \<iota>)\<close> ..
interpretation \<rho>: transformation_by_components C C
\<open>\<lambda>f. Prod (f, cod \<iota>)\<close> map \<open>\<lambda>a. pr1 a (cod \<iota>)\<close>
using \<iota>_is_terminal_arr
by unfold_locales auto
interpretation \<rho>: natural_isomorphism C C \<open>\<lambda>f. Prod (f, cod \<iota>)\<close> map \<rho>.map
using \<rho>.map_simp_ide inverse_arrows_runit ide_some_terminal
by unfold_locales auto
interpretation R: equivalence_functor C C \<open>\<lambda>f. Prod (f, cod \<iota>)\<close>
using \<rho>.natural_isomorphism_axioms naturally_isomorphic_def
R.isomorphic_to_identity_is_equivalence
by blast
interpretation C: monoidal_category C Prod \<alpha>.map \<iota>
using ide_some_terminal \<iota>_is_iso pentagon comp_assoc
by unfold_locales auto
interpretation \<Omega>: constant_functor C C C.unity
using C.ide_unity
by unfold_locales auto
interpretation \<tau>: natural_transformation C C map \<Omega>.map trm
using C.unity_def \<Omega>.map_def ide_some_terminal trm_naturality comp_cod_arr trm_in_hom
apply unfold_locales
using trm_def
apply auto[1]
apply fastforce
apply fastforce
apply (metis in_homE trm_eqI trm_in_hom cod_pr0 dom_dom)
by (metis trm_eqI trm_in_hom dom_dom map_simp)
interpretation \<Delta>: "functor" C CC.comp Diag
using functor_Diag by simp
interpretation \<Pi>o\<Delta>: composite_functor C CC.comp C Diag Prod ..
interpretation natural_transformation C C map \<open>Prod o Diag\<close> dup
using dup_is_natural_transformation by simp
lemma unity_agreement:
shows "C.unity = \<one>"
using C.unity_def ide_some_terminal by simp
lemma assoc_agreement:
assumes "ide a" and "ide b" and "ide c"
shows "C.assoc a b c = assoc a b c"
using assms assoc_def \<alpha>.map_simp_ide by simp
lemma assoc'_agreement:
assumes "ide a" and "ide b" and "ide c"
shows "C.assoc' a b c = assoc' a b c"
using assms inverse_arrows_assoc inverse_unique by auto
lemma runit_char_eqn:
assumes "ide a"
shows "prod (runit a) \<one> = prod a \<iota> \<cdot> assoc a \<one> \<one>"
using assms ide_one assoc_def comp_assoc prod_tuple comp_cod_arr
by (intro pr_joint_monic [of a \<one> "prod (runit a) \<one>" "prod a \<iota> \<cdot> assoc a \<one> \<one>"]) auto
lemma runit_agreement:
assumes "ide a"
shows "runit a = C.runit a"
using assms unity_agreement assoc_agreement C.runit_char(2) runit_char_eqn
ide_some_terminal
by (intro C.runit_eqI) auto
lemma lunit_char_eqn:
assumes "ide a"
shows "prod \<one> (lunit a) = prod \<iota> a \<cdot> assoc' \<one> \<one> a"
proof (intro pr_joint_monic [of \<one> a "prod \<one> (lunit a)" "prod \<iota> a \<cdot> assoc' \<one> \<one> a"])
show "seq (lunit a) (local.prod \<one> (lunit a))"
using assms ide_one by simp
show "lunit a \<cdot> prod \<one> (lunit a) = lunit a \<cdot> prod \<iota> a \<cdot> assoc' \<one> \<one> a"
using assms ide_one assoc'_def comp_assoc prod_tuple comp_cod_arr by simp
show "pr1 \<one> a \<cdot> prod \<one> (lunit a) = pr1 \<one> a \<cdot> prod \<iota> a \<cdot> assoc' \<one> \<one> a"
using assms ide_one assoc'_def comp_cod_arr prod_tuple pr_naturality
apply simp
by (metis trm_eqI cod_pr0 cod_pr1 comp_in_homI' ide_prod pr_simps(1,3-6) pr1_in_hom')
qed
lemma lunit_agreement:
assumes "ide a"
shows "lunit a = C.lunit a"
using assms unity_agreement assoc'_agreement C.lunit_char(2) lunit_char_eqn
ide_some_terminal
by (intro C.lunit_eqI) auto
interpretation C: cartesian_monoidal_category C Prod \<alpha>.map \<iota> dup trm
proof
show "trm C.unity = C.unity"
by (simp add: C.unity_def ide_some_terminal trm_one)
show "\<And>a. ide a \<Longrightarrow> C.runit a \<cdot> C.tensor a \<t>[a] \<cdot> dup a = a"
using comp_runit_term_dup runit_agreement by simp
show "\<And>a. ide a \<Longrightarrow> C.lunit a \<cdot> C.tensor \<t>[a] a \<cdot> dup a = a"
using comp_lunit_term_dup lunit_agreement by auto
show "\<And>a b. \<lbrakk>ide a; ide b\<rbrakk>
\<Longrightarrow> C.tensor (C.runit a \<cdot> C.tensor a \<t>[b])
(C.lunit b \<cdot> C.tensor \<t>[a] b) \<cdot> dup (C.tensor a b) =
C.tensor a b"
proof -
fix a b
assume a: "ide a" and b: "ide b"
have "C.tensor (C.runit a \<cdot> C.tensor a \<t>[b])
(C.lunit b \<cdot> C.tensor \<t>[a] b) \<cdot> dup (C.tensor a b) =
prod (C.runit a \<cdot> prod a \<t>[b]) (C.lunit b \<cdot> prod \<t>[a] b) \<cdot> dup (prod a b)"
using a b by simp
also have "... = tuple ((C.runit a \<cdot> prod a \<t>[b]) \<cdot> prod a b)
((C.lunit b \<cdot> prod \<t>[a] b) \<cdot> prod a b)"
using a b ide_one trm_in_hom [of a] trm_in_hom [of b] unity_agreement prod_tuple
by fastforce
also have "... = tuple (C.runit a \<cdot> prod a \<t>[b] \<cdot> prod a b)
(C.lunit b \<cdot> prod \<t>[a] b \<cdot> prod a b)"
using comp_assoc by simp
also have "... = tuple (C.runit a \<cdot> prod a \<t>[b]) (C.lunit b \<cdot> prod \<t>[a] b)"
using a b comp_arr_dom by simp
also have "... = tuple (runit a \<cdot> prod a \<t>[b]) (lunit b \<cdot> prod \<t>[a] b)"
using a b lunit_agreement runit_agreement by simp
also have "... = tuple (pr1 a b) (pr0 a b)"
proof -
have "runit a \<cdot> prod a \<t>[b] = pr1 a b"
using a b pr_naturality(2) trm_in_hom [of b]
by (metis cod_pr1 comp_ide_arr ide_char in_homE pr_simps(4,6) seqI)
moreover have "lunit b \<cdot> prod \<t>[a] b = pr0 a b"
using a b pr_naturality(1) [of b b b "\<t>[a]" a \<one>] trm_in_hom [of a] comp_cod_arr
by (metis cod_pr0 ide_char in_homE pr_simps(1))
ultimately show ?thesis by simp
qed
also have "... = prod a b"
using a b by simp
finally show "C.tensor (C.runit a \<cdot> C.tensor a \<t>[b])
(C.lunit b \<cdot> C.tensor \<t>[a] b) \<cdot> dup (C.tensor a b) =
C.tensor a b"
by auto
qed
qed
lemma extends_to_cartesian_monoidal_category:
shows "cartesian_monoidal_category C Prod \<alpha>.map \<iota> dup trm"
..
end
text \<open>
In a \<open>cartesian_monoidal_category\<close>, the monoidal structure is given by a categorical product
and terminal object, so that the underlying category is cartesian.
\<close>
context cartesian_monoidal_category
begin
definition pr0 ("\<p>\<^sub>0[_, _]")
where "\<p>\<^sub>0[a, b] \<equiv> if ide a \<and> ide b then \<r>[a] \<cdot> (a \<otimes> \<t>[b]) else null"
definition pr1 ("\<p>\<^sub>1[_, _]")
where "\<p>\<^sub>1[a, b] \<equiv> if ide a \<and> ide b then \<l>[b] \<cdot> (\<t>[a] \<otimes> b) else null"
lemma pr_in_hom [intro]:
assumes "ide a0" and "ide a1"
shows "\<guillemotleft>\<p>\<^sub>0[a0, a1] : a0 \<otimes> a1 \<rightarrow> a0\<guillemotright>"
and "\<guillemotleft>\<p>\<^sub>1[a0, a1] : a0 \<otimes> a1 \<rightarrow> a1\<guillemotright>"
proof -
show "\<guillemotleft>\<p>\<^sub>0[a0, a1] : a0 \<otimes> a1 \<rightarrow> a0\<guillemotright>"
unfolding pr0_def
using assms runit_in_hom by fastforce
show "\<guillemotleft>\<p>\<^sub>1[a0, a1] : a0 \<otimes> a1 \<rightarrow> a1\<guillemotright>"
unfolding pr1_def
using assms lunit_in_hom by fastforce
qed
lemma pr_simps [simp]:
assumes "ide a0" and "ide a1"
shows "arr \<p>\<^sub>0[a0, a1]" and "dom \<p>\<^sub>0[a0, a1] = a0 \<otimes> a1" and "cod \<p>\<^sub>0[a0, a1] = a0"
and "arr \<p>\<^sub>1[a0, a1]" and "dom \<p>\<^sub>1[a0, a1] = a0 \<otimes> a1" and "cod \<p>\<^sub>1[a0, a1] = a1"
using assms pr_in_hom(1-2) by blast+
interpretation P: composite_functor CC.comp C CC.comp T \<Delta>.map ..
interpretation ECC: elementary_cartesian_category C pr1 pr0 \<I> \<tau>
proof
show "\<And>a b. \<lbrakk>ide a; ide b\<rbrakk> \<Longrightarrow> span \<p>\<^sub>0[a, b] \<p>\<^sub>1[a, b]"
by simp
show "\<And>a b. \<lbrakk>ide a; ide b\<rbrakk> \<Longrightarrow> cod \<p>\<^sub>1[a, b] = b"
by simp
show "\<And>a b. \<lbrakk>ide a; ide b\<rbrakk> \<Longrightarrow> cod \<p>\<^sub>0[a, b] = a"
by simp
show "ide \<I>"
by simp
show "\<And>a. ide a \<Longrightarrow> \<guillemotleft>\<tau> a : a \<rightarrow> \<I>\<guillemotright>"
by auto
show "\<And>a f. \<lbrakk>ide a; \<guillemotleft>f : a \<rightarrow> \<I>\<guillemotright>\<rbrakk> \<Longrightarrow> f = \<t>[a]"
using \<open>\<And>a. ide a \<Longrightarrow> \<guillemotleft>\<t>[a] : a \<rightarrow> \<I>\<guillemotright>\<close> terminalE terminal_unity by blast
show "\<And>a b. \<not> (ide a \<and> ide b) \<Longrightarrow> \<p>\<^sub>1[a, b] = null"
using pr1_def by auto
show "\<And>a b. \<not> (ide a \<and> ide b) \<Longrightarrow> \<p>\<^sub>0[a, b] = null"
using pr0_def by auto
show "\<And>f g. span f g \<Longrightarrow> \<exists>!l. \<p>\<^sub>0[cod f, cod g] \<cdot> l = f \<and> \<p>\<^sub>1[cod f, cod g] \<cdot> l = g"
proof -
fix f g
assume fg: "span f g"
let ?l = "(f \<otimes> g) \<cdot> \<d>[dom f]"
have "\<p>\<^sub>0[cod f, cod g] \<cdot> ?l = f"
proof -
have "\<p>\<^sub>0[cod f, cod g] \<cdot> ?l = (\<r>[cod f] \<cdot> (cod f \<otimes> \<t>[cod g])) \<cdot> (f \<otimes> g) \<cdot> \<d>[dom f]"
using fg pr0_def by simp
also have "... = \<r>[cod f] \<cdot> ((cod f \<otimes> \<t>[cod g]) \<cdot> (f \<otimes> g)) \<cdot> \<d>[dom f]"
using comp_assoc by simp
also have "... = \<r>[cod f] \<cdot> (f \<otimes> \<t>[dom f]) \<cdot> \<d>[dom f]"
using fg interchange comp_cod_arr \<tau>.naturality by simp
also have "... = \<r>[cod f] \<cdot> ((cod f \<otimes> \<t>[cod f]) \<cdot> (f \<otimes> f)) \<cdot> \<d>[dom f]"
using fg interchange comp_cod_arr \<tau>.naturality by simp
also have "... = \<r>[cod f] \<cdot> (cod f \<otimes> \<t>[cod f]) \<cdot> (f \<otimes> f) \<cdot> \<d>[dom f]"
using comp_assoc by simp
also have "... = (\<r>[cod f] \<cdot> (cod f \<otimes> \<t>[cod f]) \<cdot> \<d>[cod f]) \<cdot> f"
using fg \<delta>.naturality comp_assoc by simp
also have "... = f"
using fg pr0_dup comp_cod_arr by simp
finally show ?thesis by blast
qed
moreover have "\<p>\<^sub>1[cod f, cod g] \<cdot> ?l = g"
proof -
have "\<p>\<^sub>1[cod f, cod g] \<cdot> ?l = \<l>[cod g] \<cdot> ((\<t>[cod f] \<otimes> cod g) \<cdot> (f \<otimes> g)) \<cdot> \<d>[dom g]"
using fg pr1_def comp_assoc by simp
also have "... = \<l>[cod g] \<cdot> (\<t>[dom f] \<otimes> g) \<cdot> \<d>[dom g]"
using fg interchange comp_cod_arr \<tau>.naturality
by simp
also have "... = \<l>[cod g] \<cdot> ((\<t>[cod g] \<otimes> cod g) \<cdot> (g \<otimes> g)) \<cdot> \<d>[dom g]"
using fg interchange comp_cod_arr \<tau>.naturality by simp
also have "... = \<l>[cod g] \<cdot> (\<t>[cod g] \<otimes> cod g) \<cdot> (g \<otimes> g) \<cdot> \<d>[dom g]"
using comp_assoc by simp
also have "... = (\<l>[cod g] \<cdot> (\<t>[cod g] \<otimes> cod g) \<cdot> \<d>[cod g]) \<cdot> g"
using fg \<delta>.naturality comp_assoc by simp
also have "... = g"
using fg pr1_dup comp_cod_arr by simp
finally show ?thesis by blast
qed
moreover have "\<And>l. \<lbrakk> \<p>\<^sub>0[cod f, cod g] \<cdot> l = f; \<p>\<^sub>1[cod f, cod g] \<cdot> l = g \<rbrakk> \<Longrightarrow> l = ?l"
proof -
fix l
assume f: "\<p>\<^sub>0[cod f, cod g] \<cdot> l = f" and g: "\<p>\<^sub>1[cod f, cod g] \<cdot> l = g"
have l: "\<guillemotleft>l : dom f \<rightarrow> cod f \<otimes> cod g\<guillemotright>"
using f g fg
by (metis arr_iff_in_hom dom_comp ide_cod pr_simps(5) seqE)
have "?l = (\<p>\<^sub>0[cod f, cod g] \<cdot> l \<otimes> \<p>\<^sub>1[cod f, cod g] \<cdot> l) \<cdot> \<d>[dom f]"
using f g by simp
also have "... = ((\<p>\<^sub>0[cod f, cod g] \<otimes> \<p>\<^sub>1[cod f, cod g]) \<cdot> (l \<otimes> l)) \<cdot> \<d>[dom f]"
using fg f g interchange by simp
also have "... = (\<p>\<^sub>0[cod f, cod g] \<otimes> \<p>\<^sub>1[cod f, cod g]) \<cdot> (l \<otimes> l) \<cdot> \<d>[dom f]"
using comp_assoc by simp
also have "... = ((\<p>\<^sub>0[cod f, cod g] \<otimes> \<p>\<^sub>1[cod f, cod g]) \<cdot> \<d>[cod f \<otimes> cod g]) \<cdot> l"
using l \<delta>.naturality [of l] comp_assoc by auto
also have "... = (cod f \<otimes> cod g) \<cdot> l"
using f g fg tuple_pr pr0_def pr1_def by auto
also have "... = l"
using l comp_cod_arr by auto
finally show "l = ?l" by simp
qed
ultimately show "\<exists>!l. \<p>\<^sub>0[cod f, cod g] \<cdot> l = f \<and> \<p>\<^sub>1[cod f, cod g] \<cdot> l = g"
by auto
qed
qed
lemma extends_to_elementary_cartesian_category:
shows "elementary_cartesian_category C pr1 pr0 \<I> \<tau>"
..
lemma is_cartesian_category:
shows "cartesian_category C"
using ECC.is_cartesian_category by simp
end
(*
* TODO: I would like to have coherence theorems for symmetric monoidal and cartesian
* monoidal categories here, but I haven't yet figured out a suitably economical way
* to extend the existing result.
*)
end
|
(*
File: Ring.thy
Author: Bohua Zhan
Rings.
*)
theory Ring
imports Nat
begin
section \<open>Rings\<close>
definition is_ring :: "i \<Rightarrow> o" where [rewrite]:
"is_ring(R) \<longleftrightarrow> (is_ring_raw(R) \<and> is_abgroup(R) \<and> is_monoid(R) \<and>
is_left_distrib(R) \<and> is_right_distrib(R) \<and> \<zero>\<^sub>R \<noteq> \<one>\<^sub>R)"
lemma is_ringD [forward]:
"is_ring(R) \<Longrightarrow> is_ring_raw(R)"
"is_ring(R) \<Longrightarrow> is_abgroup(R)"
"is_ring(R) \<Longrightarrow> is_monoid(R)"
"is_ring(R) \<Longrightarrow> is_left_distrib(R)"
"is_ring(R) \<Longrightarrow> is_right_distrib(R)" by auto2+
lemma is_ringD' [resolve]: "is_ring(R) \<Longrightarrow> \<zero>\<^sub>R \<noteq> \<one>\<^sub>R" by auto2
setup {* del_prfstep_thm_eqforward @{thm is_ring_def} *}
lemma is_ring_ring_prop [forward]:
"is_ring_raw(H) \<Longrightarrow> is_ring(G) \<Longrightarrow> eq_str_ring(G,H) \<Longrightarrow> is_ring(H)" by auto2
setup {* fold add_rewrite_rule [
@{thm times_commD}, @{thm left_distribD}, @{thm right_distribD}, @{thm left_distribD_back},
@{thm right_distribD_back}] *}
lemma comm_distribs [forward]:
"is_ring_raw(R) \<Longrightarrow> is_left_distrib(R) \<Longrightarrow> is_times_comm(R) \<Longrightarrow> is_right_distrib(R)" by auto2
lemma ring_mult0_left [rewrite]: "is_ring(R) \<Longrightarrow> x \<in>. R \<Longrightarrow> \<zero>\<^sub>R *\<^sub>R x = \<zero>\<^sub>R"
@proof @have "\<zero>\<^sub>R *\<^sub>R x +\<^sub>R \<zero>\<^sub>R *\<^sub>R x = (\<zero>\<^sub>R +\<^sub>R \<zero>\<^sub>R) *\<^sub>R x +\<^sub>R \<zero>\<^sub>R" @qed
lemma ring_mult0_right [rewrite]: "is_ring(R) \<Longrightarrow> x \<in>. R \<Longrightarrow> x *\<^sub>R \<zero>\<^sub>R = \<zero>\<^sub>R"
@proof @have "x *\<^sub>R \<zero>\<^sub>R +\<^sub>R x *\<^sub>R \<zero>\<^sub>R = x *\<^sub>R (\<zero>\<^sub>R +\<^sub>R \<zero>\<^sub>R) +\<^sub>R \<zero>\<^sub>R" @qed
lemma units_non_zero [forward]: "is_ring(R) \<Longrightarrow> x \<in> units(R) \<Longrightarrow> x \<noteq> \<zero>\<^sub>R"
@proof @obtain "y\<in>.R" where "y *\<^sub>R x = \<one>\<^sub>R" @qed
lemma ring_mult_sign_l [rewrite]:
"is_ring(R) \<Longrightarrow> x \<in>. R \<Longrightarrow> y \<in>. R \<Longrightarrow> (-\<^sub>R x) *\<^sub>R y = -\<^sub>R (x *\<^sub>R y) \<and> x *\<^sub>R y \<in>. R"
@proof @have "(-\<^sub>R x) *\<^sub>R y +\<^sub>R x *\<^sub>R y = \<zero>\<^sub>R" @qed
lemma ring_mult_sign_r [rewrite]:
"is_ring(R) \<Longrightarrow> x \<in>. R \<Longrightarrow> y \<in>. R \<Longrightarrow> x *\<^sub>R (-\<^sub>R y) = -\<^sub>R (x *\<^sub>R y) \<and> x *\<^sub>R y \<in>. R"
@proof @have "x *\<^sub>R (-\<^sub>R y) +\<^sub>R x *\<^sub>R y = \<zero>\<^sub>R" @qed
lemma ring_mult_sign_both [rewrite]:
"is_ring(R) \<Longrightarrow> x \<in>. R \<Longrightarrow> y \<in>. R \<Longrightarrow> (-\<^sub>R x) *\<^sub>R (-\<^sub>R y) = x *\<^sub>R y" by auto2
section \<open>Commutative rings\<close>
definition is_comm_ring :: "i \<Rightarrow> o" where [rewrite]:
"is_comm_ring(R) \<longleftrightarrow> (is_ring(R) \<and> is_times_comm(R))"
lemma is_comm_ringD [forward]:
"is_comm_ring(R) \<Longrightarrow> is_ring(R)"
"is_comm_ring(R) \<Longrightarrow> is_times_comm(R)" by auto2+
setup {* del_prfstep_thm_eqforward @{thm is_comm_ring_def} *}
lemma is_comm_ring_ring_prop [forward]:
"is_ring_raw(H) \<Longrightarrow> is_comm_ring(G) \<Longrightarrow> eq_str_ring(G,H) \<Longrightarrow> is_comm_ring(H)" by auto2
lemma comm_ring_is_unit [forward]:
"is_comm_ring(R) \<Longrightarrow> x \<in>. R \<Longrightarrow> y \<in>. R \<Longrightarrow> y *\<^sub>R x = \<one>\<^sub>R \<Longrightarrow> x \<in> units(R)" by auto2
lemma comm_ring_is_unit2 [forward]:
"is_comm_ring(R) \<Longrightarrow> x \<in>. R \<Longrightarrow> y \<in>. R \<Longrightarrow> x *\<^sub>R y = \<one>\<^sub>R \<Longrightarrow> x \<in> units(R)" by auto2
lemma comm_ring_prod_unit [forward]:
"is_comm_ring(R) \<Longrightarrow> x \<in>. R \<Longrightarrow> y \<in>. R \<Longrightarrow> x *\<^sub>R y \<in> units(R) \<Longrightarrow> x \<in> units(R) \<and> y \<in> units(R)"
@proof
@obtain "z\<in>.R" where "z *\<^sub>R (x *\<^sub>R y) = \<one>\<^sub>R" "(x *\<^sub>R y) *\<^sub>R z = \<one>\<^sub>R"
@have "(y *\<^sub>R z) *\<^sub>R x = \<one>\<^sub>R" @have "y *\<^sub>R (x *\<^sub>R z) = (y *\<^sub>R x) *\<^sub>R z"
@qed
lemma inv_distrib_comm_ring [rewrite]:
"is_comm_ring(R) \<Longrightarrow> x \<in>. R \<Longrightarrow> y \<in>. R \<Longrightarrow> x *\<^sub>R y \<in> units(R) \<Longrightarrow>
inv(R, x *\<^sub>R y) = inv(R,y) *\<^sub>R inv(R,x) \<and> x \<in> units(R) \<and> y \<in> units(R) \<and>
inv(R,y) \<in>. R \<and> inv(R,x) \<in>. R"
@proof @have "inv(R,y) *\<^sub>R inv(R,x) *\<^sub>R (x *\<^sub>R y) = inv(R,y) *\<^sub>R (inv(R,x) *\<^sub>R x) *\<^sub>R y" @qed
lemma comm_ring_prod_is_unit [backward1, backward2]:
"is_comm_ring(R) \<Longrightarrow> x \<in> units(R) \<Longrightarrow> y \<in> units(R) \<Longrightarrow> x *\<^sub>R y \<in> units(R)"
@proof @have "inv(R,y) *\<^sub>R inv(R,x) *\<^sub>R (x *\<^sub>R y) = inv(R,y) *\<^sub>R (inv(R,x) *\<^sub>R x) *\<^sub>R y" @qed
section \<open>of\_nat on rings\<close>
(* Recursion on x:
of_nat(0) = 0
| of_nat(n + 1) = of_nat(n) + 1
*)
definition of_nat :: "i \<Rightarrow> i \<Rightarrow> i" where [rewrite_bidir]:
"of_nat(R,x) = nat_act(R,x,\<one>\<^sub>R)"
setup {* register_wellform_data ("of_nat(R,x)", ["x \<in> nat"]) *}
lemma of_nat_zero [rewrite_bidir]: "is_ring(R) \<Longrightarrow> of_nat(R,0) = \<zero>\<^sub>R" by auto2
lemma of_nat_one [rewrite_bidir]: "is_ring(R) \<Longrightarrow> of_nat(R,1) = \<one>\<^sub>R" by auto2
lemma of_nat_type [typing]: "is_ring(R) \<Longrightarrow> n \<in> nat \<Longrightarrow> of_nat(R,n) \<in>. R" by auto2
abbreviation ZeroR ("0\<^sub>_" [91] 90) where "0\<^sub>R \<equiv> of_nat(R,0)"
abbreviation OneR ("1\<^sub>_" [91] 90) where "1\<^sub>R \<equiv> of_nat(R,1)"
abbreviation TwoR ("2\<^sub>_" [91] 90) where "2\<^sub>R \<equiv> of_nat(R,2)"
abbreviation ThreeR ("3\<^sub>_" [91] 90) where "3\<^sub>R \<equiv> of_nat(R,3)"
abbreviation FourR ("4\<^sub>_" [91] 90) where "4\<^sub>R \<equiv> of_nat(R,4)"
abbreviation FiveR ("5\<^sub>_" [91] 90) where "5\<^sub>R \<equiv> of_nat(R,5)"
abbreviation NegOneR ("-1\<^sub>_" [91] 90) where "-1\<^sub>R \<equiv> -\<^sub>R of_nat(R,1)"
lemma of_nat_add:
"is_comm_ring(R) \<Longrightarrow> x \<in> nat \<Longrightarrow> y \<in> nat \<Longrightarrow> of_nat(R,x) +\<^sub>R of_nat(R,y) = of_nat(R, x +\<^sub>\<nat> y) \<and> x +\<^sub>\<nat> y \<in> nat" by auto2
setup {* add_rewrite_rule_cond @{thm of_nat_add}
(with_conds ["?x \<noteq> 0", "?x \<noteq> Suc(?z)", "?y \<noteq> 0", "?y \<noteq> Suc(?z)"]) *}
lemma add_monomial_same:
"is_ring(R) \<Longrightarrow> p \<in>. R \<Longrightarrow> p +\<^sub>R p = p *\<^sub>R 2\<^sub>R \<and> 2 \<in> nat \<and> 2\<^sub>R \<in>. R"
@proof @have "2 = 1 +\<^sub>\<nat> 1" @qed
setup {* del_prfstep_thm_str "" @{thm of_nat_def} *}
lemma of_nat_add_back [rewrite]:
"is_comm_ring(R) \<Longrightarrow> x \<in>. \<nat> \<Longrightarrow> y \<in>. \<nat> \<Longrightarrow> of_nat(R, x +\<^sub>\<nat> y) = of_nat(R,x) +\<^sub>R of_nat(R,y)" by auto2
lemma of_nat_mult:
"is_comm_ring(R) \<Longrightarrow> x \<in> nat \<Longrightarrow> y \<in> nat \<Longrightarrow> of_nat(R,x) *\<^sub>R of_nat(R,y) = of_nat(R, x *\<^sub>\<nat> y) \<and> x *\<^sub>\<nat> y \<in> nat"
@proof @var_induct "x \<in> nat" @qed
setup {* add_rewrite_rule_cond @{thm of_nat_mult}
(with_conds ["?x \<noteq> 0", "?x \<noteq> Suc(?z)", "?y \<noteq> 0", "?y \<noteq> Suc(?z)"]) *}
lemma of_nat_mult_back [rewrite]:
"is_comm_ring(R) \<Longrightarrow> x \<in>. \<nat> \<Longrightarrow> y \<in>. \<nat> \<Longrightarrow> of_nat(R, x *\<^sub>\<nat> y) = of_nat(R,x) *\<^sub>R of_nat(R,y)" by auto2
lemma of_nat_sub1 [rewrite]:
"is_comm_ring(R) \<Longrightarrow> x \<ge>\<^sub>\<nat> y \<Longrightarrow> of_nat(R,x) +\<^sub>R -\<^sub>R of_nat(R,y) = of_nat(R,x -\<^sub>\<nat> y) \<and> x -\<^sub>\<nat> y \<in> nat"
@proof @have "(of_nat(R,x) -\<^sub>R of_nat(R,y)) +\<^sub>R of_nat(R,y) = of_nat(R, x -\<^sub>\<nat> y) +\<^sub>R of_nat(R,y)" @qed
lemma of_nat_sub2:
"is_comm_ring(R) \<Longrightarrow> x \<le>\<^sub>\<nat> y \<Longrightarrow> of_nat(R,x) +\<^sub>R -\<^sub>R of_nat(R,y) = -\<^sub>R of_nat(R,y -\<^sub>\<nat> x) \<and>
y -\<^sub>\<nat> x \<in> nat \<and> of_nat(R,y -\<^sub>\<nat> x) \<in>. R"
@proof @have "of_nat(R,x) +\<^sub>R -\<^sub>R of_nat(R,y) = -\<^sub>R (of_nat(R,y) +\<^sub>R -\<^sub>R of_nat(R,x))" @qed
lemma of_nat_sub_back [rewrite]:
"is_comm_ring(R) \<Longrightarrow> x \<ge>\<^sub>\<nat> y \<Longrightarrow> of_nat(R,x -\<^sub>\<nat> y) = of_nat(R,x) -\<^sub>R of_nat(R,y)"
@proof @have "of_nat(R,x) -\<^sub>R of_nat(R,y) = of_nat(R,x) +\<^sub>R -\<^sub>R of_nat(R,y)" @qed
lemma add_monomial_l [rewrite]:
"is_ring(R) \<Longrightarrow> p \<in>. R \<Longrightarrow> r \<in>. R \<Longrightarrow> p +\<^sub>R p *\<^sub>R r = p *\<^sub>R (1\<^sub>R +\<^sub>R r) \<and>
1 \<in> nat \<and> 1\<^sub>R \<in>. R \<and> 1\<^sub>R +\<^sub>R r \<in>. R" by auto2
lemma neg_is_minus_1:
"is_ring(R) \<Longrightarrow> p \<in>. R \<Longrightarrow> -\<^sub>R p = p *\<^sub>R -1\<^sub>R \<and> 1 \<in> nat \<and> 1\<^sub>R \<in>. R \<and> -1\<^sub>R \<in>. R" by auto2
setup {* fold del_prfstep_thm [@{thm of_nat_sub1}, @{thm add_monomial_l}] *}
section \<open>Division in commutative rings\<close>
definition divide :: "i \<Rightarrow> i \<Rightarrow> i \<Rightarrow> i" where [rewrite]:
"divide(G,x,y) = (THE z. z \<in>. G \<and> z *\<^sub>G y = x)"
abbreviation divide_notation ("(_/ '/\<^sub>_ _)" [70,70,71] 70) where "x /\<^sub>G y \<equiv> divide(G,x,y)"
setup {* register_wellform_data ("x /\<^sub>G y", ["x \<in>. G", "y \<in> units(G)"]) *}
setup {* add_gen_prfstep ("ring_inv_case",
[WithProperty @{term_pat "is_ring(?R)"}, WithTerm @{term_pat "inv(?R,?x)"},
CreateConcl @{term_pat "?x \<in> units(?R)"}]) *}
setup {* add_gen_prfstep ("ring_div_case",
[WithProperty @{term_pat "is_ring(?R)"}, WithTerm @{term_pat "?x /\<^sub>?R ?y"},
CreateConcl @{term_pat "?y \<in> units(?R)"}]) *}
lemma divide_exist [resolve]:
"is_comm_ring(G) \<Longrightarrow> x \<in>. G \<Longrightarrow> y \<in> units(G) \<Longrightarrow> (x *\<^sub>G inv(G,y)) *\<^sub>G y = x"
@proof @have "(x *\<^sub>G inv(G,y)) *\<^sub>G y = x *\<^sub>G (inv(G,y) *\<^sub>G y)" @qed
lemma divide_type [typing]:
"is_comm_ring(G) \<Longrightarrow> x \<in>. G \<Longrightarrow> y \<in> units(G) \<Longrightarrow> x /\<^sub>G y \<in>. G"
@proof @have "(x *\<^sub>G inv(G,y)) *\<^sub>G y = x" @qed
lemma divideD [rewrite]:
"is_comm_ring(G) \<Longrightarrow> x \<in>. G \<Longrightarrow> y \<in> units(G) \<Longrightarrow> x /\<^sub>G y = x *\<^sub>G inv(G,y) \<and> inv(G,y) \<in>. G"
@proof @have "(x *\<^sub>G inv(G,y)) *\<^sub>G y = x" @qed
setup {* del_prfstep_thm @{thm divide_def} *}
lemma comm_ring_divide_1:
"is_comm_ring(G) \<Longrightarrow> n \<in> nat \<Longrightarrow> of_nat(G,n) = of_nat(G,n) /\<^sub>G 1\<^sub>G \<and>
of_nat(G,n) \<in>. G \<and> 1 \<in> nat \<and> 1\<^sub>G \<in> units(G)" by auto2
lemma comm_ring_neg_divide_1:
"is_comm_ring(G) \<Longrightarrow> n \<in> nat \<Longrightarrow> -\<^sub>G of_nat(G,n) = -\<^sub>G of_nat(G,n) /\<^sub>G 1\<^sub>G \<and>
of_nat(G,n) \<in>. G \<and> -\<^sub>G of_nat(G,n) \<in>. G \<and> 1 \<in> nat \<and> 1\<^sub>G \<in> units(G)" by auto2
lemma comm_ring_divide_1_back [rewrite]:
"is_comm_ring(G) \<Longrightarrow> p \<in>. G \<Longrightarrow> p /\<^sub>G 1\<^sub>G = p" by auto2
lemma comm_ring_zero_divide [rewrite]:
"is_comm_ring(R) \<Longrightarrow> a \<in> units(R) \<Longrightarrow> 0\<^sub>R /\<^sub>R a = 0\<^sub>R" by auto2
lemma comm_ring_zero_divide' [forward]:
"is_comm_ring(R) \<Longrightarrow> a \<in>. R \<Longrightarrow> b \<in> units(R) \<Longrightarrow> a /\<^sub>R b = 0\<^sub>R \<Longrightarrow> a = 0\<^sub>R"
@proof @have "a /\<^sub>R b *\<^sub>R b = a" @qed
lemma divide_cancel_right [rewrite]:
"is_comm_ring(G) \<Longrightarrow> x \<in>. G \<Longrightarrow> y \<in>. G \<Longrightarrow> z \<in>. G \<Longrightarrow> y *\<^sub>G z \<in> units(G) \<Longrightarrow>
(x *\<^sub>G z) /\<^sub>G (y *\<^sub>G z) = x /\<^sub>G y \<and> y \<in> units(G)"
@proof @have "(x *\<^sub>G z) *\<^sub>G (inv(G,z) *\<^sub>G inv(G,y)) = x *\<^sub>G (z *\<^sub>G inv(G,z)) *\<^sub>G inv(G,y)" @qed
lemma divide_cancel_left [rewrite]:
"is_comm_ring(G) \<Longrightarrow> x \<in>. G \<Longrightarrow> y \<in>. G \<Longrightarrow> z \<in>. G \<Longrightarrow> z *\<^sub>G y \<in> units(G) \<Longrightarrow>
(z *\<^sub>G x) /\<^sub>G (z *\<^sub>G y) = x /\<^sub>G y \<and> y \<in> units(G)"
@proof @have "z *\<^sub>G x = x *\<^sub>G z" @have "z *\<^sub>G y = y *\<^sub>G z" @qed
lemma divide_cross:
"is_comm_ring(G) \<Longrightarrow> p \<in>. G \<Longrightarrow> q \<in> units(G) \<Longrightarrow> r \<in>. G \<Longrightarrow> s \<in> units(G) \<Longrightarrow>
p /\<^sub>G q +\<^sub>G r /\<^sub>G s = (p *\<^sub>G s +\<^sub>G q *\<^sub>G r) /\<^sub>G (q *\<^sub>G s) \<and>
q \<in>. G \<and> s \<in>. G \<and> p *\<^sub>G s \<in>. G \<and> q *\<^sub>G r \<in>. G \<and> p *\<^sub>G s +\<^sub>G q *\<^sub>G r \<in>. G \<and> q *\<^sub>G s \<in> units(G)"
@proof @have "(p *\<^sub>G s +\<^sub>G q *\<^sub>G r) /\<^sub>G (q *\<^sub>G s) = (p *\<^sub>G s) /\<^sub>G (q *\<^sub>G s) +\<^sub>G (q *\<^sub>G r) /\<^sub>G (q *\<^sub>G s)" @qed
lemma divide_mult:
"is_comm_ring(G) \<Longrightarrow> p \<in>. G \<Longrightarrow> q \<in> units(G) \<Longrightarrow> r \<in>. G \<Longrightarrow> s \<in> units(G) \<Longrightarrow>
(p /\<^sub>G q) *\<^sub>G (r /\<^sub>G s) = (p *\<^sub>G r) /\<^sub>G (q *\<^sub>G s) \<and>
q \<in>. G \<and> s \<in>. G \<and> p *\<^sub>G r \<in>. G \<and> q *\<^sub>G s \<in> units(G)"
@proof
@have "(p *\<^sub>G inv(G,q)) *\<^sub>G (r *\<^sub>G inv(G,s)) = p *\<^sub>G (inv(G,q) *\<^sub>G r) *\<^sub>G inv(G,s)"
@have "p *\<^sub>G (r *\<^sub>G inv(G,q)) *\<^sub>G inv(G,s) = (p *\<^sub>G r) *\<^sub>G (inv(G,q) *\<^sub>G inv(G,s))"
@qed
lemma comm_ring_units_minus [typing]:
"is_comm_ring(G) \<Longrightarrow> p \<in> units(G) \<Longrightarrow> -\<^sub>G p \<in> units(G)"
@proof
@obtain "q\<in>.G" where "p *\<^sub>G q = \<one>\<^sub>G" @have "(-\<^sub>G p) *\<^sub>G (-\<^sub>G q) = p *\<^sub>G q"
@qed
lemma comm_ring_units_minus_back [typing]:
"is_comm_ring(G) \<Longrightarrow> p \<in>. G \<Longrightarrow> -\<^sub>G p \<in> units(G) \<Longrightarrow> p \<in> units(G)"
@proof
@obtain "q\<in>.G" where "(-\<^sub>G p) *\<^sub>G q = \<one>\<^sub>G" @have "p *\<^sub>G (-\<^sub>G q) = -\<^sub>G p *\<^sub>G q"
@qed
lemma inv_neg [rewrite]:
"is_comm_ring(G) \<Longrightarrow> p \<in>. G \<Longrightarrow> -\<^sub>G p \<in> units(G) \<Longrightarrow> inv(G, -\<^sub>G p) = -\<^sub>G (inv(G,p)) \<and>
p \<in> units(G) \<and> inv(G,p) \<in>. G"
@proof @have "-\<^sub>G p *\<^sub>G (-\<^sub>G inv(G,p)) = \<one>\<^sub>G" @qed
lemma divide_inv [rewrite]:
"is_comm_ring(G) \<Longrightarrow> p \<in>. G \<Longrightarrow> q \<in> units(G) \<Longrightarrow> p /\<^sub>G q \<in> units(G) \<Longrightarrow>
inv(G,p /\<^sub>G q) = q /\<^sub>G p \<and> p \<in> units(G) \<and> q \<in>. G" by auto2
lemma divide_inv2:
"is_comm_ring(G) \<Longrightarrow> p \<in>. G \<Longrightarrow> q \<in> units(G) \<Longrightarrow> (-\<^sub>G p) /\<^sub>G q \<in> units(G) \<Longrightarrow>
inv(G,(-\<^sub>G p) /\<^sub>G q) = (-\<^sub>G q) /\<^sub>G p \<and> p \<in> units(G) \<and> q \<in>. G \<and> -\<^sub>G q \<in>. G"
@proof
@have "(-\<^sub>G p) /\<^sub>G q = -\<^sub>G (p /\<^sub>G q)"
@have "p = -\<^sub>G (-\<^sub>G p)"
@have "(-\<^sub>G q) /\<^sub>G p = -\<^sub>G (q /\<^sub>G p)"
@qed
lemma uminus_zero:
"is_comm_ring(G) \<Longrightarrow> -\<^sub>G 0\<^sub>G = 0\<^sub>G \<and> 0 \<in> nat" by auto2
lemma uminus_inv1:
"is_comm_ring(G) \<Longrightarrow> p \<in>. G \<Longrightarrow> q \<in> units(G) \<Longrightarrow> -\<^sub>G (p /\<^sub>G q) = (-\<^sub>G p) /\<^sub>G q \<and> -\<^sub>G p \<in>. G" by auto2
lemma uminus_inv2:
"is_comm_ring(G) \<Longrightarrow> p \<in>. G \<Longrightarrow> q \<in> units(G) \<Longrightarrow> -\<^sub>G (-\<^sub>G p /\<^sub>G q) = p /\<^sub>G q" by auto2
setup {* fold del_prfstep_thm [@{thm times_commD}, @{thm left_distribD}, @{thm right_distribD},
@{thm left_distribD_back}, @{thm right_distribD_back}] *}
setup {* fold del_prfstep_thm [@{thm ring_mult_sign_both}, @{thm divide_exist}, @{thm divideD},
@{thm divide_cancel_left}, @{thm divide_cancel_right}, @{thm divide_inv}] *}
lemma zero_l': "is_ring(R) \<Longrightarrow> x \<in>. R \<Longrightarrow> 0\<^sub>R +\<^sub>R x = x" by auto2
lemma unit_l': "is_ring(R) \<Longrightarrow> x \<in>. R \<Longrightarrow> 1\<^sub>R *\<^sub>R x = x" by auto2
lemma mult_zero_l': "is_ring(R) \<Longrightarrow> x \<in>. R \<Longrightarrow> 0\<^sub>R *\<^sub>R x = 0\<^sub>R" by auto2
lemma inv_l': "is_ring(R) \<Longrightarrow> x \<in> units(R) \<Longrightarrow> inv(R,x) *\<^sub>R x = 1\<^sub>R \<and> 1 \<in> nat" by auto2
lemma of_nat_zero': "is_ring(R) \<Longrightarrow> \<zero>\<^sub>R = of_nat(R,0) \<and> 0 \<in> nat" by auto2
lemma of_nat_one': "is_ring(R) \<Longrightarrow> \<one>\<^sub>R = of_nat(R,1) \<and> 1 \<in> nat" by auto2
ML_file "rat_arith.ML"
ML_file "alg_ring.ML"
ML_file "alg_ring_test.ML"
section \<open>Integral domain\<close>
definition integral_domain :: "i \<Rightarrow> o" where [rewrite]:
"integral_domain(R) \<longleftrightarrow> (is_comm_ring(R) \<and> (\<forall>x\<in>.R. \<forall>y\<in>.R. x *\<^sub>R y = \<zero>\<^sub>R \<longrightarrow> x = \<zero>\<^sub>R \<or> y = \<zero>\<^sub>R))"
lemma integral_domainD [forward]:
"integral_domain(R) \<Longrightarrow> is_comm_ring(R)"
"integral_domain(R) \<Longrightarrow> x \<in>. R \<Longrightarrow> y \<in>. R \<Longrightarrow> x *\<^sub>R y = \<zero>\<^sub>R \<Longrightarrow> x \<noteq> \<zero>\<^sub>R \<Longrightarrow> y = \<zero>\<^sub>R"
"integral_domain(R) \<Longrightarrow> x \<in>. R \<Longrightarrow> y \<in>. R \<Longrightarrow> x *\<^sub>R y = \<zero>\<^sub>R \<Longrightarrow> y \<noteq> \<zero>\<^sub>R \<Longrightarrow> x = \<zero>\<^sub>R" by auto2+
setup {* del_prfstep_thm_eqforward @{thm integral_domain_def} *}
lemma integral_domain_cancel_right [forward]:
"integral_domain(R) \<Longrightarrow> x \<in>. R \<Longrightarrow> y \<in>. R \<Longrightarrow> z \<in>. R \<Longrightarrow> z \<noteq> \<zero>\<^sub>R \<Longrightarrow> x *\<^sub>R z = y *\<^sub>R z \<Longrightarrow> x = y"
@proof @have "x *\<^sub>R z -\<^sub>R y *\<^sub>R z = (x -\<^sub>R y) *\<^sub>R z" @qed
lemma integral_domain_cancel_left [forward]:
"integral_domain(R) \<Longrightarrow> x \<in>. R \<Longrightarrow> y \<in>. R \<Longrightarrow> z \<in>. R \<Longrightarrow> z \<noteq> \<zero>\<^sub>R \<Longrightarrow> z *\<^sub>R x = z *\<^sub>R y \<Longrightarrow> x = y"
@proof @have "z *\<^sub>R x -\<^sub>R z *\<^sub>R y = z *\<^sub>R (x -\<^sub>R y)" @qed
section \<open>Ordered rings\<close>
definition is_ord_ring :: "i \<Rightarrow> o" where [rewrite]:
"is_ord_ring(R) \<longleftrightarrow> (is_ord_ring_raw(R) \<and> is_comm_ring(R) \<and> linorder(R) \<and>
ord_ring_add_left(R) \<and> ord_ring_mult_pos(R))"
lemma is_ord_ringD [forward]:
"is_ord_ring(R) \<Longrightarrow> is_ord_ring_raw(R)"
"is_ord_ring(R) \<Longrightarrow> is_comm_ring(R)"
"is_ord_ring(R) \<Longrightarrow> linorder(R)"
"is_ord_ring(R) \<Longrightarrow> ord_ring_add_left(R)"
"is_ord_ring(R) \<Longrightarrow> ord_ring_mult_pos(R)" by auto2+
setup {* del_prfstep_thm_eqforward @{thm is_ord_ring_def} *}
lemma is_ord_ring_prop [forward]:
"is_ord_ring(R) \<Longrightarrow> is_ord_ring_raw(S) \<Longrightarrow> eq_str_ord_ring(R,S) \<Longrightarrow> is_ord_ring(S)" by auto2
(* Usually we don't convert > to \<noteq>, but this case is especially frequent. *)
lemma ord_ring_nonzero [forward]:
"is_ord_ring(R) \<Longrightarrow> x >\<^sub>R \<zero>\<^sub>R \<Longrightarrow> x \<noteq> \<zero>\<^sub>R"
"is_ord_ring(R) \<Longrightarrow> x <\<^sub>R \<zero>\<^sub>R \<Longrightarrow> x \<noteq> \<zero>\<^sub>R" by auto2+
lemma ord_ring_ordered_left_iff [rewrite]:
"is_ord_ring(R) \<Longrightarrow> x \<in>. R \<Longrightarrow> y \<in>. R \<Longrightarrow> z \<in>. R \<Longrightarrow> z +\<^sub>R x \<le>\<^sub>R z +\<^sub>R y \<longleftrightarrow> x \<le>\<^sub>R y"
@proof @have "x = (-\<^sub>R z) +\<^sub>R (x +\<^sub>R z)" @have "y = (-\<^sub>R z) +\<^sub>R (y +\<^sub>R z)" @qed
lemma ord_ring_ordered_right_iff [rewrite]:
"is_ord_ring(R) \<Longrightarrow> x \<in>. R \<Longrightarrow> y \<in>. R \<Longrightarrow> z \<in>. R \<Longrightarrow> x +\<^sub>R z \<le>\<^sub>R y +\<^sub>R z \<longleftrightarrow> x \<le>\<^sub>R y"
@proof @have "x +\<^sub>R z = z +\<^sub>R x" @have "y +\<^sub>R z = z +\<^sub>R y" @qed
(* The main results for automatic simplification *)
lemma ord_ring_le_switch_left:
"is_ord_ring(R) \<Longrightarrow> x \<in>. R \<Longrightarrow> y \<in>. R \<Longrightarrow> (x \<le>\<^sub>R y \<longleftrightarrow> 0\<^sub>R \<le>\<^sub>R y -\<^sub>R x) \<and> y -\<^sub>R x \<in>. R \<and> 0\<^sub>R \<in>. R \<and> 0 \<in> nat"
@proof @contradiction @have "0\<^sub>R +\<^sub>R x = y -\<^sub>R x +\<^sub>R x" @qed
lemma ord_ring_less_switch_left:
"is_ord_ring(R) \<Longrightarrow> x \<in>. R \<Longrightarrow> y \<in>. R \<Longrightarrow> (x <\<^sub>R y \<longleftrightarrow> 0\<^sub>R <\<^sub>R y -\<^sub>R x) \<and> y -\<^sub>R x \<in>. R \<and> 0\<^sub>R \<in>. R \<and> 0 \<in> nat"
@proof @contradiction @have "0\<^sub>R +\<^sub>R x = y -\<^sub>R x +\<^sub>R x" @qed
ML_file "ord_ring_steps.ML"
lemma ord_ring_single_less_add [backward]:
"is_ord_ring(R) \<Longrightarrow> x \<in>. R \<Longrightarrow> \<zero>\<^sub>R <\<^sub>R y \<Longrightarrow> x <\<^sub>R x +\<^sub>R y" by auto2
lemma ord_ring_single_less_sub [backward]:
"is_ord_ring(R) \<Longrightarrow> x \<in>. R \<Longrightarrow> \<zero>\<^sub>R <\<^sub>R y \<Longrightarrow> x >\<^sub>R x -\<^sub>R y" by auto2
lemma ord_ring_single_le_add [backward]:
"is_ord_ring(R) \<Longrightarrow> x \<in>. R \<Longrightarrow> \<zero>\<^sub>R \<le>\<^sub>R y \<Longrightarrow> x \<le>\<^sub>R x +\<^sub>R y" by auto2
lemma ord_ring_mix1 [backward1, backward2]:
"is_ord_ring(R) \<Longrightarrow> p \<le>\<^sub>R q \<Longrightarrow> r \<le>\<^sub>R s \<Longrightarrow> p +\<^sub>R r \<le>\<^sub>R q +\<^sub>R s"
@proof @have "p +\<^sub>R r \<le>\<^sub>R p +\<^sub>R s" @qed
lemma ord_ring_mix2 [backward1, backward2]:
"is_ord_ring(R) \<Longrightarrow> p \<le>\<^sub>R q \<Longrightarrow> r <\<^sub>R s \<Longrightarrow> p +\<^sub>R r <\<^sub>R q +\<^sub>R s"
@proof @have "p +\<^sub>R r <\<^sub>R p +\<^sub>R s" @qed
lemma ord_ring_mix3 [backward1, backward2]:
"is_ord_ring(R) \<Longrightarrow> p <\<^sub>R q \<Longrightarrow> r \<le>\<^sub>R s \<Longrightarrow> p +\<^sub>R r <\<^sub>R q +\<^sub>R s"
@proof @have "p +\<^sub>R r <\<^sub>R q +\<^sub>R r" @qed
lemma ord_ring_strict_ordered_left_iff [rewrite]:
"is_ord_ring(R) \<Longrightarrow> x \<in>. R \<Longrightarrow> y \<in>. R \<Longrightarrow> z \<in>. R \<Longrightarrow> z +\<^sub>R x <\<^sub>R z +\<^sub>R y \<longleftrightarrow> x <\<^sub>R y" by auto2
lemma ord_ring_strict_ordered_right_iff [rewrite]:
"is_ord_ring(R) \<Longrightarrow> x \<in>. R \<Longrightarrow> y \<in>. R \<Longrightarrow> z \<in>. R \<Longrightarrow> x +\<^sub>R z <\<^sub>R y +\<^sub>R z \<longleftrightarrow> x <\<^sub>R y" by auto2
lemma ord_ring_ge_equiv [rewrite]:
"is_ord_ring(R) \<Longrightarrow> p \<in>. R \<Longrightarrow> q \<in>. R \<Longrightarrow> p -\<^sub>R q \<ge>\<^sub>R \<zero>\<^sub>R \<longleftrightarrow> p \<ge>\<^sub>R q" by auto2
lemma ord_ring_gt_equiv [rewrite]:
"is_ord_ring(R) \<Longrightarrow> p \<in>. R \<Longrightarrow> q \<in>. R \<Longrightarrow> p -\<^sub>R q >\<^sub>R \<zero>\<^sub>R \<longleftrightarrow> p >\<^sub>R q" by auto2
lemma ord_ring_mult_le_right [backward1, backward2]:
"is_ord_ring(R) \<Longrightarrow> x \<ge>\<^sub>R y \<Longrightarrow> z \<ge>\<^sub>R \<zero>\<^sub>R \<Longrightarrow> x *\<^sub>R z \<ge>\<^sub>R y *\<^sub>R z"
@proof
@have "x -\<^sub>R y \<ge>\<^sub>R \<zero>\<^sub>R"
@have "x *\<^sub>R z -\<^sub>R y *\<^sub>R z = (x -\<^sub>R y) *\<^sub>R z"
@have "x *\<^sub>R z -\<^sub>R y *\<^sub>R z \<ge>\<^sub>R \<zero>\<^sub>R"
@qed
lemma ord_ring_mult_le_left [backward1, backward2]:
"is_ord_ring(R) \<Longrightarrow> x \<ge>\<^sub>R y \<Longrightarrow> z \<ge>\<^sub>R \<zero>\<^sub>R \<Longrightarrow> z *\<^sub>R x \<ge>\<^sub>R z *\<^sub>R y"
@proof @have "x *\<^sub>R z \<ge>\<^sub>R y *\<^sub>R z" @qed
lemma ord_ring_mult_lt_right [backward1, backward2]:
"is_ord_ring(R) \<Longrightarrow> integral_domain(R) \<Longrightarrow> x >\<^sub>R y \<Longrightarrow> z >\<^sub>R \<zero>\<^sub>R \<Longrightarrow> x *\<^sub>R z >\<^sub>R y *\<^sub>R z"
@proof @have "x \<noteq> y" @have "x *\<^sub>R z \<noteq> y *\<^sub>R z" @qed
lemma ord_ring_mult_lt_left [backward1, backward2]:
"is_ord_ring(R) \<Longrightarrow> integral_domain(R) \<Longrightarrow> x >\<^sub>R y \<Longrightarrow> z >\<^sub>R \<zero>\<^sub>R \<Longrightarrow> z *\<^sub>R x >\<^sub>R z *\<^sub>R y"
@proof @have "x *\<^sub>R z >\<^sub>R y *\<^sub>R z" @qed
lemma ord_ring_mult_mix [backward1, backward2]:
"is_ord_ring(R) \<Longrightarrow> p \<ge>\<^sub>R q \<Longrightarrow> q \<ge>\<^sub>R \<zero>\<^sub>R \<Longrightarrow> s \<ge>\<^sub>R \<zero>\<^sub>R \<Longrightarrow> r \<ge>\<^sub>R s \<Longrightarrow> p *\<^sub>R r \<ge>\<^sub>R q *\<^sub>R s"
@proof @have "p *\<^sub>R r \<ge>\<^sub>R q *\<^sub>R r" @qed
lemma ord_ring_mult_mix2 [backward1, backward2]:
"is_ord_ring(R) \<Longrightarrow> integral_domain(R) \<Longrightarrow> p >\<^sub>R q \<Longrightarrow> q >\<^sub>R \<zero>\<^sub>R \<Longrightarrow> s >\<^sub>R \<zero>\<^sub>R \<Longrightarrow> r \<ge>\<^sub>R s \<Longrightarrow> p *\<^sub>R r >\<^sub>R q *\<^sub>R s"
@proof @have "p *\<^sub>R r >\<^sub>R q *\<^sub>R r" @qed
lemma ord_ring_mult_mix3 [backward1, backward2]:
"is_ord_ring(R) \<Longrightarrow> integral_domain(R) \<Longrightarrow> p \<ge>\<^sub>R q \<Longrightarrow> q >\<^sub>R \<zero>\<^sub>R \<Longrightarrow> s >\<^sub>R \<zero>\<^sub>R \<Longrightarrow> r >\<^sub>R s \<Longrightarrow> p *\<^sub>R r >\<^sub>R q *\<^sub>R s"
by auto2
lemma ord_ring_neg_ge_zero [backward]:
"is_ord_ring(R) \<Longrightarrow> a \<in>. R \<Longrightarrow> a \<ge>\<^sub>R \<zero>\<^sub>R \<Longrightarrow> -\<^sub>R a \<le>\<^sub>R \<zero>\<^sub>R" by auto2
setup {* add_forward_prfstep_cond @{thm ord_ring_neg_ge_zero} [with_term "-\<^sub>?R ?a"] *}
lemma ord_ring_neg_gt_zero [backward]:
"is_ord_ring(R) \<Longrightarrow> a \<in>. R \<Longrightarrow> a >\<^sub>R \<zero>\<^sub>R \<Longrightarrow> -\<^sub>R a <\<^sub>R \<zero>\<^sub>R" by auto2
setup {* add_forward_prfstep_cond @{thm ord_ring_neg_gt_zero} [with_term "-\<^sub>?R ?a"] *}
lemma ord_ring_neg_le_zero [backward]:
"is_ord_ring(R) \<Longrightarrow> a \<in>. R \<Longrightarrow> a \<le>\<^sub>R \<zero>\<^sub>R \<Longrightarrow> -\<^sub>R a \<ge>\<^sub>R \<zero>\<^sub>R" by auto2
setup {* add_forward_prfstep_cond @{thm ord_ring_neg_le_zero} [with_term "-\<^sub>?R ?a"] *}
lemma ord_ring_neg_lt_zero [backward]:
"is_ord_ring(R) \<Longrightarrow> a \<in>. R \<Longrightarrow> a <\<^sub>R \<zero>\<^sub>R \<Longrightarrow> -\<^sub>R a >\<^sub>R \<zero>\<^sub>R" by auto2
setup {* add_forward_prfstep_cond @{thm ord_ring_neg_lt_zero} [with_term "-\<^sub>?R ?a"] *}
lemma ord_ring_mult_pos_neg [backward1, backward2]:
"is_ord_ring(R) \<Longrightarrow> a \<ge>\<^sub>R \<zero>\<^sub>R \<Longrightarrow> b \<le>\<^sub>R \<zero>\<^sub>R \<Longrightarrow> a *\<^sub>R b \<le>\<^sub>R \<zero>\<^sub>R"
@proof @have "a *\<^sub>R (-\<^sub>R b) \<ge>\<^sub>R \<zero>\<^sub>R" @qed
setup {* add_forward_prfstep_cond @{thm ord_ring_mult_pos_neg} [with_term "?a *\<^sub>?R ?b"] *}
lemma ord_ring_mult_neg_pos [backward1, backward2]:
"is_ord_ring(R) \<Longrightarrow> a \<le>\<^sub>R \<zero>\<^sub>R \<Longrightarrow> b \<ge>\<^sub>R \<zero>\<^sub>R \<Longrightarrow> a *\<^sub>R b \<le>\<^sub>R \<zero>\<^sub>R"
@proof @contradiction @have "b *\<^sub>R a \<ge>\<^sub>R \<zero>\<^sub>R" @qed
setup {* add_forward_prfstep_cond @{thm ord_ring_mult_neg_pos} [with_term "?a *\<^sub>?R ?b"] *}
lemma ord_field_mult_le_cancel_right [forward]:
"is_ord_ring(R) \<Longrightarrow> integral_domain(R) \<Longrightarrow> x \<in>. R \<Longrightarrow> y \<in>. R \<Longrightarrow> z >\<^sub>R \<zero>\<^sub>R \<Longrightarrow>
x *\<^sub>R z \<ge>\<^sub>R y *\<^sub>R z \<Longrightarrow> x \<ge>\<^sub>R y" by auto2
lemma ord_ring_mult_neg [backward1, backward2]:
"is_ord_ring(R) \<Longrightarrow> a \<le>\<^sub>R \<zero>\<^sub>R \<Longrightarrow> b \<le>\<^sub>R \<zero>\<^sub>R \<Longrightarrow> a *\<^sub>R b \<ge>\<^sub>R \<zero>\<^sub>R"
@proof @have "(-\<^sub>R a) *\<^sub>R (-\<^sub>R b) \<ge>\<^sub>R \<zero>\<^sub>R" @qed
setup {* add_forward_prfstep_cond @{thm ord_ring_mult_neg} [with_term "?a *\<^sub>?R ?b"] *}
lemma ord_ring_square_ge_zero [resolve]:
"is_ord_ring(R) \<Longrightarrow> a \<in>. R \<Longrightarrow> a *\<^sub>R a \<ge>\<^sub>R \<zero>\<^sub>R"
@proof @case "a \<ge>\<^sub>R \<zero>\<^sub>R" @qed
lemma ord_ring_square_gt_zero [backward]:
"is_ord_ring(R) \<Longrightarrow> integral_domain(R) \<Longrightarrow> a \<in>. R \<Longrightarrow> a \<noteq> \<zero>\<^sub>R \<Longrightarrow> a *\<^sub>R a >\<^sub>R \<zero>\<^sub>R"
@proof @have "a *\<^sub>R a \<noteq> \<zero>\<^sub>R" @qed
lemma ord_ring_one_ge_zero [resolve]:
"is_ord_ring(R) \<Longrightarrow> \<one>\<^sub>R >\<^sub>R \<zero>\<^sub>R"
@proof @have "\<one>\<^sub>R = \<one>\<^sub>R *\<^sub>R \<one>\<^sub>R" @qed
lemma ord_ring_mult_pos_strict [backward1]:
"is_ord_ring(R) \<Longrightarrow> integral_domain(R) \<Longrightarrow> a >\<^sub>R \<zero>\<^sub>R \<Longrightarrow> b >\<^sub>R \<zero>\<^sub>R \<Longrightarrow> a *\<^sub>R b >\<^sub>R \<zero>\<^sub>R" by auto2
setup {* add_forward_prfstep_cond @{thm ord_ring_mult_pos_strict} [with_term "?a *\<^sub>?R ?b"] *}
lemma ord_ring_mult_pos_neg_strict [backward1]:
"is_ord_ring(R) \<Longrightarrow> integral_domain(R) \<Longrightarrow> a >\<^sub>R \<zero>\<^sub>R \<Longrightarrow> b <\<^sub>R \<zero>\<^sub>R \<Longrightarrow> a *\<^sub>R b <\<^sub>R \<zero>\<^sub>R" by auto2
lemma ord_ring_nonneg_add [backward1, backward2]:
"is_ord_ring(R) \<Longrightarrow> a \<ge>\<^sub>R \<zero>\<^sub>R \<Longrightarrow> b \<ge>\<^sub>R \<zero>\<^sub>R \<Longrightarrow> a +\<^sub>R b \<ge>\<^sub>R \<zero>\<^sub>R" by auto2
lemma ord_ring_pos_add1 [backward1, backward2]:
"is_ord_ring(R) \<Longrightarrow> a >\<^sub>R \<zero>\<^sub>R \<Longrightarrow> b \<ge>\<^sub>R \<zero>\<^sub>R \<Longrightarrow> a +\<^sub>R b >\<^sub>R \<zero>\<^sub>R" by auto2
lemma ord_ring_pos_add2 [backward1, backward2]:
"is_ord_ring(R) \<Longrightarrow> a \<ge>\<^sub>R \<zero>\<^sub>R \<Longrightarrow> b >\<^sub>R \<zero>\<^sub>R \<Longrightarrow> a +\<^sub>R b >\<^sub>R \<zero>\<^sub>R" by auto2
lemma ord_ring_le_to_lt_plus_one [backward]:
"is_ord_ring(R) \<Longrightarrow> x \<le>\<^sub>R y \<Longrightarrow> x <\<^sub>R y +\<^sub>R \<one>\<^sub>R"
@proof @have "x +\<^sub>R \<zero>\<^sub>R <\<^sub>R y +\<^sub>R \<one>\<^sub>R" @qed
lemma ord_ring_le_minus_switch [rewrite]:
"is_ord_ring(R) \<Longrightarrow> a \<in>. R \<Longrightarrow> b \<in>. R \<Longrightarrow> -\<^sub>R a \<le>\<^sub>R -\<^sub>R b \<longleftrightarrow> a \<ge>\<^sub>R b" by auto2
lemma ord_ring_le_minus_switch2 [resolve]:
"is_ord_ring(R) \<Longrightarrow> a \<in>. R \<Longrightarrow> -\<^sub>R a \<le>\<^sub>R b \<Longrightarrow> a \<ge>\<^sub>R -\<^sub>R b" by auto2
lemma ord_ring_le_minus_switch3 [resolve]:
"is_ord_ring(R) \<Longrightarrow> a \<in>. R \<Longrightarrow> -\<^sub>R a \<ge>\<^sub>R b \<Longrightarrow> a \<le>\<^sub>R -\<^sub>R b" by auto2
lemma ord_ring_of_nat_Suc:
"is_ord_ring(R) \<Longrightarrow> n \<in>. \<nat> \<Longrightarrow> of_nat(R,n) <\<^sub>R of_nat(R, n +\<^sub>\<nat> 1)" by auto2
setup {* add_forward_prfstep_cond @{thm ord_ring_of_nat_Suc} [with_term "of_nat(?R, ?n +\<^sub>\<nat> 1)"] *}
lemma ord_ring_of_nat_ge_zero [backward]:
"is_ord_ring(R) \<Longrightarrow> n \<in> nat \<Longrightarrow> of_nat(R,n) \<ge>\<^sub>R \<zero>\<^sub>R"
@proof @var_induct "n \<in> nat" @qed
setup {* del_prfstep_thm @{thm ord_ring_of_nat_Suc} *}
lemma ord_field_char_zero' [backward]:
"is_ord_ring(R) \<Longrightarrow> n \<in> nat \<Longrightarrow> n \<noteq> 0 \<Longrightarrow> of_nat(R,n) >\<^sub>R \<zero>\<^sub>R"
@proof @obtain "m\<in>.\<nat>" where "n = m +\<^sub>\<nat> 1" @have "of_nat(R,m) \<ge>\<^sub>R \<zero>\<^sub>R" @qed
lemma ord_ring_of_nat_le [backward]:
"is_ord_ring(R) \<Longrightarrow> m \<le>\<^sub>\<nat> n \<Longrightarrow> of_nat(R,m) \<le>\<^sub>R of_nat(R,n)"
@proof @obtain "p\<in>.\<nat>" where "n = m +\<^sub>\<nat> p" @qed
lemma ord_ring_of_nat_less [backward]:
"is_ord_ring(R) \<Longrightarrow> m <\<^sub>\<nat> n \<Longrightarrow> of_nat(R,m) <\<^sub>R of_nat(R,n)"
@proof @obtain "p\<in>nat" where "p\<noteq>0" "n = m +\<^sub>\<nat> p" @qed
lemma ord_ring_of_nat_le_back [forward]:
"is_ord_ring(R) \<Longrightarrow> m \<in> nat \<Longrightarrow> n \<in> nat \<Longrightarrow> of_nat(R,m) \<le>\<^sub>R of_nat(R,n) \<Longrightarrow> m \<le>\<^sub>\<nat> n"
@proof @have "\<not>of_nat(R,n) <\<^sub>R of_nat(R,m)" @qed
lemma ord_ring_of_nat_eq [forward]:
"is_ord_ring(R) \<Longrightarrow> m \<in> nat \<Longrightarrow> n \<in> nat \<Longrightarrow> of_nat(R,m) = of_nat(R,n) \<Longrightarrow> m = n"
@proof
@case "m <\<^sub>\<nat> n" @with @have "of_nat(R,m) <\<^sub>R of_nat(R,n)" @end
@case "m >\<^sub>\<nat> n" @with @have "of_nat(R,m) >\<^sub>R of_nat(R,n)" @end
@qed
lemma ord_ring_of_nat_ge_one [backward]:
"is_ord_ring(R) \<Longrightarrow> a \<in> nat \<Longrightarrow> b \<in> nat \<Longrightarrow> of_nat(R,a) >\<^sub>R of_nat(R,b) \<Longrightarrow>
of_nat(R,a) \<ge>\<^sub>R of_nat(R,b) +\<^sub>R 1\<^sub>R"
@proof @have "of_nat(R,b) +\<^sub>R 1\<^sub>R = of_nat(R, b +\<^sub>\<nat> 1)" @qed
lemma ord_ring_has_pos_greater [backward]:
"is_ord_ring(R) \<Longrightarrow> x \<in>. R \<Longrightarrow> \<exists>y\<in>.R. y >\<^sub>R \<zero>\<^sub>R \<and> y \<ge>\<^sub>R x"
@proof @let "m = max(R,\<one>\<^sub>R,x)" @have "\<one>\<^sub>R >\<^sub>R \<zero>\<^sub>R" @qed
lemma ord_ring_is_unbounded [forward]:
"is_ord_ring(R) \<Longrightarrow> order_unbounded(R)"
@proof
@have (@rule) "\<forall>x\<in>.R. \<exists>y. y <\<^sub>R x" @with
@have "x <\<^sub>R x +\<^sub>R 1\<^sub>R" @have "x -\<^sub>R 1\<^sub>R <\<^sub>R x" @end
@have (@rule) "\<forall>x\<in>.R. \<exists>y. y >\<^sub>R x" @with @have "x +\<^sub>R 1\<^sub>R >\<^sub>R x" @end
@qed
lemma power_gt_0 [backward]:
"is_ord_ring(R) \<Longrightarrow> integral_domain(R) \<Longrightarrow> e \<in> nat \<Longrightarrow> b >\<^sub>R \<zero>\<^sub>R \<Longrightarrow> b ^\<^sub>R e >\<^sub>R \<zero>\<^sub>R"
@proof @var_induct "e \<in> nat" @qed
lemma power_gt_n [resolve]: "is_ord_ring(R) \<Longrightarrow> n \<in> nat \<Longrightarrow> of_nat(R,n) <\<^sub>R 2\<^sub>R ^\<^sub>R n"
@proof
@var_induct "n \<in> nat" @with
@subgoal "n = n' +\<^sub>\<nat> 1" @have "2\<^sub>R ^\<^sub>R (n' +\<^sub>\<nat> 1) = 2\<^sub>R ^\<^sub>R n' +\<^sub>R 2\<^sub>R ^\<^sub>R n'" @endgoal
@end
@qed
section \<open>Subsets of an ordered ring\<close>
definition pos_elts :: "i \<Rightarrow> i" where [rewrite]:
"pos_elts(R) = {x\<in>.R. x >\<^sub>R \<zero>\<^sub>R}"
lemma pos_eltsD [forward]: "x \<in> pos_elts(R) \<Longrightarrow> x \<in>. R \<and> x >\<^sub>R \<zero>\<^sub>R" by auto2
lemma pos_eltsI [backward2]: "x \<in>. R \<Longrightarrow> x >\<^sub>R \<zero>\<^sub>R \<Longrightarrow> x \<in> pos_elts(R)" by auto2
lemma pos_elts_one [resolve]: "is_ord_ring(R) \<Longrightarrow> \<one>\<^sub>R \<in> pos_elts(R)" by auto2
lemma pos_elts_mult [typing]:
"is_ord_ring(R) \<Longrightarrow> integral_domain(R) \<Longrightarrow> x \<in> pos_elts(R) \<Longrightarrow> y \<in> pos_elts(R) \<Longrightarrow> x *\<^sub>R y \<in> pos_elts(R)" by auto2
lemma pos_elts_add [typing]:
"is_ord_ring(R) \<Longrightarrow> x \<in> pos_elts(R) \<Longrightarrow> y \<in> pos_elts(R) \<Longrightarrow> x +\<^sub>R y \<in> pos_elts(R)" by auto2
section \<open>Construction of ordered ring from non-negative elements\<close>
(* See Bourbaki, Algebra VI.2.1 *)
definition subset_add_closed :: "i \<Rightarrow> i \<Rightarrow> o" where [rewrite]:
"subset_add_closed(R,S) \<longleftrightarrow> (\<forall>x\<in>S. \<forall>y\<in>S. x +\<^sub>R y \<in> S)"
lemma subset_add_closedD [typing]:
"subset_add_closed(R,S) \<Longrightarrow> x \<in> S \<Longrightarrow> y \<in> S \<Longrightarrow> x +\<^sub>R y \<in> S" by auto2
setup {* del_prfstep_thm_eqforward @{thm subset_add_closed_def} *}
definition subset_mult_closed :: "i \<Rightarrow> i \<Rightarrow> o" where [rewrite]:
"subset_mult_closed(R,S) \<longleftrightarrow> (\<forall>x\<in>S. \<forall>y\<in>S. x *\<^sub>R y \<in> S)"
lemma subset_mult_closedD [typing]:
"subset_mult_closed(R,S) \<Longrightarrow> x \<in> S \<Longrightarrow> y \<in> S \<Longrightarrow> x *\<^sub>R y \<in> S" by auto2
setup {* del_prfstep_thm_eqforward @{thm subset_mult_closed_def} *}
definition nonneg_compat_inter :: "i \<Rightarrow> i \<Rightarrow> o" where [rewrite]:
"nonneg_compat_inter(R,S) \<longleftrightarrow> (\<forall>x\<in>S. -\<^sub>R x \<in> S \<longrightarrow> x = \<zero>\<^sub>R)"
lemma nonneg_compat_interD [forward]:
"nonneg_compat_inter(R,S) \<Longrightarrow> -\<^sub>R x \<in> S \<Longrightarrow> x \<in> S \<Longrightarrow> x = \<zero>\<^sub>R" by auto2
setup {* del_prfstep_thm_eqforward @{thm nonneg_compat_inter_def} *}
definition nonneg_compat_union :: "i \<Rightarrow> i \<Rightarrow> o" where [rewrite]:
"nonneg_compat_union(R,S) \<longleftrightarrow> (\<forall>x\<in>.R. x \<in> S \<or> -\<^sub>R x \<in> S)"
lemma nonneg_compat_unionD [forward]:
"x \<in>. R \<Longrightarrow> nonneg_compat_union(R,S) \<Longrightarrow> -\<^sub>R x \<notin> S \<Longrightarrow> x \<in> S" by auto2
setup {* del_prfstep_thm_eqforward @{thm nonneg_compat_union_def} *}
definition ord_ring_from_nonneg :: "i \<Rightarrow> i \<Rightarrow> i" where [rewrite]:
"ord_ring_from_nonneg(R,S) =
OrdRing(carrier(R), \<zero>\<^sub>R, \<lambda>x y. x +\<^sub>R y, \<one>\<^sub>R, \<lambda>x y. x *\<^sub>R y, \<lambda>x y. y -\<^sub>R x \<in> S)"
definition nonneg_compat :: "i \<Rightarrow> i \<Rightarrow> o" where [rewrite]:
"nonneg_compat(R,S) \<longleftrightarrow>
(\<zero>\<^sub>R \<in> S \<and> subset_add_closed(R,S) \<and> subset_mult_closed(R,S) \<and>
nonneg_compat_inter(R,S) \<and> nonneg_compat_union(R,S))"
lemma ord_ring_from_nonneg_is_ord_ring_raw [forward]:
"is_ring_raw(R) \<Longrightarrow> ord_ring_form(ord_ring_from_nonneg(R,S))" by auto2
lemma ord_ring_from_nonneg_eq_str:
"is_ring_raw(R) \<Longrightarrow> eq_str_ring(R,ord_ring_from_nonneg(R,S))" by auto2
setup {* add_forward_prfstep_cond @{thm ord_ring_from_nonneg_eq_str} [with_term "ord_ring_from_nonneg(?R,?S)"] *}
lemma ord_ring_from_nonneg_eval [rewrite]:
"is_ring_raw(R) \<Longrightarrow> A = ord_ring_from_nonneg(R,S) \<Longrightarrow> is_abgroup(A) \<Longrightarrow>
x \<in>. A \<Longrightarrow> y \<in>. A \<Longrightarrow> x \<le>\<^sub>A y \<longleftrightarrow> y -\<^sub>A x \<in> S" by auto2
setup {* del_prfstep_thm @{thm ord_ring_from_nonneg_def} *}
lemma ord_ring_from_nonneg_is_linorder [forward]:
"is_ring_raw(R) \<Longrightarrow> A = ord_ring_from_nonneg(R,S) \<Longrightarrow> is_comm_ring(A) \<Longrightarrow>
nonneg_compat(A,S) \<Longrightarrow> linorder(A)"
@proof
@have "\<forall>x y z. x \<le>\<^sub>A y \<longrightarrow> y \<le>\<^sub>A z \<longrightarrow> x \<le>\<^sub>A z" @with
@have "z -\<^sub>A x = (z -\<^sub>A y) +\<^sub>A (y -\<^sub>A x)" @end
@have "\<forall>x y. x \<le>\<^sub>A y \<longrightarrow> y \<le>\<^sub>A x \<longrightarrow> x = y" @with
@have "-\<^sub>A (y -\<^sub>A x) = x -\<^sub>A y" @end
@have "\<forall>x\<in>.A. \<forall>y\<in>.A. x \<le>\<^sub>A y \<or> x \<ge>\<^sub>A y" @with
@have "-\<^sub>A (y -\<^sub>A x) = x -\<^sub>A y" @end
@qed
lemma ord_ring_from_nonneg_compat_plus [forward]:
"is_ring_raw(R) \<Longrightarrow> A = ord_ring_from_nonneg(R,S) \<Longrightarrow> is_comm_ring(A) \<Longrightarrow>
nonneg_compat(A,S) \<Longrightarrow> ord_ring_add_left(A)"
@proof
@have "\<forall>a\<in>.A. \<forall>b c. b \<le>\<^sub>A c \<longrightarrow> a +\<^sub>A b \<le>\<^sub>A a +\<^sub>A c" @with
@have "(a +\<^sub>R c) -\<^sub>R (a +\<^sub>R b) = c -\<^sub>R b" @end
@qed
lemma ord_ring_from_nonneg_is_ord_ring [forward]:
"is_ring_raw(R) \<Longrightarrow> A = ord_ring_from_nonneg(R,S) \<Longrightarrow> is_comm_ring(A) \<Longrightarrow>
nonneg_compat(A,S) \<Longrightarrow> is_ord_ring(ord_ring_from_nonneg(R,S))" by auto2
end
|
function centroid(
verts::AbstractVector{<:AbstractPoint{3,T1}},
) where {T1 <: Real}
centroid_point = reduce(+, verts) / length(verts)
return centroid_point
end
function centroid(mesh)
verts = coordinates(mesh)
centroid_point = centroid(verts)
end
function decompose_vertex_and_face(mesh::Mesh)
verts = coordinates(mesh)
triangles = faces(mesh)
return verts, triangles
end
function angle_between_vector(v1, v2)
v1 = v1 / norm(v1)
v2 = v2 / norm(v2)
cos_theta = dot(v1, v2)
if cos_theta >= 1.0
return 0.0
end
theta = acos(cos_theta)
return theta
end
function calculate_area_bins(verts::AbstractVector{<:AbstractPoint{3,T1}},
triangles::AbstractVector{<:TriangleFace},
) where T1 <: AbstractFloat
areas_array = area.(Ref(verts), triangles)
cumsum_area = similar(areas_array)
cumsum_area = cumsum!(cumsum_area, areas_array)
total_area = cumsum_area[end]
bins = cumsum_area / total_area
return bins
end
function triangle_area(p1::T, p2::T, p3::T) where {T <: AbstractVector}
p1p2 = p2 - p1
p1p3 = p3 - p1
area = 0.5 * norm(cross(p1p2, p1p3))
return area
end
function tetrahedron_volume(v1::T, v2::T, v3::T, v4::T) where {T <: AbstractVector}
a = v1 - v4
b = v2 - v4
c = v3 - v4
vol = norm(a ⋅ cross(b, c)) / 6
return vol
end
|
/-
Copyright (c) 2020 Kevin Buzzard. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Kevin Buzzard
-/
import Mathlib.PrePort
import Mathlib.Lean3Lib.init.default
import Mathlib.ring_theory.principal_ideal_domain
import Mathlib.order.conditionally_complete_lattice
import Mathlib.ring_theory.multiplicity
import Mathlib.ring_theory.valuation.basic
import Mathlib.PostPort
universes u l u_1
namespace Mathlib
/-!
# Discrete valuation rings
This file defines discrete valuation rings (DVRs) and develops a basic interface
for them.
## Important definitions
There are various definitions of a DVR in the literature; we define a DVR to be a local PID
which is not a field (the first definition in Wikipedia) and prove that this is equivalent
to being a PID with a unique non-zero prime ideal (the definition in Serre's
book "Local Fields").
Let R be an integral domain, assumed to be a principal ideal ring and a local ring.
* `discrete_valuation_ring R` : a predicate expressing that R is a DVR
### Definitions
* `add_val R : R → ℕ` : the additive valuation on a DVR (sending 0 to 0 rather than the
mathematically correct +∞).
TODO -- the multiplicative valuation, taking values in something
like `with_zero (multiplicative ℤ)`?
## Implementation notes
It's a theorem that an element of a DVR is a uniformizer if and only if it's irreducible.
We do not hence define `uniformizer` at all, because we can use `irreducible` instead.
## Tags
discrete valuation ring
-/
/-- An integral domain is a *discrete valuation ring* (DVR) if it's a local PID which
is not a field. -/
class discrete_valuation_ring (R : Type u) [integral_domain R]
extends is_principal_ideal_ring R, local_ring R where
not_a_field' : local_ring.maximal_ideal R ≠ ⊥
namespace discrete_valuation_ring
theorem not_a_field (R : Type u) [integral_domain R] [discrete_valuation_ring R] :
local_ring.maximal_ideal R ≠ ⊥ :=
not_a_field'
/-- An element of a DVR is irreducible iff it is a uniformizer, that is, generates the
maximal ideal of R -/
theorem irreducible_iff_uniformizer {R : Type u} [integral_domain R] [discrete_valuation_ring R]
(ϖ : R) : irreducible ϖ ↔ local_ring.maximal_ideal R = ideal.span (singleton ϖ) :=
sorry
/-- Uniformisers exist in a DVR -/
theorem exists_irreducible (R : Type u) [integral_domain R] [discrete_valuation_ring R] :
∃ (ϖ : R), irreducible ϖ :=
sorry
/-- an integral domain is a DVR iff it's a PID with a unique non-zero prime ideal -/
theorem iff_pid_with_one_nonzero_prime (R : Type u) [integral_domain R] :
discrete_valuation_ring R ↔
is_principal_ideal_ring R ∧ exists_unique fun (P : ideal R) => P ≠ ⊥ ∧ ideal.is_prime P :=
sorry
theorem associated_of_irreducible (R : Type u) [integral_domain R] [discrete_valuation_ring R]
{a : R} {b : R} (ha : irreducible a) (hb : irreducible b) : associated a b :=
sorry
end discrete_valuation_ring
namespace discrete_valuation_ring
/-- Alternative characterisation of discrete valuation rings. -/
def has_unit_mul_pow_irreducible_factorization (R : Type u_1) [integral_domain R] :=
∃ (p : R), irreducible p ∧ ∀ {x : R}, x ≠ 0 → ∃ (n : ℕ), associated (p ^ n) x
namespace has_unit_mul_pow_irreducible_factorization
theorem unique_irreducible {R : Type u_1} [integral_domain R]
(hR : has_unit_mul_pow_irreducible_factorization R) {p : R} {q : R} (hp : irreducible p)
(hq : irreducible q) : associated p q :=
sorry
/-- An integral domain in which there is an irreducible element `p`
such that every nonzero element is associated to a power of `p` is a unique factorization domain.
See `discrete_valuation_ring.of_has_unit_mul_pow_irreducible_factorization`. -/
theorem to_unique_factorization_monoid {R : Type u_1} [integral_domain R]
(hR : has_unit_mul_pow_irreducible_factorization R) : unique_factorization_monoid R :=
sorry
theorem of_ufd_of_unique_irreducible {R : Type u_1} [integral_domain R]
[unique_factorization_monoid R] (h₁ : ∃ (p : R), irreducible p)
(h₂ : ∀ {p q : R}, irreducible p → irreducible q → associated p q) :
has_unit_mul_pow_irreducible_factorization R :=
sorry
end has_unit_mul_pow_irreducible_factorization
theorem aux_pid_of_ufd_of_unique_irreducible (R : Type u) [integral_domain R]
[unique_factorization_monoid R] (h₁ : ∃ (p : R), irreducible p)
(h₂ : ∀ {p q : R}, irreducible p → irreducible q → associated p q) :
is_principal_ideal_ring R :=
sorry
/--
A unique factorization domain with at least one irreducible element
in which all irreducible elements are associated
is a discrete valuation ring.
-/
theorem of_ufd_of_unique_irreducible {R : Type u} [integral_domain R]
[unique_factorization_monoid R] (h₁ : ∃ (p : R), irreducible p)
(h₂ : ∀ {p q : R}, irreducible p → irreducible q → associated p q) :
discrete_valuation_ring R :=
sorry
/--
An integral domain in which there is an irreducible element `p`
such that every nonzero element is associated to a power of `p`
is a discrete valuation ring.
-/
theorem of_has_unit_mul_pow_irreducible_factorization {R : Type u} [integral_domain R]
(hR : has_unit_mul_pow_irreducible_factorization R) : discrete_valuation_ring R :=
sorry
theorem associated_pow_irreducible {R : Type u_1} [integral_domain R] [discrete_valuation_ring R]
{x : R} (hx : x ≠ 0) {ϖ : R} (hirr : irreducible ϖ) : ∃ (n : ℕ), associated x (ϖ ^ n) :=
sorry
theorem eq_unit_mul_pow_irreducible {R : Type u_1} [integral_domain R] [discrete_valuation_ring R]
{x : R} (hx : x ≠ 0) {ϖ : R} (hirr : irreducible ϖ) :
∃ (n : ℕ), ∃ (u : units R), x = ↑u * ϖ ^ n :=
sorry
theorem ideal_eq_span_pow_irreducible {R : Type u_1} [integral_domain R] [discrete_valuation_ring R]
{s : ideal R} (hs : s ≠ ⊥) {ϖ : R} (hirr : irreducible ϖ) :
∃ (n : ℕ), s = ideal.span (singleton (ϖ ^ n)) :=
sorry
theorem unit_mul_pow_congr_pow {R : Type u_1} [integral_domain R] [discrete_valuation_ring R]
{p : R} {q : R} (hp : irreducible p) (hq : irreducible q) (u : units R) (v : units R) (m : ℕ)
(n : ℕ) (h : ↑u * p ^ m = ↑v * q ^ n) : m = n :=
sorry
theorem unit_mul_pow_congr_unit {R : Type u_1} [integral_domain R] [discrete_valuation_ring R]
{ϖ : R} (hirr : irreducible ϖ) (u : units R) (v : units R) (m : ℕ) (n : ℕ)
(h : ↑u * ϖ ^ m = ↑v * ϖ ^ n) : u = v :=
sorry
/-!
## The additive valuation on a DVR
-/
/-- The `ℕ`-valued additive valuation on a DVR (returns junk at `0` rather than `+∞`) -/
def add_val (R : Type u) [integral_domain R] [discrete_valuation_ring R] : R → ℕ :=
fun (r : R) => dite (r = 0) (fun (hr : r = 0) => 0) fun (hr : ¬r = 0) => classical.some sorry
theorem add_val_spec {R : Type u_1} [integral_domain R] [discrete_valuation_ring R] {r : R}
(hr : r ≠ 0) :
let ϖ : R := classical.some (exists_irreducible R);
let n : ℕ :=
classical.some (associated_pow_irreducible hr (classical.some_spec (exists_irreducible R)));
associated r (ϖ ^ n) :=
classical.some_spec (associated_pow_irreducible hr (classical.some_spec (exists_irreducible R)))
theorem add_val_def {R : Type u_1} [integral_domain R] [discrete_valuation_ring R] (r : R)
(u : units R) {ϖ : R} (hϖ : irreducible ϖ) (n : ℕ) (hr : r = ↑u * ϖ ^ n) : add_val R r = n :=
sorry
theorem add_val_def' {R : Type u_1} [integral_domain R] [discrete_valuation_ring R] (u : units R)
{ϖ : R} (hϖ : irreducible ϖ) (n : ℕ) : add_val R (↑u * ϖ ^ n) = n :=
add_val_def (↑u * ϖ ^ n) u hϖ n rfl
@[simp] theorem add_val_zero {R : Type u_1} [integral_domain R] [discrete_valuation_ring R] :
add_val R 0 = 0 :=
dif_pos rfl
@[simp] theorem add_val_one {R : Type u_1} [integral_domain R] [discrete_valuation_ring R] :
add_val R 1 = 0 :=
sorry
@[simp] theorem add_val_uniformizer {R : Type u_1} [integral_domain R] [discrete_valuation_ring R]
{ϖ : R} (hϖ : irreducible ϖ) : add_val R ϖ = 1 :=
sorry
@[simp] theorem add_val_mul {R : Type u_1} [integral_domain R] [discrete_valuation_ring R] {a : R}
{b : R} (ha : a ≠ 0) (hb : b ≠ 0) : add_val R (a * b) = add_val R a + add_val R b :=
sorry
theorem add_val_pow {R : Type u_1} [integral_domain R] [discrete_valuation_ring R] (a : R) (n : ℕ) :
add_val R (a ^ n) = n * add_val R a :=
sorry
theorem add_val_le_iff_dvd {R : Type u_1} [integral_domain R] [discrete_valuation_ring R] {a : R}
{b : R} (ha : a ≠ 0) (hb : b ≠ 0) : add_val R a ≤ add_val R b ↔ a ∣ b :=
sorry
theorem add_val_add {R : Type u_1} [integral_domain R] [discrete_valuation_ring R] {a : R} {b : R}
(ha : a ≠ 0) (hb : b ≠ 0) (hab : a + b ≠ 0) :
min (add_val R a) (add_val R b) ≤ add_val R (a + b) :=
sorry
end Mathlib |
We’ve already started the conversation about security— now, let’s focus on loss prevention for businesses. Part of a good risk management strategy is to reduce threats from both outside and inside the organization. This is where video surveillance comes in.
Since their launch in June of 2013, the UCM series has become one of the most popular on-premise IP PBXs in the world. It offers small to medium sized businesses an almost unprecedented unified communications manager (hence the UCM acronym) that gives them access to enterprise-grade voice, video, data and mobility features in an easy-to-setup, easy-to-manage fashion with no licensing or recurring fees.
Back in 2002 when Grandstream was founded, we were one of the first companies in the world to manufacture SIP products – and one of the very first products we made were analog telephone adapters (ATAs). We now have over 15 years of expertise building SIP devices, and we have more experience building VoIP gateways and ATAs than almost any one in the world. Thanks to close relationships with service providers and partners, all of our ATAs and Gateways are not only thoroughly tested within Grandstream, but they are stringently tested with the help from some of the largest service providers in the world. Our devices provide a variety of high-end features and functionalities that allow analog phones not only to be integrated with VoIP networks, but provide VoIP functions for analog devices as well. Let’s take a look at some of the features and functionalities of Grandstream’s gateways and ATAs that you may have missed.
TCP versus UDP for IP Phones: How do you choose?
The internet is like a very crowded Los Angeles highway, but instead of being full of cars, it’s full of information. Due to crowding, this information needs guidance to ensure that it gets where it’s going. This is why transmission protocols exist to make sure the information gets transported as intended. |
% lyapunov_equation solves the equation V=T*V*T'+Q
%
% ::
%
% [V,retcode]=lyapunov_equation(T,Q)
% [V,retcode]=lyapunov_equation(T,Q,options)
%
% Args:
% - T :
% - Q :
% - options :
%
% Returns:
% :
% - V :
% - retcode :
%
% Note:
%
% Example:
%
% See also:
% |
import sys
import os.path
import datetime
import urllib
from PIL import Image, ImageChops, ImageFilter
import numpy
global root
root = '/home/site/data/'
imarray = numpy.random.rand(256,256,3) * 255
img = Image.fromarray(imarray.astype('uint8')).convert('RGBA')
img.save(root + 'images/gradient/color10.png')# + str(i) + '.png')
#for i in range(1,256):
# print i
# imarray = numpy.random.rand(256,256,3) * 255
#for j in range(0,256):
# for k in range(0,256):
# imarray[j][k] = imarray[j / i * i][k / i * i]
# img = Image.fromarray(imarray.astype('uint8')).convert('RGBA')
# img.save(root + 'images/gradient/textures/' + str(i) + '.png')
|
export TR_step_computation
function TR_step_computation(h :: Float64,
g :: Float64,
dN :: Float64,
Δ :: Float64)
if h > 0.0
if g > 0.0
d = max(-Δ, dN)
else
d = min(dN, Δ)
end
else
if g > 0.0
d = -Δ
else
d = Δ
end
end
return d
end
|
library(knitr)
source.rmd <- function(x, ...) {
source(purl(x, output = tempfile()), ...)
}
download.url <- function(url, dir) {
destfile <- file.path(dir, basename(url))
if (!file.exists(destfile))
download.file(url, destfile=desfile)
}
dir.create(output.dir <- "output")
full.dir <- file.path(output.dir, "data-full")
data.dir <- file.path(output.dir, "data")
## download the dataset from GEO
if (!file.exists(full.dir)) {
dir.create(full.dir)
data.url <- "ftp://ftp.ncbi.nlm.nih.gov/geo/series/GSE53nnn/GSE53261/matrix/"
download.url(file.path(data.url, "GSE53261-GPL11154_series_matrix.txt.gz"), full.dir)
download.url(file.path(data.url, "GSE53261-GPL13534_series_matrix.txt.gz"), full.dir)
download.url(file.path(data.url, "GSE53261-GPL6883_series_matrix.txt.gz"), full.dir)
download.url(file.path(data.url, "GSE53261-GPL6984_series_matrix.txt.gz"), full.dir)
}
if (!file.exists(data.dir)) {
dir.create(data.dir)
## reformat and subset data so that it is easy to analyze
source.rmd("retrieve-dataset.rmd")
## calculate EAF and create simulated associations with BMI
## (ended up deciding not to use this ...)
source.rmd("prepare-dataset.rmd")
}
|
{-# OPTIONS --warning=error #-}
module Issue329 where
mutual
infixl 0 D Undeclared
data D : Set where
|
State Before: E : Type u_1
X : Type u_2
inst✝¹ : TopologicalSpace E
inst✝ : TopologicalSpace X
f : E → X
s : Set X
hf : IsCoveringMapOn f s
⊢ IsLocallyHomeomorphOn f (f ⁻¹' s) State After: E : Type u_1
X : Type u_2
inst✝¹ : TopologicalSpace E
inst✝ : TopologicalSpace X
f : E → X
s : Set X
hf : IsCoveringMapOn f s
x : E
hx : x ∈ f ⁻¹' s
⊢ ∃ e, x ∈ e.source ∧ ∀ (y : E), y ∈ e.source → f y = ↑e y Tactic: refine' IsLocallyHomeomorphOn.mk f (f ⁻¹' s) fun x hx => _ State Before: E : Type u_1
X : Type u_2
inst✝¹ : TopologicalSpace E
inst✝ : TopologicalSpace X
f : E → X
s : Set X
hf : IsCoveringMapOn f s
x : E
hx : x ∈ f ⁻¹' s
⊢ ∃ e, x ∈ e.source ∧ ∀ (y : E), y ∈ e.source → f y = ↑e y State After: E : Type u_1
X : Type u_2
inst✝¹ : TopologicalSpace E
inst✝ : TopologicalSpace X
f : E → X
s : Set X
hf : IsCoveringMapOn f s
x : E
hx : x ∈ f ⁻¹' s
e : Trivialization (↑(f ⁻¹' {f x})) f := IsEvenlyCovered.toTrivialization (_ : IsEvenlyCovered f (f x) ↑(f ⁻¹' {f x}))
⊢ ∃ e, x ∈ e.source ∧ ∀ (y : E), y ∈ e.source → f y = ↑e y Tactic: let e := (hf (f x) hx).toTrivialization State Before: E : Type u_1
X : Type u_2
inst✝¹ : TopologicalSpace E
inst✝ : TopologicalSpace X
f : E → X
s : Set X
hf : IsCoveringMapOn f s
x : E
hx : x ∈ f ⁻¹' s
e : Trivialization (↑(f ⁻¹' {f x})) f := IsEvenlyCovered.toTrivialization (_ : IsEvenlyCovered f (f x) ↑(f ⁻¹' {f x}))
⊢ ∃ e, x ∈ e.source ∧ ∀ (y : E), y ∈ e.source → f y = ↑e y State After: E : Type u_1
X : Type u_2
inst✝¹ : TopologicalSpace E
inst✝ : TopologicalSpace X
f : E → X
s : Set X
hf : IsCoveringMapOn f s
x : E
hx : x ∈ f ⁻¹' s
e : Trivialization (↑(f ⁻¹' {f x})) f := IsEvenlyCovered.toTrivialization (_ : IsEvenlyCovered f (f x) ↑(f ⁻¹' {f x}))
h : f x ∈ (IsEvenlyCovered.toTrivialization (_ : IsEvenlyCovered f (f x) ↑(f ⁻¹' {f x}))).baseSet
⊢ ∃ e, x ∈ e.source ∧ ∀ (y : E), y ∈ e.source → f y = ↑e y Tactic: have h := (hf (f x) hx).mem_toTrivialization_baseSet State Before: E : Type u_1
X : Type u_2
inst✝¹ : TopologicalSpace E
inst✝ : TopologicalSpace X
f : E → X
s : Set X
hf : IsCoveringMapOn f s
x : E
hx : x ∈ f ⁻¹' s
e : Trivialization (↑(f ⁻¹' {f x})) f := IsEvenlyCovered.toTrivialization (_ : IsEvenlyCovered f (f x) ↑(f ⁻¹' {f x}))
h : f x ∈ (IsEvenlyCovered.toTrivialization (_ : IsEvenlyCovered f (f x) ↑(f ⁻¹' {f x}))).baseSet
⊢ ∃ e, x ∈ e.source ∧ ∀ (y : E), y ∈ e.source → f y = ↑e y State After: E : Type u_1
X : Type u_2
inst✝¹ : TopologicalSpace E
inst✝ : TopologicalSpace X
f : E → X
s : Set X
hf : IsCoveringMapOn f s
x : E
hx : x ∈ f ⁻¹' s
e : Trivialization (↑(f ⁻¹' {f x})) f := IsEvenlyCovered.toTrivialization (_ : IsEvenlyCovered f (f x) ↑(f ⁻¹' {f x}))
h : f x ∈ (IsEvenlyCovered.toTrivialization (_ : IsEvenlyCovered f (f x) ↑(f ⁻¹' {f x}))).baseSet
he : x ∈ e.source := Iff.mpr (Trivialization.mem_source e) h
⊢ ∃ e, x ∈ e.source ∧ ∀ (y : E), y ∈ e.source → f y = ↑e y Tactic: let he := e.mem_source.2 h State Before: E : Type u_1
X : Type u_2
inst✝¹ : TopologicalSpace E
inst✝ : TopologicalSpace X
f : E → X
s : Set X
hf : IsCoveringMapOn f s
x : E
hx : x ∈ f ⁻¹' s
e : Trivialization (↑(f ⁻¹' {f x})) f := IsEvenlyCovered.toTrivialization (_ : IsEvenlyCovered f (f x) ↑(f ⁻¹' {f x}))
h : f x ∈ (IsEvenlyCovered.toTrivialization (_ : IsEvenlyCovered f (f x) ↑(f ⁻¹' {f x}))).baseSet
he : x ∈ e.source := Iff.mpr (Trivialization.mem_source e) h
⊢ ∃ e, x ∈ e.source ∧ ∀ (y : E), y ∈ e.source → f y = ↑e y State After: no goals Tactic: refine'
⟨e.toLocalHomeomorph.trans
{ toFun := fun p => p.1
invFun := fun p => ⟨p, x, rfl⟩
source := e.baseSet ×ˢ ({⟨x, rfl⟩} : Set (f ⁻¹' {f x}))
target := e.baseSet
open_source :=
e.open_baseSet.prod (singletons_open_iff_discrete.2 (hf (f x) hx).1 ⟨x, rfl⟩)
open_target := e.open_baseSet
map_source' := fun p => And.left
map_target' := fun p hp => ⟨hp, rfl⟩
left_inv' := fun p hp => Prod.ext rfl hp.2.symm
right_inv' := fun p _ => rfl
continuous_toFun := continuous_fst.continuousOn
continuous_invFun := (continuous_id'.prod_mk continuous_const).continuousOn },
⟨he, by rwa [e.toLocalHomeomorph.symm_symm, e.proj_toFun x he],
(hf (f x) hx).toTrivialization_apply⟩,
fun p h => (e.proj_toFun p h.1).symm⟩ State Before: E : Type u_1
X : Type u_2
inst✝¹ : TopologicalSpace E
inst✝ : TopologicalSpace X
f : E → X
s : Set X
hf : IsCoveringMapOn f s
x : E
hx : x ∈ f ⁻¹' s
e : Trivialization (↑(f ⁻¹' {f x})) f := IsEvenlyCovered.toTrivialization (_ : IsEvenlyCovered f (f x) ↑(f ⁻¹' {f x}))
h : f x ∈ (IsEvenlyCovered.toTrivialization (_ : IsEvenlyCovered f (f x) ↑(f ⁻¹' {f x}))).baseSet
he : x ∈ e.source := Iff.mpr (Trivialization.mem_source e) h
⊢ (↑(LocalHomeomorph.symm (LocalHomeomorph.symm e.toLocalHomeomorph)) x).fst ∈ e.baseSet State After: no goals Tactic: rwa [e.toLocalHomeomorph.symm_symm, e.proj_toFun x he] |
// Copyright 2016 Bogumił Chojnowski
// bogumil DOT chojnowski AT gmail DOT com
// This is extended version of the state machine available in the boost::mpl library
// Distributed under the same license as the original.
// Copyright for the original version:
// Copyright 2010 Christophe Henry
// henry UNDERSCORE christophe AT hotmail DOT com
// This is an extended version of the state machine available in the boost::mpl library
// Distributed under the same license as the original.
// Copyright for the original version:
// Copyright 2005 David Abrahams and Aleksey Gurtovoy. Distributed
// under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <iostream>
#include <memory>
// back-end
#include <boost/msm/back/state_machine.hpp>
//front-end
#include <boost/msm/front/state_machine_def.hpp>
#ifndef BOOST_MSM_NONSTANDALONE_TEST
#define BOOST_TEST_MODULE MyTest
#endif
#include <boost/test/unit_test.hpp>
namespace msm = boost::msm;
namespace mpl = boost::mpl;
namespace
{
struct Lightbulp
{
Lightbulp(int c) : current(c) {}
int current;
};
// events
struct ev_toggle {};
// front-end: define the FSM structure
struct bistable_switch_ : public msm::front::state_machine_def<bistable_switch_>
{
bistable_switch_(std::unique_ptr<Lightbulp> bulp, int load)
: bulp_(std::move(bulp))
{
BOOST_CHECK_MESSAGE(bulp_->current == 3, "Wrong current value");
BOOST_CHECK_MESSAGE(load == 5, "Wrong load value");
bulp_->current = 10;
}
std::unique_ptr<Lightbulp> bulp_;
// The list of FSM states
struct Off : public msm::front::state<>
{
template <typename Event, typename FSM>
void on_entry(Event const&, FSM& ) { }
template <typename Event, typename FSM>
void on_exit(Event const&, FSM&) { }
};
struct On : public msm::front::state<>
{
template <typename Event, typename FSM>
void on_entry(Event const&, FSM& ) { }
template <typename Event, typename FSM>
void on_exit(Event const&, FSM&) { }
};
// the initial state of the player SM. Must be defined
typedef Off initial_state;
void turn_on(ev_toggle const&) { bulp_->current = 11; }
void turn_off(ev_toggle const&) { bulp_->current = 9; }
typedef bistable_switch_ bs_; // makes transition table cleaner
// Transition table for player
struct transition_table : mpl::vector<
// Start Event Next Action Guard
// +---------+-------------+---------+---------------------+----------------------+
a_row < Off , ev_toggle , On , &bs_::turn_on >,
a_row < On , ev_toggle , Off , &bs_::turn_off >
// +---------+-------------+---------+---------------------+----------------------+
> {};
// Replaces the default no-transition response.
template <typename Event, typename FSM>
void no_transition(Event const&, FSM&, int)
{
BOOST_FAIL("no_transition called!");
}
};
// Pick a back-end
typedef msm::back::state_machine<bistable_switch_> bistable_switch;
BOOST_AUTO_TEST_CASE(my_test)
{
auto bulp = std::make_unique<Lightbulp>(3);
bistable_switch bs(std::move(bulp), 5);
BOOST_CHECK_MESSAGE(bs.bulp_->current == 10, "Wrong returned current value");
bs.start();
bs.process_event(ev_toggle());
BOOST_CHECK_MESSAGE(bs.bulp_->current == 11, "Wrong returned current value");
bs.process_event(ev_toggle());
BOOST_CHECK_MESSAGE(bs.bulp_->current == 9, "Wrong returned current value");
bs.stop();
}
}
|
# -*- coding:utf-8 -*-
import numpy as np
from .utils import get_sample_indices
import torch
def unnormalize(state, output):
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
# mean=torch.tensor(state['mean']).to(device)
# std=torch.tensor(state['std']).to(device)
f_mean=torch.tensor(state['f_mean']).to(device)
f_std=torch.tensor(state['f_std']).to(device)
o_mean = torch.tensor(state['o_mean']).to(device)
o_std = torch.tensor(state['o_std']).to(device)
s_mean = torch.tensor(state['s_mean']).to(device)
s_std = torch.tensor(state['s_std']).to(device)
f_out=output[:,:,0,:]*f_std+f_mean
o_out = output[:, :, 1, :] * o_std + o_mean
s_out = output[:, :, 2, :] * s_std + s_mean
out=torch.stack([f_out,o_out,s_out],dim=0).permute((1,3,2,0))
# output=output.to(device)
# return output*std+mean
return out
def normalization(train, val, test, stats):
"""
Parameters
----------
train, val, test: np.ndarray
Returns
----------
stats: dict, two keys: mean and std
train_norm, val_norm, test_norm: np.ndarray,
shape is the same as original,形状与原稿相同
"""
assert train.shape[1:] == val.shape[1:] and val.shape[1:] == test.shape[1:]
#mean = train.mean(axis=0, keepdims=True)#keepdims=True保持矩阵维数不变,.mean用来求均值
mean = train.mean(axis=0, keepdims=True)
std = train.std(axis=0, keepdims=True)#.std用来计算标准差
#
# def normalize(x):
# return (x - mean) / std
#
# train_norm = normalize(train) # wd: ??
# val_norm = normalize(val)
# test_norm = normalize(test)
f_mean=stats['f_mean']
f_std=stats['f_std']
o_mean=stats['o_mean']
o_std=stats['o_std']
s_mean=stats['s_mean']
s_std=stats['s_std']
def normalize(x,mmean,sstd):
# s_mean=np.ones(x.shape)
# s_mean=s_mean*mmean
return (x - mmean) / sstd
train_f_norm=normalize(train[:,:,0,:],f_mean,f_std)
train_o_norm = normalize(train[:, :, 1, :],o_mean,o_std)
train_s_norm=normalize(train[:,:,2,:],s_mean,s_std)
val_f_norm = normalize(val[:, :, 0, :], f_mean, f_std)
val_o_norm = normalize(val[:, :, 1, :], o_mean, o_std)
val_s_norm = normalize(val[:, :, 2, :], s_mean, s_std)
test_f_norm = normalize(test[:, :, 0, :], f_mean, f_std)
test_o_norm = normalize(test[:, :, 1, :], o_mean, o_std)
test_s_norm = normalize(test[:, :, 2, :], s_mean, s_std)
# train_norm=[]
# val_norm=[]
# test_norm=[]
# train_norm.append(train_f_norm)
# train_norm.append(train_o_norm)
# train_norm.append(train_s_norm)
# val_norm.append(val_f_norm)
# val_norm.append(val_o_norm)
# val_norm.append(val_s_norm)
# test_norm.append(test_f_norm)
# test_norm.append(test_o_norm)
# test_norm.append(test_s_norm)
train_norm=np.array([train_f_norm,train_o_norm,train_s_norm]).transpose((1,2,0,3))
val_norm = np.array([val_f_norm, val_o_norm, val_s_norm]).transpose((1,2,0,3))
test_norm = np.array([test_f_norm, test_o_norm, test_s_norm]).transpose((1,2,0,3))
train_norm=train_norm.astype(np.float32)
val_norm = val_norm.astype(np.float32)
test_norm=test_norm.astype(np.float32)
return {'mean': mean, 'std': std}, train_norm, val_norm, test_norm
def read_and_generate_dataset(graph_signal_matrix_filename,
num_of_weeks, num_of_days,
num_of_hours, num_for_predict,
points_per_hour=12, merge=False):
"""
Parameters
----------
graph_signal_matrix_filename: str, path of graph signal matrix file
num_of_weeks, num_of_days, num_of_hours: int
num_for_predict: int
points_per_hour: int, default 12, depends on data,默认值12
merge: boolean, default False,
whether to merge training set and validation set to train model
Returns
----------
feature: np.ndarray,
shape is (num_of_samples, num_of_batches * points_per_hour,
num_of_vertices, num_of_features)
wd: shape is (num_of_samples, num_of_vertices, num_of_features,
num_of_weeks/days/hours * points_per_hour)??
target: np.ndarray,
shape is (num_of_samples, num_of_vertices, num_for_predict)
"""
# wd: if there are 60 days, then 60 * 24 * 12 = 17280, which is close to 16992如果有60天，那么60*24*12=17280，接近16992
data_seq = np.load(graph_signal_matrix_filename)['data'] # wd: (16992, 307, 3)
data_seq = np.float32(data_seq) # wd: to reduce computation,减少计算
#stats={'f_mean':[],'f_std':[],'o_mean':[],'o_std':[],'s_mean':[],'s_std':[]}
#stats['f_mean']=np.mean(data_seq[:,:,0])
data_seq[:,:,1]=data_seq[:,:,1]*100
f_mean=np.mean(data_seq[:,:,0])
f_std=np.std(data_seq[:,:,0])
o_mean = np.mean(data_seq[:, :, 1])
o_std = np.std(data_seq[:, :, 1])
s_mean = np.mean(data_seq[:, :, 2])
s_std = np.std(data_seq[:, :, 2])
stats = {'f_mean': f_mean, 'f_std': f_std, 'o_mean': o_mean, 'o_std': o_std, 's_mean': s_mean, 's_std': s_std}
all_samples = []
for idx in range(data_seq.shape[0]):#shape[0]输出为矩阵的行数,shape[1]输出列数
sample = get_sample_indices(data_seq, num_of_weeks, num_of_days,
num_of_hours, idx, num_for_predict,
points_per_hour)
if not sample:
continue
week_sample, day_sample, hour_sample, target = sample
all_samples.append((
np.expand_dims(week_sample, axis=0).transpose((0, 2, 3, 1)),#np.expand_dims:用于扩展数组的形状
np.expand_dims(day_sample, axis=0).transpose((0, 2, 3, 1)),
np.expand_dims(hour_sample, axis=0).transpose((0, 2, 3, 1)),
np.expand_dims(target, axis=0).transpose((0, 2, 3, 1)) # wd: first feature is the traffic flow，第一个特点是交通流,将最后的[:, :, 0, :] 去掉
))
split_line1 = int(len(all_samples) * 0.6)
split_line2 = int(len(all_samples) * 0.8)
if not merge:
#取出前60%的数据作为训练集的数据
training_set = [np.concatenate(i, axis=0)#np.concatenate()能够一次完成多个数组的拼接。
for i in zip(*all_samples[:split_line1])]#zip是将对象中对应的元素打包成一个个tuple（元组），然后返回由这些 tuples组成的list（列表）
else:
print('Merge training set and validation set!')#合并训练集和验证集
training_set = [np.concatenate(i, axis=0)
for i in zip(*all_samples[:split_line2])]
validation_set = [np.concatenate(i, axis=0)#获得验证集数据，数据范围是60%到80%之间的20%的数据
for i in zip(*all_samples[split_line1: split_line2])]
testing_set = [np.concatenate(i, axis=0)
for i in zip(*all_samples[split_line2:])]#获得测试集，测试集是最后20%，即80%到100%
train_week, train_day, train_hour, train_target = training_set
val_week, val_day, val_hour, val_target = validation_set
test_week, test_day, test_hour, test_target = testing_set
# wd: week: (8979, 307, 3, 12), day: (8979, 307, 3, 12), recent: (8979, 307, 3, 36), target: (8979, 307, 12)
# wd: week/day/recent: num_samples, num_vertices, num_features, num_of_weeks/days/hours * points_per_hour
# wd: target: num_samples, num_vertices, num_predict
print('training data: week: {}, day: {}, recent: {}, target: {}'.format(
train_week.shape, train_day.shape,
train_hour.shape, train_target.shape))
print('validation data: week: {}, day: {}, recent: {}, target: {}'.format(
val_week.shape, val_day.shape, val_hour.shape, val_target.shape))
print('testing data: week: {}, day: {}, recent: {}, target: {}'.format(
test_week.shape, test_day.shape, test_hour.shape, test_target.shape))
(week_stats, train_week_norm,
val_week_norm, test_week_norm) = normalization(train_week,
val_week,
test_week,
stats)
(day_stats, train_day_norm,
val_day_norm, test_day_norm) = normalization(train_day,
val_day,
test_day,
stats)
(recent_stats, train_recent_norm,
val_recent_norm, test_recent_norm) = normalization(train_hour,
val_hour,
test_hour,
stats)
#增加的计算target标准化
(target_stats,train_target_norm,
val_target_norm,test_target_norm) = normalization(train_target,
val_target,
test_target,
stats)
all_data = {
'train': {
'week': train_week_norm,
'day': train_day_norm,
'recent': train_recent_norm,
'target': train_target, # wd: target does not need to be normalized?
},
'val': {
'week': val_week_norm,
'day': val_day_norm,
'recent': val_recent_norm,
'target': val_target
},
'test': {
'week': test_week_norm,
'day': test_day_norm,
'recent': test_recent_norm,
'target': test_target
},
'stats': {
'week': week_stats,
'day': day_stats,
'recent': recent_stats,
'target': target_stats,
'stats':stats
}
}
return all_data
|
State Before: a b : ℝ
f : C(↑(Set.Icc a b), ℝ)
⊢ f ∈ Subalgebra.topologicalClosure (polynomialFunctions (Set.Icc a b)) State After: a b : ℝ
f : C(↑(Set.Icc a b), ℝ)
⊢ f ∈ ⊤ Tactic: rw [polynomialFunctions_closure_eq_top _ _] State Before: a b : ℝ
f : C(↑(Set.Icc a b), ℝ)
⊢ f ∈ ⊤ State After: no goals Tactic: simp |
= = = White has an enduring advantage = = =
|
lemma map_poly_id' [simp]: "map_poly (\<lambda>x. x) p = p" |
library(quantreg)
library(Rfit)
# plot function
plot_df <- function(df, rankscale = FALSE, ylim = NULL, stripcol = c("#21A883CC", "#4591CCCC", "#673AB7CC"), COL = c("#21A883", "#4591CC", "#673AB7") ) {
path <- rownames(df$tau)
tau <- df$tau
df <- df$df; df$x <- df$x + 1
if(rankscale == TRUE) {
range_y <- range(df$y)
rank_y <- rank(df$y)
rank_y_sc <- (rank_y - min(rank_y))/(max(rank_y)-min(rank_y) )
df$y <- (rank_y_sc)*(max(range_y)-min(range_y)) + min(range_y)
}
q0 = round(tau$tau, 3)
ptau = round(tau$p, 5)
X0 <- seq(1, 3, 0.1)
mm <- model.matrix( ~ X0)
m1 <- rfit(y ~ x, df)
pred.m1 <- coef(m1)[[1]] + X0*coef(m1)[[2]]
pred.se <- apply(mm, 1, function(Xrow) t(Xrow) %*% vcov(m1) %*% Xrow)
upp <- pred.m1 + 1.96*sqrt(pred.se)
lwr <- pred.m1 - 1.96*sqrt(pred.se)
upp_sd <- aggregate(y ~ x, data=df, function(x) mean(x) + sd(x))$y
lwr_sd <- aggregate(y ~ x, data=df, function(x) mean(x) - sd(x))$y
if(is.null(ylim)) { ylim <- range(c(df$y, upp, lwr, upp_sd, lwr_sd)) }
stripchart(df$y ~ I(df$x-1), vertical=T, method="jitter", pch=c(15,16, 17), col=stripcol, add=F, cex=2, ylab = colnames(H1N1_noise_paths)[H1N1_idx], ylim = ylim, las=1)
polygon(c(X0, rev(X0)), c(lwr, rev(upp)), col="#00000033", border = NA);
lines(X0, pred.m1, col=1, lty=2, lwd=3);
segments(c(1:3), upp_sd, c(1:3), lwr_sd, col = COL, lwd=3 )
points(c(1:3), aggregate(y ~ x, data=df, function(x) mean(x))$y, pch=21, col = COL, bg = "white", cex=3, lwd=3 )
legend("topleft", legend = paste0("H1N1: tau = ", q0, ", p = ", ptau))
}
################################################################################
setwd("/media/yuri/Data/home1/GNI_data/infection/ResultsSciRep")
load("CAP_Sepsis_Ensemble_noise_sig.RDat")
load("H1N1_Ensemble_noise_sig.RDat")
pheno_CAP$mort_num[pheno_CAP$mort == "NA"] <- -1
pheno_CAP$mort_num <- pheno_CAP$mort_num + 1
pheno_SPS$mort_num[pheno_SPS$mort == "NA"] <- -1
pheno_SPS$mort_num <- pheno_SPS$mort_num + 1
ALL_UP <- Reduce(intersect, list( H1N1 = rownames(padjR_H1N1_stage_sig_UP),
CAP = rownames(padjR_CAP_stage_sig_UP),
sepsis = rownames(padjR_SPS_stage_sig_UP)))
CAP_H1N1_UP <- Reduce(intersect, list( H1N1 = rownames(padjR_H1N1_stage_sig_UP), CAP = rownames(padjR_CAP_stage_sig_UP) ) )
CAP_H1N1_UP <- CAP_H1N1_UP[!(CAP_H1N1_UP %in% ALL_UP)]
CAP_SPS_UP <- Reduce(intersect, list( SPS = rownames(padjR_SPS_stage_sig_UP), CAP = rownames(padjR_CAP_stage_sig_UP) ) )
CAP_SPS_UP <- CAP_SPS_UP[!(CAP_SPS_UP %in% ALL_UP)]
################################################################################
setwd("/media/yuri/Data/home1/GNI_data/infection/ResultsSciRep/Figures")
pdf("Figure2B.pdf", paper="a4r", width=8, height=5)
for(k in seq(ALL_UP)) {
idx <- ALL_UP[k]
H1N1_idx <- which(colnames(H1N1_noise_paths) == idx)
df0 <- data.frame(y=H1N1_noise_paths[,H1N1_idx] , x = as.numeric(factor(H1N1_stage))-1)
cap_idx <- which(colnames(affyDat_noise_paths_CAP) == idx)
df1 <- data.frame(y = affyDat_noise_paths_CAP[,cap_idx] , x = pheno_CAP$mort_num, age=pheno_CAP$age)
m00 <- lm(y ~ age, data=df1)
df1$y <-coefficients(m00)[[1]] + resid(m00)
df1$age <- NULL
sps_idx <- which(colnames(affyDat_noise_paths_SPS) == idx)
df2 <- data.frame(y = affyDat_noise_paths_SPS[,cap_idx] , x = pheno_SPS$mort_num, age=pheno_SPS$age)
m00 <- lm(y ~ age, data=df2)
df2$y <- coefficients(m00)[[1]] + resid(m00)
df2$age <- NULL
ylim = range(c(df1$y, df2$y))
par(mfrow = c(1,3))
plot_df(list(df = df0, tau = padjR_H1N1_stage[H1N1_idx,]), ylim = NULL, stripcol = c("#21A883CC", "#4591CCCC", "#673AB7CC"), COL=1)
plot_df(list(df = df1, tau = padjR_CAP_stage[cap_idx,]), ylim = ylim, stripcol = c("#21A88388", "#4591CC88", "#673AB788"), COL=1)
plot_df(list(df = df2, tau = padjR_SPS_stage[sps_idx,]), ylim = ylim, stripcol = c("#21A88388", "#4591CC88", "#673AB788"), COL=1)
}
dev.off()
################################################################################
pdf("Figure2C.pdf", paper="a4r", width=8, height=5)
for(k in seq(CAP_H1N1_UP)) {
idx <- CAP_H1N1_UP[k]
H1N1_idx <- which(colnames(H1N1_noise_paths) == idx)
df0 <- data.frame(y=H1N1_noise_paths[,H1N1_idx] , x = as.numeric(factor(H1N1_stage))-1)
cap_idx <- which(colnames(affyDat_noise_paths_CAP) == idx)
df1 <- data.frame(y = affyDat_noise_paths_CAP[,cap_idx] , x = pheno_CAP$mort_num, age=pheno_CAP$age)
m00 <- lm(y ~ age, data=df1)
df1$y <-coefficients(m00)[[1]] + resid(m00)
df1$age <- NULL
sps_idx <- which(colnames(affyDat_noise_paths_SPS) == idx)
df2 <- data.frame(y = affyDat_noise_paths_SPS[,cap_idx] , x = pheno_SPS$mort_num, age=pheno_SPS$age)
m00 <- lm(y ~ age, data=df2)
df2$y <- coefficients(m00)[[1]] + resid(m00)
df2$age <- NULL
ylim = range(c(df1$y, df2$y))
par(mfrow = c(1,3))
plot_df(list(df = df0, tau = padjR_H1N1_stage[H1N1_idx,]), ylim = NULL, stripcol = c("#21A883CC", "#4591CCCC", "#673AB7CC"), COL=1)
plot_df(list(df = df1, tau = padjR_CAP_stage[cap_idx,]), ylim = ylim, stripcol = c("#21A88388", "#4591CC88", "#673AB788"), COL=1)
plot_df(list(df = df2, tau = padjR_SPS_stage[sps_idx,]), ylim = ylim, stripcol = c("#21A88388", "#4591CC88", "#673AB788"), COL=1)
}
dev.off()
################################################################################
# Supplementary tables
# ALL_UP_table <- lapply(seq(ALL_UP), function(k) {
# idx <- ALL_UP[k]
# H1N1_idx <- which(colnames(H1N1_noise_paths) == idx)
# cap_idx <- which(colnames(affyDat_noise_paths_CAP) == idx)
# sps_idx <- which(colnames(affyDat_noise_paths_SPS) == idx)
#
# path <- names(core_paths_subset)[grep(ALL_UP[k], names(core_paths_subset), fixed=T)]
# genes <- sort(core_paths_subset[grep(ALL_UP[k], names(core_paths_subset), fixed=T)][[1]])
# tau_h1n <- round(as.numeric(padjR_H1N1_stage[H1N1_idx,1]),3)
# tau_cap <- round(as.numeric(padjR_CAP_stage[cap_idx,1]),3)
# tau_sps <- round(as.numeric(padjR_SPS_stage[sps_idx,1]),3)
#
# p_h1n <- round(as.numeric(padjR_H1N1_stage[H1N1_idx,2]),6)
# p_cap <- round(as.numeric(padjR_CAP_stage[cap_idx,2]),6)
# p_sps <- round(as.numeric(padjR_SPS_stage[sps_idx,2]),6)
#
# res <- data.frame(path = path,
# H1N1 = paste(tau_h1n, p_h1n, sep="; "),
# CAP = paste(tau_cap, p_cap, sep="; "),
# SPS = paste(tau_sps, p_sps, sep="; "),
# genes = paste(genes, collapse = "; ") )
# res
# })
# ALL_UP_table <- do.call(rbind, ALL_UP_table)
#
#
# CAP_H1N1_UP_table <- lapply(seq(CAP_H1N1_UP), function(k) {
# idx <- CAP_H1N1_UP[k]
# H1N1_idx <- which(colnames(H1N1_noise_paths) == idx)
# cap_idx <- which(colnames(affyDat_noise_paths_CAP) == idx)
# sps_idx <- which(colnames(affyDat_noise_paths_SPS) == idx)
#
# path <- names(core_paths_subset)[grep(CAP_H1N1_UP[k], names(core_paths_subset), fixed=T)]
# genes <- sort(core_paths_subset[grep(CAP_H1N1_UP[k], names(core_paths_subset), fixed=T)][[1]])
# tau_h1n <- round(as.numeric(padjR_H1N1_stage[H1N1_idx,1]),3)
# tau_cap <- round(as.numeric(padjR_CAP_stage[cap_idx,1]),3)
# tau_sps <- round(as.numeric(padjR_SPS_stage[sps_idx,1]),3)
#
# p_h1n <- round(as.numeric(padjR_H1N1_stage[H1N1_idx,2]),6)
# p_cap <- round(as.numeric(padjR_CAP_stage[cap_idx,2]),6)
# p_sps <- round(as.numeric(padjR_SPS_stage[sps_idx,2]),6)
#
# res <- data.frame(path = path,
# H1N1 = paste(tau_h1n, p_h1n, sep="; "),
# CAP = paste(tau_cap, p_cap, sep="; "),
# SPS = paste(tau_sps, p_sps, sep="; "),
# genes = paste(genes, collapse = "; ") )
# res
# })
# CAP_H1N1_UP_table <- do.call(rbind, CAP_H1N1_UP_table)
#
# write.table(ALL_UP_table, "ALL_UP_table.txt", row.names=F, col.names=T, quote=F, sep="\t")
# write.table(CAP_H1N1_UP_table, "CAP_H1N1_UP_table.txt", row.names=F, col.names=T, quote=F, sep="\t")
|
import itertools
import numpy as np
import torch
import torch.nn.functional as F
import torch.optim as optim
from .util import atomic_save
class PPO:
"""
A base implementation of Proximal Policy Optimization.
See: https://arxiv.org/abs/1707.06347.
"""
def __init__(self, model, epsilon=0.2, gamma=0.99, lam=0.95, lr=1e-4, ent_reg=0.001):
self.model = model
self.epsilon = epsilon
self.gamma = gamma
self.lam = lam
self.optimizer = optim.Adam(model.parameters(), lr=lr)
self.ent_reg = ent_reg
def outer_loop(self, roller, save_path='save.pkl', **kwargs):
"""
Run training indefinitely, saving periodically.
"""
for i in itertools.count():
terms, last_terms = self.inner_loop(roller.rollout(), **kwargs)
self.print_outer_loop(i, terms, last_terms)
atomic_save(self.model.state_dict(), save_path)
def print_outer_loop(self, i, terms, last_terms):
print('step %d: clipped=%f entropy=%f explained=%f' %
(i, last_terms['clip_frac'], terms['entropy'], terms['explained']))
def inner_loop(self, rollout, num_steps=12, batch_size=None):
if batch_size is None:
batch_size = rollout.num_steps * rollout.batch_size
advs = rollout.advantages(self.gamma, self.lam)
targets = advs + rollout.value_predictions()[:-1]
advs = (advs - np.mean(advs)) / (1e-8 + np.std(advs))
actions = rollout.actions()
log_probs = rollout.log_probs()
firstterms = None
lastterms = None
for entries in rollout.batches(batch_size, num_steps):
def choose(values):
return self.model.tensor(np.array([values[t, b] for t, b in entries]))
terms = self.terms(choose(rollout.states),
choose(rollout.obses),
choose(advs),
choose(targets),
choose(actions),
choose(log_probs))
self.optimizer.zero_grad()
terms['loss'].backward()
self.optimizer.step()
lastterms = {k: v.item() for k, v in terms.items() if k != 'model_outs'}
if firstterms is None:
firstterms = lastterms
del terms
return firstterms, lastterms
def terms(self, states, obses, advs, targets, actions, log_probs):
model_outs = self.model(states, obses)
vf_loss = torch.mean(torch.pow(model_outs['critic'] - targets, 2))
variance = torch.var(targets)
explained = 1 - vf_loss / variance
new_log_probs = -F.cross_entropy(model_outs['actor'], actions.long(), reduction='none')
ratio = torch.exp(new_log_probs - log_probs)
clip_ratio = torch.clamp(ratio, 1 - self.epsilon, 1 + self.epsilon)
pi_loss = -torch.mean(torch.min(ratio * advs, clip_ratio * advs))
clip_frac = torch.mean(torch.gt(ratio * advs, clip_ratio * advs).float())
all_probs = torch.log_softmax(model_outs['actor'], dim=-1)
neg_entropy = torch.mean(torch.sum(torch.exp(all_probs) * all_probs, dim=-1))
ent_loss = self.ent_reg * neg_entropy
return {
'explained': explained,
'clip_frac': clip_frac,
'entropy': -neg_entropy,
'vf_loss': vf_loss,
'pi_loss': pi_loss,
'ent_loss': ent_loss,
'loss': vf_loss + pi_loss + ent_loss,
'model_outs': model_outs,
}
|
module Statistics.GModeling.Models.HMM
(
) where
import Statistics.GModeling.DSL
import Statistics.GModeling.Gibbs
import qualified Data.Vector as V
import qualified Data.Vector.Unboxed as U
import qualified Data.Vector.Generic as G
import qualified Data.Vector.Unboxed.Mutable as MU
data HMM = Alpha | Beta | Transition
| Topic | Symbols | Symbol
hmm :: Network HMM
hmm =
[
Only Alpha :-> Transition
, Only Beta :-> Symbols
, (Transition :@ Topic) :-> Topic
, (Symbols :@ Topic) :-> Symbol
]
type D = V.Vector (U.Vector (Int,Int))
reader :: D -> Reader HMM Int
reader v = Reader
{
size = G.sum (G.map G.length v)
, readn = \idx k ->
let (i,j) = indices G.! idx
(topic,symbol) = v G.! i G.! j
(prev_topic,_) = v G.! i G.! (j-1)
in case k of
Topic -> topic
Symbol -> symbol
Symbols -> topic
Transition -> if j==0
-- reserve Topic 0 for initial distribution
then 0
else prev_topic
, copy = do
m <- G.mapM U.thaw v
return Writer
{
writen = \idx k v -> do
let (i,j) = indices G.! idx
case k of
Topic -> do
(_,s) <- MU.unsafeRead (m G.! i) j
MU.unsafeWrite (m G.! i) j (v,s)
, readOnly = G.mapM U.freeze m >>= return . reader
}
}
where indices = U.fromList $ do
i <- [0..G.length v-1]
j <- [0..G.length (v G.! i)-1]
return (i,j)
|
/-
Copyright (c) 2021 Ashvni Narayanan. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Ashvni Narayanan
-/
import padic_int.clopen_properties
import padic_integral
import bernoulli_measure.eventually_constant_sequence
import bernoulli_measure.bernoulli_distribution
import nat_properties
/-!
# Equivalence class on ℤ/(d * p^n)ℤ
This file defines `equi_class` and its properties on `zmod (d * p^n)`.
We also use `zmod'`, which is the universal (sub)set of `zmod`, to make computations on sums easier.
## Main definitions and theorems
* `equi_class`
* `zmod'`
* `equi_class.zmod'_succ_eq_bUnion`
* `bernoulli_distribution_sum`
## Implementation notes
* Changed bernoulli_measure_one to bernoulli_measure_def and bernoulli_measure_two to equi_class
## References
Introduction to Cyclotomic Fields, Washington (Chapter 12, Section 2)
## Tags
p-adic, L-function, Bernoulli measure
-/
local attribute [instance] zmod.topological_space
variables {p : ℕ} {d : ℕ} (R : Type*) [normed_comm_ring R] {c : ℕ}
open eventually_constant_seq
open_locale big_operators
/-- A variant of `zmod` which has type `finset _`. -/
def zmod' (n : ℕ) (h : 0 < n) : finset (zmod n) :=
@finset.univ _ (@zmod.fintype n (fact_iff.2 h))
open nat padic_int zmod discrete_quotient_of_to_zmod_pow
/-- Given `a ∈ zmod (d * p^n)`, the set of all `b ∈ zmod (d * p^m)` such that
`b = a mod (d * p^n)`. -/
def equi_class {n : ℕ} (m : ℕ) (a : zmod (d * p^n)) :=
{b : zmod (d * p^m) | (b : zmod (d * p^n)) = a}
-- change def to a + k*dp^m
-- need h to be n ≤ m, not n < m for g_char_fn
variable [fact p.prime]
namespace int
lemma fract_eq_self' {a : ℚ} (h : 0 ≤ a) (ha : a < 1) : int.fract a = a :=
int.fract_eq_iff.2 ⟨h, ha, ⟨0, by simp⟩⟩
end int
namespace finset
lemma sum_equiv {α β γ : Type*} {s : finset α} {s' : finset β} {φ : s ≃ s'} {f : α → γ}
[add_comm_monoid γ] : ∑ x : s, f x = ∑ y : s', f(φ.inv_fun y) :=
begin
apply finset.sum_bij',
swap 4, { rintros, exact φ.to_fun a, },
swap 5, { rintros, exact φ.inv_fun a, },
all_goals { simp },
end
end finset
lemma sum_rat_fin (n : ℕ) : (((∑ (x : fin n), (x : ℤ)) : ℤ) : ℚ) = (n - 1) * (n : ℚ) / 2 :=
begin
have : ∀ (x : fin n), (x : ℤ) = ((x : ℕ) : ℤ),
{ simp only [_root_.coe_coe, eq_self_iff_true, implies_true_iff], },
conv_lhs { congr, congr, skip, funext, rw this x, },
rw ←finset.sum_range,
induction n with d hd,
{ simp only [finset.range_zero, finset.sum_empty, int.cast_zero, nat.cast_zero, mul_zero,
zero_div], },
{ rw [finset.sum_range_succ, int.cast_add, hd _],
{ simp only [int.cast_coe_nat, cast_succ, add_tsub_cancel_right],
rw div_add',
{ rw [mul_comm _ (d : ℚ), ←mul_add], ring, },
{ simp only [ne.def, bit0_eq_zero, one_ne_zero, not_false_iff], }, },
{ simp only [_root_.coe_coe, eq_self_iff_true, implies_true_iff], }, },
end
namespace equi_class
lemma mem {n m : ℕ} (a : zmod (d * p^n)) (b : zmod (d * p^m)) :
b ∈ equi_class m a ↔ (b : zmod (d * p^n)) = a := ⟨λ hb, hb, λ hb, hb⟩
variable [fact (0 < d)]
lemma some {n : ℕ} (x : zmod (d * p^n)) (y : equi_class n.succ x) : ∃ k : ℕ, k < p ∧
(y : zmod (d * p^n.succ)).val = x.val + k * d * p^n :=
begin
conv { congr, funext, conv { congr, skip, to_rhs,
rw ←((@mem p d _ n n.succ x y).1 (y.prop)), }, },
rw [← zmod.nat_cast_val (y : zmod (d * p^n.succ)), zmod.val_nat_cast],
refine ⟨(y : zmod (d * p^n.succ)).val / (d * p^n), nat.div_lt_of_lt_mul _, _⟩,
{ rw [nat.mul_assoc, ←pow_succ'], apply zmod.val_lt (y : zmod (d * p^n.succ)), },
{ rw [mul_assoc, nat.mod_add_div' (y : zmod (d * p^n.succ)).val (d * p^n)], },
end
/-- Giving an equivalence between `equi_class` and `fin p`. -/
def equi_iso_fin (m : ℕ) (a : zmod (d * p^m)) : equi_class m.succ a ≃ fin p :=
{ to_fun := λ y, ⟨((y.val).val - a.val) / (d * p^m), nat.div_lt_of_lt_mul begin
rw [mul_assoc, ←pow_succ'],
exact lt_of_le_of_lt (nat.sub_le (y.val).val a.val) (zmod.val_lt y.val), end⟩,
inv_fun := λ k, ⟨(a.val + k * d * p^m : ℕ), begin
have g : (d * (p^m)) ∣ (d * p^(m.succ)) := mul_dvd_mul dvd_rfl (pow_dvd_pow p (nat.le_succ _)),
rw [mem, zmod.cast_nat_cast g _, nat.cast_add, zmod.nat_cast_zmod_val, mul_assoc,
nat.cast_mul, zmod.nat_cast_self, mul_zero, add_zero],
refine zmod.char_p _, end⟩,
left_inv := λ x, begin
rw subtype.ext_iff_val, simp only [fin.coe_mk, subtype.val_eq_coe, _root_.coe_coe],
rw mul_assoc,
obtain ⟨k, hk, h⟩ := some a x,
rw nat.div_mul_cancel,
{ rw [← nat.add_sub_assoc _ _, nat.add_sub_cancel_left],
{ rw zmod.nat_cast_val _, norm_cast, apply_instance, },
{ rw h, apply nat.le_add_right, }, },
{ rw [h, nat.add_sub_cancel_left, mul_assoc], simp, }, end,
right_inv := λ x, begin
simp only [nat.cast_pow],
rw subtype.ext_iff_val,
simp only [fin.coe_mk, subtype.val_eq_coe, _root_.coe_coe],
apply nat.div_eq_of_eq_mul_left (fact.out _) (tsub_eq_of_eq_add _),
{ apply_instance, },
rw [mul_assoc, zmod.val_nat_cast, nat.mod_eq_of_lt],
rw add_comm,
have h2 : ↑x * (d * p ^ m) ≤ (d * p ^ m) * (p - 1),
{ rw mul_comm, apply nat.mul_le_mul_left,
rw [←nat.lt_succ_iff, nat.succ_eq_add_one, nat.sub_add_cancel], apply x.2,
{ apply le_of_lt (fact_iff.1 (nat.prime.one_lt' p)), }, },
convert add_lt_add_of_lt_of_le (zmod.val_lt a) h2,
ring_nf, rw nat.sub_add_cancel,
{ rw ←pow_succ, },
{ apply le_of_lt (fact_iff.1 (nat.prime.one_lt' p)), }, end}
noncomputable instance {n m : ℕ} (a : zmod (d * p^n)) : fintype (equi_class m a) :=
set.finite.fintype (set.finite.subset (set.univ_finite_iff_nonempty_fintype.2
(nonempty.intro infer_instance)) (set.subset_univ _))
open padic_int zmod nat
lemma zmod'_succ_eq_bUnion [fact (0 < d)] (m : ℕ) :
zmod' (d * (p^m.succ)) (mul_prime_pow_pos m.succ) = (zmod' (d*p^m) (mul_prime_pow_pos m)).bUnion
(λ a : zmod (d * p ^ m), set.to_finset ((equi_class m.succ) a)) :=
finset.ext (λ y, iff.trans begin simp only [exists_prop, set.mem_to_finset],
refine ⟨λ h, ⟨(y : zmod (d * p^m)), finset.mem_univ y, (equi_class.mem _ _).2 rfl⟩,
λ h, finset.mem_univ y⟩, end (iff.symm finset.mem_bUnion))
lemma eq [fact (0 < d)] {m : ℕ} (hd : d.coprime p)
{f : locally_constant (zmod d × ℤ_[p]) R} (h : classical.some (le hd f) ≤ m) (x : zmod (d * p^m))
(y : zmod (d * p^m.succ)) (hy : y ∈ set.to_finset ((equi_class m.succ) x)) : f y = f x :=
begin
-- note that y ≠ ↑x !
rw [set.mem_to_finset, equi_class.mem] at hy,
rw [←locally_constant.factors, function.comp_apply],
apply congr_arg,
have h' := classical.some_spec (le hd f),
rw [←discrete_quotient.of_le_proj (le_trans (le_of_ge p d h) h'), function.comp_apply],
refine congr_arg _ _,
change ↑y ∈ ((discrete_quotient_of_to_zmod_pow p d m).proj)⁻¹'
{(discrete_quotient_of_to_zmod_pow p d m).proj x},
simp_rw [discrete_quotient.fiber_eq, set.mem_set_of_eq, discrete_quotient_of_to_zmod_pow.rel,
prod.fst_zmod_cast, prod.snd_zmod_cast, ←hy],
have val_le_val : (y.val : zmod (d * p^m)).val ≤ y.val := val_coe_val_le_val _,
have dvds : (d * p^m) ∣ y.val - (y.val : zmod (d * p^m)).val,
{ rw [←zmod.nat_coe_zmod_eq_zero_iff_dvd, nat.cast_sub val_le_val],
simp only [zmod.cast_id', id.def, sub_self, zmod.nat_cast_val], },
split,
{ rw [←sub_eq_zero, ←ring_hom.map_sub, ←ring_hom.mem_ker, ker_to_zmod_pow,
ideal.mem_span_singleton],
repeat { rw ←zmod.nat_cast_val, },
rw [←dvd_neg, neg_sub, ←nat.cast_pow, ←nat.cast_sub val_le_val],
apply nat.coe_nat_dvd (dvd_trans (dvd_mul_left _ _) dvds), },
{ repeat { rw ←zmod.nat_cast_val, },
rw [zmod.nat_coe_eq_nat_coe_iff, nat.modeq_iff_dvd' val_le_val],
apply dvd_trans (dvd_mul_right _ _) dvds, },
end
-- This lemma has a lot of mini lemmas that can be generalized.
lemma card [fact (0 < d)] {m : ℕ} (x : zmod (d * p^m)) :
finset.card (@finset.univ (equi_class m.succ x) _) = p :=
begin
rw [finset.card_univ, ←fintype.of_equiv_card (equi_iso_fin m x)],
convert fintype.card_fin p,
end
lemma equi_iso_fun_inv_val [fact (0 < d)] {m : ℕ} (x : zmod (d * p^m)) (k : fin p) :
((equi_iso_fin m x).inv_fun k).val = x.val + ↑k * (d * p^m) :=
by { unfold equi_iso_fin, dsimp, norm_cast, rw mul_assoc, }
variables (p d)
lemma helper_2 [fact (0 < d)] (m : ℕ) (y : fin p) : ((y * (d * p ^ m) : zmod (d * p^m.succ)) : ℤ) =
↑y * (↑(d : zmod (d * p^m.succ)) * ↑(p : zmod (d * p^m.succ))^m) :=
begin
have prime_gt_one : 1 < p := prime.one_lt (fact.out _),
have le_mul_p : p ≤ d * p^m.succ,
{ rw mul_comm,
apply le_mul_of_le_of_one_le (le_pow (le_of_lt prime_gt_one)
(nat.succ_le_iff.2 (succ_pos _))) (nat.succ_le_iff.2 (fact.out _)),
{ assumption, }, },
rw [←zmod.nat_cast_val, zmod.val_mul, nat.mod_eq_of_lt _, nat.cast_mul],
{ apply congr_arg2,
{ rw [cast_val_eq_of_le _ le_mul_p, int.nat_cast_eq_coe_nat, _root_.coe_coe], },
{ rw [zmod.val_mul, nat.mod_eq_of_lt _],
{ rw [nat.cast_mul, zmod.nat_cast_val, zmod.nat_cast_val, ←nat.cast_pow],
apply congr_arg2 _ rfl _,
by_cases m = 0,
{ rw [h, pow_zero, pow_zero, nat.cast_one],
haveI : fact (1 < d * p^1),
{ apply fact_iff.2 (one_lt_mul (nat.succ_le_iff.2 (fact.out _)) _),
{ assumption, },
{ rw pow_one p, assumption, }, },
apply cast_int_one, },
{ rw [nat_cast_zmod_cast_int (lt_mul_pow_right (fact.out _) prime_gt_one
(nat.succ_lt_succ (nat.pos_of_ne_zero h))), nat_cast_zmod_cast_int
(pow_lt_mul_pow_succ_right _), int.coe_nat_pow],
any_goals { assumption, }, }, },
{ rw [←nat.cast_pow, zmod.val_cast_of_lt _, zmod.val_cast_of_lt (pow_lt_mul_pow_succ_right _)],
apply mul_pow_lt_mul_pow_succ,
any_goals { assumption, },
{ apply lt_mul_of_one_lt_right (fact.out _) (nat.one_lt_pow _ _ (nat.succ_pos _)
(nat.prime.one_lt (fact.out _))),
any_goals { assumption }, }, }, }, },
{ rw [←nat.cast_pow, ←nat.cast_mul, zmod.val_cast_of_lt (mul_pow_lt_mul_pow_succ _),
cast_val_eq_of_le _ le_mul_p],
{ apply fin_prime_mul_prime_pow_lt_mul_prime_pow_succ, },
any_goals { assumption, }, },
end
-- should p be implicit or explicit?
variables {p d}
theorem sum_fract [fact (0 < d)] {m : ℕ} (x : zmod (d * p^m)) :
∑ (x_1 : (equi_class m.succ x)), int.fract (((x_1 : zmod (d * p^m.succ)).val : ℚ) /
((d : ℚ) * (p : ℚ)^m.succ)) = (x.val : ℚ) / (d * p^m) + (p - 1) / 2 :=
begin
conv_lhs { congr, skip, funext, rw [← nat.cast_pow, ← nat.cast_mul,
int.fract_eq_self' ((zero_le_div_and_div_lt_one (x_1 : zmod (d * p ^ m.succ))).1)
((zero_le_div_and_div_lt_one (x_1 : zmod (d * p ^ m.succ))).2), nat.cast_mul, nat.cast_pow], },
rw fintype.sum_equiv (equi_iso_fin m x) (λ y, _)
(λ k, (((equi_iso_fin m x).inv_fun k).val : ℚ) / (d * p ^ m.succ)),
{ rw ←finset.sum_div,
have h1 : ∀ y : fin p, ((x.val : zmod (d * p^m.succ)) : ℤ) + ↑((y : zmod (d * p^m.succ)) *
(d * p ^ m : zmod (d * p^m.succ))) < ↑(d * p ^ m.succ : ℕ),
{ intro y,
rw [zmod.nat_cast_val, ←zmod.nat_cast_val, ←zmod.nat_cast_val (↑y * (_ * _)), ←nat.cast_add],
{ convert (int.coe_nat_lt).2 (val_add_fin_mul_lt x y) using 1,
apply congr (funext int.nat_cast_eq_coe_nat) (congr_arg2 _ _ _),
{ rw [←zmod.nat_cast_val, coe_val_eq_val_of_lt (mul_pow_lt_mul_pow_succ _) _],
any_goals { apply_instance, }, },
{ rw [←nat.cast_pow, ←nat.cast_mul, fin_prime_coe_coe, ←nat.cast_mul, zmod.val_cast_of_lt],
apply fin_prime_mul_prime_pow_lt_mul_prime_pow_succ, }, },
{ apply_instance, }, },
conv_lhs { congr, congr, skip, funext, rw [equi_iso_fun_inv_val, ←zmod.int_cast_cast,
coe_add_eq_pos' (h1 _), int.cast_add, helper_2 p d m _], },
{ rw [finset.sum_add_distrib, finset.sum_const, finset.card_univ, fintype.card_fin _],
norm_cast,
rw [←finset.sum_mul, _root_.add_div],
apply congr_arg2 _ ((div_eq_iff _).2 _) _,
{ norm_cast, apply ne_of_gt (fact_iff.1 _), apply_instance, apply_instance, },
{ rw [div_mul_comm, _root_.nsmul_eq_mul],
apply congr_arg2 _ _ _,
{ norm_num,
rw [mul_div_mul_left _, pow_succ, mul_div_cancel _],
{ norm_cast,
apply pow_ne_zero m (nat.prime.ne_zero (fact_iff.1 _)), assumption, },
{ norm_num,
apply ne_of_gt (fact_iff.1 infer_instance), apply_instance, assumption, }, },
{ rw [zmod.int_cast_cast, zmod.nat_cast_val, ←zmod.nat_cast_val (x : zmod (d * p^m.succ))],
refine congr_arg _ _,
rw [←zmod.nat_cast_val x, coe_val_eq_val_of_lt _ _],
{ apply_instance, },
{ rw [mul_comm d (p^m), mul_comm d (p^m.succ)],
apply mul_lt_mul (pow_lt_pow (nat.prime.one_lt (fact_iff.1 _)) (nat.lt_succ_self m))
le_rfl (fact.out _) (nat.zero_le _),
any_goals { assumption, }, }, }, },
{ rw [int.cast_mul, mul_div_assoc, sum_rat_fin, nat.cast_mul, int.cast_mul],
have one : ((p : ℚ) - 1) * (p : ℚ) / 2 * (1 / (p : ℚ)) = ((p : ℚ) - 1) / 2,
{ rw [_root_.div_mul_div_comm, mul_one, mul_div_mul_right],
norm_cast, apply ne_of_gt (nat.prime.pos (fact_iff.1 _)), assumption, },
convert one using 2,
rw div_eq_div_iff _ _,
{ rw [one_mul, zmod.int_cast_cast, int.cast_pow, zmod.int_cast_cast, pow_succ',
nat.cast_mul, nat.cast_pow, mul_assoc],
apply congr_arg2 _ _ _,
{ rw ←zmod.nat_cast_val _,
{ rw zmod.val_nat_cast,
apply congr_arg _ (nat.mod_eq_of_lt ((lt_mul_iff_one_lt_right (fact_iff.1 _)).2 _)),
{ assumption, },
{ rw ←pow_succ',
apply _root_.one_lt_pow (nat.prime.one_lt (fact_iff.1 _)) (succ_ne_zero _),
{ assumption, }, }, },
{ rw ←pow_succ', apply_instance, } },
{ apply congr_arg2 _ _ rfl,
{ by_cases m = 0,
{ rw [h, pow_zero, pow_zero], },
apply congr_arg2 _ _ rfl,
{ rw ←zmod.nat_cast_val _,
{ rw zmod.val_nat_cast,
apply congr_arg _ (nat.mod_eq_of_lt _),
rw [←mul_assoc, lt_mul_iff_one_lt_left (prime.pos (fact_iff.1 _))],
{ apply one_lt_mul (nat.succ_le_iff.2 (fact_iff.1 _)) _,
{ assumption, },
{ apply _root_.one_lt_pow (nat.prime.one_lt (fact_iff.1 _)) h,
assumption, }, },
{ assumption, }, },
{ rw ←pow_succ', apply_instance, }, }, }, }, },
{ rw ←nat.cast_mul, norm_cast,
apply ne_of_gt (fact_iff.1 _), apply_instance, apply_instance, },
{ norm_cast, apply ne_of_gt (nat.prime.pos (fact_iff.1 _)), assumption, }, }, }, },
{ rintros y,
simp only [equiv.symm_apply_apply, subtype.val_eq_coe, equiv.inv_fun_as_coe,
zmod.nat_cast_val], },
end
-- break up into smaller pieces
variable {m : ℕ}
lemma helper_bernoulli_distribution_sum' (hc' : c.coprime d) (hc : c.coprime p) (x : zmod (d * p^m)) :
∑ (x_1 : (equi_class m.succ x)), int.fract (((c : zmod (d * p^(2 * m.succ)))⁻¹.val : ℚ) *
↑(x_1 : zmod (d * p^m.succ)) / (↑d * ↑p ^ m.succ)) =
∑ (x_1 : (equi_class m.succ (↑((c : zmod (d * p^(2 * m.succ)))⁻¹.val) * x))),
int.fract (↑((x_1 : zmod (d * p^m.succ)).val) / (↑d * ↑p ^ m.succ)) :=
begin
have h1 : d * p ^ m ∣ d * p ^ m.succ,
{ apply mul_dvd_mul_left, rw pow_succ', apply dvd_mul_right, },
have h2 : ∀ z : ℕ, d * p ^ z ∣ d * p ^ (2 * z),
{ intro z, apply mul_dvd_mul_left _ (pow_dvd_pow p _), linarith, },
have h3 : d * p ^ m ∣ d * p ^ (2 * m.succ),
{ apply mul_dvd_mul_left _ (pow_dvd_pow p _),
rw [nat.succ_eq_add_one, mul_add], linarith, },
have h4 : (((c : zmod (d * p^(2 * m.succ)))⁻¹ : zmod (d * p^(2 * m.succ))) :
zmod (d * p^m.succ)).val ≤ (c : zmod (d * p^(2 * m.succ)))⁻¹.val := val_coe_val_le_val' _,
apply finset.sum_bij (λ a ha, _) (λ a ha, finset.mem_univ _) (λ a ha, _) (λ a1 a2 ha1 ha2 h, _) _,
{ refine ⟨(((c : zmod (d * p^(2*m.succ)))⁻¹).val : zmod (d * p^m.succ)) * a,
(equi_class.mem _ _).2 _⟩,
rw [zmod.cast_mul h1, cast_nat_cast h1 _],
conv_rhs { congr, skip, rw ←((@equi_class.mem p d _ _ m.succ x a).1 a.prop), },
any_goals { refine zmod.char_p _, }, },
{ rw [int.fract_eq_fract, subtype.coe_mk, div_sub_div_same, ← nat_cast_val
(a : zmod (d * p^m.succ)), zmod.val_mul, ← nat.cast_mul, ← nat.cast_sub
(le_trans (mod_le _ _) _), nat_cast_val, nat.cast_sub (le_trans (mod_le _ _) _),
← sub_add_sub_cancel _ ((((c : zmod (d * p^(2 * m.succ)))⁻¹ : zmod (d * p^(2 * m.succ))) :
zmod (d * p^m.succ)).val * (a : zmod (d * p^m.succ)).val : ℚ) _, ← nat.cast_mul],
obtain ⟨z₁, hz₁⟩ := @dvd_sub_mod (d * p^m.succ) ((((c : zmod (d * p^(2 * m.succ)))⁻¹ :
zmod (d * p^(2 * m.succ))) : zmod (d * p^m.succ)).val * (a : zmod (d * p^m.succ)).val),
obtain ⟨z₂, hz₂⟩ := dvd_val_sub_cast_val (d * p^m.succ) (c : zmod (d * p^(2 * m.succ)))⁻¹,
rw [← nat.cast_sub (mod_le _ _), hz₁, ← nat.cast_sub, ← nat.mul_sub_right_distrib, hz₂,
mul_assoc (d * p^(m.succ)) _ _, nat.cast_mul, nat.cast_mul _ z₁, ← mul_add,
← nat.cast_pow, ← nat.cast_mul d _, mul_comm,
mul_div_cancel _ ((@cast_ne_zero ℚ _ _ _ _).2 (ne_of_gt (fact_iff.1 _)))],
refine ⟨((z₂ * (a : zmod (d * p ^ m.succ)).val + z₁ : ℕ) : ℤ), by { norm_cast } ⟩,
any_goals { refine mul_le_mul_right' h4 _, },
{ apply_instance, },
{ rw nat_cast_val, refine mul_le_mul_right' h4 _, }, },
{ simp only [subtype.mk_eq_mk, nat_cast_val] at h,
rw subtype.ext ((is_unit.mul_right_inj (is_unit_iff_exists_inv'.2
⟨((c : zmod (d * p^(2 * (m.succ)))) : zmod (d * p^(m.succ))), _⟩)).1 h),
rw [cast_inv (nat.coprime.mul_pow _ hc' hc) (h2 _), cast_nat_cast (h2 m.succ)],
apply zmod.mul_inv_of_unit _ (is_unit_mul m.succ hc' hc),
{ refine zmod.char_p _, }, },
{ simp only [cast_nat_cast, nat_cast_val, subtype.coe_mk, finset.mem_univ, exists_true_left,
set_coe.exists, forall_true_left, set_coe.forall, subtype.mk_eq_mk, exists_prop],
rintros a ha, rw equi_class.mem at ha,
refine ⟨((c : zmod (d * p^(2 * m.succ))) : zmod (d * p^m.succ)) * a, _, _⟩,
{ rw [equi_class.mem, zmod.cast_mul h1],
{ rw [ha, ←mul_assoc, cast_inv (nat.coprime.mul_pow _ hc' hc) h3,
cast_nat_cast (h2 m.succ) _, cast_nat_cast h1 _, cast_nat_cast h3 _,
zmod.mul_inv_of_unit _ (is_unit_mul m hc' hc), one_mul],
any_goals { refine zmod.char_p _ }, },
{ refine zmod.char_p _, }, },
{ rw [←mul_assoc, zmod.cast_inv (nat.coprime.mul_pow _ hc' hc) (h2 _),
zmod.inv_mul_of_unit _ _, one_mul a, true_and],
rw cast_nat_cast (h2 m.succ) c,
apply is_unit_mul _ hc' hc,
{ refine zmod.char_p _, }, }, },
end
open equi_class
lemma bernoulli_distribution_sum' (x : zmod (d * p^m)) (hc : c.coprime p) (hc' : c.coprime d) :
∑ (y : equi_class m.succ x), (bernoulli_distribution p d c m.succ y) = (bernoulli_distribution p d c m x) :=
begin
rw [bernoulli_distribution, ← ring_hom.map_sum],
apply congr_arg,
rw [finset.sum_add_distrib, finset.sum_sub_distrib, equi_class.sum_fract, ←finset.mul_sum],
have h2 : ∀ z : ℕ, d * p ^ z ∣ d * p ^ (2 * z),
{ intro z, apply mul_dvd_mul_left _ (pow_dvd_pow p _), linarith, },
have h3 : d * p ^ m ∣ d * p ^ (2 * m.succ),
{ apply mul_dvd_mul_left _ (pow_dvd_pow p _),
rw [nat.succ_eq_add_one, mul_add], linarith, },
convert_to ((x.val : ℚ) / (d * p ^ m) + (p - 1) / 2) - (c : ℚ) *
∑ (x_1 : (equi_class m.succ ( ((c : zmod (d * p^(2*m.succ)))⁻¹.val) * x))),
int.fract (((x_1 : zmod (d * p^m.succ)).val : ℚ) / ((d : ℚ) * (p : ℚ)^m.succ)) +
(∑ (x : (equi_class m.succ x)), ((c : ℚ) - 1) / 2) = _ - _ + _,
{ rw [add_right_cancel_iff, sub_right_inj],
refine congr_arg _ (helper_bernoulli_distribution_sum' hc' hc _), },
rw [sum_fract, ←nat.cast_pow, ←nat.cast_mul, int.fract_eq_self' (zero_le_div_and_div_lt_one x).1
(zero_le_div_and_div_lt_one x).2, mul_add, finset.sum_const, equi_class.card,
_root_.nsmul_eq_mul, sub_add_eq_add_sub, sub_add_eq_add_sub, sub_add_eq_sub_sub, sub_right_comm],
apply congr_arg2 _ _ (congr_arg _ _),
{ rw [add_assoc, add_sub_assoc], congr, linarith, },
{ rw [←fract_eq_val _, ← zmod.nat_cast_val, ← zmod.nat_cast_val, ← nat.cast_mul],
apply fract_eq_of_zmod_eq,
rw [nat.cast_mul, zmod.nat_cast_val, zmod.nat_cast_val, zmod.nat_cast_val, zmod.cast_mul',
zmod.nat_cast_val, zmod.cast_id],
apply congr_arg2 _ _ rfl,
rw [cast_inv (nat.coprime.mul_pow _ hc' hc) h3, cast_inv (nat.coprime.mul_pow _ hc' hc) (h2 _),
cast_nat_cast h3, cast_nat_cast (h2 _)],
any_goals { refine zmod.char_p _, },
{ apply_instance, }, },
end
variable [algebra ℚ_[p] R]
--`E_c_sum_equi_class` replaced with `bernoulli_distribution_sum`
lemma bernoulli_distribution_sum (x : zmod (d * p^m)) (hc : c.gcd p = 1) (hc' : c.gcd d = 1) :
∑ (y : zmod (d * p ^ m.succ)) in (λ a : zmod (d * p ^ m), ((equi_class m.succ) a).to_finset) x,
((algebra_map ℚ_[p] R) (bernoulli_distribution p d c m.succ y)) = (algebra_map ℚ_[p] R) (bernoulli_distribution p d c m x) :=
begin
rw ←bernoulli_distribution_sum',
{ rw ring_hom.map_sum,
apply finset.sum_bij (λ a ha, subtype.mk a _) (λ a ha, finset.mem_univ _) (λ a ha, _)
(λ a b ha hb h, _) (λ b hb, _),
{ refine set.mem_to_finset.1 ha, },
{ simp only [subtype.coe_mk], },
{ simp only [subtype.mk_eq_mk, subtype.ext_iff, subtype.coe_mk] at h, rw h, },
{ simp only [set.mem_to_finset],
refine ⟨b.val, b.prop, by { rw subtype.ext_iff_val, }⟩, }, },
any_goals { assumption, },
end
open clopen_from
-- does not require [fact (0 < d)]
lemma clopen {n : ℕ} (a : zmod (d * p^n)) (hm : n ≤ m) (b : (equi_class m a)) :
(b.val : zmod d × ℤ_[p]) ∈ (clopen_from a) :=
begin
simp_rw [subtype.val_eq_coe, mem_clopen_from, ←(mem _ _).1 b.prop],
refine ⟨_, _⟩,
{ conv_rhs { congr, rw ←nat_cast_val, },
rw [prod.fst_zmod_cast, cast_nat_cast (dvd_mul_right d _) _, nat_cast_val],
refine zmod.char_p _, },
{ rw [prod.snd_zmod_cast],
convert_to _ = ((b: zmod (d * p^m)) : zmod (p^n)),
{ rw ←zmod.int_cast_cast (b: zmod (d * p^m)),
conv_rhs { rw ←zmod.int_cast_cast (b: zmod (d * p^m)), },
change (ring_hom.comp (to_zmod_pow n) (int.cast_ring_hom ℤ_[p])) ((b : zmod (d * p^m)) : ℤ) =
(int.cast_ring_hom (zmod (p^n))) ((b : zmod (d * p^m)) : ℤ),
apply _root_.congr_fun _ _,
congr,
convert @ring_hom.ext_zmod 0 _ _ _ _, },
{ rw [←cast_hom_apply' (zmod (p^n)) (dvd_mul_left (p^n) d) _, ←cast_hom_apply' (zmod (d * p^n))
(mul_dvd_mul_left d (pow_dvd_pow p hm)) _, ←cast_hom_apply' (zmod (p^n))
(dvd_mul_of_dvd_right (pow_dvd_pow p hm) d) _, ←ring_hom.comp_apply],
apply _root_.congr_fun _,
congr,
convert ring_hom.ext_zmod _ _, }, },
end
end equi_class |
Formal statement is: lemma of_real_add [simp]: "of_real (x + y) = of_real x + of_real y" Informal statement is: The real number $x + y$ is equal to the complex number $x + y$. |
import sys, os
sys.path.append(os.path.dirname(__file__))
import torch
from torch import nn
import numpy as np
from nets import Conv2dBlock, Conv3dBlock
class IdentityEncoder(nn.Module):
def __init__(self, in_channels = 3, out_channels = 256, init_inner_channels = 64, nlayers = 3):
super(IdentityEncoder, self).__init__()
channels = init_inner_channels
layers = [Conv2dBlock(in_channels, channels, kernel = 7, stride = 2, padding = 3)]
for _ in range(nlayers - 1):
conv_block = Conv2dBlock(
channels,
out_channels,
kernel = 3,
stride = 2,
padding = 1,
)
channels = out_channels
layers.append(conv_block)
self.layers = nn.Sequential(*layers)
def forward(self, x):
return self.layers(x)
class StreamEncoder(nn.Module):
def __init__(self, in_channels = 3, out_channels = 256, init_inner_channels = 64, nlayers = 4):
super(StreamEncoder, self).__init__()
layers = [
Conv3dBlock(in_channels, init_inner_channels, kernel = 4, stride = 2, padding = 1),
Conv3dBlock(init_inner_channels, out_channels, kernel = 4, stride = 2, padding = 1),
Conv3dBlock(out_channels, out_channels, kernel = 4, stride = 2, padding = 1),
Conv3dBlock(out_channels, out_channels, kernel = 4, stride = 2, padding = 1),
]
self.layers = nn.Sequential(*layers)
def forward(self, x):
return self.layers(x).squeeze(2)
class FlowEncoder(nn.Module):
def __init__(self, in_channels = 2, out_channels = 128, init_inner_channels = 32, nlayers = 3):
super(FlowEncoder, self).__init__()
channels = init_inner_channels
layers = [Conv3dBlock(in_channels, channels, kernel = (3, 7, 7), stride = (2, 4, 4), padding = (1, 3, 3))]
for _ in range(nlayers - 1):
cout = channels * 2
conv_block = Conv3dBlock(
channels,
cout if cout < out_channels else out_channels,
kernel = (3, 7, 7),
stride = (2, 4, 4),
padding = (1, 3, 3),
)
if cout < out_channels:
channels = cout
layers.append(conv_block)
self.layers = nn.Sequential(*layers)
self.fc = nn.Linear(out_channels * 2, out_channels)
self.__out_channels = out_channels
def forward(self, x):
'''
batch video shape is: (batch, frames, channels, h, w)
'''
batch_size = x.shape[0]
x = x.transpose(1, 2)
x = self.layers(x)
x = x.reshape(batch_size, -1)
x = self.fc(x)
return x
if __name__ == "__main__":
import pickle
v_enc = IdentityEncoder()
print(v_enc)
s_enc = StreamEncoder()
print(s_enc)
with open("./../grid-dataset/sample/s1/bbaf2n.pkl", 'rb') as fd:
data = pickle.load(fd)
video = data['video']
print(video.shape)
video = torch.tensor(video)
processed_video = v_enc(video.float())
print(processed_video.shape)
print("---------------------------------------------")
sample = torch.ones(59, 3, 16, 64, 64)
output = s_enc(sample.float())
print(output.shape)
|
ELEMENTAL FUNCTION func_radians(x) RESULT(ans)
! This function returns the passed angle converted from degrees to radians.
USE ISO_FORTRAN_ENV
IMPLICIT NONE
! Declare input variables ...
REAL(kind = REAL64), INTENT(in) :: x ! The input angle in degrees.
! Declare output variables ...
REAL(kind = REAL64) :: ans ! The output angle in radians.
! Set value ...
ans = const_pi * x / 180.0e0_REAL64 ! [rad]
END FUNCTION func_radians
|
selectOutput <- function(ensembles, item = 1)
lapply(ensembles, function(j) layer.apply(j, function(i) i[[item]])) |
[STATEMENT]
lemma succ_pred_no [simp]:
"word_succ (numeral w) = numeral w + 1"
"word_pred (numeral w) = numeral w - 1"
"word_succ (- numeral w) = - numeral w + 1"
"word_pred (- numeral w) = - numeral w - 1"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. (word_succ (numeral w) = numeral w + 1 &&& word_pred (numeral w) = numeral w - 1) &&& word_succ (- numeral w) = - numeral w + 1 &&& word_pred (- numeral w) = - numeral w - 1
[PROOF STEP]
by (simp_all add: word_succ_p1 word_pred_m1) |
(* Title: HOL/Limits.thy
Author: Brian Huffman
Author: Jacques D. Fleuriot, University of Cambridge
Author: Lawrence C Paulson
Author: Jeremy Avigad
*)
section \<open>Limits on Real Vector Spaces\<close>
theory Limits
imports Real_Vector_Spaces
begin
text \<open>Lemmas related to shifting/scaling\<close>
lemma range_add [simp]:
fixes a::"'a::group_add" shows "range ((+) a) = UNIV"
by (metis add_minus_cancel surjI)
lemma range_diff [simp]:
fixes a::"'a::group_add" shows "range ((-) a) = UNIV"
by (metis (full_types) add_minus_cancel diff_minus_eq_add surj_def)
lemma range_mult [simp]:
fixes a::"real" shows "range ((*) a) = (if a=0 then {0} else UNIV)"
by (simp add: surj_def) (meson dvdE dvd_field_iff)
subsection \<open>Filter going to infinity norm\<close>
definition at_infinity :: "'a::real_normed_vector filter"
where "at_infinity = (INF r. principal {x. r \<le> norm x})"
lemma eventually_at_infinity: "eventually P at_infinity \<longleftrightarrow> (\<exists>b. \<forall>x. b \<le> norm x \<longrightarrow> P x)"
unfolding at_infinity_def
by (subst eventually_INF_base)
(auto simp: subset_eq eventually_principal intro!: exI[of _ "max a b" for a b])
corollary eventually_at_infinity_pos:
"eventually p at_infinity \<longleftrightarrow> (\<exists>b. 0 < b \<and> (\<forall>x. norm x \<ge> b \<longrightarrow> p x))"
unfolding eventually_at_infinity
by (meson le_less_trans norm_ge_zero not_le zero_less_one)
lemma at_infinity_eq_at_top_bot: "(at_infinity :: real filter) = sup at_top at_bot"
proof -
have 1: "\<lbrakk>\<forall>n\<ge>u. A n; \<forall>n\<le>v. A n\<rbrakk>
\<Longrightarrow> \<exists>b. \<forall>x. b \<le> \<bar>x\<bar> \<longrightarrow> A x" for A and u v::real
by (rule_tac x="max (- v) u" in exI) (auto simp: abs_real_def)
have 2: "\<forall>x. u \<le> \<bar>x\<bar> \<longrightarrow> A x \<Longrightarrow> \<exists>N. \<forall>n\<ge>N. A n" for A and u::real
by (meson abs_less_iff le_cases less_le_not_le)
have 3: "\<forall>x. u \<le> \<bar>x\<bar> \<longrightarrow> A x \<Longrightarrow> \<exists>N. \<forall>n\<le>N. A n" for A and u::real
by (metis (full_types) abs_ge_self abs_minus_cancel le_minus_iff order_trans)
show ?thesis
by (auto simp: filter_eq_iff eventually_sup eventually_at_infinity
eventually_at_top_linorder eventually_at_bot_linorder intro: 1 2 3)
qed
lemma at_top_le_at_infinity: "at_top \<le> (at_infinity :: real filter)"
unfolding at_infinity_eq_at_top_bot by simp
lemma at_bot_le_at_infinity: "at_bot \<le> (at_infinity :: real filter)"
unfolding at_infinity_eq_at_top_bot by simp
lemma filterlim_at_top_imp_at_infinity: "filterlim f at_top F \<Longrightarrow> filterlim f at_infinity F"
for f :: "_ \<Rightarrow> real"
by (rule filterlim_mono[OF _ at_top_le_at_infinity order_refl])
lemma filterlim_real_at_infinity_sequentially: "filterlim real at_infinity sequentially"
by (simp add: filterlim_at_top_imp_at_infinity filterlim_real_sequentially)
lemma lim_infinity_imp_sequentially: "(f \<longlongrightarrow> l) at_infinity \<Longrightarrow> ((\<lambda>n. f(n)) \<longlongrightarrow> l) sequentially"
by (simp add: filterlim_at_top_imp_at_infinity filterlim_compose filterlim_real_sequentially)
subsubsection \<open>Boundedness\<close>
definition Bfun :: "('a \<Rightarrow> 'b::metric_space) \<Rightarrow> 'a filter \<Rightarrow> bool"
where Bfun_metric_def: "Bfun f F = (\<exists>y. \<exists>K>0. eventually (\<lambda>x. dist (f x) y \<le> K) F)"
abbreviation Bseq :: "(nat \<Rightarrow> 'a::metric_space) \<Rightarrow> bool"
where "Bseq X \<equiv> Bfun X sequentially"
lemma Bseq_conv_Bfun: "Bseq X \<longleftrightarrow> Bfun X sequentially" ..
lemma Bseq_ignore_initial_segment: "Bseq X \<Longrightarrow> Bseq (\<lambda>n. X (n + k))"
unfolding Bfun_metric_def by (subst eventually_sequentially_seg)
lemma Bseq_offset: "Bseq (\<lambda>n. X (n + k)) \<Longrightarrow> Bseq X"
unfolding Bfun_metric_def by (subst (asm) eventually_sequentially_seg)
lemma Bfun_def: "Bfun f F \<longleftrightarrow> (\<exists>K>0. eventually (\<lambda>x. norm (f x) \<le> K) F)"
unfolding Bfun_metric_def norm_conv_dist
proof safe
fix y K
assume K: "0 < K" and *: "eventually (\<lambda>x. dist (f x) y \<le> K) F"
moreover have "eventually (\<lambda>x. dist (f x) 0 \<le> dist (f x) y + dist 0 y) F"
by (intro always_eventually) (metis dist_commute dist_triangle)
with * have "eventually (\<lambda>x. dist (f x) 0 \<le> K + dist 0 y) F"
by eventually_elim auto
with \<open>0 < K\<close> show "\<exists>K>0. eventually (\<lambda>x. dist (f x) 0 \<le> K) F"
by (intro exI[of _ "K + dist 0 y"] add_pos_nonneg conjI zero_le_dist) auto
qed (force simp del: norm_conv_dist [symmetric])
lemma BfunI:
assumes K: "eventually (\<lambda>x. norm (f x) \<le> K) F"
shows "Bfun f F"
unfolding Bfun_def
proof (intro exI conjI allI)
show "0 < max K 1" by simp
show "eventually (\<lambda>x. norm (f x) \<le> max K 1) F"
using K by (rule eventually_mono) simp
qed
lemma BfunE:
assumes "Bfun f F"
obtains B where "0 < B" and "eventually (\<lambda>x. norm (f x) \<le> B) F"
using assms unfolding Bfun_def by blast
lemma Cauchy_Bseq:
assumes "Cauchy X" shows "Bseq X"
proof -
have "\<exists>y K. 0 < K \<and> (\<exists>N. \<forall>n\<ge>N. dist (X n) y \<le> K)"
if "\<And>m n. \<lbrakk>m \<ge> M; n \<ge> M\<rbrakk> \<Longrightarrow> dist (X m) (X n) < 1" for M
by (meson order.order_iff_strict that zero_less_one)
with assms show ?thesis
by (force simp: Cauchy_def Bfun_metric_def eventually_sequentially)
qed
subsubsection \<open>Bounded Sequences\<close>
lemma BseqI': "(\<And>n. norm (X n) \<le> K) \<Longrightarrow> Bseq X"
by (intro BfunI) (auto simp: eventually_sequentially)
lemma Bseq_def: "Bseq X \<longleftrightarrow> (\<exists>K>0. \<forall>n. norm (X n) \<le> K)"
unfolding Bfun_def eventually_sequentially
proof safe
fix N K
assume "0 < K" "\<forall>n\<ge>N. norm (X n) \<le> K"
then show "\<exists>K>0. \<forall>n. norm (X n) \<le> K"
by (intro exI[of _ "max (Max (norm ` X ` {..N})) K"] max.strict_coboundedI2)
(auto intro!: imageI not_less[where 'a=nat, THEN iffD1] Max_ge simp: le_max_iff_disj)
qed auto
lemma BseqE: "Bseq X \<Longrightarrow> (\<And>K. 0 < K \<Longrightarrow> \<forall>n. norm (X n) \<le> K \<Longrightarrow> Q) \<Longrightarrow> Q"
unfolding Bseq_def by auto
lemma BseqD: "Bseq X \<Longrightarrow> \<exists>K. 0 < K \<and> (\<forall>n. norm (X n) \<le> K)"
by (simp add: Bseq_def)
lemma BseqI: "0 < K \<Longrightarrow> \<forall>n. norm (X n) \<le> K \<Longrightarrow> Bseq X"
by (auto simp: Bseq_def)
lemma Bseq_bdd_above: "Bseq X \<Longrightarrow> bdd_above (range X)"
for X :: "nat \<Rightarrow> real"
proof (elim BseqE, intro bdd_aboveI2)
fix K n
assume "0 < K" "\<forall>n. norm (X n) \<le> K"
then show "X n \<le> K"
by (auto elim!: allE[of _ n])
qed
lemma Bseq_bdd_above': "Bseq X \<Longrightarrow> bdd_above (range (\<lambda>n. norm (X n)))"
for X :: "nat \<Rightarrow> 'a :: real_normed_vector"
proof (elim BseqE, intro bdd_aboveI2)
fix K n
assume "0 < K" "\<forall>n. norm (X n) \<le> K"
then show "norm (X n) \<le> K"
by (auto elim!: allE[of _ n])
qed
lemma Bseq_bdd_below: "Bseq X \<Longrightarrow> bdd_below (range X)"
for X :: "nat \<Rightarrow> real"
proof (elim BseqE, intro bdd_belowI2)
fix K n
assume "0 < K" "\<forall>n. norm (X n) \<le> K"
then show "- K \<le> X n"
by (auto elim!: allE[of _ n])
qed
lemma Bseq_eventually_mono:
assumes "eventually (\<lambda>n. norm (f n) \<le> norm (g n)) sequentially" "Bseq g"
shows "Bseq f"
proof -
from assms(2) obtain K where "0 < K" and "eventually (\<lambda>n. norm (g n) \<le> K) sequentially"
unfolding Bfun_def by fast
with assms(1) have "eventually (\<lambda>n. norm (f n) \<le> K) sequentially"
by (fast elim: eventually_elim2 order_trans)
with \<open>0 < K\<close> show "Bseq f"
unfolding Bfun_def by fast
qed
lemma lemma_NBseq_def: "(\<exists>K > 0. \<forall>n. norm (X n) \<le> K) \<longleftrightarrow> (\<exists>N. \<forall>n. norm (X n) \<le> real(Suc N))"
proof safe
fix K :: real
from reals_Archimedean2 obtain n :: nat where "K < real n" ..
then have "K \<le> real (Suc n)" by auto
moreover assume "\<forall>m. norm (X m) \<le> K"
ultimately have "\<forall>m. norm (X m) \<le> real (Suc n)"
by (blast intro: order_trans)
then show "\<exists>N. \<forall>n. norm (X n) \<le> real (Suc N)" ..
next
show "\<And>N. \<forall>n. norm (X n) \<le> real (Suc N) \<Longrightarrow> \<exists>K>0. \<forall>n. norm (X n) \<le> K"
using of_nat_0_less_iff by blast
qed
text \<open>Alternative definition for \<open>Bseq\<close>.\<close>
lemma Bseq_iff: "Bseq X \<longleftrightarrow> (\<exists>N. \<forall>n. norm (X n) \<le> real(Suc N))"
by (simp add: Bseq_def) (simp add: lemma_NBseq_def)
lemma lemma_NBseq_def2: "(\<exists>K > 0. \<forall>n. norm (X n) \<le> K) = (\<exists>N. \<forall>n. norm (X n) < real(Suc N))"
proof -
have *: "\<And>N. \<forall>n. norm (X n) \<le> 1 + real N \<Longrightarrow>
\<exists>N. \<forall>n. norm (X n) < 1 + real N"
by (metis add.commute le_less_trans less_add_one of_nat_Suc)
then show ?thesis
unfolding lemma_NBseq_def
by (metis less_le_not_le not_less_iff_gr_or_eq of_nat_Suc)
qed
text \<open>Yet another definition for Bseq.\<close>
lemma Bseq_iff1a: "Bseq X \<longleftrightarrow> (\<exists>N. \<forall>n. norm (X n) < real (Suc N))"
by (simp add: Bseq_def lemma_NBseq_def2)
subsubsection \<open>A Few More Equivalence Theorems for Boundedness\<close>
text \<open>Alternative formulation for boundedness.\<close>
lemma Bseq_iff2: "Bseq X \<longleftrightarrow> (\<exists>k > 0. \<exists>x. \<forall>n. norm (X n + - x) \<le> k)"
by (metis BseqE BseqI' add.commute add_cancel_right_left add_uminus_conv_diff norm_add_leD
norm_minus_cancel norm_minus_commute)
text \<open>Alternative formulation for boundedness.\<close>
lemma Bseq_iff3: "Bseq X \<longleftrightarrow> (\<exists>k>0. \<exists>N. \<forall>n. norm (X n + - X N) \<le> k)"
(is "?P \<longleftrightarrow> ?Q")
proof
assume ?P
then obtain K where *: "0 < K" and **: "\<And>n. norm (X n) \<le> K"
by (auto simp: Bseq_def)
from * have "0 < K + norm (X 0)" by (rule order_less_le_trans) simp
from ** have "\<forall>n. norm (X n - X 0) \<le> K + norm (X 0)"
by (auto intro: order_trans norm_triangle_ineq4)
then have "\<forall>n. norm (X n + - X 0) \<le> K + norm (X 0)"
by simp
with \<open>0 < K + norm (X 0)\<close> show ?Q by blast
next
assume ?Q
then show ?P by (auto simp: Bseq_iff2)
qed
subsubsection \<open>Upper Bounds and Lubs of Bounded Sequences\<close>
lemma Bseq_minus_iff: "Bseq (\<lambda>n. - (X n) :: 'a::real_normed_vector) \<longleftrightarrow> Bseq X"
by (simp add: Bseq_def)
lemma Bseq_add:
fixes f :: "nat \<Rightarrow> 'a::real_normed_vector"
assumes "Bseq f"
shows "Bseq (\<lambda>x. f x + c)"
proof -
from assms obtain K where K: "\<And>x. norm (f x) \<le> K"
unfolding Bseq_def by blast
{
fix x :: nat
have "norm (f x + c) \<le> norm (f x) + norm c" by (rule norm_triangle_ineq)
also have "norm (f x) \<le> K" by (rule K)
finally have "norm (f x + c) \<le> K + norm c" by simp
}
then show ?thesis by (rule BseqI')
qed
lemma Bseq_add_iff: "Bseq (\<lambda>x. f x + c) \<longleftrightarrow> Bseq f"
for f :: "nat \<Rightarrow> 'a::real_normed_vector"
using Bseq_add[of f c] Bseq_add[of "\<lambda>x. f x + c" "-c"] by auto
lemma Bseq_mult:
fixes f g :: "nat \<Rightarrow> 'a::real_normed_field"
assumes "Bseq f" and "Bseq g"
shows "Bseq (\<lambda>x. f x * g x)"
proof -
from assms obtain K1 K2 where K: "norm (f x) \<le> K1" "K1 > 0" "norm (g x) \<le> K2" "K2 > 0"
for x
unfolding Bseq_def by blast
then have "norm (f x * g x) \<le> K1 * K2" for x
by (auto simp: norm_mult intro!: mult_mono)
then show ?thesis by (rule BseqI')
qed
lemma Bfun_const [simp]: "Bfun (\<lambda>_. c) F"
unfolding Bfun_metric_def by (auto intro!: exI[of _ c] exI[of _ "1::real"])
lemma Bseq_cmult_iff:
fixes c :: "'a::real_normed_field"
assumes "c \<noteq> 0"
shows "Bseq (\<lambda>x. c * f x) \<longleftrightarrow> Bseq f"
proof
assume "Bseq (\<lambda>x. c * f x)"
with Bfun_const have "Bseq (\<lambda>x. inverse c * (c * f x))"
by (rule Bseq_mult)
with \<open>c \<noteq> 0\<close> show "Bseq f"
by (simp add: field_split_simps)
qed (intro Bseq_mult Bfun_const)
lemma Bseq_subseq: "Bseq f \<Longrightarrow> Bseq (\<lambda>x. f (g x))"
for f :: "nat \<Rightarrow> 'a::real_normed_vector"
unfolding Bseq_def by auto
lemma Bseq_Suc_iff: "Bseq (\<lambda>n. f (Suc n)) \<longleftrightarrow> Bseq f"
for f :: "nat \<Rightarrow> 'a::real_normed_vector"
using Bseq_offset[of f 1] by (auto intro: Bseq_subseq)
lemma increasing_Bseq_subseq_iff:
assumes "\<And>x y. x \<le> y \<Longrightarrow> norm (f x :: 'a::real_normed_vector) \<le> norm (f y)" "strict_mono g"
shows "Bseq (\<lambda>x. f (g x)) \<longleftrightarrow> Bseq f"
proof
assume "Bseq (\<lambda>x. f (g x))"
then obtain K where K: "\<And>x. norm (f (g x)) \<le> K"
unfolding Bseq_def by auto
{
fix x :: nat
from filterlim_subseq[OF assms(2)] obtain y where "g y \<ge> x"
by (auto simp: filterlim_at_top eventually_at_top_linorder)
then have "norm (f x) \<le> norm (f (g y))"
using assms(1) by blast
also have "norm (f (g y)) \<le> K" by (rule K)
finally have "norm (f x) \<le> K" .
}
then show "Bseq f" by (rule BseqI')
qed (use Bseq_subseq[of f g] in simp_all)
lemma nonneg_incseq_Bseq_subseq_iff:
fixes f :: "nat \<Rightarrow> real"
and g :: "nat \<Rightarrow> nat"
assumes "\<And>x. f x \<ge> 0" "incseq f" "strict_mono g"
shows "Bseq (\<lambda>x. f (g x)) \<longleftrightarrow> Bseq f"
using assms by (intro increasing_Bseq_subseq_iff) (auto simp: incseq_def)
lemma Bseq_eq_bounded: "range f \<subseteq> {a..b} \<Longrightarrow> Bseq f"
for a b :: real
proof (rule BseqI'[where K="max (norm a) (norm b)"])
fix n assume "range f \<subseteq> {a..b}"
then have "f n \<in> {a..b}"
by blast
then show "norm (f n) \<le> max (norm a) (norm b)"
by auto
qed
lemma incseq_bounded: "incseq X \<Longrightarrow> \<forall>i. X i \<le> B \<Longrightarrow> Bseq X"
for B :: real
by (intro Bseq_eq_bounded[of X "X 0" B]) (auto simp: incseq_def)
lemma decseq_bounded: "decseq X \<Longrightarrow> \<forall>i. B \<le> X i \<Longrightarrow> Bseq X"
for B :: real
by (intro Bseq_eq_bounded[of X B "X 0"]) (auto simp: decseq_def)
subsubsection\<^marker>\<open>tag unimportant\<close> \<open>Polynomal function extremal theorem, from HOL Light\<close>
lemma polyfun_extremal_lemma:
fixes c :: "nat \<Rightarrow> 'a::real_normed_div_algebra"
assumes "0 < e"
shows "\<exists>M. \<forall>z. M \<le> norm(z) \<longrightarrow> norm (\<Sum>i\<le>n. c(i) * z^i) \<le> e * norm(z) ^ (Suc n)"
proof (induct n)
case 0 with assms
show ?case
apply (rule_tac x="norm (c 0) / e" in exI)
apply (auto simp: field_simps)
done
next
case (Suc n)
obtain M where M: "\<And>z. M \<le> norm z \<Longrightarrow> norm (\<Sum>i\<le>n. c i * z^i) \<le> e * norm z ^ Suc n"
using Suc assms by blast
show ?case
proof (rule exI [where x= "max M (1 + norm(c(Suc n)) / e)"], clarsimp simp del: power_Suc)
fix z::'a
assume z1: "M \<le> norm z" and "1 + norm (c (Suc n)) / e \<le> norm z"
then have z2: "e + norm (c (Suc n)) \<le> e * norm z"
using assms by (simp add: field_simps)
have "norm (\<Sum>i\<le>n. c i * z^i) \<le> e * norm z ^ Suc n"
using M [OF z1] by simp
then have "norm (\<Sum>i\<le>n. c i * z^i) + norm (c (Suc n) * z ^ Suc n) \<le> e * norm z ^ Suc n + norm (c (Suc n) * z ^ Suc n)"
by simp
then have "norm ((\<Sum>i\<le>n. c i * z^i) + c (Suc n) * z ^ Suc n) \<le> e * norm z ^ Suc n + norm (c (Suc n) * z ^ Suc n)"
by (blast intro: norm_triangle_le elim: )
also have "... \<le> (e + norm (c (Suc n))) * norm z ^ Suc n"
by (simp add: norm_power norm_mult algebra_simps)
also have "... \<le> (e * norm z) * norm z ^ Suc n"
by (metis z2 mult.commute mult_left_mono norm_ge_zero norm_power)
finally show "norm ((\<Sum>i\<le>n. c i * z^i) + c (Suc n) * z ^ Suc n) \<le> e * norm z ^ Suc (Suc n)"
by simp
qed
qed
lemma polyfun_extremal: (*COMPLEX_POLYFUN_EXTREMAL in HOL Light*)
fixes c :: "nat \<Rightarrow> 'a::real_normed_div_algebra"
assumes k: "c k \<noteq> 0" "1\<le>k" and kn: "k\<le>n"
shows "eventually (\<lambda>z. norm (\<Sum>i\<le>n. c(i) * z^i) \<ge> B) at_infinity"
using kn
proof (induction n)
case 0
then show ?case
using k by simp
next
case (Suc m)
show ?case
proof (cases "c (Suc m) = 0")
case True
then show ?thesis using Suc k
by auto (metis antisym_conv less_eq_Suc_le not_le)
next
case False
then obtain M where M:
"\<And>z. M \<le> norm z \<Longrightarrow> norm (\<Sum>i\<le>m. c i * z^i) \<le> norm (c (Suc m)) / 2 * norm z ^ Suc m"
using polyfun_extremal_lemma [of "norm(c (Suc m)) / 2" c m] Suc
by auto
have "\<exists>b. \<forall>z. b \<le> norm z \<longrightarrow> B \<le> norm (\<Sum>i\<le>Suc m. c i * z^i)"
proof (rule exI [where x="max M (max 1 (\<bar>B\<bar> / (norm(c (Suc m)) / 2)))"], clarsimp simp del: power_Suc)
fix z::'a
assume z1: "M \<le> norm z" "1 \<le> norm z"
and "\<bar>B\<bar> * 2 / norm (c (Suc m)) \<le> norm z"
then have z2: "\<bar>B\<bar> \<le> norm (c (Suc m)) * norm z / 2"
using False by (simp add: field_simps)
have nz: "norm z \<le> norm z ^ Suc m"
by (metis \<open>1 \<le> norm z\<close> One_nat_def less_eq_Suc_le power_increasing power_one_right zero_less_Suc)
have *: "\<And>y x. norm (c (Suc m)) * norm z / 2 \<le> norm y - norm x \<Longrightarrow> B \<le> norm (x + y)"
by (metis abs_le_iff add.commute norm_diff_ineq order_trans z2)
have "norm z * norm (c (Suc m)) + 2 * norm (\<Sum>i\<le>m. c i * z^i)
\<le> norm (c (Suc m)) * norm z + norm (c (Suc m)) * norm z ^ Suc m"
using M [of z] Suc z1 by auto
also have "... \<le> 2 * (norm (c (Suc m)) * norm z ^ Suc m)"
using nz by (simp add: mult_mono del: power_Suc)
finally show "B \<le> norm ((\<Sum>i\<le>m. c i * z^i) + c (Suc m) * z ^ Suc m)"
using Suc.IH
apply (auto simp: eventually_at_infinity)
apply (rule *)
apply (simp add: field_simps norm_mult norm_power)
done
qed
then show ?thesis
by (simp add: eventually_at_infinity)
qed
qed
subsection \<open>Convergence to Zero\<close>
definition Zfun :: "('a \<Rightarrow> 'b::real_normed_vector) \<Rightarrow> 'a filter \<Rightarrow> bool"
where "Zfun f F = (\<forall>r>0. eventually (\<lambda>x. norm (f x) < r) F)"
lemma ZfunI: "(\<And>r. 0 < r \<Longrightarrow> eventually (\<lambda>x. norm (f x) < r) F) \<Longrightarrow> Zfun f F"
by (simp add: Zfun_def)
lemma ZfunD: "Zfun f F \<Longrightarrow> 0 < r \<Longrightarrow> eventually (\<lambda>x. norm (f x) < r) F"
by (simp add: Zfun_def)
lemma Zfun_ssubst: "eventually (\<lambda>x. f x = g x) F \<Longrightarrow> Zfun g F \<Longrightarrow> Zfun f F"
unfolding Zfun_def by (auto elim!: eventually_rev_mp)
lemma Zfun_zero: "Zfun (\<lambda>x. 0) F"
unfolding Zfun_def by simp
lemma Zfun_norm_iff: "Zfun (\<lambda>x. norm (f x)) F = Zfun (\<lambda>x. f x) F"
unfolding Zfun_def by simp
lemma Zfun_imp_Zfun:
assumes f: "Zfun f F"
and g: "eventually (\<lambda>x. norm (g x) \<le> norm (f x) * K) F"
shows "Zfun (\<lambda>x. g x) F"
proof (cases "0 < K")
case K: True
show ?thesis
proof (rule ZfunI)
fix r :: real
assume "0 < r"
then have "0 < r / K" using K by simp
then have "eventually (\<lambda>x. norm (f x) < r / K) F"
using ZfunD [OF f] by blast
with g show "eventually (\<lambda>x. norm (g x) < r) F"
proof eventually_elim
case (elim x)
then have "norm (f x) * K < r"
by (simp add: pos_less_divide_eq K)
then show ?case
by (simp add: order_le_less_trans [OF elim(1)])
qed
qed
next
case False
then have K: "K \<le> 0" by (simp only: not_less)
show ?thesis
proof (rule ZfunI)
fix r :: real
assume "0 < r"
from g show "eventually (\<lambda>x. norm (g x) < r) F"
proof eventually_elim
case (elim x)
also have "norm (f x) * K \<le> norm (f x) * 0"
using K norm_ge_zero by (rule mult_left_mono)
finally show ?case
using \<open>0 < r\<close> by simp
qed
qed
qed
lemma Zfun_le: "Zfun g F \<Longrightarrow> \<forall>x. norm (f x) \<le> norm (g x) \<Longrightarrow> Zfun f F"
by (erule Zfun_imp_Zfun [where K = 1]) simp
lemma Zfun_add:
assumes f: "Zfun f F"
and g: "Zfun g F"
shows "Zfun (\<lambda>x. f x + g x) F"
proof (rule ZfunI)
fix r :: real
assume "0 < r"
then have r: "0 < r / 2" by simp
have "eventually (\<lambda>x. norm (f x) < r/2) F"
using f r by (rule ZfunD)
moreover
have "eventually (\<lambda>x. norm (g x) < r/2) F"
using g r by (rule ZfunD)
ultimately
show "eventually (\<lambda>x. norm (f x + g x) < r) F"
proof eventually_elim
case (elim x)
have "norm (f x + g x) \<le> norm (f x) + norm (g x)"
by (rule norm_triangle_ineq)
also have "\<dots> < r/2 + r/2"
using elim by (rule add_strict_mono)
finally show ?case
by simp
qed
qed
lemma Zfun_minus: "Zfun f F \<Longrightarrow> Zfun (\<lambda>x. - f x) F"
unfolding Zfun_def by simp
lemma Zfun_diff: "Zfun f F \<Longrightarrow> Zfun g F \<Longrightarrow> Zfun (\<lambda>x. f x - g x) F"
using Zfun_add [of f F "\<lambda>x. - g x"] by (simp add: Zfun_minus)
lemma (in bounded_linear) Zfun:
assumes g: "Zfun g F"
shows "Zfun (\<lambda>x. f (g x)) F"
proof -
obtain K where "norm (f x) \<le> norm x * K" for x
using bounded by blast
then have "eventually (\<lambda>x. norm (f (g x)) \<le> norm (g x) * K) F"
by simp
with g show ?thesis
by (rule Zfun_imp_Zfun)
qed
lemma (in bounded_bilinear) Zfun:
assumes f: "Zfun f F"
and g: "Zfun g F"
shows "Zfun (\<lambda>x. f x ** g x) F"
proof (rule ZfunI)
fix r :: real
assume r: "0 < r"
obtain K where K: "0 < K"
and norm_le: "norm (x ** y) \<le> norm x * norm y * K" for x y
using pos_bounded by blast
from K have K': "0 < inverse K"
by (rule positive_imp_inverse_positive)
have "eventually (\<lambda>x. norm (f x) < r) F"
using f r by (rule ZfunD)
moreover
have "eventually (\<lambda>x. norm (g x) < inverse K) F"
using g K' by (rule ZfunD)
ultimately
show "eventually (\<lambda>x. norm (f x ** g x) < r) F"
proof eventually_elim
case (elim x)
have "norm (f x ** g x) \<le> norm (f x) * norm (g x) * K"
by (rule norm_le)
also have "norm (f x) * norm (g x) * K < r * inverse K * K"
by (intro mult_strict_right_mono mult_strict_mono' norm_ge_zero elim K)
also from K have "r * inverse K * K = r"
by simp
finally show ?case .
qed
qed
lemma (in bounded_bilinear) Zfun_left: "Zfun f F \<Longrightarrow> Zfun (\<lambda>x. f x ** a) F"
by (rule bounded_linear_left [THEN bounded_linear.Zfun])
lemma (in bounded_bilinear) Zfun_right: "Zfun f F \<Longrightarrow> Zfun (\<lambda>x. a ** f x) F"
by (rule bounded_linear_right [THEN bounded_linear.Zfun])
lemmas Zfun_mult = bounded_bilinear.Zfun [OF bounded_bilinear_mult]
lemmas Zfun_mult_right = bounded_bilinear.Zfun_right [OF bounded_bilinear_mult]
lemmas Zfun_mult_left = bounded_bilinear.Zfun_left [OF bounded_bilinear_mult]
lemma tendsto_Zfun_iff: "(f \<longlongrightarrow> a) F = Zfun (\<lambda>x. f x - a) F"
by (simp only: tendsto_iff Zfun_def dist_norm)
lemma tendsto_0_le:
"(f \<longlongrightarrow> 0) F \<Longrightarrow> eventually (\<lambda>x. norm (g x) \<le> norm (f x) * K) F \<Longrightarrow> (g \<longlongrightarrow> 0) F"
by (simp add: Zfun_imp_Zfun tendsto_Zfun_iff)
subsubsection \<open>Distance and norms\<close>
lemma tendsto_dist [tendsto_intros]:
fixes l m :: "'a::metric_space"
assumes f: "(f \<longlongrightarrow> l) F"
and g: "(g \<longlongrightarrow> m) F"
shows "((\<lambda>x. dist (f x) (g x)) \<longlongrightarrow> dist l m) F"
proof (rule tendstoI)
fix e :: real
assume "0 < e"
then have e2: "0 < e/2" by simp
from tendstoD [OF f e2] tendstoD [OF g e2]
show "eventually (\<lambda>x. dist (dist (f x) (g x)) (dist l m) < e) F"
proof (eventually_elim)
case (elim x)
then show "dist (dist (f x) (g x)) (dist l m) < e"
unfolding dist_real_def
using dist_triangle2 [of "f x" "g x" "l"]
and dist_triangle2 [of "g x" "l" "m"]
and dist_triangle3 [of "l" "m" "f x"]
and dist_triangle [of "f x" "m" "g x"]
by arith
qed
qed
lemma continuous_dist[continuous_intros]:
fixes f g :: "_ \<Rightarrow> 'a :: metric_space"
shows "continuous F f \<Longrightarrow> continuous F g \<Longrightarrow> continuous F (\<lambda>x. dist (f x) (g x))"
unfolding continuous_def by (rule tendsto_dist)
lemma continuous_on_dist[continuous_intros]:
fixes f g :: "_ \<Rightarrow> 'a :: metric_space"
shows "continuous_on s f \<Longrightarrow> continuous_on s g \<Longrightarrow> continuous_on s (\<lambda>x. dist (f x) (g x))"
unfolding continuous_on_def by (auto intro: tendsto_dist)
lemma continuous_at_dist: "isCont (dist a) b"
using continuous_on_dist [OF continuous_on_const continuous_on_id] continuous_on_eq_continuous_within by blast
lemma tendsto_norm [tendsto_intros]: "(f \<longlongrightarrow> a) F \<Longrightarrow> ((\<lambda>x. norm (f x)) \<longlongrightarrow> norm a) F"
unfolding norm_conv_dist by (intro tendsto_intros)
lemma continuous_norm [continuous_intros]: "continuous F f \<Longrightarrow> continuous F (\<lambda>x. norm (f x))"
unfolding continuous_def by (rule tendsto_norm)
lemma continuous_on_norm [continuous_intros]:
"continuous_on s f \<Longrightarrow> continuous_on s (\<lambda>x. norm (f x))"
unfolding continuous_on_def by (auto intro: tendsto_norm)
lemma continuous_on_norm_id [continuous_intros]: "continuous_on S norm"
by (intro continuous_on_id continuous_on_norm)
lemma tendsto_norm_zero: "(f \<longlongrightarrow> 0) F \<Longrightarrow> ((\<lambda>x. norm (f x)) \<longlongrightarrow> 0) F"
by (drule tendsto_norm) simp
lemma tendsto_norm_zero_cancel: "((\<lambda>x. norm (f x)) \<longlongrightarrow> 0) F \<Longrightarrow> (f \<longlongrightarrow> 0) F"
unfolding tendsto_iff dist_norm by simp
lemma tendsto_norm_zero_iff: "((\<lambda>x. norm (f x)) \<longlongrightarrow> 0) F \<longleftrightarrow> (f \<longlongrightarrow> 0) F"
unfolding tendsto_iff dist_norm by simp
lemma tendsto_rabs [tendsto_intros]: "(f \<longlongrightarrow> l) F \<Longrightarrow> ((\<lambda>x. \<bar>f x\<bar>) \<longlongrightarrow> \<bar>l\<bar>) F"
for l :: real
by (fold real_norm_def) (rule tendsto_norm)
lemma continuous_rabs [continuous_intros]:
"continuous F f \<Longrightarrow> continuous F (\<lambda>x. \<bar>f x :: real\<bar>)"
unfolding real_norm_def[symmetric] by (rule continuous_norm)
lemma continuous_on_rabs [continuous_intros]:
"continuous_on s f \<Longrightarrow> continuous_on s (\<lambda>x. \<bar>f x :: real\<bar>)"
unfolding real_norm_def[symmetric] by (rule continuous_on_norm)
lemma tendsto_rabs_zero: "(f \<longlongrightarrow> (0::real)) F \<Longrightarrow> ((\<lambda>x. \<bar>f x\<bar>) \<longlongrightarrow> 0) F"
by (fold real_norm_def) (rule tendsto_norm_zero)
lemma tendsto_rabs_zero_cancel: "((\<lambda>x. \<bar>f x\<bar>) \<longlongrightarrow> (0::real)) F \<Longrightarrow> (f \<longlongrightarrow> 0) F"
by (fold real_norm_def) (rule tendsto_norm_zero_cancel)
lemma tendsto_rabs_zero_iff: "((\<lambda>x. \<bar>f x\<bar>) \<longlongrightarrow> (0::real)) F \<longleftrightarrow> (f \<longlongrightarrow> 0) F"
by (fold real_norm_def) (rule tendsto_norm_zero_iff)
subsection \<open>Topological Monoid\<close>
class topological_monoid_add = topological_space + monoid_add +
assumes tendsto_add_Pair: "LIM x (nhds a \<times>\<^sub>F nhds b). fst x + snd x :> nhds (a + b)"
class topological_comm_monoid_add = topological_monoid_add + comm_monoid_add
lemma tendsto_add [tendsto_intros]:
fixes a b :: "'a::topological_monoid_add"
shows "(f \<longlongrightarrow> a) F \<Longrightarrow> (g \<longlongrightarrow> b) F \<Longrightarrow> ((\<lambda>x. f x + g x) \<longlongrightarrow> a + b) F"
using filterlim_compose[OF tendsto_add_Pair, of "\<lambda>x. (f x, g x)" a b F]
by (simp add: nhds_prod[symmetric] tendsto_Pair)
lemma continuous_add [continuous_intros]:
fixes f g :: "_ \<Rightarrow> 'b::topological_monoid_add"
shows "continuous F f \<Longrightarrow> continuous F g \<Longrightarrow> continuous F (\<lambda>x. f x + g x)"
unfolding continuous_def by (rule tendsto_add)
lemma continuous_on_add [continuous_intros]:
fixes f g :: "_ \<Rightarrow> 'b::topological_monoid_add"
shows "continuous_on s f \<Longrightarrow> continuous_on s g \<Longrightarrow> continuous_on s (\<lambda>x. f x + g x)"
unfolding continuous_on_def by (auto intro: tendsto_add)
lemma tendsto_add_zero:
fixes f g :: "_ \<Rightarrow> 'b::topological_monoid_add"
shows "(f \<longlongrightarrow> 0) F \<Longrightarrow> (g \<longlongrightarrow> 0) F \<Longrightarrow> ((\<lambda>x. f x + g x) \<longlongrightarrow> 0) F"
by (drule (1) tendsto_add) simp
lemma tendsto_sum [tendsto_intros]:
fixes f :: "'a \<Rightarrow> 'b \<Rightarrow> 'c::topological_comm_monoid_add"
shows "(\<And>i. i \<in> I \<Longrightarrow> (f i \<longlongrightarrow> a i) F) \<Longrightarrow> ((\<lambda>x. \<Sum>i\<in>I. f i x) \<longlongrightarrow> (\<Sum>i\<in>I. a i)) F"
by (induct I rule: infinite_finite_induct) (simp_all add: tendsto_add)
lemma tendsto_null_sum:
fixes f :: "'a \<Rightarrow> 'b \<Rightarrow> 'c::topological_comm_monoid_add"
assumes "\<And>i. i \<in> I \<Longrightarrow> ((\<lambda>x. f x i) \<longlongrightarrow> 0) F"
shows "((\<lambda>i. sum (f i) I) \<longlongrightarrow> 0) F"
using tendsto_sum [of I "\<lambda>x y. f y x" "\<lambda>x. 0"] assms by simp
lemma continuous_sum [continuous_intros]:
fixes f :: "'a \<Rightarrow> 'b::t2_space \<Rightarrow> 'c::topological_comm_monoid_add"
shows "(\<And>i. i \<in> I \<Longrightarrow> continuous F (f i)) \<Longrightarrow> continuous F (\<lambda>x. \<Sum>i\<in>I. f i x)"
unfolding continuous_def by (rule tendsto_sum)
lemma continuous_on_sum [continuous_intros]:
fixes f :: "'a \<Rightarrow> 'b::topological_space \<Rightarrow> 'c::topological_comm_monoid_add"
shows "(\<And>i. i \<in> I \<Longrightarrow> continuous_on S (f i)) \<Longrightarrow> continuous_on S (\<lambda>x. \<Sum>i\<in>I. f i x)"
unfolding continuous_on_def by (auto intro: tendsto_sum)
instance nat :: topological_comm_monoid_add
by standard
(simp add: nhds_discrete principal_prod_principal filterlim_principal eventually_principal)
instance int :: topological_comm_monoid_add
by standard
(simp add: nhds_discrete principal_prod_principal filterlim_principal eventually_principal)
subsubsection \<open>Topological group\<close>
class topological_group_add = topological_monoid_add + group_add +
assumes tendsto_uminus_nhds: "(uminus \<longlongrightarrow> - a) (nhds a)"
begin
lemma tendsto_minus [tendsto_intros]: "(f \<longlongrightarrow> a) F \<Longrightarrow> ((\<lambda>x. - f x) \<longlongrightarrow> - a) F"
by (rule filterlim_compose[OF tendsto_uminus_nhds])
end
class topological_ab_group_add = topological_group_add + ab_group_add
instance topological_ab_group_add < topological_comm_monoid_add ..
lemma continuous_minus [continuous_intros]: "continuous F f \<Longrightarrow> continuous F (\<lambda>x. - f x)"
for f :: "'a::t2_space \<Rightarrow> 'b::topological_group_add"
unfolding continuous_def by (rule tendsto_minus)
lemma continuous_on_minus [continuous_intros]: "continuous_on s f \<Longrightarrow> continuous_on s (\<lambda>x. - f x)"
for f :: "_ \<Rightarrow> 'b::topological_group_add"
unfolding continuous_on_def by (auto intro: tendsto_minus)
lemma tendsto_minus_cancel: "((\<lambda>x. - f x) \<longlongrightarrow> - a) F \<Longrightarrow> (f \<longlongrightarrow> a) F"
for a :: "'a::topological_group_add"
by (drule tendsto_minus) simp
lemma tendsto_minus_cancel_left:
"(f \<longlongrightarrow> - (y::_::topological_group_add)) F \<longleftrightarrow> ((\<lambda>x. - f x) \<longlongrightarrow> y) F"
using tendsto_minus_cancel[of f "- y" F] tendsto_minus[of f "- y" F]
by auto
lemma tendsto_diff [tendsto_intros]:
fixes a b :: "'a::topological_group_add"
shows "(f \<longlongrightarrow> a) F \<Longrightarrow> (g \<longlongrightarrow> b) F \<Longrightarrow> ((\<lambda>x. f x - g x) \<longlongrightarrow> a - b) F"
using tendsto_add [of f a F "\<lambda>x. - g x" "- b"] by (simp add: tendsto_minus)
lemma continuous_diff [continuous_intros]:
fixes f g :: "'a::t2_space \<Rightarrow> 'b::topological_group_add"
shows "continuous F f \<Longrightarrow> continuous F g \<Longrightarrow> continuous F (\<lambda>x. f x - g x)"
unfolding continuous_def by (rule tendsto_diff)
lemma continuous_on_diff [continuous_intros]:
fixes f g :: "_ \<Rightarrow> 'b::topological_group_add"
shows "continuous_on s f \<Longrightarrow> continuous_on s g \<Longrightarrow> continuous_on s (\<lambda>x. f x - g x)"
unfolding continuous_on_def by (auto intro: tendsto_diff)
lemma continuous_on_op_minus: "continuous_on (s::'a::topological_group_add set) ((-) x)"
by (rule continuous_intros | simp)+
instance real_normed_vector < topological_ab_group_add
proof
fix a b :: 'a
show "((\<lambda>x. fst x + snd x) \<longlongrightarrow> a + b) (nhds a \<times>\<^sub>F nhds b)"
unfolding tendsto_Zfun_iff add_diff_add
using tendsto_fst[OF filterlim_ident, of "(a,b)"] tendsto_snd[OF filterlim_ident, of "(a,b)"]
by (intro Zfun_add)
(auto simp: tendsto_Zfun_iff[symmetric] nhds_prod[symmetric] intro!: tendsto_fst)
show "(uminus \<longlongrightarrow> - a) (nhds a)"
unfolding tendsto_Zfun_iff minus_diff_minus
using filterlim_ident[of "nhds a"]
by (intro Zfun_minus) (simp add: tendsto_Zfun_iff)
qed
lemmas real_tendsto_sandwich = tendsto_sandwich[where 'a=real]
subsubsection \<open>Linear operators and multiplication\<close>
lemma linear_times [simp]: "linear (\<lambda>x. c * x)"
for c :: "'a::real_algebra"
by (auto simp: linearI distrib_left)
lemma (in bounded_linear) tendsto: "(g \<longlongrightarrow> a) F \<Longrightarrow> ((\<lambda>x. f (g x)) \<longlongrightarrow> f a) F"
by (simp only: tendsto_Zfun_iff diff [symmetric] Zfun)
lemma (in bounded_linear) continuous: "continuous F g \<Longrightarrow> continuous F (\<lambda>x. f (g x))"
using tendsto[of g _ F] by (auto simp: continuous_def)
lemma (in bounded_linear) continuous_on: "continuous_on s g \<Longrightarrow> continuous_on s (\<lambda>x. f (g x))"
using tendsto[of g] by (auto simp: continuous_on_def)
lemma (in bounded_linear) tendsto_zero: "(g \<longlongrightarrow> 0) F \<Longrightarrow> ((\<lambda>x. f (g x)) \<longlongrightarrow> 0) F"
by (drule tendsto) (simp only: zero)
lemma (in bounded_bilinear) tendsto:
"(f \<longlongrightarrow> a) F \<Longrightarrow> (g \<longlongrightarrow> b) F \<Longrightarrow> ((\<lambda>x. f x ** g x) \<longlongrightarrow> a ** b) F"
by (simp only: tendsto_Zfun_iff prod_diff_prod Zfun_add Zfun Zfun_left Zfun_right)
lemma (in bounded_bilinear) continuous:
"continuous F f \<Longrightarrow> continuous F g \<Longrightarrow> continuous F (\<lambda>x. f x ** g x)"
using tendsto[of f _ F g] by (auto simp: continuous_def)
lemma (in bounded_bilinear) continuous_on:
"continuous_on s f \<Longrightarrow> continuous_on s g \<Longrightarrow> continuous_on s (\<lambda>x. f x ** g x)"
using tendsto[of f _ _ g] by (auto simp: continuous_on_def)
lemma (in bounded_bilinear) tendsto_zero:
assumes f: "(f \<longlongrightarrow> 0) F"
and g: "(g \<longlongrightarrow> 0) F"
shows "((\<lambda>x. f x ** g x) \<longlongrightarrow> 0) F"
using tendsto [OF f g] by (simp add: zero_left)
lemma (in bounded_bilinear) tendsto_left_zero:
"(f \<longlongrightarrow> 0) F \<Longrightarrow> ((\<lambda>x. f x ** c) \<longlongrightarrow> 0) F"
by (rule bounded_linear.tendsto_zero [OF bounded_linear_left])
lemma (in bounded_bilinear) tendsto_right_zero:
"(f \<longlongrightarrow> 0) F \<Longrightarrow> ((\<lambda>x. c ** f x) \<longlongrightarrow> 0) F"
by (rule bounded_linear.tendsto_zero [OF bounded_linear_right])
lemmas tendsto_of_real [tendsto_intros] =
bounded_linear.tendsto [OF bounded_linear_of_real]
lemmas tendsto_scaleR [tendsto_intros] =
bounded_bilinear.tendsto [OF bounded_bilinear_scaleR]
text\<open>Analogous type class for multiplication\<close>
class topological_semigroup_mult = topological_space + semigroup_mult +
assumes tendsto_mult_Pair: "LIM x (nhds a \<times>\<^sub>F nhds b). fst x * snd x :> nhds (a * b)"
instance real_normed_algebra < topological_semigroup_mult
proof
fix a b :: 'a
show "((\<lambda>x. fst x * snd x) \<longlongrightarrow> a * b) (nhds a \<times>\<^sub>F nhds b)"
unfolding nhds_prod[symmetric]
using tendsto_fst[OF filterlim_ident, of "(a,b)"] tendsto_snd[OF filterlim_ident, of "(a,b)"]
by (simp add: bounded_bilinear.tendsto [OF bounded_bilinear_mult])
qed
lemma tendsto_mult [tendsto_intros]:
fixes a b :: "'a::topological_semigroup_mult"
shows "(f \<longlongrightarrow> a) F \<Longrightarrow> (g \<longlongrightarrow> b) F \<Longrightarrow> ((\<lambda>x. f x * g x) \<longlongrightarrow> a * b) F"
using filterlim_compose[OF tendsto_mult_Pair, of "\<lambda>x. (f x, g x)" a b F]
by (simp add: nhds_prod[symmetric] tendsto_Pair)
lemma tendsto_mult_left: "(f \<longlongrightarrow> l) F \<Longrightarrow> ((\<lambda>x. c * (f x)) \<longlongrightarrow> c * l) F"
for c :: "'a::topological_semigroup_mult"
by (rule tendsto_mult [OF tendsto_const])
lemma tendsto_mult_right: "(f \<longlongrightarrow> l) F \<Longrightarrow> ((\<lambda>x. (f x) * c) \<longlongrightarrow> l * c) F"
for c :: "'a::topological_semigroup_mult"
by (rule tendsto_mult [OF _ tendsto_const])
lemma tendsto_mult_left_iff [simp]:
"c \<noteq> 0 \<Longrightarrow> tendsto(\<lambda>x. c * f x) (c * l) F \<longleftrightarrow> tendsto f l F" for c :: "'a::{topological_semigroup_mult,field}"
by (auto simp: tendsto_mult_left dest: tendsto_mult_left [where c = "1/c"])
lemma tendsto_mult_right_iff [simp]:
"c \<noteq> 0 \<Longrightarrow> tendsto(\<lambda>x. f x * c) (l * c) F \<longleftrightarrow> tendsto f l F" for c :: "'a::{topological_semigroup_mult,field}"
by (auto simp: tendsto_mult_right dest: tendsto_mult_left [where c = "1/c"])
lemma tendsto_zero_mult_left_iff [simp]:
fixes c::"'a::{topological_semigroup_mult,field}" assumes "c \<noteq> 0" shows "(\<lambda>n. c * a n)\<longlonglongrightarrow> 0 \<longleftrightarrow> a \<longlonglongrightarrow> 0"
using assms tendsto_mult_left tendsto_mult_left_iff by fastforce
lemma tendsto_zero_mult_right_iff [simp]:
fixes c::"'a::{topological_semigroup_mult,field}" assumes "c \<noteq> 0" shows "(\<lambda>n. a n * c)\<longlonglongrightarrow> 0 \<longleftrightarrow> a \<longlonglongrightarrow> 0"
using assms tendsto_mult_right tendsto_mult_right_iff by fastforce
lemma tendsto_zero_divide_iff [simp]:
fixes c::"'a::{topological_semigroup_mult,field}" assumes "c \<noteq> 0" shows "(\<lambda>n. a n / c)\<longlonglongrightarrow> 0 \<longleftrightarrow> a \<longlonglongrightarrow> 0"
using tendsto_zero_mult_right_iff [of "1/c" a] assms by (simp add: field_simps)
lemma lim_const_over_n [tendsto_intros]:
fixes a :: "'a::real_normed_field"
shows "(\<lambda>n. a / of_nat n) \<longlonglongrightarrow> 0"
using tendsto_mult [OF tendsto_const [of a] lim_1_over_n] by simp
lemmas continuous_of_real [continuous_intros] =
bounded_linear.continuous [OF bounded_linear_of_real]
lemmas continuous_scaleR [continuous_intros] =
bounded_bilinear.continuous [OF bounded_bilinear_scaleR]
lemmas continuous_mult [continuous_intros] =
bounded_bilinear.continuous [OF bounded_bilinear_mult]
lemmas continuous_on_of_real [continuous_intros] =
bounded_linear.continuous_on [OF bounded_linear_of_real]
lemmas continuous_on_scaleR [continuous_intros] =
bounded_bilinear.continuous_on [OF bounded_bilinear_scaleR]
lemmas continuous_on_mult [continuous_intros] =
bounded_bilinear.continuous_on [OF bounded_bilinear_mult]
lemmas tendsto_mult_zero =
bounded_bilinear.tendsto_zero [OF bounded_bilinear_mult]
lemmas tendsto_mult_left_zero =
bounded_bilinear.tendsto_left_zero [OF bounded_bilinear_mult]
lemmas tendsto_mult_right_zero =
bounded_bilinear.tendsto_right_zero [OF bounded_bilinear_mult]
lemma continuous_mult_left:
fixes c::"'a::real_normed_algebra"
shows "continuous F f \<Longrightarrow> continuous F (\<lambda>x. c * f x)"
by (rule continuous_mult [OF continuous_const])
lemma continuous_mult_right:
fixes c::"'a::real_normed_algebra"
shows "continuous F f \<Longrightarrow> continuous F (\<lambda>x. f x * c)"
by (rule continuous_mult [OF _ continuous_const])
lemma continuous_on_mult_left:
fixes c::"'a::real_normed_algebra"
shows "continuous_on s f \<Longrightarrow> continuous_on s (\<lambda>x. c * f x)"
by (rule continuous_on_mult [OF continuous_on_const])
lemma continuous_on_mult_right:
fixes c::"'a::real_normed_algebra"
shows "continuous_on s f \<Longrightarrow> continuous_on s (\<lambda>x. f x * c)"
by (rule continuous_on_mult [OF _ continuous_on_const])
lemma continuous_on_mult_const [simp]:
fixes c::"'a::real_normed_algebra"
shows "continuous_on s ((*) c)"
by (intro continuous_on_mult_left continuous_on_id)
lemma tendsto_divide_zero:
fixes c :: "'a::real_normed_field"
shows "(f \<longlongrightarrow> 0) F \<Longrightarrow> ((\<lambda>x. f x / c) \<longlongrightarrow> 0) F"
by (cases "c=0") (simp_all add: divide_inverse tendsto_mult_left_zero)
lemma tendsto_power [tendsto_intros]: "(f \<longlongrightarrow> a) F \<Longrightarrow> ((\<lambda>x. f x ^ n) \<longlongrightarrow> a ^ n) F"
for f :: "'a \<Rightarrow> 'b::{power,real_normed_algebra}"
by (induct n) (simp_all add: tendsto_mult)
lemma tendsto_null_power: "\<lbrakk>(f \<longlongrightarrow> 0) F; 0 < n\<rbrakk> \<Longrightarrow> ((\<lambda>x. f x ^ n) \<longlongrightarrow> 0) F"
for f :: "'a \<Rightarrow> 'b::{power,real_normed_algebra_1}"
using tendsto_power [of f 0 F n] by (simp add: power_0_left)
lemma continuous_power [continuous_intros]: "continuous F f \<Longrightarrow> continuous F (\<lambda>x. (f x)^n)"
for f :: "'a::t2_space \<Rightarrow> 'b::{power,real_normed_algebra}"
unfolding continuous_def by (rule tendsto_power)
lemma continuous_on_power [continuous_intros]:
fixes f :: "_ \<Rightarrow> 'b::{power,real_normed_algebra}"
shows "continuous_on s f \<Longrightarrow> continuous_on s (\<lambda>x. (f x)^n)"
unfolding continuous_on_def by (auto intro: tendsto_power)
lemma tendsto_prod [tendsto_intros]:
fixes f :: "'a \<Rightarrow> 'b \<Rightarrow> 'c::{real_normed_algebra,comm_ring_1}"
shows "(\<And>i. i \<in> S \<Longrightarrow> (f i \<longlongrightarrow> L i) F) \<Longrightarrow> ((\<lambda>x. \<Prod>i\<in>S. f i x) \<longlongrightarrow> (\<Prod>i\<in>S. L i)) F"
by (induct S rule: infinite_finite_induct) (simp_all add: tendsto_mult)
lemma continuous_prod [continuous_intros]:
fixes f :: "'a \<Rightarrow> 'b::t2_space \<Rightarrow> 'c::{real_normed_algebra,comm_ring_1}"
shows "(\<And>i. i \<in> S \<Longrightarrow> continuous F (f i)) \<Longrightarrow> continuous F (\<lambda>x. \<Prod>i\<in>S. f i x)"
unfolding continuous_def by (rule tendsto_prod)
lemma continuous_on_prod [continuous_intros]:
fixes f :: "'a \<Rightarrow> _ \<Rightarrow> 'c::{real_normed_algebra,comm_ring_1}"
shows "(\<And>i. i \<in> S \<Longrightarrow> continuous_on s (f i)) \<Longrightarrow> continuous_on s (\<lambda>x. \<Prod>i\<in>S. f i x)"
unfolding continuous_on_def by (auto intro: tendsto_prod)
lemma tendsto_of_real_iff:
"((\<lambda>x. of_real (f x) :: 'a::real_normed_div_algebra) \<longlongrightarrow> of_real c) F \<longleftrightarrow> (f \<longlongrightarrow> c) F"
unfolding tendsto_iff by simp
lemma tendsto_add_const_iff:
"((\<lambda>x. c + f x :: 'a::topological_group_add) \<longlongrightarrow> c + d) F \<longleftrightarrow> (f \<longlongrightarrow> d) F"
using tendsto_add[OF tendsto_const[of c], of f d]
and tendsto_add[OF tendsto_const[of "-c"], of "\<lambda>x. c + f x" "c + d"] by auto
class topological_monoid_mult = topological_semigroup_mult + monoid_mult
class topological_comm_monoid_mult = topological_monoid_mult + comm_monoid_mult
lemma tendsto_power_strong [tendsto_intros]:
fixes f :: "_ \<Rightarrow> 'b :: topological_monoid_mult"
assumes "(f \<longlongrightarrow> a) F" "(g \<longlongrightarrow> b) F"
shows "((\<lambda>x. f x ^ g x) \<longlongrightarrow> a ^ b) F"
proof -
have "((\<lambda>x. f x ^ b) \<longlongrightarrow> a ^ b) F"
by (induction b) (auto intro: tendsto_intros assms)
also from assms(2) have "eventually (\<lambda>x. g x = b) F"
by (simp add: nhds_discrete filterlim_principal)
hence "eventually (\<lambda>x. f x ^ b = f x ^ g x) F"
by eventually_elim simp
hence "((\<lambda>x. f x ^ b) \<longlongrightarrow> a ^ b) F \<longleftrightarrow> ((\<lambda>x. f x ^ g x) \<longlongrightarrow> a ^ b) F"
by (intro filterlim_cong refl)
finally show ?thesis .
qed
lemma continuous_mult' [continuous_intros]:
fixes f g :: "_ \<Rightarrow> 'b::topological_semigroup_mult"
shows "continuous F f \<Longrightarrow> continuous F g \<Longrightarrow> continuous F (\<lambda>x. f x * g x)"
unfolding continuous_def by (rule tendsto_mult)
lemma continuous_power' [continuous_intros]:
fixes f :: "_ \<Rightarrow> 'b::topological_monoid_mult"
shows "continuous F f \<Longrightarrow> continuous F g \<Longrightarrow> continuous F (\<lambda>x. f x ^ g x)"
unfolding continuous_def by (rule tendsto_power_strong) auto
lemma continuous_on_mult' [continuous_intros]:
fixes f g :: "_ \<Rightarrow> 'b::topological_semigroup_mult"
shows "continuous_on A f \<Longrightarrow> continuous_on A g \<Longrightarrow> continuous_on A (\<lambda>x. f x * g x)"
unfolding continuous_on_def by (auto intro: tendsto_mult)
lemma continuous_on_power' [continuous_intros]:
fixes f :: "_ \<Rightarrow> 'b::topological_monoid_mult"
shows "continuous_on A f \<Longrightarrow> continuous_on A g \<Longrightarrow> continuous_on A (\<lambda>x. f x ^ g x)"
unfolding continuous_on_def by (auto intro: tendsto_power_strong)
lemma tendsto_mult_one:
fixes f g :: "_ \<Rightarrow> 'b::topological_monoid_mult"
shows "(f \<longlongrightarrow> 1) F \<Longrightarrow> (g \<longlongrightarrow> 1) F \<Longrightarrow> ((\<lambda>x. f x * g x) \<longlongrightarrow> 1) F"
by (drule (1) tendsto_mult) simp
lemma tendsto_prod' [tendsto_intros]:
fixes f :: "'a \<Rightarrow> 'b \<Rightarrow> 'c::topological_comm_monoid_mult"
shows "(\<And>i. i \<in> I \<Longrightarrow> (f i \<longlongrightarrow> a i) F) \<Longrightarrow> ((\<lambda>x. \<Prod>i\<in>I. f i x) \<longlongrightarrow> (\<Prod>i\<in>I. a i)) F"
by (induct I rule: infinite_finite_induct) (simp_all add: tendsto_mult)
lemma tendsto_one_prod':
fixes f :: "'a \<Rightarrow> 'b \<Rightarrow> 'c::topological_comm_monoid_mult"
assumes "\<And>i. i \<in> I \<Longrightarrow> ((\<lambda>x. f x i) \<longlongrightarrow> 1) F"
shows "((\<lambda>i. prod (f i) I) \<longlongrightarrow> 1) F"
using tendsto_prod' [of I "\<lambda>x y. f y x" "\<lambda>x. 1"] assms by simp
lemma continuous_prod' [continuous_intros]:
fixes f :: "'a \<Rightarrow> 'b::t2_space \<Rightarrow> 'c::topological_comm_monoid_mult"
shows "(\<And>i. i \<in> I \<Longrightarrow> continuous F (f i)) \<Longrightarrow> continuous F (\<lambda>x. \<Prod>i\<in>I. f i x)"
unfolding continuous_def by (rule tendsto_prod')
lemma continuous_on_prod' [continuous_intros]:
fixes f :: "'a \<Rightarrow> 'b::topological_space \<Rightarrow> 'c::topological_comm_monoid_mult"
shows "(\<And>i. i \<in> I \<Longrightarrow> continuous_on S (f i)) \<Longrightarrow> continuous_on S (\<lambda>x. \<Prod>i\<in>I. f i x)"
unfolding continuous_on_def by (auto intro: tendsto_prod')
instance nat :: topological_comm_monoid_mult
by standard
(simp add: nhds_discrete principal_prod_principal filterlim_principal eventually_principal)
instance int :: topological_comm_monoid_mult
by standard
(simp add: nhds_discrete principal_prod_principal filterlim_principal eventually_principal)
class comm_real_normed_algebra_1 = real_normed_algebra_1 + comm_monoid_mult
context real_normed_field
begin
subclass comm_real_normed_algebra_1
proof
from norm_mult[of "1 :: 'a" 1] show "norm 1 = 1" by simp
qed (simp_all add: norm_mult)
end
subsubsection \<open>Inverse and division\<close>
lemma (in bounded_bilinear) Zfun_prod_Bfun:
assumes f: "Zfun f F"
and g: "Bfun g F"
shows "Zfun (\<lambda>x. f x ** g x) F"
proof -
obtain K where K: "0 \<le> K"
and norm_le: "\<And>x y. norm (x ** y) \<le> norm x * norm y * K"
using nonneg_bounded by blast
obtain B where B: "0 < B"
and norm_g: "eventually (\<lambda>x. norm (g x) \<le> B) F"
using g by (rule BfunE)
have "eventually (\<lambda>x. norm (f x ** g x) \<le> norm (f x) * (B * K)) F"
using norm_g proof eventually_elim
case (elim x)
have "norm (f x ** g x) \<le> norm (f x) * norm (g x) * K"
by (rule norm_le)
also have "\<dots> \<le> norm (f x) * B * K"
by (intro mult_mono' order_refl norm_g norm_ge_zero mult_nonneg_nonneg K elim)
also have "\<dots> = norm (f x) * (B * K)"
by (rule mult.assoc)
finally show "norm (f x ** g x) \<le> norm (f x) * (B * K)" .
qed
with f show ?thesis
by (rule Zfun_imp_Zfun)
qed
lemma (in bounded_bilinear) Bfun_prod_Zfun:
assumes f: "Bfun f F"
and g: "Zfun g F"
shows "Zfun (\<lambda>x. f x ** g x) F"
using flip g f by (rule bounded_bilinear.Zfun_prod_Bfun)
lemma Bfun_inverse:
fixes a :: "'a::real_normed_div_algebra"
assumes f: "(f \<longlongrightarrow> a) F"
assumes a: "a \<noteq> 0"
shows "Bfun (\<lambda>x. inverse (f x)) F"
proof -
from a have "0 < norm a" by simp
then have "\<exists>r>0. r < norm a" by (rule dense)
then obtain r where r1: "0 < r" and r2: "r < norm a"
by blast
have "eventually (\<lambda>x. dist (f x) a < r) F"
using tendstoD [OF f r1] by blast
then have "eventually (\<lambda>x. norm (inverse (f x)) \<le> inverse (norm a - r)) F"
proof eventually_elim
case (elim x)
then have 1: "norm (f x - a) < r"
by (simp add: dist_norm)
then have 2: "f x \<noteq> 0" using r2 by auto
then have "norm (inverse (f x)) = inverse (norm (f x))"
by (rule nonzero_norm_inverse)
also have "\<dots> \<le> inverse (norm a - r)"
proof (rule le_imp_inverse_le)
show "0 < norm a - r"
using r2 by simp
have "norm a - norm (f x) \<le> norm (a - f x)"
by (rule norm_triangle_ineq2)
also have "\<dots> = norm (f x - a)"
by (rule norm_minus_commute)
also have "\<dots> < r" using 1 .
finally show "norm a - r \<le> norm (f x)"
by simp
qed
finally show "norm (inverse (f x)) \<le> inverse (norm a - r)" .
qed
then show ?thesis by (rule BfunI)
qed
lemma tendsto_inverse [tendsto_intros]:
fixes a :: "'a::real_normed_div_algebra"
assumes f: "(f \<longlongrightarrow> a) F"
and a: "a \<noteq> 0"
shows "((\<lambda>x. inverse (f x)) \<longlongrightarrow> inverse a) F"
proof -
from a have "0 < norm a" by simp
with f have "eventually (\<lambda>x. dist (f x) a < norm a) F"
by (rule tendstoD)
then have "eventually (\<lambda>x. f x \<noteq> 0) F"
unfolding dist_norm by (auto elim!: eventually_mono)
with a have "eventually (\<lambda>x. inverse (f x) - inverse a =
- (inverse (f x) * (f x - a) * inverse a)) F"
by (auto elim!: eventually_mono simp: inverse_diff_inverse)
moreover have "Zfun (\<lambda>x. - (inverse (f x) * (f x - a) * inverse a)) F"
by (intro Zfun_minus Zfun_mult_left
bounded_bilinear.Bfun_prod_Zfun [OF bounded_bilinear_mult]
Bfun_inverse [OF f a] f [unfolded tendsto_Zfun_iff])
ultimately show ?thesis
unfolding tendsto_Zfun_iff by (rule Zfun_ssubst)
qed
lemma continuous_inverse:
fixes f :: "'a::t2_space \<Rightarrow> 'b::real_normed_div_algebra"
assumes "continuous F f"
and "f (Lim F (\<lambda>x. x)) \<noteq> 0"
shows "continuous F (\<lambda>x. inverse (f x))"
using assms unfolding continuous_def by (rule tendsto_inverse)
lemma continuous_at_within_inverse[continuous_intros]:
fixes f :: "'a::t2_space \<Rightarrow> 'b::real_normed_div_algebra"
assumes "continuous (at a within s) f"
and "f a \<noteq> 0"
shows "continuous (at a within s) (\<lambda>x. inverse (f x))"
using assms unfolding continuous_within by (rule tendsto_inverse)
lemma continuous_on_inverse[continuous_intros]:
fixes f :: "'a::topological_space \<Rightarrow> 'b::real_normed_div_algebra"
assumes "continuous_on s f"
and "\<forall>x\<in>s. f x \<noteq> 0"
shows "continuous_on s (\<lambda>x. inverse (f x))"
using assms unfolding continuous_on_def by (blast intro: tendsto_inverse)
lemma tendsto_divide [tendsto_intros]:
fixes a b :: "'a::real_normed_field"
shows "(f \<longlongrightarrow> a) F \<Longrightarrow> (g \<longlongrightarrow> b) F \<Longrightarrow> b \<noteq> 0 \<Longrightarrow> ((\<lambda>x. f x / g x) \<longlongrightarrow> a / b) F"
by (simp add: tendsto_mult tendsto_inverse divide_inverse)
lemma continuous_divide:
fixes f g :: "'a::t2_space \<Rightarrow> 'b::real_normed_field"
assumes "continuous F f"
and "continuous F g"
and "g (Lim F (\<lambda>x. x)) \<noteq> 0"
shows "continuous F (\<lambda>x. (f x) / (g x))"
using assms unfolding continuous_def by (rule tendsto_divide)
lemma continuous_at_within_divide[continuous_intros]:
fixes f g :: "'a::t2_space \<Rightarrow> 'b::real_normed_field"
assumes "continuous (at a within s) f" "continuous (at a within s) g"
and "g a \<noteq> 0"
shows "continuous (at a within s) (\<lambda>x. (f x) / (g x))"
using assms unfolding continuous_within by (rule tendsto_divide)
lemma isCont_divide[continuous_intros, simp]:
fixes f g :: "'a::t2_space \<Rightarrow> 'b::real_normed_field"
assumes "isCont f a" "isCont g a" "g a \<noteq> 0"
shows "isCont (\<lambda>x. (f x) / g x) a"
using assms unfolding continuous_at by (rule tendsto_divide)
lemma continuous_on_divide[continuous_intros]:
fixes f :: "'a::topological_space \<Rightarrow> 'b::real_normed_field"
assumes "continuous_on s f" "continuous_on s g"
and "\<forall>x\<in>s. g x \<noteq> 0"
shows "continuous_on s (\<lambda>x. (f x) / (g x))"
using assms unfolding continuous_on_def by (blast intro: tendsto_divide)
lemma tendsto_power_int [tendsto_intros]:
fixes a :: "'a::real_normed_div_algebra"
assumes f: "(f \<longlongrightarrow> a) F"
and a: "a \<noteq> 0"
shows "((\<lambda>x. power_int (f x) n) \<longlongrightarrow> power_int a n) F"
using assms by (cases n rule: int_cases4) (auto intro!: tendsto_intros simp: power_int_minus)
lemma continuous_power_int:
fixes f :: "'a::t2_space \<Rightarrow> 'b::real_normed_div_algebra"
assumes "continuous F f"
and "f (Lim F (\<lambda>x. x)) \<noteq> 0"
shows "continuous F (\<lambda>x. power_int (f x) n)"
using assms unfolding continuous_def by (rule tendsto_power_int)
lemma continuous_at_within_power_int[continuous_intros]:
fixes f :: "'a::t2_space \<Rightarrow> 'b::real_normed_div_algebra"
assumes "continuous (at a within s) f"
and "f a \<noteq> 0"
shows "continuous (at a within s) (\<lambda>x. power_int (f x) n)"
using assms unfolding continuous_within by (rule tendsto_power_int)
lemma continuous_on_power_int [continuous_intros]:
fixes f :: "'a::topological_space \<Rightarrow> 'b::real_normed_div_algebra"
assumes "continuous_on s f" and "\<forall>x\<in>s. f x \<noteq> 0"
shows "continuous_on s (\<lambda>x. power_int (f x) n)"
using assms unfolding continuous_on_def by (blast intro: tendsto_power_int)
lemma tendsto_sgn [tendsto_intros]: "(f \<longlongrightarrow> l) F \<Longrightarrow> l \<noteq> 0 \<Longrightarrow> ((\<lambda>x. sgn (f x)) \<longlongrightarrow> sgn l) F"
for l :: "'a::real_normed_vector"
unfolding sgn_div_norm by (simp add: tendsto_intros)
lemma continuous_sgn:
fixes f :: "'a::t2_space \<Rightarrow> 'b::real_normed_vector"
assumes "continuous F f"
and "f (Lim F (\<lambda>x. x)) \<noteq> 0"
shows "continuous F (\<lambda>x. sgn (f x))"
using assms unfolding continuous_def by (rule tendsto_sgn)
lemma continuous_at_within_sgn[continuous_intros]:
fixes f :: "'a::t2_space \<Rightarrow> 'b::real_normed_vector"
assumes "continuous (at a within s) f"
and "f a \<noteq> 0"
shows "continuous (at a within s) (\<lambda>x. sgn (f x))"
using assms unfolding continuous_within by (rule tendsto_sgn)
lemma isCont_sgn[continuous_intros]:
fixes f :: "'a::t2_space \<Rightarrow> 'b::real_normed_vector"
assumes "isCont f a"
and "f a \<noteq> 0"
shows "isCont (\<lambda>x. sgn (f x)) a"
using assms unfolding continuous_at by (rule tendsto_sgn)
lemma continuous_on_sgn[continuous_intros]:
fixes f :: "'a::topological_space \<Rightarrow> 'b::real_normed_vector"
assumes "continuous_on s f"
and "\<forall>x\<in>s. f x \<noteq> 0"
shows "continuous_on s (\<lambda>x. sgn (f x))"
using assms unfolding continuous_on_def by (blast intro: tendsto_sgn)
lemma filterlim_at_infinity:
fixes f :: "_ \<Rightarrow> 'a::real_normed_vector"
assumes "0 \<le> c"
shows "(LIM x F. f x :> at_infinity) \<longleftrightarrow> (\<forall>r>c. eventually (\<lambda>x. r \<le> norm (f x)) F)"
unfolding filterlim_iff eventually_at_infinity
proof safe
fix P :: "'a \<Rightarrow> bool"
fix b
assume *: "\<forall>r>c. eventually (\<lambda>x. r \<le> norm (f x)) F"
assume P: "\<forall>x. b \<le> norm x \<longrightarrow> P x"
have "max b (c + 1) > c" by auto
with * have "eventually (\<lambda>x. max b (c + 1) \<le> norm (f x)) F"
by auto
then show "eventually (\<lambda>x. P (f x)) F"
proof eventually_elim
case (elim x)
with P show "P (f x)" by auto
qed
qed force
lemma filterlim_at_infinity_imp_norm_at_top:
fixes F
assumes "filterlim f at_infinity F"
shows "filterlim (\<lambda>x. norm (f x)) at_top F"
proof -
{
fix r :: real
have "\<forall>\<^sub>F x in F. r \<le> norm (f x)" using filterlim_at_infinity[of 0 f F] assms
by (cases "r > 0")
(auto simp: not_less intro: always_eventually order.trans[OF _ norm_ge_zero])
}
thus ?thesis by (auto simp: filterlim_at_top)
qed
lemma filterlim_norm_at_top_imp_at_infinity:
fixes F
assumes "filterlim (\<lambda>x. norm (f x)) at_top F"
shows "filterlim f at_infinity F"
using filterlim_at_infinity[of 0 f F] assms by (auto simp: filterlim_at_top)
lemma filterlim_norm_at_top: "filterlim norm at_top at_infinity"
by (rule filterlim_at_infinity_imp_norm_at_top) (rule filterlim_ident)
lemma filterlim_at_infinity_conv_norm_at_top:
"filterlim f at_infinity G \<longleftrightarrow> filterlim (\<lambda>x. norm (f x)) at_top G"
by (auto simp: filterlim_at_infinity[OF order.refl] filterlim_at_top_gt[of _ _ 0])
lemma eventually_not_equal_at_infinity:
"eventually (\<lambda>x. x \<noteq> (a :: 'a :: {real_normed_vector})) at_infinity"
proof -
from filterlim_norm_at_top[where 'a = 'a]
have "\<forall>\<^sub>F x in at_infinity. norm a < norm (x::'a)" by (auto simp: filterlim_at_top_dense)
thus ?thesis by eventually_elim auto
qed
lemma filterlim_int_of_nat_at_topD:
fixes F
assumes "filterlim (\<lambda>x. f (int x)) F at_top"
shows "filterlim f F at_top"
proof -
have "filterlim (\<lambda>x. f (int (nat x))) F at_top"
by (rule filterlim_compose[OF assms filterlim_nat_sequentially])
also have "?this \<longleftrightarrow> filterlim f F at_top"
by (intro filterlim_cong refl eventually_mono [OF eventually_ge_at_top[of "0::int"]]) auto
finally show ?thesis .
qed
lemma filterlim_int_sequentially [tendsto_intros]:
"filterlim int at_top sequentially"
unfolding filterlim_at_top
proof
fix C :: int
show "eventually (\<lambda>n. int n \<ge> C) at_top"
using eventually_ge_at_top[of "nat \<lceil>C\<rceil>"] by eventually_elim linarith
qed
lemma filterlim_real_of_int_at_top [tendsto_intros]:
"filterlim real_of_int at_top at_top"
unfolding filterlim_at_top
proof
fix C :: real
show "eventually (\<lambda>n. real_of_int n \<ge> C) at_top"
using eventually_ge_at_top[of "\<lceil>C\<rceil>"] by eventually_elim linarith
qed
lemma filterlim_abs_real: "filterlim (abs::real \<Rightarrow> real) at_top at_top"
proof (subst filterlim_cong[OF refl refl])
from eventually_ge_at_top[of "0::real"] show "eventually (\<lambda>x::real. \<bar>x\<bar> = x) at_top"
by eventually_elim simp
qed (simp_all add: filterlim_ident)
lemma filterlim_of_real_at_infinity [tendsto_intros]:
"filterlim (of_real :: real \<Rightarrow> 'a :: real_normed_algebra_1) at_infinity at_top"
by (intro filterlim_norm_at_top_imp_at_infinity) (auto simp: filterlim_abs_real)
lemma not_tendsto_and_filterlim_at_infinity:
fixes c :: "'a::real_normed_vector"
assumes "F \<noteq> bot"
and "(f \<longlongrightarrow> c) F"
and "filterlim f at_infinity F"
shows False
proof -
from tendstoD[OF assms(2), of "1/2"]
have "eventually (\<lambda>x. dist (f x) c < 1/2) F"
by simp
moreover
from filterlim_at_infinity[of "norm c" f F] assms(3)
have "eventually (\<lambda>x. norm (f x) \<ge> norm c + 1) F" by simp
ultimately have "eventually (\<lambda>x. False) F"
proof eventually_elim
fix x
assume A: "dist (f x) c < 1/2"
assume "norm (f x) \<ge> norm c + 1"
also have "norm (f x) = dist (f x) 0" by simp
also have "\<dots> \<le> dist (f x) c + dist c 0" by (rule dist_triangle)
finally show False using A by simp
qed
with assms show False by simp
qed
lemma filterlim_at_infinity_imp_not_convergent:
assumes "filterlim f at_infinity sequentially"
shows "\<not> convergent f"
by (rule notI, rule not_tendsto_and_filterlim_at_infinity[OF _ _ assms])
(simp_all add: convergent_LIMSEQ_iff)
lemma filterlim_at_infinity_imp_eventually_ne:
assumes "filterlim f at_infinity F"
shows "eventually (\<lambda>z. f z \<noteq> c) F"
proof -
have "norm c + 1 > 0"
by (intro add_nonneg_pos) simp_all
with filterlim_at_infinity[OF order.refl, of f F] assms
have "eventually (\<lambda>z. norm (f z) \<ge> norm c + 1) F"
by blast
then show ?thesis
by eventually_elim auto
qed
lemma tendsto_of_nat [tendsto_intros]:
"filterlim (of_nat :: nat \<Rightarrow> 'a::real_normed_algebra_1) at_infinity sequentially"
proof (subst filterlim_at_infinity[OF order.refl], intro allI impI)
fix r :: real
assume r: "r > 0"
define n where "n = nat \<lceil>r\<rceil>"
from r have n: "\<forall>m\<ge>n. of_nat m \<ge> r"
unfolding n_def by linarith
from eventually_ge_at_top[of n] show "eventually (\<lambda>m. norm (of_nat m :: 'a) \<ge> r) sequentially"
by eventually_elim (use n in simp_all)
qed
subsection \<open>Relate \<^const>\<open>at\<close>, \<^const>\<open>at_left\<close> and \<^const>\<open>at_right\<close>\<close>
text \<open>
This lemmas are useful for conversion between \<^term>\<open>at x\<close> to \<^term>\<open>at_left x\<close> and
\<^term>\<open>at_right x\<close> and also \<^term>\<open>at_right 0\<close>.
\<close>
lemmas filterlim_split_at_real = filterlim_split_at[where 'a=real]
lemma filtermap_nhds_shift: "filtermap (\<lambda>x. x - d) (nhds a) = nhds (a - d)"
for a d :: "'a::real_normed_vector"
by (rule filtermap_fun_inverse[where g="\<lambda>x. x + d"])
(auto intro!: tendsto_eq_intros filterlim_ident)
lemma filtermap_nhds_minus: "filtermap (\<lambda>x. - x) (nhds a) = nhds (- a)"
for a :: "'a::real_normed_vector"
by (rule filtermap_fun_inverse[where g=uminus])
(auto intro!: tendsto_eq_intros filterlim_ident)
lemma filtermap_at_shift: "filtermap (\<lambda>x. x - d) (at a) = at (a - d)"
for a d :: "'a::real_normed_vector"
by (simp add: filter_eq_iff eventually_filtermap eventually_at_filter filtermap_nhds_shift[symmetric])
lemma filtermap_at_right_shift: "filtermap (\<lambda>x. x - d) (at_right a) = at_right (a - d)"
for a d :: "real"
by (simp add: filter_eq_iff eventually_filtermap eventually_at_filter filtermap_nhds_shift[symmetric])
lemma filterlim_shift:
fixes d :: "'a::real_normed_vector"
assumes "filterlim f F (at a)"
shows "filterlim (f \<circ> (+) d) F (at (a - d))"
unfolding filterlim_iff
proof (intro strip)
fix P
assume "eventually P F"
then have "\<forall>\<^sub>F x in filtermap (\<lambda>y. y - d) (at a). P (f (d + x))"
using assms by (force simp add: filterlim_iff eventually_filtermap)
then show "(\<forall>\<^sub>F x in at (a - d). P ((f \<circ> (+) d) x))"
by (force simp add: filtermap_at_shift)
qed
lemma filterlim_shift_iff:
fixes d :: "'a::real_normed_vector"
shows "filterlim (f \<circ> (+) d) F (at (a - d)) = filterlim f F (at a)" (is "?lhs = ?rhs")
proof
assume L: ?lhs show ?rhs
using filterlim_shift [OF L, of "-d"] by (simp add: filterlim_iff)
qed (metis filterlim_shift)
lemma at_right_to_0: "at_right a = filtermap (\<lambda>x. x + a) (at_right 0)"
for a :: real
using filtermap_at_right_shift[of "-a" 0] by simp
lemma filterlim_at_right_to_0:
"filterlim f F (at_right a) \<longleftrightarrow> filterlim (\<lambda>x. f (x + a)) F (at_right 0)"
for a :: real
unfolding filterlim_def filtermap_filtermap at_right_to_0[of a] ..
lemma eventually_at_right_to_0:
"eventually P (at_right a) \<longleftrightarrow> eventually (\<lambda>x. P (x + a)) (at_right 0)"
for a :: real
unfolding at_right_to_0[of a] by (simp add: eventually_filtermap)
lemma at_to_0: "at a = filtermap (\<lambda>x. x + a) (at 0)"
for a :: "'a::real_normed_vector"
using filtermap_at_shift[of "-a" 0] by simp
lemma filterlim_at_to_0:
"filterlim f F (at a) \<longleftrightarrow> filterlim (\<lambda>x. f (x + a)) F (at 0)"
for a :: "'a::real_normed_vector"
unfolding filterlim_def filtermap_filtermap at_to_0[of a] ..
lemma eventually_at_to_0:
"eventually P (at a) \<longleftrightarrow> eventually (\<lambda>x. P (x + a)) (at 0)"
for a :: "'a::real_normed_vector"
unfolding at_to_0[of a] by (simp add: eventually_filtermap)
lemma filtermap_at_minus: "filtermap (\<lambda>x. - x) (at a) = at (- a)"
for a :: "'a::real_normed_vector"
by (simp add: filter_eq_iff eventually_filtermap eventually_at_filter filtermap_nhds_minus[symmetric])
lemma at_left_minus: "at_left a = filtermap (\<lambda>x. - x) (at_right (- a))"
for a :: real
by (simp add: filter_eq_iff eventually_filtermap eventually_at_filter filtermap_nhds_minus[symmetric])
lemma at_right_minus: "at_right a = filtermap (\<lambda>x. - x) (at_left (- a))"
for a :: real
by (simp add: filter_eq_iff eventually_filtermap eventually_at_filter filtermap_nhds_minus[symmetric])
lemma filterlim_at_left_to_right:
"filterlim f F (at_left a) \<longleftrightarrow> filterlim (\<lambda>x. f (- x)) F (at_right (-a))"
for a :: real
unfolding filterlim_def filtermap_filtermap at_left_minus[of a] ..
lemma eventually_at_left_to_right:
"eventually P (at_left a) \<longleftrightarrow> eventually (\<lambda>x. P (- x)) (at_right (-a))"
for a :: real
unfolding at_left_minus[of a] by (simp add: eventually_filtermap)
lemma filterlim_uminus_at_top_at_bot: "LIM x at_bot. - x :: real :> at_top"
unfolding filterlim_at_top eventually_at_bot_dense
by (metis leI minus_less_iff order_less_asym)
lemma filterlim_uminus_at_bot_at_top: "LIM x at_top. - x :: real :> at_bot"
unfolding filterlim_at_bot eventually_at_top_dense
by (metis leI less_minus_iff order_less_asym)
lemma at_bot_mirror :
shows "(at_bot::('a::{ordered_ab_group_add,linorder} filter)) = filtermap uminus at_top"
proof (rule filtermap_fun_inverse[symmetric])
show "filterlim uminus at_top (at_bot::'a filter)"
using eventually_at_bot_linorder filterlim_at_top le_minus_iff by force
show "filterlim uminus (at_bot::'a filter) at_top"
by (simp add: filterlim_at_bot minus_le_iff)
qed auto
lemma at_top_mirror :
shows "(at_top::('a::{ordered_ab_group_add,linorder} filter)) = filtermap uminus at_bot"
apply (subst at_bot_mirror)
by (auto simp: filtermap_filtermap)
lemma filterlim_at_top_mirror: "(LIM x at_top. f x :> F) \<longleftrightarrow> (LIM x at_bot. f (-x::real) :> F)"
unfolding filterlim_def at_top_mirror filtermap_filtermap ..
lemma filterlim_at_bot_mirror: "(LIM x at_bot. f x :> F) \<longleftrightarrow> (LIM x at_top. f (-x::real) :> F)"
unfolding filterlim_def at_bot_mirror filtermap_filtermap ..
lemma filterlim_uminus_at_top: "(LIM x F. f x :> at_top) \<longleftrightarrow> (LIM x F. - (f x) :: real :> at_bot)"
using filterlim_compose[OF filterlim_uminus_at_bot_at_top, of f F]
and filterlim_compose[OF filterlim_uminus_at_top_at_bot, of "\<lambda>x. - f x" F]
by auto
lemma tendsto_at_botI_sequentially:
fixes f :: "real \<Rightarrow> 'b::first_countable_topology"
assumes *: "\<And>X. filterlim X at_bot sequentially \<Longrightarrow> (\<lambda>n. f (X n)) \<longlonglongrightarrow> y"
shows "(f \<longlongrightarrow> y) at_bot"
unfolding filterlim_at_bot_mirror
proof (rule tendsto_at_topI_sequentially)
fix X :: "nat \<Rightarrow> real" assume "filterlim X at_top sequentially"
thus "(\<lambda>n. f (-X n)) \<longlonglongrightarrow> y" by (intro *) (auto simp: filterlim_uminus_at_top)
qed
lemma filterlim_at_infinity_imp_filterlim_at_top:
assumes "filterlim (f :: 'a \<Rightarrow> real) at_infinity F"
assumes "eventually (\<lambda>x. f x > 0) F"
shows "filterlim f at_top F"
proof -
from assms(2) have *: "eventually (\<lambda>x. norm (f x) = f x) F" by eventually_elim simp
from assms(1) show ?thesis unfolding filterlim_at_infinity_conv_norm_at_top
by (subst (asm) filterlim_cong[OF refl refl *])
qed
lemma filterlim_at_infinity_imp_filterlim_at_bot:
assumes "filterlim (f :: 'a \<Rightarrow> real) at_infinity F"
assumes "eventually (\<lambda>x. f x < 0) F"
shows "filterlim f at_bot F"
proof -
from assms(2) have *: "eventually (\<lambda>x. norm (f x) = -f x) F" by eventually_elim simp
from assms(1) have "filterlim (\<lambda>x. - f x) at_top F"
unfolding filterlim_at_infinity_conv_norm_at_top
by (subst (asm) filterlim_cong[OF refl refl *])
thus ?thesis by (simp add: filterlim_uminus_at_top)
qed
lemma filterlim_uminus_at_bot: "(LIM x F. f x :> at_bot) \<longleftrightarrow> (LIM x F. - (f x) :: real :> at_top)"
unfolding filterlim_uminus_at_top by simp
lemma filterlim_inverse_at_top_right: "LIM x at_right (0::real). inverse x :> at_top"
unfolding filterlim_at_top_gt[where c=0] eventually_at_filter
proof safe
fix Z :: real
assume [arith]: "0 < Z"
then have "eventually (\<lambda>x. x < inverse Z) (nhds 0)"
by (auto simp: eventually_nhds_metric dist_real_def intro!: exI[of _ "\<bar>inverse Z\<bar>"])
then show "eventually (\<lambda>x. x \<noteq> 0 \<longrightarrow> x \<in> {0<..} \<longrightarrow> Z \<le> inverse x) (nhds 0)"
by (auto elim!: eventually_mono simp: inverse_eq_divide field_simps)
qed
lemma tendsto_inverse_0:
fixes x :: "_ \<Rightarrow> 'a::real_normed_div_algebra"
shows "(inverse \<longlongrightarrow> (0::'a)) at_infinity"
unfolding tendsto_Zfun_iff diff_0_right Zfun_def eventually_at_infinity
proof safe
fix r :: real
assume "0 < r"
show "\<exists>b. \<forall>x. b \<le> norm x \<longrightarrow> norm (inverse x :: 'a) < r"
proof (intro exI[of _ "inverse (r / 2)"] allI impI)
fix x :: 'a
from \<open>0 < r\<close> have "0 < inverse (r / 2)" by simp
also assume *: "inverse (r / 2) \<le> norm x"
finally show "norm (inverse x) < r"
using * \<open>0 < r\<close>
by (subst nonzero_norm_inverse) (simp_all add: inverse_eq_divide field_simps)
qed
qed
lemma tendsto_add_filterlim_at_infinity:
fixes c :: "'b::real_normed_vector"
and F :: "'a filter"
assumes "(f \<longlongrightarrow> c) F"
and "filterlim g at_infinity F"
shows "filterlim (\<lambda>x. f x + g x) at_infinity F"
proof (subst filterlim_at_infinity[OF order_refl], safe)
fix r :: real
assume r: "r > 0"
from assms(1) have "((\<lambda>x. norm (f x)) \<longlongrightarrow> norm c) F"
by (rule tendsto_norm)
then have "eventually (\<lambda>x. norm (f x) < norm c + 1) F"
by (rule order_tendstoD) simp_all
moreover from r have "r + norm c + 1 > 0"
by (intro add_pos_nonneg) simp_all
with assms(2) have "eventually (\<lambda>x. norm (g x) \<ge> r + norm c + 1) F"
unfolding filterlim_at_infinity[OF order_refl]
by (elim allE[of _ "r + norm c + 1"]) simp_all
ultimately show "eventually (\<lambda>x. norm (f x + g x) \<ge> r) F"
proof eventually_elim
fix x :: 'a
assume A: "norm (f x) < norm c + 1" and B: "r + norm c + 1 \<le> norm (g x)"
from A B have "r \<le> norm (g x) - norm (f x)"
by simp
also have "norm (g x) - norm (f x) \<le> norm (g x + f x)"
by (rule norm_diff_ineq)
finally show "r \<le> norm (f x + g x)"
by (simp add: add_ac)
qed
qed
lemma tendsto_add_filterlim_at_infinity':
fixes c :: "'b::real_normed_vector"
and F :: "'a filter"
assumes "filterlim f at_infinity F"
and "(g \<longlongrightarrow> c) F"
shows "filterlim (\<lambda>x. f x + g x) at_infinity F"
by (subst add.commute) (rule tendsto_add_filterlim_at_infinity assms)+
lemma filterlim_inverse_at_right_top: "LIM x at_top. inverse x :> at_right (0::real)"
unfolding filterlim_at
by (auto simp: eventually_at_top_dense)
(metis tendsto_inverse_0 filterlim_mono at_top_le_at_infinity order_refl)
lemma filterlim_inverse_at_top:
"(f \<longlongrightarrow> (0 :: real)) F \<Longrightarrow> eventually (\<lambda>x. 0 < f x) F \<Longrightarrow> LIM x F. inverse (f x) :> at_top"
by (intro filterlim_compose[OF filterlim_inverse_at_top_right])
(simp add: filterlim_def eventually_filtermap eventually_mono at_within_def le_principal)
lemma filterlim_inverse_at_bot_neg:
"LIM x (at_left (0::real)). inverse x :> at_bot"
by (simp add: filterlim_inverse_at_top_right filterlim_uminus_at_bot filterlim_at_left_to_right)
lemma filterlim_inverse_at_bot:
"(f \<longlongrightarrow> (0 :: real)) F \<Longrightarrow> eventually (\<lambda>x. f x < 0) F \<Longrightarrow> LIM x F. inverse (f x) :> at_bot"
unfolding filterlim_uminus_at_bot inverse_minus_eq[symmetric]
by (rule filterlim_inverse_at_top) (simp_all add: tendsto_minus_cancel_left[symmetric])
lemma at_right_to_top: "(at_right (0::real)) = filtermap inverse at_top"
by (intro filtermap_fun_inverse[symmetric, where g=inverse])
(auto intro: filterlim_inverse_at_top_right filterlim_inverse_at_right_top)
lemma eventually_at_right_to_top:
"eventually P (at_right (0::real)) \<longleftrightarrow> eventually (\<lambda>x. P (inverse x)) at_top"
unfolding at_right_to_top eventually_filtermap ..
lemma filterlim_at_right_to_top:
"filterlim f F (at_right (0::real)) \<longleftrightarrow> (LIM x at_top. f (inverse x) :> F)"
unfolding filterlim_def at_right_to_top filtermap_filtermap ..
lemma at_top_to_right: "at_top = filtermap inverse (at_right (0::real))"
unfolding at_right_to_top filtermap_filtermap inverse_inverse_eq filtermap_ident ..
lemma eventually_at_top_to_right:
"eventually P at_top \<longleftrightarrow> eventually (\<lambda>x. P (inverse x)) (at_right (0::real))"
unfolding at_top_to_right eventually_filtermap ..
lemma filterlim_at_top_to_right:
"filterlim f F at_top \<longleftrightarrow> (LIM x (at_right (0::real)). f (inverse x) :> F)"
unfolding filterlim_def at_top_to_right filtermap_filtermap ..
lemma filterlim_inverse_at_infinity:
fixes x :: "_ \<Rightarrow> 'a::{real_normed_div_algebra, division_ring}"
shows "filterlim inverse at_infinity (at (0::'a))"
unfolding filterlim_at_infinity[OF order_refl]
proof safe
fix r :: real
assume "0 < r"
then show "eventually (\<lambda>x::'a. r \<le> norm (inverse x)) (at 0)"
unfolding eventually_at norm_inverse
by (intro exI[of _ "inverse r"])
(auto simp: norm_conv_dist[symmetric] field_simps inverse_eq_divide)
qed
lemma filterlim_inverse_at_iff:
fixes g :: "'a \<Rightarrow> 'b::{real_normed_div_algebra, division_ring}"
shows "(LIM x F. inverse (g x) :> at 0) \<longleftrightarrow> (LIM x F. g x :> at_infinity)"
unfolding filterlim_def filtermap_filtermap[symmetric]
proof
assume "filtermap g F \<le> at_infinity"
then have "filtermap inverse (filtermap g F) \<le> filtermap inverse at_infinity"
by (rule filtermap_mono)
also have "\<dots> \<le> at 0"
using tendsto_inverse_0[where 'a='b]
by (auto intro!: exI[of _ 1]
simp: le_principal eventually_filtermap filterlim_def at_within_def eventually_at_infinity)
finally show "filtermap inverse (filtermap g F) \<le> at 0" .
next
assume "filtermap inverse (filtermap g F) \<le> at 0"
then have "filtermap inverse (filtermap inverse (filtermap g F)) \<le> filtermap inverse (at 0)"
by (rule filtermap_mono)
with filterlim_inverse_at_infinity show "filtermap g F \<le> at_infinity"
by (auto intro: order_trans simp: filterlim_def filtermap_filtermap)
qed
lemma tendsto_mult_filterlim_at_infinity:
fixes c :: "'a::real_normed_field"
assumes "(f \<longlongrightarrow> c) F" "c \<noteq> 0"
assumes "filterlim g at_infinity F"
shows "filterlim (\<lambda>x. f x * g x) at_infinity F"
proof -
have "((\<lambda>x. inverse (f x) * inverse (g x)) \<longlongrightarrow> inverse c * 0) F"
by (intro tendsto_mult tendsto_inverse assms filterlim_compose[OF tendsto_inverse_0])
then have "filterlim (\<lambda>x. inverse (f x) * inverse (g x)) (at (inverse c * 0)) F"
unfolding filterlim_at
using assms
by (auto intro: filterlim_at_infinity_imp_eventually_ne tendsto_imp_eventually_ne eventually_conj)
then show ?thesis
by (subst filterlim_inverse_at_iff[symmetric]) simp_all
qed
lemma tendsto_inverse_0_at_top: "LIM x F. f x :> at_top \<Longrightarrow> ((\<lambda>x. inverse (f x) :: real) \<longlongrightarrow> 0) F"
by (metis filterlim_at filterlim_mono[OF _ at_top_le_at_infinity order_refl] filterlim_inverse_at_iff)
lemma filterlim_inverse_at_top_iff:
"eventually (\<lambda>x. 0 < f x) F \<Longrightarrow> (LIM x F. inverse (f x) :> at_top) \<longleftrightarrow> (f \<longlongrightarrow> (0 :: real)) F"
by (auto dest: tendsto_inverse_0_at_top filterlim_inverse_at_top)
lemma filterlim_at_top_iff_inverse_0:
"eventually (\<lambda>x. 0 < f x) F \<Longrightarrow> (LIM x F. f x :> at_top) \<longleftrightarrow> ((inverse \<circ> f) \<longlongrightarrow> (0 :: real)) F"
using filterlim_inverse_at_top_iff [of "inverse \<circ> f"] by auto
lemma real_tendsto_divide_at_top:
fixes c::"real"
assumes "(f \<longlongrightarrow> c) F"
assumes "filterlim g at_top F"
shows "((\<lambda>x. f x / g x) \<longlongrightarrow> 0) F"
by (auto simp: divide_inverse_commute
intro!: tendsto_mult[THEN tendsto_eq_rhs] tendsto_inverse_0_at_top assms)
lemma mult_nat_left_at_top: "c > 0 \<Longrightarrow> filterlim (\<lambda>x. c * x) at_top sequentially"
for c :: nat
by (rule filterlim_subseq) (auto simp: strict_mono_def)
lemma mult_nat_right_at_top: "c > 0 \<Longrightarrow> filterlim (\<lambda>x. x * c) at_top sequentially"
for c :: nat
by (rule filterlim_subseq) (auto simp: strict_mono_def)
lemma filterlim_times_pos:
"LIM x F1. c * f x :> at_right l"
if "filterlim f (at_right p) F1" "0 < c" "l = c * p"
for c::"'a::{linordered_field, linorder_topology}"
unfolding filterlim_iff
proof safe
fix P
assume "\<forall>\<^sub>F x in at_right l. P x"
then obtain d where "c * p < d" "\<And>y. y > c * p \<Longrightarrow> y < d \<Longrightarrow> P y"
unfolding \<open>l = _ \<close> eventually_at_right_field
by auto
then have "\<forall>\<^sub>F a in at_right p. P (c * a)"
by (auto simp: eventually_at_right_field \<open>0 < c\<close> field_simps intro!: exI[where x="d/c"])
from that(1)[unfolded filterlim_iff, rule_format, OF this]
show "\<forall>\<^sub>F x in F1. P (c * f x)" .
qed
lemma filtermap_nhds_times: "c \<noteq> 0 \<Longrightarrow> filtermap (times c) (nhds a) = nhds (c * a)"
for a c :: "'a::real_normed_field"
by (rule filtermap_fun_inverse[where g="\<lambda>x. inverse c * x"])
(auto intro!: tendsto_eq_intros filterlim_ident)
lemma filtermap_times_pos_at_right:
fixes c::"'a::{linordered_field, linorder_topology}"
assumes "c > 0"
shows "filtermap (times c) (at_right p) = at_right (c * p)"
using assms
by (intro filtermap_fun_inverse[where g="\<lambda>x. inverse c * x"])
(auto intro!: filterlim_ident filterlim_times_pos)
lemma at_to_infinity: "(at (0::'a::{real_normed_field,field})) = filtermap inverse at_infinity"
proof (rule antisym)
have "(inverse \<longlongrightarrow> (0::'a)) at_infinity"
by (fact tendsto_inverse_0)
then show "filtermap inverse at_infinity \<le> at (0::'a)"
using filterlim_def filterlim_ident filterlim_inverse_at_iff by fastforce
next
have "filtermap inverse (filtermap inverse (at (0::'a))) \<le> filtermap inverse at_infinity"
using filterlim_inverse_at_infinity unfolding filterlim_def
by (rule filtermap_mono)
then show "at (0::'a) \<le> filtermap inverse at_infinity"
by (simp add: filtermap_ident filtermap_filtermap)
qed
lemma lim_at_infinity_0:
fixes l :: "'a::{real_normed_field,field}"
shows "(f \<longlongrightarrow> l) at_infinity \<longleftrightarrow> ((f \<circ> inverse) \<longlongrightarrow> l) (at (0::'a))"
by (simp add: tendsto_compose_filtermap at_to_infinity filtermap_filtermap)
lemma lim_zero_infinity:
fixes l :: "'a::{real_normed_field,field}"
shows "((\<lambda>x. f(1 / x)) \<longlongrightarrow> l) (at (0::'a)) \<Longrightarrow> (f \<longlongrightarrow> l) at_infinity"
by (simp add: inverse_eq_divide lim_at_infinity_0 comp_def)
text \<open>
We only show rules for multiplication and addition when the functions are either against a real
value or against infinity. Further rules are easy to derive by using @{thm
filterlim_uminus_at_top}.
\<close>
lemma filterlim_tendsto_pos_mult_at_top:
assumes f: "(f \<longlongrightarrow> c) F"
and c: "0 < c"
and g: "LIM x F. g x :> at_top"
shows "LIM x F. (f x * g x :: real) :> at_top"
unfolding filterlim_at_top_gt[where c=0]
proof safe
fix Z :: real
assume "0 < Z"
from f \<open>0 < c\<close> have "eventually (\<lambda>x. c / 2 < f x) F"
by (auto dest!: tendstoD[where e="c / 2"] elim!: eventually_mono
simp: dist_real_def abs_real_def split: if_split_asm)
moreover from g have "eventually (\<lambda>x. (Z / c * 2) \<le> g x) F"
unfolding filterlim_at_top by auto
ultimately show "eventually (\<lambda>x. Z \<le> f x * g x) F"
proof eventually_elim
case (elim x)
with \<open>0 < Z\<close> \<open>0 < c\<close> have "c / 2 * (Z / c * 2) \<le> f x * g x"
by (intro mult_mono) (auto simp: zero_le_divide_iff)
with \<open>0 < c\<close> show "Z \<le> f x * g x"
by simp
qed
qed
lemma filterlim_at_top_mult_at_top:
assumes f: "LIM x F. f x :> at_top"
and g: "LIM x F. g x :> at_top"
shows "LIM x F. (f x * g x :: real) :> at_top"
unfolding filterlim_at_top_gt[where c=0]
proof safe
fix Z :: real
assume "0 < Z"
from f have "eventually (\<lambda>x. 1 \<le> f x) F"
unfolding filterlim_at_top by auto
moreover from g have "eventually (\<lambda>x. Z \<le> g x) F"
unfolding filterlim_at_top by auto
ultimately show "eventually (\<lambda>x. Z \<le> f x * g x) F"
proof eventually_elim
case (elim x)
with \<open>0 < Z\<close> have "1 * Z \<le> f x * g x"
by (intro mult_mono) (auto simp: zero_le_divide_iff)
then show "Z \<le> f x * g x"
by simp
qed
qed
lemma filterlim_at_top_mult_tendsto_pos:
assumes f: "(f \<longlongrightarrow> c) F"
and c: "0 < c"
and g: "LIM x F. g x :> at_top"
shows "LIM x F. (g x * f x:: real) :> at_top"
by (auto simp: mult.commute intro!: filterlim_tendsto_pos_mult_at_top f c g)
lemma filterlim_tendsto_pos_mult_at_bot:
fixes c :: real
assumes "(f \<longlongrightarrow> c) F" "0 < c" "filterlim g at_bot F"
shows "LIM x F. f x * g x :> at_bot"
using filterlim_tendsto_pos_mult_at_top[OF assms(1,2), of "\<lambda>x. - g x"] assms(3)
unfolding filterlim_uminus_at_bot by simp
lemma filterlim_tendsto_neg_mult_at_bot:
fixes c :: real
assumes c: "(f \<longlongrightarrow> c) F" "c < 0" and g: "filterlim g at_top F"
shows "LIM x F. f x * g x :> at_bot"
using c filterlim_tendsto_pos_mult_at_top[of "\<lambda>x. - f x" "- c" F, OF _ _ g]
unfolding filterlim_uminus_at_bot tendsto_minus_cancel_left by simp
lemma filterlim_pow_at_top:
fixes f :: "'a \<Rightarrow> real"
assumes "0 < n"
and f: "LIM x F. f x :> at_top"
shows "LIM x F. (f x)^n :: real :> at_top"
using \<open>0 < n\<close>
proof (induct n)
case 0
then show ?case by simp
next
case (Suc n) with f show ?case
by (cases "n = 0") (auto intro!: filterlim_at_top_mult_at_top)
qed
lemma filterlim_pow_at_bot_even:
fixes f :: "real \<Rightarrow> real"
shows "0 < n \<Longrightarrow> LIM x F. f x :> at_bot \<Longrightarrow> even n \<Longrightarrow> LIM x F. (f x)^n :> at_top"
using filterlim_pow_at_top[of n "\<lambda>x. - f x" F] by (simp add: filterlim_uminus_at_top)
lemma filterlim_pow_at_bot_odd:
fixes f :: "real \<Rightarrow> real"
shows "0 < n \<Longrightarrow> LIM x F. f x :> at_bot \<Longrightarrow> odd n \<Longrightarrow> LIM x F. (f x)^n :> at_bot"
using filterlim_pow_at_top[of n "\<lambda>x. - f x" F] by (simp add: filterlim_uminus_at_bot)
lemma filterlim_power_at_infinity [tendsto_intros]:
fixes F and f :: "'a \<Rightarrow> 'b :: real_normed_div_algebra"
assumes "filterlim f at_infinity F" "n > 0"
shows "filterlim (\<lambda>x. f x ^ n) at_infinity F"
by (rule filterlim_norm_at_top_imp_at_infinity)
(auto simp: norm_power intro!: filterlim_pow_at_top assms
intro: filterlim_at_infinity_imp_norm_at_top)
lemma filterlim_tendsto_add_at_top:
assumes f: "(f \<longlongrightarrow> c) F"
and g: "LIM x F. g x :> at_top"
shows "LIM x F. (f x + g x :: real) :> at_top"
unfolding filterlim_at_top_gt[where c=0]
proof safe
fix Z :: real
assume "0 < Z"
from f have "eventually (\<lambda>x. c - 1 < f x) F"
by (auto dest!: tendstoD[where e=1] elim!: eventually_mono simp: dist_real_def)
moreover from g have "eventually (\<lambda>x. Z - (c - 1) \<le> g x) F"
unfolding filterlim_at_top by auto
ultimately show "eventually (\<lambda>x. Z \<le> f x + g x) F"
by eventually_elim simp
qed
lemma LIM_at_top_divide:
fixes f g :: "'a \<Rightarrow> real"
assumes f: "(f \<longlongrightarrow> a) F" "0 < a"
and g: "(g \<longlongrightarrow> 0) F" "eventually (\<lambda>x. 0 < g x) F"
shows "LIM x F. f x / g x :> at_top"
unfolding divide_inverse
by (rule filterlim_tendsto_pos_mult_at_top[OF f]) (rule filterlim_inverse_at_top[OF g])
lemma filterlim_at_top_add_at_top:
assumes f: "LIM x F. f x :> at_top"
and g: "LIM x F. g x :> at_top"
shows "LIM x F. (f x + g x :: real) :> at_top"
unfolding filterlim_at_top_gt[where c=0]
proof safe
fix Z :: real
assume "0 < Z"
from f have "eventually (\<lambda>x. 0 \<le> f x) F"
unfolding filterlim_at_top by auto
moreover from g have "eventually (\<lambda>x. Z \<le> g x) F"
unfolding filterlim_at_top by auto
ultimately show "eventually (\<lambda>x. Z \<le> f x + g x) F"
by eventually_elim simp
qed
lemma tendsto_divide_0:
fixes f :: "_ \<Rightarrow> 'a::{real_normed_div_algebra, division_ring}"
assumes f: "(f \<longlongrightarrow> c) F"
and g: "LIM x F. g x :> at_infinity"
shows "((\<lambda>x. f x / g x) \<longlongrightarrow> 0) F"
using tendsto_mult[OF f filterlim_compose[OF tendsto_inverse_0 g]]
by (simp add: divide_inverse)
lemma linear_plus_1_le_power:
fixes x :: real
assumes x: "0 \<le> x"
shows "real n * x + 1 \<le> (x + 1) ^ n"
proof (induct n)
case 0
then show ?case by simp
next
case (Suc n)
from x have "real (Suc n) * x + 1 \<le> (x + 1) * (real n * x + 1)"
by (simp add: field_simps)
also have "\<dots> \<le> (x + 1)^Suc n"
using Suc x by (simp add: mult_left_mono)
finally show ?case .
qed
lemma filterlim_realpow_sequentially_gt1:
fixes x :: "'a :: real_normed_div_algebra"
assumes x[arith]: "1 < norm x"
shows "LIM n sequentially. x ^ n :> at_infinity"
proof (intro filterlim_at_infinity[THEN iffD2] allI impI)
fix y :: real
assume "0 < y"
obtain N :: nat where "y < real N * (norm x - 1)"
by (meson diff_gt_0_iff_gt reals_Archimedean3 x)
also have "\<dots> \<le> real N * (norm x - 1) + 1"
by simp
also have "\<dots> \<le> (norm x - 1 + 1) ^ N"
by (rule linear_plus_1_le_power) simp
also have "\<dots> = norm x ^ N"
by simp
finally have "\<forall>n\<ge>N. y \<le> norm x ^ n"
by (metis order_less_le_trans power_increasing order_less_imp_le x)
then show "eventually (\<lambda>n. y \<le> norm (x ^ n)) sequentially"
unfolding eventually_sequentially
by (auto simp: norm_power)
qed simp
lemma filterlim_divide_at_infinity:
fixes f g :: "'a \<Rightarrow> 'a :: real_normed_field"
assumes "filterlim f (nhds c) F" "filterlim g (at 0) F" "c \<noteq> 0"
shows "filterlim (\<lambda>x. f x / g x) at_infinity F"
proof -
have "filterlim (\<lambda>x. f x * inverse (g x)) at_infinity F"
by (intro tendsto_mult_filterlim_at_infinity[OF assms(1,3)]
filterlim_compose [OF filterlim_inverse_at_infinity assms(2)])
thus ?thesis by (simp add: field_simps)
qed
subsection \<open>Floor and Ceiling\<close>
lemma eventually_floor_less:
fixes f :: "'a \<Rightarrow> 'b::{order_topology,floor_ceiling}"
assumes f: "(f \<longlongrightarrow> l) F"
and l: "l \<notin> \<int>"
shows "\<forall>\<^sub>F x in F. of_int (floor l) < f x"
by (intro order_tendstoD[OF f]) (metis Ints_of_int antisym_conv2 floor_correct l)
lemma eventually_less_ceiling:
fixes f :: "'a \<Rightarrow> 'b::{order_topology,floor_ceiling}"
assumes f: "(f \<longlongrightarrow> l) F"
and l: "l \<notin> \<int>"
shows "\<forall>\<^sub>F x in F. f x < of_int (ceiling l)"
by (intro order_tendstoD[OF f]) (metis Ints_of_int l le_of_int_ceiling less_le)
lemma eventually_floor_eq:
fixes f::"'a \<Rightarrow> 'b::{order_topology,floor_ceiling}"
assumes f: "(f \<longlongrightarrow> l) F"
and l: "l \<notin> \<int>"
shows "\<forall>\<^sub>F x in F. floor (f x) = floor l"
using eventually_floor_less[OF assms] eventually_less_ceiling[OF assms]
by eventually_elim (meson floor_less_iff less_ceiling_iff not_less_iff_gr_or_eq)
lemma eventually_ceiling_eq:
fixes f::"'a \<Rightarrow> 'b::{order_topology,floor_ceiling}"
assumes f: "(f \<longlongrightarrow> l) F"
and l: "l \<notin> \<int>"
shows "\<forall>\<^sub>F x in F. ceiling (f x) = ceiling l"
using eventually_floor_less[OF assms] eventually_less_ceiling[OF assms]
by eventually_elim (meson floor_less_iff less_ceiling_iff not_less_iff_gr_or_eq)
lemma tendsto_of_int_floor:
fixes f::"'a \<Rightarrow> 'b::{order_topology,floor_ceiling}"
assumes "(f \<longlongrightarrow> l) F"
and "l \<notin> \<int>"
shows "((\<lambda>x. of_int (floor (f x)) :: 'c::{ring_1,topological_space}) \<longlongrightarrow> of_int (floor l)) F"
using eventually_floor_eq[OF assms]
by (simp add: eventually_mono topological_tendstoI)
lemma tendsto_of_int_ceiling:
fixes f::"'a \<Rightarrow> 'b::{order_topology,floor_ceiling}"
assumes "(f \<longlongrightarrow> l) F"
and "l \<notin> \<int>"
shows "((\<lambda>x. of_int (ceiling (f x)):: 'c::{ring_1,topological_space}) \<longlongrightarrow> of_int (ceiling l)) F"
using eventually_ceiling_eq[OF assms]
by (simp add: eventually_mono topological_tendstoI)
lemma continuous_on_of_int_floor:
"continuous_on (UNIV - \<int>::'a::{order_topology, floor_ceiling} set)
(\<lambda>x. of_int (floor x)::'b::{ring_1, topological_space})"
unfolding continuous_on_def
by (auto intro!: tendsto_of_int_floor)
lemma continuous_on_of_int_ceiling:
"continuous_on (UNIV - \<int>::'a::{order_topology, floor_ceiling} set)
(\<lambda>x. of_int (ceiling x)::'b::{ring_1, topological_space})"
unfolding continuous_on_def
by (auto intro!: tendsto_of_int_ceiling)
subsection \<open>Limits of Sequences\<close>
lemma [trans]: "X = Y \<Longrightarrow> Y \<longlonglongrightarrow> z \<Longrightarrow> X \<longlonglongrightarrow> z"
by simp
lemma LIMSEQ_iff:
fixes L :: "'a::real_normed_vector"
shows "(X \<longlonglongrightarrow> L) = (\<forall>r>0. \<exists>no. \<forall>n \<ge> no. norm (X n - L) < r)"
unfolding lim_sequentially dist_norm ..
lemma LIMSEQ_I: "(\<And>r. 0 < r \<Longrightarrow> \<exists>no. \<forall>n\<ge>no. norm (X n - L) < r) \<Longrightarrow> X \<longlonglongrightarrow> L"
for L :: "'a::real_normed_vector"
by (simp add: LIMSEQ_iff)
lemma LIMSEQ_D: "X \<longlonglongrightarrow> L \<Longrightarrow> 0 < r \<Longrightarrow> \<exists>no. \<forall>n\<ge>no. norm (X n - L) < r"
for L :: "'a::real_normed_vector"
by (simp add: LIMSEQ_iff)
lemma LIMSEQ_linear: "X \<longlonglongrightarrow> x \<Longrightarrow> l > 0 \<Longrightarrow> (\<lambda> n. X (n * l)) \<longlonglongrightarrow> x"
unfolding tendsto_def eventually_sequentially
by (metis div_le_dividend div_mult_self1_is_m le_trans mult.commute)
text \<open>Transformation of limit.\<close>
lemma Lim_transform: "(g \<longlongrightarrow> a) F \<Longrightarrow> ((\<lambda>x. f x - g x) \<longlongrightarrow> 0) F \<Longrightarrow> (f \<longlongrightarrow> a) F"
for a b :: "'a::real_normed_vector"
using tendsto_add [of g a F "\<lambda>x. f x - g x" 0] by simp
lemma Lim_transform2: "(f \<longlongrightarrow> a) F \<Longrightarrow> ((\<lambda>x. f x - g x) \<longlongrightarrow> 0) F \<Longrightarrow> (g \<longlongrightarrow> a) F"
for a b :: "'a::real_normed_vector"
by (erule Lim_transform) (simp add: tendsto_minus_cancel)
proposition Lim_transform_eq: "((\<lambda>x. f x - g x) \<longlongrightarrow> 0) F \<Longrightarrow> (f \<longlongrightarrow> a) F \<longleftrightarrow> (g \<longlongrightarrow> a) F"
for a :: "'a::real_normed_vector"
using Lim_transform Lim_transform2 by blast
lemma Lim_transform_eventually:
"\<lbrakk>(f \<longlongrightarrow> l) F; eventually (\<lambda>x. f x = g x) F\<rbrakk> \<Longrightarrow> (g \<longlongrightarrow> l) F"
using eventually_elim2 by (fastforce simp add: tendsto_def)
lemma Lim_transform_within:
assumes "(f \<longlongrightarrow> l) (at x within S)"
and "0 < d"
and "\<And>x'. x'\<in>S \<Longrightarrow> 0 < dist x' x \<Longrightarrow> dist x' x < d \<Longrightarrow> f x' = g x'"
shows "(g \<longlongrightarrow> l) (at x within S)"
proof (rule Lim_transform_eventually)
show "eventually (\<lambda>x. f x = g x) (at x within S)"
using assms by (auto simp: eventually_at)
show "(f \<longlongrightarrow> l) (at x within S)"
by fact
qed
lemma filterlim_transform_within:
assumes "filterlim g G (at x within S)"
assumes "G \<le> F" "0<d" "(\<And>x'. x' \<in> S \<Longrightarrow> 0 < dist x' x \<Longrightarrow> dist x' x < d \<Longrightarrow> f x' = g x') "
shows "filterlim f F (at x within S)"
using assms
apply (elim filterlim_mono_eventually)
unfolding eventually_at by auto
text \<open>Common case assuming being away from some crucial point like 0.\<close>
lemma Lim_transform_away_within:
fixes a b :: "'a::t1_space"
assumes "a \<noteq> b"
and "\<forall>x\<in>S. x \<noteq> a \<and> x \<noteq> b \<longrightarrow> f x = g x"
and "(f \<longlongrightarrow> l) (at a within S)"
shows "(g \<longlongrightarrow> l) (at a within S)"
proof (rule Lim_transform_eventually)
show "(f \<longlongrightarrow> l) (at a within S)"
by fact
show "eventually (\<lambda>x. f x = g x) (at a within S)"
unfolding eventually_at_topological
by (rule exI [where x="- {b}"]) (simp add: open_Compl assms)
qed
lemma Lim_transform_away_at:
fixes a b :: "'a::t1_space"
assumes ab: "a \<noteq> b"
and fg: "\<forall>x. x \<noteq> a \<and> x \<noteq> b \<longrightarrow> f x = g x"
and fl: "(f \<longlongrightarrow> l) (at a)"
shows "(g \<longlongrightarrow> l) (at a)"
using Lim_transform_away_within[OF ab, of UNIV f g l] fg fl by simp
text \<open>Alternatively, within an open set.\<close>
lemma Lim_transform_within_open:
assumes "(f \<longlongrightarrow> l) (at a within T)"
and "open s" and "a \<in> s"
and "\<And>x. x\<in>s \<Longrightarrow> x \<noteq> a \<Longrightarrow> f x = g x"
shows "(g \<longlongrightarrow> l) (at a within T)"
proof (rule Lim_transform_eventually)
show "eventually (\<lambda>x. f x = g x) (at a within T)"
unfolding eventually_at_topological
using assms by auto
show "(f \<longlongrightarrow> l) (at a within T)" by fact
qed
text \<open>A congruence rule allowing us to transform limits assuming not at point.\<close>
lemma Lim_cong_within:
assumes "a = b"
and "x = y"
and "S = T"
and "\<And>x. x \<noteq> b \<Longrightarrow> x \<in> T \<Longrightarrow> f x = g x"
shows "(f \<longlongrightarrow> x) (at a within S) \<longleftrightarrow> (g \<longlongrightarrow> y) (at b within T)"
unfolding tendsto_def eventually_at_topological
using assms by simp
text \<open>An unbounded sequence's inverse tends to 0.\<close>
lemma LIMSEQ_inverse_zero:
assumes "\<And>r::real. \<exists>N. \<forall>n\<ge>N. r < X n"
shows "(\<lambda>n. inverse (X n)) \<longlonglongrightarrow> 0"
apply (rule filterlim_compose[OF tendsto_inverse_0])
by (metis assms eventually_at_top_linorderI filterlim_at_top_dense filterlim_at_top_imp_at_infinity)
text \<open>The sequence \<^term>\<open>1/n\<close> tends to 0 as \<^term>\<open>n\<close> tends to infinity.\<close>
lemma LIMSEQ_inverse_real_of_nat: "(\<lambda>n. inverse (real (Suc n))) \<longlonglongrightarrow> 0"
by (metis filterlim_compose tendsto_inverse_0 filterlim_mono order_refl filterlim_Suc
filterlim_compose[OF filterlim_real_sequentially] at_top_le_at_infinity)
text \<open>
The sequence \<^term>\<open>r + 1/n\<close> tends to \<^term>\<open>r\<close> as \<^term>\<open>n\<close> tends to
infinity is now easily proved.
\<close>
lemma LIMSEQ_inverse_real_of_nat_add: "(\<lambda>n. r + inverse (real (Suc n))) \<longlonglongrightarrow> r"
using tendsto_add [OF tendsto_const LIMSEQ_inverse_real_of_nat] by auto
lemma LIMSEQ_inverse_real_of_nat_add_minus: "(\<lambda>n. r + -inverse (real (Suc n))) \<longlonglongrightarrow> r"
using tendsto_add [OF tendsto_const tendsto_minus [OF LIMSEQ_inverse_real_of_nat]]
by auto
lemma LIMSEQ_inverse_real_of_nat_add_minus_mult: "(\<lambda>n. r * (1 + - inverse (real (Suc n)))) \<longlonglongrightarrow> r"
using tendsto_mult [OF tendsto_const LIMSEQ_inverse_real_of_nat_add_minus [of 1]]
by auto
lemma lim_inverse_n: "((\<lambda>n. inverse(of_nat n)) \<longlongrightarrow> (0::'a::real_normed_field)) sequentially"
using lim_1_over_n by (simp add: inverse_eq_divide)
lemma lim_inverse_n': "((\<lambda>n. 1 / n) \<longlongrightarrow> 0) sequentially"
using lim_inverse_n
by (simp add: inverse_eq_divide)
lemma LIMSEQ_Suc_n_over_n: "(\<lambda>n. of_nat (Suc n) / of_nat n :: 'a :: real_normed_field) \<longlonglongrightarrow> 1"
proof (rule Lim_transform_eventually)
show "eventually (\<lambda>n. 1 + inverse (of_nat n :: 'a) = of_nat (Suc n) / of_nat n) sequentially"
using eventually_gt_at_top[of "0::nat"]
by eventually_elim (simp add: field_simps)
have "(\<lambda>n. 1 + inverse (of_nat n) :: 'a) \<longlonglongrightarrow> 1 + 0"
by (intro tendsto_add tendsto_const lim_inverse_n)
then show "(\<lambda>n. 1 + inverse (of_nat n) :: 'a) \<longlonglongrightarrow> 1"
by simp
qed
lemma LIMSEQ_n_over_Suc_n: "(\<lambda>n. of_nat n / of_nat (Suc n) :: 'a :: real_normed_field) \<longlonglongrightarrow> 1"
proof (rule Lim_transform_eventually)
show "eventually (\<lambda>n. inverse (of_nat (Suc n) / of_nat n :: 'a) =
of_nat n / of_nat (Suc n)) sequentially"
using eventually_gt_at_top[of "0::nat"]
by eventually_elim (simp add: field_simps del: of_nat_Suc)
have "(\<lambda>n. inverse (of_nat (Suc n) / of_nat n :: 'a)) \<longlonglongrightarrow> inverse 1"
by (intro tendsto_inverse LIMSEQ_Suc_n_over_n) simp_all
then show "(\<lambda>n. inverse (of_nat (Suc n) / of_nat n :: 'a)) \<longlonglongrightarrow> 1"
by simp
qed
subsection \<open>Convergence on sequences\<close>
lemma convergent_cong:
assumes "eventually (\<lambda>x. f x = g x) sequentially"
shows "convergent f \<longleftrightarrow> convergent g"
unfolding convergent_def
by (subst filterlim_cong[OF refl refl assms]) (rule refl)
lemma convergent_Suc_iff: "convergent (\<lambda>n. f (Suc n)) \<longleftrightarrow> convergent f"
by (auto simp: convergent_def filterlim_sequentially_Suc)
lemma convergent_ignore_initial_segment: "convergent (\<lambda>n. f (n + m)) = convergent f"
proof (induct m arbitrary: f)
case 0
then show ?case by simp
next
case (Suc m)
have "convergent (\<lambda>n. f (n + Suc m)) \<longleftrightarrow> convergent (\<lambda>n. f (Suc n + m))"
by simp
also have "\<dots> \<longleftrightarrow> convergent (\<lambda>n. f (n + m))"
by (rule convergent_Suc_iff)
also have "\<dots> \<longleftrightarrow> convergent f"
by (rule Suc)
finally show ?case .
qed
lemma convergent_add:
fixes X Y :: "nat \<Rightarrow> 'a::topological_monoid_add"
assumes "convergent (\<lambda>n. X n)"
and "convergent (\<lambda>n. Y n)"
shows "convergent (\<lambda>n. X n + Y n)"
using assms unfolding convergent_def by (blast intro: tendsto_add)
lemma convergent_sum:
fixes X :: "'a \<Rightarrow> nat \<Rightarrow> 'b::topological_comm_monoid_add"
shows "(\<And>i. i \<in> A \<Longrightarrow> convergent (\<lambda>n. X i n)) \<Longrightarrow> convergent (\<lambda>n. \<Sum>i\<in>A. X i n)"
by (induct A rule: infinite_finite_induct) (simp_all add: convergent_const convergent_add)
lemma (in bounded_linear) convergent:
assumes "convergent (\<lambda>n. X n)"
shows "convergent (\<lambda>n. f (X n))"
using assms unfolding convergent_def by (blast intro: tendsto)
lemma (in bounded_bilinear) convergent:
assumes "convergent (\<lambda>n. X n)"
and "convergent (\<lambda>n. Y n)"
shows "convergent (\<lambda>n. X n ** Y n)"
using assms unfolding convergent_def by (blast intro: tendsto)
lemma convergent_minus_iff:
fixes X :: "nat \<Rightarrow> 'a::topological_group_add"
shows "convergent X \<longleftrightarrow> convergent (\<lambda>n. - X n)"
unfolding convergent_def by (force dest: tendsto_minus)
lemma convergent_diff:
fixes X Y :: "nat \<Rightarrow> 'a::topological_group_add"
assumes "convergent (\<lambda>n. X n)"
assumes "convergent (\<lambda>n. Y n)"
shows "convergent (\<lambda>n. X n - Y n)"
using assms unfolding convergent_def by (blast intro: tendsto_diff)
lemma convergent_norm:
assumes "convergent f"
shows "convergent (\<lambda>n. norm (f n))"
proof -
from assms have "f \<longlonglongrightarrow> lim f"
by (simp add: convergent_LIMSEQ_iff)
then have "(\<lambda>n. norm (f n)) \<longlonglongrightarrow> norm (lim f)"
by (rule tendsto_norm)
then show ?thesis
by (auto simp: convergent_def)
qed
lemma convergent_of_real:
"convergent f \<Longrightarrow> convergent (\<lambda>n. of_real (f n) :: 'a::real_normed_algebra_1)"
unfolding convergent_def by (blast intro!: tendsto_of_real)
lemma convergent_add_const_iff:
"convergent (\<lambda>n. c + f n :: 'a::topological_ab_group_add) \<longleftrightarrow> convergent f"
proof
assume "convergent (\<lambda>n. c + f n)"
from convergent_diff[OF this convergent_const[of c]] show "convergent f"
by simp
next
assume "convergent f"
from convergent_add[OF convergent_const[of c] this] show "convergent (\<lambda>n. c + f n)"
by simp
qed
lemma convergent_add_const_right_iff:
"convergent (\<lambda>n. f n + c :: 'a::topological_ab_group_add) \<longleftrightarrow> convergent f"
using convergent_add_const_iff[of c f] by (simp add: add_ac)
lemma convergent_diff_const_right_iff:
"convergent (\<lambda>n. f n - c :: 'a::topological_ab_group_add) \<longleftrightarrow> convergent f"
using convergent_add_const_right_iff[of f "-c"] by (simp add: add_ac)
lemma convergent_mult:
fixes X Y :: "nat \<Rightarrow> 'a::topological_semigroup_mult"
assumes "convergent (\<lambda>n. X n)"
and "convergent (\<lambda>n. Y n)"
shows "convergent (\<lambda>n. X n * Y n)"
using assms unfolding convergent_def by (blast intro: tendsto_mult)
lemma convergent_mult_const_iff:
assumes "c \<noteq> 0"
shows "convergent (\<lambda>n. c * f n :: 'a::{field,topological_semigroup_mult}) \<longleftrightarrow> convergent f"
proof
assume "convergent (\<lambda>n. c * f n)"
from assms convergent_mult[OF this convergent_const[of "inverse c"]]
show "convergent f" by (simp add: field_simps)
next
assume "convergent f"
from convergent_mult[OF convergent_const[of c] this] show "convergent (\<lambda>n. c * f n)"
by simp
qed
lemma convergent_mult_const_right_iff:
fixes c :: "'a::{field,topological_semigroup_mult}"
assumes "c \<noteq> 0"
shows "convergent (\<lambda>n. f n * c) \<longleftrightarrow> convergent f"
using convergent_mult_const_iff[OF assms, of f] by (simp add: mult_ac)
lemma convergent_imp_Bseq: "convergent f \<Longrightarrow> Bseq f"
by (simp add: Cauchy_Bseq convergent_Cauchy)
text \<open>A monotone sequence converges to its least upper bound.\<close>
lemma LIMSEQ_incseq_SUP:
fixes X :: "nat \<Rightarrow> 'a::{conditionally_complete_linorder,linorder_topology}"
assumes u: "bdd_above (range X)"
and X: "incseq X"
shows "X \<longlonglongrightarrow> (SUP i. X i)"
by (rule order_tendstoI)
(auto simp: eventually_sequentially u less_cSUP_iff
intro: X[THEN incseqD] less_le_trans cSUP_lessD[OF u])
lemma LIMSEQ_decseq_INF:
fixes X :: "nat \<Rightarrow> 'a::{conditionally_complete_linorder, linorder_topology}"
assumes u: "bdd_below (range X)"
and X: "decseq X"
shows "X \<longlonglongrightarrow> (INF i. X i)"
by (rule order_tendstoI)
(auto simp: eventually_sequentially u cINF_less_iff
intro: X[THEN decseqD] le_less_trans less_cINF_D[OF u])
text \<open>Main monotonicity theorem.\<close>
lemma Bseq_monoseq_convergent: "Bseq X \<Longrightarrow> monoseq X \<Longrightarrow> convergent X"
for X :: "nat \<Rightarrow> real"
by (auto simp: monoseq_iff convergent_def intro: LIMSEQ_decseq_INF LIMSEQ_incseq_SUP
dest: Bseq_bdd_above Bseq_bdd_below)
lemma Bseq_mono_convergent: "Bseq X \<Longrightarrow> (\<forall>m n. m \<le> n \<longrightarrow> X m \<le> X n) \<Longrightarrow> convergent X"
for X :: "nat \<Rightarrow> real"
by (auto intro!: Bseq_monoseq_convergent incseq_imp_monoseq simp: incseq_def)
lemma monoseq_imp_convergent_iff_Bseq: "monoseq f \<Longrightarrow> convergent f \<longleftrightarrow> Bseq f"
for f :: "nat \<Rightarrow> real"
using Bseq_monoseq_convergent[of f] convergent_imp_Bseq[of f] by blast
lemma Bseq_monoseq_convergent'_inc:
fixes f :: "nat \<Rightarrow> real"
shows "Bseq (\<lambda>n. f (n + M)) \<Longrightarrow> (\<And>m n. M \<le> m \<Longrightarrow> m \<le> n \<Longrightarrow> f m \<le> f n) \<Longrightarrow> convergent f"
by (subst convergent_ignore_initial_segment [symmetric, of _ M])
(auto intro!: Bseq_monoseq_convergent simp: monoseq_def)
lemma Bseq_monoseq_convergent'_dec:
fixes f :: "nat \<Rightarrow> real"
shows "Bseq (\<lambda>n. f (n + M)) \<Longrightarrow> (\<And>m n. M \<le> m \<Longrightarrow> m \<le> n \<Longrightarrow> f m \<ge> f n) \<Longrightarrow> convergent f"
by (subst convergent_ignore_initial_segment [symmetric, of _ M])
(auto intro!: Bseq_monoseq_convergent simp: monoseq_def)
lemma Cauchy_iff: "Cauchy X \<longleftrightarrow> (\<forall>e>0. \<exists>M. \<forall>m\<ge>M. \<forall>n\<ge>M. norm (X m - X n) < e)"
for X :: "nat \<Rightarrow> 'a::real_normed_vector"
unfolding Cauchy_def dist_norm ..
lemma CauchyI: "(\<And>e. 0 < e \<Longrightarrow> \<exists>M. \<forall>m\<ge>M. \<forall>n\<ge>M. norm (X m - X n) < e) \<Longrightarrow> Cauchy X"
for X :: "nat \<Rightarrow> 'a::real_normed_vector"
by (simp add: Cauchy_iff)
lemma CauchyD: "Cauchy X \<Longrightarrow> 0 < e \<Longrightarrow> \<exists>M. \<forall>m\<ge>M. \<forall>n\<ge>M. norm (X m - X n) < e"
for X :: "nat \<Rightarrow> 'a::real_normed_vector"
by (simp add: Cauchy_iff)
lemma incseq_convergent:
fixes X :: "nat \<Rightarrow> real"
assumes "incseq X"
and "\<forall>i. X i \<le> B"
obtains L where "X \<longlonglongrightarrow> L" "\<forall>i. X i \<le> L"
proof atomize_elim
from incseq_bounded[OF assms] \<open>incseq X\<close> Bseq_monoseq_convergent[of X]
obtain L where "X \<longlonglongrightarrow> L"
by (auto simp: convergent_def monoseq_def incseq_def)
with \<open>incseq X\<close> show "\<exists>L. X \<longlonglongrightarrow> L \<and> (\<forall>i. X i \<le> L)"
by (auto intro!: exI[of _ L] incseq_le)
qed
lemma decseq_convergent:
fixes X :: "nat \<Rightarrow> real"
assumes "decseq X"
and "\<forall>i. B \<le> X i"
obtains L where "X \<longlonglongrightarrow> L" "\<forall>i. L \<le> X i"
proof atomize_elim
from decseq_bounded[OF assms] \<open>decseq X\<close> Bseq_monoseq_convergent[of X]
obtain L where "X \<longlonglongrightarrow> L"
by (auto simp: convergent_def monoseq_def decseq_def)
with \<open>decseq X\<close> show "\<exists>L. X \<longlonglongrightarrow> L \<and> (\<forall>i. L \<le> X i)"
by (auto intro!: exI[of _ L] decseq_ge)
qed
lemma monoseq_convergent:
fixes X :: "nat \<Rightarrow> real"
assumes X: "monoseq X" and B: "\<And>i. \<bar>X i\<bar> \<le> B"
obtains L where "X \<longlonglongrightarrow> L"
using X unfolding monoseq_iff
proof
assume "incseq X"
show thesis
using abs_le_D1 [OF B] incseq_convergent [OF \<open>incseq X\<close>] that by meson
next
assume "decseq X"
show thesis
using decseq_convergent [OF \<open>decseq X\<close>] that
by (metis B abs_le_iff add.inverse_inverse neg_le_iff_le)
qed
subsection \<open>Power Sequences\<close>
lemma Bseq_realpow: "0 \<le> x \<Longrightarrow> x \<le> 1 \<Longrightarrow> Bseq (\<lambda>n. x ^ n)"
for x :: real
by (metis decseq_bounded decseq_def power_decreasing zero_le_power)
lemma monoseq_realpow: "0 \<le> x \<Longrightarrow> x \<le> 1 \<Longrightarrow> monoseq (\<lambda>n. x ^ n)"
for x :: real
using monoseq_def power_decreasing by blast
lemma convergent_realpow: "0 \<le> x \<Longrightarrow> x \<le> 1 \<Longrightarrow> convergent (\<lambda>n. x ^ n)"
for x :: real
by (blast intro!: Bseq_monoseq_convergent Bseq_realpow monoseq_realpow)
lemma LIMSEQ_inverse_realpow_zero: "1 < x \<Longrightarrow> (\<lambda>n. inverse (x ^ n)) \<longlonglongrightarrow> 0"
for x :: real
by (rule filterlim_compose[OF tendsto_inverse_0 filterlim_realpow_sequentially_gt1]) simp
lemma LIMSEQ_realpow_zero:
fixes x :: real
assumes "0 \<le> x" "x < 1"
shows "(\<lambda>n. x ^ n) \<longlonglongrightarrow> 0"
proof (cases "x = 0")
case False
with \<open>0 \<le> x\<close> have x0: "0 < x" by simp
then have "1 < inverse x"
using \<open>x < 1\<close> by (rule one_less_inverse)
then have "(\<lambda>n. inverse (inverse x ^ n)) \<longlonglongrightarrow> 0"
by (rule LIMSEQ_inverse_realpow_zero)
then show ?thesis by (simp add: power_inverse)
next
case True
show ?thesis
by (rule LIMSEQ_imp_Suc) (simp add: True)
qed
lemma LIMSEQ_power_zero [tendsto_intros]: "norm x < 1 \<Longrightarrow> (\<lambda>n. x ^ n) \<longlonglongrightarrow> 0"
for x :: "'a::real_normed_algebra_1"
apply (drule LIMSEQ_realpow_zero [OF norm_ge_zero])
by (simp add: Zfun_le norm_power_ineq tendsto_Zfun_iff)
lemma LIMSEQ_divide_realpow_zero: "1 < x \<Longrightarrow> (\<lambda>n. a / (x ^ n) :: real) \<longlonglongrightarrow> 0"
by (rule tendsto_divide_0 [OF tendsto_const filterlim_realpow_sequentially_gt1]) simp
lemma
tendsto_power_zero:
fixes x::"'a::real_normed_algebra_1"
assumes "filterlim f at_top F"
assumes "norm x < 1"
shows "((\<lambda>y. x ^ (f y)) \<longlongrightarrow> 0) F"
proof (rule tendstoI)
fix e::real assume "0 < e"
from tendstoD[OF LIMSEQ_power_zero[OF \<open>norm x < 1\<close>] \<open>0 < e\<close>]
have "\<forall>\<^sub>F xa in sequentially. norm (x ^ xa) < e"
by simp
then obtain N where N: "norm (x ^ n) < e" if "n \<ge> N" for n
by (auto simp: eventually_sequentially)
have "\<forall>\<^sub>F i in F. f i \<ge> N"
using \<open>filterlim f sequentially F\<close>
by (simp add: filterlim_at_top)
then show "\<forall>\<^sub>F i in F. dist (x ^ f i) 0 < e"
by eventually_elim (auto simp: N)
qed
text \<open>Limit of \<^term>\<open>c^n\<close> for \<^term>\<open>\<bar>c\<bar> < 1\<close>.\<close>
lemma LIMSEQ_abs_realpow_zero: "\<bar>c\<bar> < 1 \<Longrightarrow> (\<lambda>n. \<bar>c\<bar> ^ n :: real) \<longlonglongrightarrow> 0"
by (rule LIMSEQ_realpow_zero [OF abs_ge_zero])
lemma LIMSEQ_abs_realpow_zero2: "\<bar>c\<bar> < 1 \<Longrightarrow> (\<lambda>n. c ^ n :: real) \<longlonglongrightarrow> 0"
by (rule LIMSEQ_power_zero) simp
subsection \<open>Limits of Functions\<close>
lemma LIM_eq: "f \<midarrow>a\<rightarrow> L = (\<forall>r>0. \<exists>s>0. \<forall>x. x \<noteq> a \<and> norm (x - a) < s \<longrightarrow> norm (f x - L) < r)"
for a :: "'a::real_normed_vector" and L :: "'b::real_normed_vector"
by (simp add: LIM_def dist_norm)
lemma LIM_I:
"(\<And>r. 0 < r \<Longrightarrow> \<exists>s>0. \<forall>x. x \<noteq> a \<and> norm (x - a) < s \<longrightarrow> norm (f x - L) < r) \<Longrightarrow> f \<midarrow>a\<rightarrow> L"
for a :: "'a::real_normed_vector" and L :: "'b::real_normed_vector"
by (simp add: LIM_eq)
lemma LIM_D: "f \<midarrow>a\<rightarrow> L \<Longrightarrow> 0 < r \<Longrightarrow> \<exists>s>0.\<forall>x. x \<noteq> a \<and> norm (x - a) < s \<longrightarrow> norm (f x - L) < r"
for a :: "'a::real_normed_vector" and L :: "'b::real_normed_vector"
by (simp add: LIM_eq)
lemma LIM_offset: "f \<midarrow>a\<rightarrow> L \<Longrightarrow> (\<lambda>x. f (x + k)) \<midarrow>(a - k)\<rightarrow> L"
for a :: "'a::real_normed_vector"
by (simp add: filtermap_at_shift[symmetric, of a k] filterlim_def filtermap_filtermap)
lemma LIM_offset_zero: "f \<midarrow>a\<rightarrow> L \<Longrightarrow> (\<lambda>h. f (a + h)) \<midarrow>0\<rightarrow> L"
for a :: "'a::real_normed_vector"
by (drule LIM_offset [where k = a]) (simp add: add.commute)
lemma LIM_offset_zero_cancel: "(\<lambda>h. f (a + h)) \<midarrow>0\<rightarrow> L \<Longrightarrow> f \<midarrow>a\<rightarrow> L"
for a :: "'a::real_normed_vector"
by (drule LIM_offset [where k = "- a"]) simp
lemma LIM_offset_zero_iff: "NO_MATCH 0 a \<Longrightarrow> f \<midarrow>a\<rightarrow> L \<longleftrightarrow> (\<lambda>h. f (a + h)) \<midarrow>0\<rightarrow> L"
for f :: "'a :: real_normed_vector \<Rightarrow> _"
using LIM_offset_zero_cancel[of f a L] LIM_offset_zero[of f L a] by auto
lemma tendsto_offset_zero_iff:
fixes f :: "'a :: real_normed_vector \<Rightarrow> _"
assumes " NO_MATCH 0 a" "a \<in> S" "open S"
shows "(f \<longlongrightarrow> L) (at a within S) \<longleftrightarrow> ((\<lambda>h. f (a + h)) \<longlongrightarrow> L) (at 0)"
using assms by (simp add: tendsto_within_open_NO_MATCH LIM_offset_zero_iff)
lemma LIM_zero: "(f \<longlongrightarrow> l) F \<Longrightarrow> ((\<lambda>x. f x - l) \<longlongrightarrow> 0) F"
for f :: "'a \<Rightarrow> 'b::real_normed_vector"
unfolding tendsto_iff dist_norm by simp
lemma LIM_zero_cancel:
fixes f :: "'a \<Rightarrow> 'b::real_normed_vector"
shows "((\<lambda>x. f x - l) \<longlongrightarrow> 0) F \<Longrightarrow> (f \<longlongrightarrow> l) F"
unfolding tendsto_iff dist_norm by simp
lemma LIM_zero_iff: "((\<lambda>x. f x - l) \<longlongrightarrow> 0) F = (f \<longlongrightarrow> l) F"
for f :: "'a \<Rightarrow> 'b::real_normed_vector"
unfolding tendsto_iff dist_norm by simp
lemma LIM_imp_LIM:
fixes f :: "'a::topological_space \<Rightarrow> 'b::real_normed_vector"
fixes g :: "'a::topological_space \<Rightarrow> 'c::real_normed_vector"
assumes f: "f \<midarrow>a\<rightarrow> l"
and le: "\<And>x. x \<noteq> a \<Longrightarrow> norm (g x - m) \<le> norm (f x - l)"
shows "g \<midarrow>a\<rightarrow> m"
by (rule metric_LIM_imp_LIM [OF f]) (simp add: dist_norm le)
lemma LIM_equal2:
fixes f g :: "'a::real_normed_vector \<Rightarrow> 'b::topological_space"
assumes "0 < R"
and "\<And>x. x \<noteq> a \<Longrightarrow> norm (x - a) < R \<Longrightarrow> f x = g x"
shows "g \<midarrow>a\<rightarrow> l \<Longrightarrow> f \<midarrow>a\<rightarrow> l"
by (rule metric_LIM_equal2 [OF _ assms]) (simp_all add: dist_norm)
lemma LIM_compose2:
fixes a :: "'a::real_normed_vector"
assumes f: "f \<midarrow>a\<rightarrow> b"
and g: "g \<midarrow>b\<rightarrow> c"
and inj: "\<exists>d>0. \<forall>x. x \<noteq> a \<and> norm (x - a) < d \<longrightarrow> f x \<noteq> b"
shows "(\<lambda>x. g (f x)) \<midarrow>a\<rightarrow> c"
by (rule metric_LIM_compose2 [OF f g inj [folded dist_norm]])
lemma real_LIM_sandwich_zero:
fixes f g :: "'a::topological_space \<Rightarrow> real"
assumes f: "f \<midarrow>a\<rightarrow> 0"
and 1: "\<And>x. x \<noteq> a \<Longrightarrow> 0 \<le> g x"
and 2: "\<And>x. x \<noteq> a \<Longrightarrow> g x \<le> f x"
shows "g \<midarrow>a\<rightarrow> 0"
proof (rule LIM_imp_LIM [OF f]) (* FIXME: use tendsto_sandwich *)
fix x
assume x: "x \<noteq> a"
with 1 have "norm (g x - 0) = g x" by simp
also have "g x \<le> f x" by (rule 2 [OF x])
also have "f x \<le> \<bar>f x\<bar>" by (rule abs_ge_self)
also have "\<bar>f x\<bar> = norm (f x - 0)" by simp
finally show "norm (g x - 0) \<le> norm (f x - 0)" .
qed
subsection \<open>Continuity\<close>
lemma LIM_isCont_iff: "(f \<midarrow>a\<rightarrow> f a) = ((\<lambda>h. f (a + h)) \<midarrow>0\<rightarrow> f a)"
for f :: "'a::real_normed_vector \<Rightarrow> 'b::topological_space"
by (rule iffI [OF LIM_offset_zero LIM_offset_zero_cancel])
lemma isCont_iff: "isCont f x = (\<lambda>h. f (x + h)) \<midarrow>0\<rightarrow> f x"
for f :: "'a::real_normed_vector \<Rightarrow> 'b::topological_space"
by (simp add: isCont_def LIM_isCont_iff)
lemma isCont_LIM_compose2:
fixes a :: "'a::real_normed_vector"
assumes f [unfolded isCont_def]: "isCont f a"
and g: "g \<midarrow>f a\<rightarrow> l"
and inj: "\<exists>d>0. \<forall>x. x \<noteq> a \<and> norm (x - a) < d \<longrightarrow> f x \<noteq> f a"
shows "(\<lambda>x. g (f x)) \<midarrow>a\<rightarrow> l"
by (rule LIM_compose2 [OF f g inj])
lemma isCont_norm [simp]: "isCont f a \<Longrightarrow> isCont (\<lambda>x. norm (f x)) a"
for f :: "'a::t2_space \<Rightarrow> 'b::real_normed_vector"
by (fact continuous_norm)
lemma isCont_rabs [simp]: "isCont f a \<Longrightarrow> isCont (\<lambda>x. \<bar>f x\<bar>) a"
for f :: "'a::t2_space \<Rightarrow> real"
by (fact continuous_rabs)
lemma isCont_add [simp]: "isCont f a \<Longrightarrow> isCont g a \<Longrightarrow> isCont (\<lambda>x. f x + g x) a"
for f :: "'a::t2_space \<Rightarrow> 'b::topological_monoid_add"
by (fact continuous_add)
lemma isCont_minus [simp]: "isCont f a \<Longrightarrow> isCont (\<lambda>x. - f x) a"
for f :: "'a::t2_space \<Rightarrow> 'b::real_normed_vector"
by (fact continuous_minus)
lemma isCont_diff [simp]: "isCont f a \<Longrightarrow> isCont g a \<Longrightarrow> isCont (\<lambda>x. f x - g x) a"
for f :: "'a::t2_space \<Rightarrow> 'b::real_normed_vector"
by (fact continuous_diff)
lemma isCont_mult [simp]: "isCont f a \<Longrightarrow> isCont g a \<Longrightarrow> isCont (\<lambda>x. f x * g x) a"
for f g :: "'a::t2_space \<Rightarrow> 'b::real_normed_algebra"
by (fact continuous_mult)
lemma (in bounded_linear) isCont: "isCont g a \<Longrightarrow> isCont (\<lambda>x. f (g x)) a"
by (fact continuous)
lemma (in bounded_bilinear) isCont: "isCont f a \<Longrightarrow> isCont g a \<Longrightarrow> isCont (\<lambda>x. f x ** g x) a"
by (fact continuous)
lemmas isCont_scaleR [simp] =
bounded_bilinear.isCont [OF bounded_bilinear_scaleR]
lemmas isCont_of_real [simp] =
bounded_linear.isCont [OF bounded_linear_of_real]
lemma isCont_power [simp]: "isCont f a \<Longrightarrow> isCont (\<lambda>x. f x ^ n) a"
for f :: "'a::t2_space \<Rightarrow> 'b::{power,real_normed_algebra}"
by (fact continuous_power)
lemma isCont_sum [simp]: "\<forall>i\<in>A. isCont (f i) a \<Longrightarrow> isCont (\<lambda>x. \<Sum>i\<in>A. f i x) a"
for f :: "'a \<Rightarrow> 'b::t2_space \<Rightarrow> 'c::topological_comm_monoid_add"
by (auto intro: continuous_sum)
subsection \<open>Uniform Continuity\<close>
lemma uniformly_continuous_on_def:
fixes f :: "'a::metric_space \<Rightarrow> 'b::metric_space"
shows "uniformly_continuous_on s f \<longleftrightarrow>
(\<forall>e>0. \<exists>d>0. \<forall>x\<in>s. \<forall>x'\<in>s. dist x' x < d \<longrightarrow> dist (f x') (f x) < e)"
unfolding uniformly_continuous_on_uniformity
uniformity_dist filterlim_INF filterlim_principal eventually_inf_principal
by (force simp: Ball_def uniformity_dist[symmetric] eventually_uniformity_metric)
abbreviation isUCont :: "['a::metric_space \<Rightarrow> 'b::metric_space] \<Rightarrow> bool"
where "isUCont f \<equiv> uniformly_continuous_on UNIV f"
lemma isUCont_def: "isUCont f \<longleftrightarrow> (\<forall>r>0. \<exists>s>0. \<forall>x y. dist x y < s \<longrightarrow> dist (f x) (f y) < r)"
by (auto simp: uniformly_continuous_on_def dist_commute)
lemma isUCont_isCont: "isUCont f \<Longrightarrow> isCont f x"
by (drule uniformly_continuous_imp_continuous) (simp add: continuous_on_eq_continuous_at)
lemma uniformly_continuous_on_Cauchy:
fixes f :: "'a::metric_space \<Rightarrow> 'b::metric_space"
assumes "uniformly_continuous_on S f" "Cauchy X" "\<And>n. X n \<in> S"
shows "Cauchy (\<lambda>n. f (X n))"
using assms
unfolding uniformly_continuous_on_def by (meson Cauchy_def)
lemma isUCont_Cauchy: "isUCont f \<Longrightarrow> Cauchy X \<Longrightarrow> Cauchy (\<lambda>n. f (X n))"
by (rule uniformly_continuous_on_Cauchy[where S=UNIV and f=f]) simp_all
lemma uniformly_continuous_imp_Cauchy_continuous:
fixes f :: "'a::metric_space \<Rightarrow> 'b::metric_space"
shows "\<lbrakk>uniformly_continuous_on S f; Cauchy \<sigma>; \<And>n. (\<sigma> n) \<in> S\<rbrakk> \<Longrightarrow> Cauchy(f \<circ> \<sigma>)"
by (simp add: uniformly_continuous_on_def Cauchy_def) meson
lemma (in bounded_linear) isUCont: "isUCont f"
unfolding isUCont_def dist_norm
proof (intro allI impI)
fix r :: real
assume r: "0 < r"
obtain K where K: "0 < K" and norm_le: "norm (f x) \<le> norm x * K" for x
using pos_bounded by blast
show "\<exists>s>0. \<forall>x y. norm (x - y) < s \<longrightarrow> norm (f x - f y) < r"
proof (rule exI, safe)
from r K show "0 < r / K" by simp
next
fix x y :: 'a
assume xy: "norm (x - y) < r / K"
have "norm (f x - f y) = norm (f (x - y))" by (simp only: diff)
also have "\<dots> \<le> norm (x - y) * K" by (rule norm_le)
also from K xy have "\<dots> < r" by (simp only: pos_less_divide_eq)
finally show "norm (f x - f y) < r" .
qed
qed
lemma (in bounded_linear) Cauchy: "Cauchy X \<Longrightarrow> Cauchy (\<lambda>n. f (X n))"
by (rule isUCont [THEN isUCont_Cauchy])
lemma LIM_less_bound:
fixes f :: "real \<Rightarrow> real"
assumes ev: "b < x" "\<forall> x' \<in> { b <..< x}. 0 \<le> f x'" and "isCont f x"
shows "0 \<le> f x"
proof (rule tendsto_lowerbound)
show "(f \<longlongrightarrow> f x) (at_left x)"
using \<open>isCont f x\<close> by (simp add: filterlim_at_split isCont_def)
show "eventually (\<lambda>x. 0 \<le> f x) (at_left x)"
using ev by (auto simp: eventually_at dist_real_def intro!: exI[of _ "x - b"])
qed simp
subsection \<open>Nested Intervals and Bisection -- Needed for Compactness\<close>
lemma nested_sequence_unique:
assumes "\<forall>n. f n \<le> f (Suc n)" "\<forall>n. g (Suc n) \<le> g n" "\<forall>n. f n \<le> g n" "(\<lambda>n. f n - g n) \<longlonglongrightarrow> 0"
shows "\<exists>l::real. ((\<forall>n. f n \<le> l) \<and> f \<longlonglongrightarrow> l) \<and> ((\<forall>n. l \<le> g n) \<and> g \<longlonglongrightarrow> l)"
proof -
have "incseq f" unfolding incseq_Suc_iff by fact
have "decseq g" unfolding decseq_Suc_iff by fact
have "f n \<le> g 0" for n
proof -
from \<open>decseq g\<close> have "g n \<le> g 0"
by (rule decseqD) simp
with \<open>\<forall>n. f n \<le> g n\<close>[THEN spec, of n] show ?thesis
by auto
qed
then obtain u where "f \<longlonglongrightarrow> u" "\<forall>i. f i \<le> u"
using incseq_convergent[OF \<open>incseq f\<close>] by auto
moreover have "f 0 \<le> g n" for n
proof -
from \<open>incseq f\<close> have "f 0 \<le> f n" by (rule incseqD) simp
with \<open>\<forall>n. f n \<le> g n\<close>[THEN spec, of n] show ?thesis
by simp
qed
then obtain l where "g \<longlonglongrightarrow> l" "\<forall>i. l \<le> g i"
using decseq_convergent[OF \<open>decseq g\<close>] by auto
moreover note LIMSEQ_unique[OF assms(4) tendsto_diff[OF \<open>f \<longlonglongrightarrow> u\<close> \<open>g \<longlonglongrightarrow> l\<close>]]
ultimately show ?thesis by auto
qed
lemma Bolzano[consumes 1, case_names trans local]:
fixes P :: "real \<Rightarrow> real \<Rightarrow> bool"
assumes [arith]: "a \<le> b"
and trans: "\<And>a b c. P a b \<Longrightarrow> P b c \<Longrightarrow> a \<le> b \<Longrightarrow> b \<le> c \<Longrightarrow> P a c"
and local: "\<And>x. a \<le> x \<Longrightarrow> x \<le> b \<Longrightarrow> \<exists>d>0. \<forall>a b. a \<le> x \<and> x \<le> b \<and> b - a < d \<longrightarrow> P a b"
shows "P a b"
proof -
define bisect where "bisect \<equiv> \<lambda>(x,y). if P x ((x+y) / 2) then ((x+y)/2, y) else (x, (x+y)/2)"
define l u where "l n \<equiv> fst ((bisect^^n)(a,b))" and "u n \<equiv> snd ((bisect^^n)(a,b))" for n
have l[simp]: "l 0 = a" "\<And>n. l (Suc n) = (if P (l n) ((l n + u n) / 2) then (l n + u n) / 2 else l n)"
and u[simp]: "u 0 = b" "\<And>n. u (Suc n) = (if P (l n) ((l n + u n) / 2) then u n else (l n + u n) / 2)"
by (simp_all add: l_def u_def bisect_def split: prod.split)
have [simp]: "l n \<le> u n" for n by (induct n) auto
have "\<exists>x. ((\<forall>n. l n \<le> x) \<and> l \<longlonglongrightarrow> x) \<and> ((\<forall>n. x \<le> u n) \<and> u \<longlonglongrightarrow> x)"
proof (safe intro!: nested_sequence_unique)
show "l n \<le> l (Suc n)" "u (Suc n) \<le> u n" for n
by (induct n) auto
next
have "l n - u n = (a - b) / 2^n" for n
by (induct n) (auto simp: field_simps)
then show "(\<lambda>n. l n - u n) \<longlonglongrightarrow> 0"
by (simp add: LIMSEQ_divide_realpow_zero)
qed fact
then obtain x where x: "\<And>n. l n \<le> x" "\<And>n. x \<le> u n" and "l \<longlonglongrightarrow> x" "u \<longlonglongrightarrow> x"
by auto
obtain d where "0 < d" and d: "a \<le> x \<Longrightarrow> x \<le> b \<Longrightarrow> b - a < d \<Longrightarrow> P a b" for a b
using \<open>l 0 \<le> x\<close> \<open>x \<le> u 0\<close> local[of x] by auto
show "P a b"
proof (rule ccontr)
assume "\<not> P a b"
have "\<not> P (l n) (u n)" for n
proof (induct n)
case 0
then show ?case
by (simp add: \<open>\<not> P a b\<close>)
next
case (Suc n)
with trans[of "l n" "(l n + u n) / 2" "u n"] show ?case
by auto
qed
moreover
{
have "eventually (\<lambda>n. x - d / 2 < l n) sequentially"
using \<open>0 < d\<close> \<open>l \<longlonglongrightarrow> x\<close> by (intro order_tendstoD[of _ x]) auto
moreover have "eventually (\<lambda>n. u n < x + d / 2) sequentially"
using \<open>0 < d\<close> \<open>u \<longlonglongrightarrow> x\<close> by (intro order_tendstoD[of _ x]) auto
ultimately have "eventually (\<lambda>n. P (l n) (u n)) sequentially"
proof eventually_elim
case (elim n)
from add_strict_mono[OF this] have "u n - l n < d" by simp
with x show "P (l n) (u n)" by (rule d)
qed
}
ultimately show False by simp
qed
qed
lemma compact_Icc[simp, intro]: "compact {a .. b::real}"
proof (cases "a \<le> b", rule compactI)
fix C
assume C: "a \<le> b" "\<forall>t\<in>C. open t" "{a..b} \<subseteq> \<Union>C"
define T where "T = {a .. b}"
from C(1,3) show "\<exists>C'\<subseteq>C. finite C' \<and> {a..b} \<subseteq> \<Union>C'"
proof (induct rule: Bolzano)
case (trans a b c)
then have *: "{a..c} = {a..b} \<union> {b..c}"
by auto
with trans obtain C1 C2
where "C1\<subseteq>C" "finite C1" "{a..b} \<subseteq> \<Union>C1" "C2\<subseteq>C" "finite C2" "{b..c} \<subseteq> \<Union>C2"
by auto
with trans show ?case
unfolding * by (intro exI[of _ "C1 \<union> C2"]) auto
next
case (local x)
with C have "x \<in> \<Union>C" by auto
with C(2) obtain c where "x \<in> c" "open c" "c \<in> C"
by auto
then obtain e where "0 < e" "{x - e <..< x + e} \<subseteq> c"
by (auto simp: open_dist dist_real_def subset_eq Ball_def abs_less_iff)
with \<open>c \<in> C\<close> show ?case
by (safe intro!: exI[of _ "e/2"] exI[of _ "{c}"]) auto
qed
qed simp
lemma continuous_image_closed_interval:
fixes a b and f :: "real \<Rightarrow> real"
defines "S \<equiv> {a..b}"
assumes "a \<le> b" and f: "continuous_on S f"
shows "\<exists>c d. f`S = {c..d} \<and> c \<le> d"
proof -
have S: "compact S" "S \<noteq> {}"
using \<open>a \<le> b\<close> by (auto simp: S_def)
obtain c where "c \<in> S" "\<forall>d\<in>S. f d \<le> f c"
using continuous_attains_sup[OF S f] by auto
moreover obtain d where "d \<in> S" "\<forall>c\<in>S. f d \<le> f c"
using continuous_attains_inf[OF S f] by auto
moreover have "connected (f`S)"
using connected_continuous_image[OF f] connected_Icc by (auto simp: S_def)
ultimately have "f ` S = {f d .. f c} \<and> f d \<le> f c"
by (auto simp: connected_iff_interval)
then show ?thesis
by auto
qed
lemma open_Collect_positive:
fixes f :: "'a::topological_space \<Rightarrow> real"
assumes f: "continuous_on s f"
shows "\<exists>A. open A \<and> A \<inter> s = {x\<in>s. 0 < f x}"
using continuous_on_open_invariant[THEN iffD1, OF f, rule_format, of "{0 <..}"]
by (auto simp: Int_def field_simps)
lemma open_Collect_less_Int:
fixes f g :: "'a::topological_space \<Rightarrow> real"
assumes f: "continuous_on s f"
and g: "continuous_on s g"
shows "\<exists>A. open A \<and> A \<inter> s = {x\<in>s. f x < g x}"
using open_Collect_positive[OF continuous_on_diff[OF g f]] by (simp add: field_simps)
subsection \<open>Boundedness of continuous functions\<close>
text\<open>By bisection, function continuous on closed interval is bounded above\<close>
lemma isCont_eq_Ub:
fixes f :: "real \<Rightarrow> 'a::linorder_topology"
shows "a \<le> b \<Longrightarrow> \<forall>x::real. a \<le> x \<and> x \<le> b \<longrightarrow> isCont f x \<Longrightarrow>
\<exists>M. (\<forall>x. a \<le> x \<and> x \<le> b \<longrightarrow> f x \<le> M) \<and> (\<exists>x. a \<le> x \<and> x \<le> b \<and> f x = M)"
using continuous_attains_sup[of "{a..b}" f]
by (auto simp: continuous_at_imp_continuous_on Ball_def Bex_def)
lemma isCont_eq_Lb:
fixes f :: "real \<Rightarrow> 'a::linorder_topology"
shows "a \<le> b \<Longrightarrow> \<forall>x. a \<le> x \<and> x \<le> b \<longrightarrow> isCont f x \<Longrightarrow>
\<exists>M. (\<forall>x. a \<le> x \<and> x \<le> b \<longrightarrow> M \<le> f x) \<and> (\<exists>x. a \<le> x \<and> x \<le> b \<and> f x = M)"
using continuous_attains_inf[of "{a..b}" f]
by (auto simp: continuous_at_imp_continuous_on Ball_def Bex_def)
lemma isCont_bounded:
fixes f :: "real \<Rightarrow> 'a::linorder_topology"
shows "a \<le> b \<Longrightarrow> \<forall>x. a \<le> x \<and> x \<le> b \<longrightarrow> isCont f x \<Longrightarrow> \<exists>M. \<forall>x. a \<le> x \<and> x \<le> b \<longrightarrow> f x \<le> M"
using isCont_eq_Ub[of a b f] by auto
lemma isCont_has_Ub:
fixes f :: "real \<Rightarrow> 'a::linorder_topology"
shows "a \<le> b \<Longrightarrow> \<forall>x. a \<le> x \<and> x \<le> b \<longrightarrow> isCont f x \<Longrightarrow>
\<exists>M. (\<forall>x. a \<le> x \<and> x \<le> b \<longrightarrow> f x \<le> M) \<and> (\<forall>N. N < M \<longrightarrow> (\<exists>x. a \<le> x \<and> x \<le> b \<and> N < f x))"
using isCont_eq_Ub[of a b f] by auto
lemma isCont_Lb_Ub:
fixes f :: "real \<Rightarrow> real"
assumes "a \<le> b" "\<forall>x. a \<le> x \<and> x \<le> b \<longrightarrow> isCont f x"
shows "\<exists>L M. (\<forall>x. a \<le> x \<and> x \<le> b \<longrightarrow> L \<le> f x \<and> f x \<le> M) \<and>
(\<forall>y. L \<le> y \<and> y \<le> M \<longrightarrow> (\<exists>x. a \<le> x \<and> x \<le> b \<and> (f x = y)))"
proof -
obtain M where M: "a \<le> M" "M \<le> b" "\<forall>x. a \<le> x \<and> x \<le> b \<longrightarrow> f x \<le> f M"
using isCont_eq_Ub[OF assms] by auto
obtain L where L: "a \<le> L" "L \<le> b" "\<forall>x. a \<le> x \<and> x \<le> b \<longrightarrow> f L \<le> f x"
using isCont_eq_Lb[OF assms] by auto
have "(\<forall>x. a \<le> x \<and> x \<le> b \<longrightarrow> f L \<le> f x \<and> f x \<le> f M)"
using M L by simp
moreover
have "(\<forall>y. f L \<le> y \<and> y \<le> f M \<longrightarrow> (\<exists>x\<ge>a. x \<le> b \<and> f x = y))"
proof (cases "L \<le> M")
case True then show ?thesis
using IVT[of f L _ M] M L assms by (metis order.trans)
next
case False then show ?thesis
using IVT2[of f L _ M]
by (metis L(2) M(1) assms(2) le_cases order.trans)
qed
ultimately show ?thesis
by blast
qed
text \<open>Continuity of inverse function.\<close>
lemma isCont_inverse_function:
fixes f g :: "real \<Rightarrow> real"
assumes d: "0 < d"
and inj: "\<And>z. \<bar>z-x\<bar> \<le> d \<Longrightarrow> g (f z) = z"
and cont: "\<And>z. \<bar>z-x\<bar> \<le> d \<Longrightarrow> isCont f z"
shows "isCont g (f x)"
proof -
let ?A = "f (x - d)"
let ?B = "f (x + d)"
let ?D = "{x - d..x + d}"
have f: "continuous_on ?D f"
using cont by (intro continuous_at_imp_continuous_on ballI) auto
then have g: "continuous_on (f`?D) g"
using inj by (intro continuous_on_inv) auto
from d f have "{min ?A ?B <..< max ?A ?B} \<subseteq> f ` ?D"
by (intro connected_contains_Ioo connected_continuous_image) (auto split: split_min split_max)
with g have "continuous_on {min ?A ?B <..< max ?A ?B} g"
by (rule continuous_on_subset)
moreover
have "(?A < f x \<and> f x < ?B) \<or> (?B < f x \<and> f x < ?A)"
using d inj by (intro continuous_inj_imp_mono[OF _ _ f] inj_on_imageI2[of g, OF inj_onI]) auto
then have "f x \<in> {min ?A ?B <..< max ?A ?B}"
by auto
ultimately show ?thesis
by (simp add: continuous_on_eq_continuous_at)
qed
lemma isCont_inverse_function2:
fixes f g :: "real \<Rightarrow> real"
shows
"\<lbrakk>a < x; x < b;
\<And>z. \<lbrakk>a \<le> z; z \<le> b\<rbrakk> \<Longrightarrow> g (f z) = z;
\<And>z. \<lbrakk>a \<le> z; z \<le> b\<rbrakk> \<Longrightarrow> isCont f z\<rbrakk> \<Longrightarrow> isCont g (f x)"
apply (rule isCont_inverse_function [where f=f and d="min (x - a) (b - x)"])
apply (simp_all add: abs_le_iff)
done
text \<open>Bartle/Sherbert: Introduction to Real Analysis, Theorem 4.2.9, p. 110.\<close>
lemma LIM_fun_gt_zero: "f \<midarrow>c\<rightarrow> l \<Longrightarrow> 0 < l \<Longrightarrow> \<exists>r. 0 < r \<and> (\<forall>x. x \<noteq> c \<and> \<bar>c - x\<bar> < r \<longrightarrow> 0 < f x)"
for f :: "real \<Rightarrow> real"
by (force simp: dest: LIM_D)
lemma LIM_fun_less_zero: "f \<midarrow>c\<rightarrow> l \<Longrightarrow> l < 0 \<Longrightarrow> \<exists>r. 0 < r \<and> (\<forall>x. x \<noteq> c \<and> \<bar>c - x\<bar> < r \<longrightarrow> f x < 0)"
for f :: "real \<Rightarrow> real"
by (drule LIM_D [where r="-l"]) force+
lemma LIM_fun_not_zero: "f \<midarrow>c\<rightarrow> l \<Longrightarrow> l \<noteq> 0 \<Longrightarrow> \<exists>r. 0 < r \<and> (\<forall>x. x \<noteq> c \<and> \<bar>c - x\<bar> < r \<longrightarrow> f x \<noteq> 0)"
for f :: "real \<Rightarrow> real"
using LIM_fun_gt_zero[of f l c] LIM_fun_less_zero[of f l c] by (auto simp: neq_iff)
end
|
Formal statement is: lemma le_emeasure_sup_measure'1: assumes "sets B = sets A" "X \<in> sets A" shows "emeasure A X \<le> emeasure (sup_measure' A B) X" Informal statement is: If $B$ is a $\sigma$-algebra that contains $A$, then the outer measure of $X$ with respect to $A$ is less than or equal to the outer measure of $X$ with respect to $B$. |
Formal statement is: lemma measure_mono_fmeasurable: "A \<subseteq> B \<Longrightarrow> A \<in> sets M \<Longrightarrow> B \<in> fmeasurable M \<Longrightarrow> measure M A \<le> measure M B" Informal statement is: If $A \subseteq B$ and $A$ is measurable, then $B$ is measurable and $\mu(A) \leq \mu(B)$. |
Serena Williams penned an emotional letter to mom Oracene Price which she shared on the social networking site Reddit on Tuesday.
Having been by her side since the beginning, 23-time Grand Slam champion Serena Williams has just one thing to say to mom Oracene Price.
The former World No.1, who became a mother herself earlier this month, penned a heartfelt thank you letter to Oracene on the social networking site Reddit, referencing her upbringing, and how her mother taught her to love herself.
"Dear Mom, You are one of the strongest women I know," the former World No.1 wrote. "I was looking at my daughter (OMG, yes, I have a daughter) and she has my arms and legs! My exact same strong, muscular, powerful, sensational arms and body."
Williams gave birth to daughter Alexis Olympia Ohanian, Jr. on Sept. 1.
The youngest of five children, of course including sister Venus, Williams shared how she hopes to now teach her own daughter the same lessons.
"I am proud we were able to show them what some women look like. We don't all look the same," she added. "We are curvy, strong, muscular, tall, small, just to name a few, and all the same: we are women and proud!
"Thank you for being the role model I needed to endure all the hardships that I now regard as a challenges--ones that I enjoy. I hope to teach my baby Alexis Olympia the same, and have the same fortitude you have had."
Read the full post from Serena, shared on Reddit, below!
Williams, who won the Australian Open in January while eight weeks pregnant, intends to return to the WTA and competitive tennis in 2018. |
myTestRule {
# Input parameters are:
# Data object path
# Local file path
# Source resource
# Output parameter is:
# Status
# Output from executing the example is:
# File /tempZone/home/rods/sub1/foo1 is retrieved from the data grid and written to foo1
msiSplitPath(*SourceFile,*Coll,*File);
msiDataObjGetWithOptions(*SourceFile,"./*File",*Resource,*Status);
writeLine("stdout","File *SourceFile is retrieved from the data grid and written to *File");
}
INPUT *SourceFile="/tempZone/home/rods/sub1/foo1", *Resource="demoResc"
OUTPUT ruleExecOut
|
postulate
@0 A : Set
_ : @0 Set → (Set → Set) → Set
_ = λ @0 where
A G → G A
|
{-# OPTIONS --safe --warning=error --without-K #-}
open import LogicalFormulae
open import Groups.Abelian.Definition
open import Groups.Homomorphisms.Definition
open import Setoids.Setoids
open import Sets.EquivalenceRelations
open import Rings.Definition
open import Lists.Lists
open import Rings.Homomorphisms.Definition
module Rings.Polynomial.Ring {a b : _} {A : Set a} {S : Setoid {a} {b} A} {_+_ _*_ : A → A → A} (R : Ring S _+_ _*_) where
open Ring R
open Setoid S
open Equivalence eq
open import Groups.Polynomials.Group additiveGroup
open import Groups.Polynomials.Definition additiveGroup
open import Rings.Polynomial.Multiplication R
polyRing : Ring naivePolySetoid _+P_ _*P_
Ring.additiveGroup polyRing = polyGroup
Ring.*WellDefined polyRing {a} {b} {c} {d} = *PwellDefined {a} {b} {c} {d}
Ring.1R polyRing = 1R :: []
Ring.groupIsAbelian polyRing {x} {y} = AbelianGroup.commutative (abelian (record { commutative = Ring.groupIsAbelian R })) {x} {y}
Ring.*Associative polyRing {a} {b} {c} = *Passoc {a} {b} {c}
Ring.*Commutative polyRing {a} {b} = p*Commutative {a} {b}
Ring.*DistributesOver+ polyRing {a} {b} {c} = *Pdistrib {a} {b} {c}
Ring.identIsIdent polyRing {a} = *Pident {a}
polyInjectionIsHom : RingHom R polyRing polyInjection
RingHom.preserves1 polyInjectionIsHom = reflexive ,, record {}
RingHom.ringHom polyInjectionIsHom = reflexive ,, (reflexive ,, record {})
GroupHom.groupHom (RingHom.groupHom polyInjectionIsHom) = reflexive ,, record {}
GroupHom.wellDefined (RingHom.groupHom polyInjectionIsHom) = SetoidInjection.wellDefined polyInjectionIsInj
|
Karan Malhotra 's action drama Brothers was Fernandez 's next release . Co @-@ starring alongside Akshay Kumar and Sidharth Malhotra , Fernandez played Jenny , a fearless mother struggling for her child , a role which she described as " challenging " , " intense " , and " difficult " . The role marked a departure from the glamorous characters that she had a reputation for portraying . Film critics praised her performance , though their response to the film was mixed . <unk> Sharma of Zee News called her character " soft , timid and promising " , and praised her for : " convincingly pull [ ing ] off a pleasing character of a street fighter 's wife " . Film critic Subhash K. Jha noted that she : " ... in a limited role gives her finest emotive shot " , while critic Raja Sen remarked : " [ she ] plays Kumar 's long @-@ sobbing wife who gets so deliriously happy on seeing a text message that it may well have contained news about a Kick sequel . "
|
% Copyright (C) 2017-2018 Titus Cieslewski, RPG, University of Zurich,
% Switzerland
% You can contact the author at <titus at ifi dot uzh dot ch>
% Copyright (C) 2017-2018 Siddharth Choudhary, College of Computing,
% Georgia Institute of Technology, Atlanta, GA, USA
% Copyright (C) 2017-2018 Davide Scaramuzza, RPG, University of Zurich,
% Switzerland
%
% This file is part of dslam_open.
%
% dslam_open is free software: you can redistribute it and/or modify
% it under the terms of the GNU General Public License as published by
% the Free Software Foundation, either version 3 of the License, or
% (at your option) any later version.
%
% dslam_open is distributed in the hope that it will be useful,
% but WITHOUT ANY WARRANTY; without even the implied warranty of
% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
% GNU General Public License for more details.
%
% You should have received a copy of the GNU General Public License
% along with dslam_open. If not, see <http://www.gnu.org/licenses/>.
function quiver = posesToQuiver(T)
n = numel(T);
quiver = zeros(n, 6);
for i = 1:n
quiver(i, :) = poseToQuiver(T{i});
end
end
|
theory Tagged_Solver
imports Refine_Util
begin
(* TODO/FIXME:
A solver is some named entity, and it should be possible to
reference it by its short/long name like a constant or a theorem!
*)
ML {*
signature TAGGED_SOLVER = sig
type solver = thm list * string * string * (Proof.context -> tactic')
val get_solvers: Proof.context -> solver list
val declare_solver: thm list -> binding -> string
-> (Proof.context -> tactic') -> morphism
-> Context.generic -> Context.generic
val lookup_solver: string -> Context.generic -> solver option
val add_triggers: string -> thm list -> morphism ->
Context.generic -> Context.generic
val delete_solver: string -> morphism -> Context.generic -> Context.generic
val tac_of_solver: Proof.context -> solver -> tactic'
val get_potential_solvers: Proof.context -> int -> thm -> solver list
val get_potential_tacs: Proof.context -> int -> thm -> tactic' list
val solve_greedy_step_tac: Proof.context -> tactic'
val solve_greedy_tac: Proof.context -> tactic'
val solve_greedy_keep_tac: Proof.context -> tactic'
val solve_full_step_tac: Proof.context -> tactic'
val solve_full_tac: Proof.context -> tactic'
val solve_full_keep_tac: Proof.context -> tactic'
val cfg_keep: bool Config.T
val cfg_trace: bool Config.T
val cfg_full: bool Config.T
val cfg_step: bool Config.T
val solve_tac: Proof.context -> tactic'
val pretty_solvers: Proof.context -> Pretty.T
end
structure Tagged_Solver : TAGGED_SOLVER = struct
type solver = thm list * string * string * (Proof.context -> tactic')
structure solvers = Generic_Data (
type T = solver Item_Net.T * solver Symtab.table
val empty = (Item_Net.init
(op = o pairself #2)
(fn p:solver => #1 p |> map concl_of)
,
Symtab.empty
)
fun merge ((n1,t1),(n2,t2))
= (Item_Net.merge (n1,n2), Symtab.merge (op = o pairself #2) (t1,t2))
val extend = I
)
fun get_solvers ctxt = solvers.get (Context.Proof ctxt)
|> #2 |> Symtab.dest |> map #2
fun lookup_solver n context = let
val tab = solvers.get context |> #2
in
Symtab.lookup tab n
end
fun add_triggers n thms phi context =
case lookup_solver n context of
NONE =>
error ("Undefined solver: " ^ n)
| SOME (trigs,n,desc,tac) => let
val thms = map (Morphism.thm phi) thms
val trigs = thms @ trigs
val solver = (trigs,n,desc,tac)
in
solvers.map (Item_Net.update solver ## Symtab.update (n, solver))
context
end
fun declare_solver thms n desc tac phi context = let
val thms = map (Morphism.thm phi) thms
val n = Morphism.binding phi n
val n = Context.cases Sign.full_name Proof_Context.full_name context n
val _ =
if Symtab.defined (solvers.get context |> #2) n then
error ("Duplicate solver " ^ n)
else ()
val solver = (thms,n,desc,tac)
in
solvers.map (Item_Net.update solver ## Symtab.update (n,solver)) context
end
fun delete_solver n _ context =
case lookup_solver n context of
NONE => error ("Undefined solver: " ^ n)
| SOME solver =>
solvers.map (Item_Net.remove solver ## Symtab.delete (#2 solver))
context
val cfg_keep =
Attrib.setup_config_bool @{binding tagged_solver_keep} (K false)
val cfg_trace =
Attrib.setup_config_bool @{binding tagged_solver_trace} (K false)
val cfg_step =
Attrib.setup_config_bool @{binding tagged_solver_step} (K false)
val cfg_full =
Attrib.setup_config_bool @{binding tagged_solver_full} (K false)
(* Get potential solvers. Overapproximation caused by net *)
fun get_potential_solvers ctxt i st =
let
val concl = Logic.concl_of_goal (prop_of st) i
val net = solvers.get (Context.Proof ctxt) |> #1
val solvers = Item_Net.retrieve net concl
in solvers end
fun notrace_tac_of_solver ctxt (thms,_,_,tac) =
match_tac thms THEN' tac ctxt
fun trace_tac_of_solver ctxt (thms,name,_,tac) i st =
let
val _ = tracing ("Trying solver " ^ name)
val r = match_tac thms i st
in
case Seq.pull r of
NONE => (tracing " No trigger"; Seq.empty)
| SOME _ => let
val r = Seq.maps (tac ctxt i) r
in
case Seq.pull r of
NONE => (tracing (" No solution (" ^ name ^ ")"); Seq.empty)
| SOME _ => (tracing (" OK (" ^ name ^ ")"); r)
end
end
fun tac_of_solver ctxt =
if Config.get ctxt cfg_trace then
trace_tac_of_solver ctxt
else
notrace_tac_of_solver ctxt
fun get_potential_tacs ctxt i st =
if i <= nprems_of st then
eq_assume_tac :: (
get_potential_solvers ctxt i st
|> map (tac_of_solver ctxt)
)
else []
fun solve_greedy_step_tac ctxt i st =
(FIRST' (get_potential_tacs ctxt i st)) i st
fun solve_full_step_tac ctxt i st =
(APPEND_LIST' (get_potential_tacs ctxt i st) i st)
(* Try to solve, take first matching tactic, but allow backtracking over
its results *)
fun solve_greedy_tac ctxt i st = let
val tacs = get_potential_tacs ctxt i st
in
(FIRST' tacs THEN_ALL_NEW_FWD solve_greedy_tac ctxt) i st
end
(* Try to solve. Allow backtracking over matching tactics. *)
fun solve_full_tac ctxt i st = let
val tacs = get_potential_tacs ctxt i st
in
(APPEND_LIST' tacs THEN_ALL_NEW_FWD solve_full_tac ctxt) i st
end
fun solve_greedy_keep_tac ctxt i st = let
val tacs = get_potential_tacs ctxt i st
in
(FIRST' tacs THEN_ALL_NEW_FWD (TRY o solve_greedy_keep_tac ctxt)) i st
end
fun solve_full_keep_tac ctxt i st = let
val tacs = get_potential_tacs ctxt i st
in
(APPEND_LIST' tacs THEN_ALL_NEW_FWD (TRY o solve_full_keep_tac ctxt)) i st
end
fun solve_tac ctxt =
case (Config.get ctxt cfg_keep, Config.get ctxt cfg_step,
Config.get ctxt cfg_full) of
(_,true,false) => solve_greedy_step_tac ctxt
| (_,true,true) => solve_full_step_tac ctxt
| (true,false,false) => solve_greedy_keep_tac ctxt
| (false,false,false) => solve_greedy_tac ctxt
| (true,false,true) => solve_full_keep_tac ctxt
| (false,false,true) => solve_full_tac ctxt
fun pretty_solvers ctxt = let
fun pretty_solver (ts,name,desc,_) = Pretty.block (
Pretty.str (name ^ ": " ^ desc) :: Pretty.fbrk
:: Pretty.str ("Triggers: ")
:: Pretty.commas (map (Display.pretty_thm ctxt) ts))
val solvers = get_solvers ctxt
in
Pretty.big_list "Solvers:" (map pretty_solver solvers)
end
end
*}
method_setup tagged_solver = {* let
open Refine_Util
val flags =
parse_bool_config "keep" Tagged_Solver.cfg_keep
|| parse_bool_config "trace" Tagged_Solver.cfg_trace
|| parse_bool_config "full" Tagged_Solver.cfg_full
|| parse_bool_config "step" Tagged_Solver.cfg_step
in
parse_paren_lists flags >> (fn _ => fn ctxt =>
SIMPLE_METHOD' (Tagged_Solver.solve_tac ctxt)
)
end
*} "Select tactic to solve goal by pattern"
term True
(* Localization Test *)
(*
locale foo =
fixes A b
assumes A: "A x = True"
begin
definition "B == A"
lemma AI: "A x" unfolding A ..
lemma A_trig: "A x ==> A x" .
lemma BI: "A x ==> B x" unfolding B_def .
lemma B_trig: "B x ==> B x" .
declaration {* fn phi =>
Tagged_Solver.declare_solver @{thms A_trig}
@{binding "A_solver"} "description"
(K (rtac (Morphism.thm phi @{thm AI}))) phi
*}
ML_val {*
Tagged_Solver.pretty_solvers @{context} |> Pretty.writeln
*}
(* FIXME: Does not work because of improper naming!
declaration {*
Tagged_Solver.add_triggers "local.A_solver" @{thms A_trig}
*}
*)
declaration {* fn phi =>
Tagged_Solver.declare_solver @{thms B_trig}
@{binding "B_solver"} "description"
(K (rtac (Morphism.thm phi @{thm BI}))) phi
*}
ML_val {*
Tagged_Solver.pretty_solvers @{context} |> Pretty.writeln
*}
end
definition "TAG x == True"
interpretation tag!: foo TAG 1
apply unfold_locales
unfolding TAG_def by simp
ML_val {*
Tagged_Solver.pretty_solvers @{context} |> Pretty.writeln
*}
definition "TAG' x == True"
interpretation tag'!: foo TAG' 2
apply unfold_locales
unfolding TAG'_def by simp
interpretation tag2!: foo TAG 3
by unfold_locales
ML_val {*
Tagged_Solver.pretty_solvers @{context} |> Pretty.writeln
*}
lemma "tag.B undefined"
by (tagged_solver (keep))
declaration {* Tagged_Solver.delete_solver "Tagged_Solver.tag.B_solver" *}
ML_val {*
Tagged_Solver.pretty_solvers @{context} |> Pretty.writeln
*}
*)
end
|
% J. C. Spall, March 1999
% This code evaluates the basic root-finding (R-M) SA algorithm. Computes sample mean
% and standard deviation of the mean from Navg realizations.
%
n=1000;
randn('seed',71111113)
a=0.081;
A=5.1;
alpha=.501;
s=.1;
theta_0=[1,1]';
Navg=2000;
loss_eq2_5(theta_0)
rslossavg=0;
rslossavgsq=0;
for i=1:Navg
theta=theta_0;
for k=1:n
theta=theta-(a/(k+A)^alpha)*gradloss(theta,s)';
end
rslossavg=(i-1)*rslossavg/i+loss_eq2_5(theta)/i;
rslossavgsq=(i-1)*rslossavgsq/i+(loss_eq2_5(theta)^2)/i;
end
mean=rslossavg
stdevmean=(((Navg/(Navg-1))*(rslossavgsq-mean^2))^.5)/(Navg^.5)
|
Very professional, courteous, excellent workmanship. Had a problem on Sunday morning and they were prompt and here in a half an hour. Left yard clean as if they had not been here. Did a thorough job of both trees not a flip flop job. Highly recommend this company!!!
Their experience and customer care speaks for itself. We've used them on multiple jobs, check them out on You Tube and see for yourself. |
Enjoy your family. Enjoy your friends.
Make lots of special memories. |
module IgnoreDo
bound : Maybe () -> Maybe b -> Maybe b
bound m n = do
x <- m
let y = Z
n
ignored : Maybe () -> Maybe b -> Maybe b
ignored m n = do
_ <- m
let _ = Z
n
seqd : Maybe () -> Maybe b -> Maybe b
seqd m n = do
m
n
|
/-
Copyright (c) 2022 Violeta Hernández Palacios. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Violeta Hernández Palacios
-/
import data.polynomial.cardinal
import ring_theory.algebraic
/-!
### Cardinality of algebraic numbers
In this file, we prove variants of the following result: the cardinality of algebraic numbers under
an R-algebra is at most `# R[X] * ℵ₀`.
Although this can be used to prove that real or complex transcendental numbers exist, a more direct
proof is given by `liouville.is_transcendental`.
-/
universes u v
open cardinal polynomial set
open_locale cardinal polynomial
namespace algebraic
lemma infinite_of_char_zero (R A : Type*) [comm_ring R] [is_domain R]
[ring A] [algebra R A] [char_zero A] : {x : A | is_algebraic R x}.infinite :=
infinite_of_injective_forall_mem nat.cast_injective is_algebraic_nat
theorem aleph_0_le_cardinal_mk_of_char_zero (R A : Type*) [comm_ring R] [is_domain R]
[ring A] [algebra R A] [char_zero A] : ℵ₀ ≤ #{x : A // is_algebraic R x} :=
infinite_iff.1 (set.infinite_coe_iff.2 $ infinite_of_char_zero R A)
section lift
variables (R : Type u) (A : Type v) [comm_ring R] [comm_ring A] [is_domain A] [algebra R A]
[no_zero_smul_divisors R A]
theorem cardinal_mk_lift_le_mul :
cardinal.lift.{u} (#{x : A // is_algebraic R x}) ≤ cardinal.lift.{v} #(R[X]) * ℵ₀ :=
begin
rw [←mk_ulift, ←mk_ulift],
choose g hg₁ hg₂ using λ x : {x : A | is_algebraic R x}, x.coe_prop,
refine lift_mk_le_lift_mk_mul_of_lift_mk_preimage_le g (λ f, _),
rw [lift_le_aleph_0, le_aleph_0_iff_set_countable],
suffices : maps_to coe (g ⁻¹' {f}) (f.root_set A),
from this.countable_of_inj_on (subtype.coe_injective.inj_on _) (f.root_set_finite A).countable,
rintro x (rfl : g x = f),
exact mem_root_set.2 ⟨hg₁ x, hg₂ x⟩
end
theorem cardinal_mk_lift_le_max :
cardinal.lift.{u} (#{x : A // is_algebraic R x}) ≤ max (cardinal.lift.{v} (#R)) ℵ₀ :=
(cardinal_mk_lift_le_mul R A).trans $
(mul_le_mul_right' (lift_le.2 cardinal_mk_le_max) _).trans $ by simp
@[simp] lemma cardinal_mk_lift_of_infinite [infinite R] :
cardinal.lift.{u} (#{x : A // is_algebraic R x}) = cardinal.lift.{v} (#R) :=
((cardinal_mk_lift_le_max R A).trans_eq (max_eq_left $ aleph_0_le_mk _)).antisymm $
lift_mk_le'.2 ⟨⟨λ x, ⟨algebra_map R A x, is_algebraic_algebra_map _⟩,
λ x y h, no_zero_smul_divisors.algebra_map_injective R A (subtype.ext_iff.1 h)⟩⟩
variable [countable R]
@[simp] protected theorem countable : set.countable {x : A | is_algebraic R x} :=
begin
rw [←le_aleph_0_iff_set_countable, ←lift_le],
apply (cardinal_mk_lift_le_max R A).trans,
simp
end
@[simp] theorem cardinal_mk_of_countble_of_char_zero [char_zero A] [is_domain R] :
#{x : A // is_algebraic R x} = ℵ₀ :=
(algebraic.countable R A).le_aleph_0.antisymm (aleph_0_le_cardinal_mk_of_char_zero R A)
end lift
section non_lift
variables (R A : Type u) [comm_ring R] [comm_ring A] [is_domain A] [algebra R A]
[no_zero_smul_divisors R A]
theorem cardinal_mk_le_mul : #{x : A // is_algebraic R x} ≤ #R[X] * ℵ₀ :=
by { rw [←lift_id (#_), ←lift_id #R[X]], exact cardinal_mk_lift_le_mul R A }
theorem cardinal_mk_le_max : #{x : A // is_algebraic R x} ≤ max (#R) ℵ₀ :=
by { rw [←lift_id (#_), ←lift_id (#R)], exact cardinal_mk_lift_le_max R A }
@[simp] theorem cardinal_mk_of_infinite [infinite R] : #{x : A // is_algebraic R x} = #R :=
lift_inj.1 $ cardinal_mk_lift_of_infinite R A
end non_lift
end algebraic
|
-- $ ghc --make -O -rtsopts -threaded parallel.hs
-- $ ./parallel 3000 +RTS -N4 -s -A200M
import System.Environment(getArgs)
import Numeric.LinearAlgebra
import Control.Parallel.Strategies
import System.Time
inParallel = parMap rwhnf id
-- matrix product decomposed into p parallel subtasks
parMul p x y = fromBlocks [ inParallel ( map (x <>) ys ) ]
where [ys] = toBlocksEvery (rows y) (cols y `div` p) y
main = do
n <- (read . head) `fmap` getArgs
let m = ident n :: Matrix Double
time $ print $ maxElement $ takeDiag $ m <> m
time $ print $ maxElement $ takeDiag $ parMul 2 m m
time $ print $ maxElement $ takeDiag $ parMul 4 m m
time $ print $ maxElement $ takeDiag $ parMul 8 m m
time act = do
t0 <- getClockTime
act
t1 <- getClockTime
print $ tdSec $ normalizeTimeDiff $ diffClockTimes t1 t0
|
program t
! test for : in format-item-list
integer::a=12345
1234 format (1x, i5/)
5678 format (1x, i5,:/)
write(*,1234) a
write(*,5678) a
endprogram t
|
import Lean
import Lean.Data.Json.Basic
import Lean.Data.Json.FromToJson
import LeanCodePrompts.ParseJson
import LeanCodePrompts.Utils
import LeanCodePrompts.TeXPrompts
open Lean
initialize texCommandCache : IO.Ref (HashMap String String) ← do
-- IO.println "Initialising TeX Command cache..."
-- let js ← Json.parseFile <| ← reroutePath "data/texcmds.json"
-- let l := js.map $ fun j => (j[0]!.getStr!, j[1]!.getStr!)
let .obj js ← IO.ofExcept $ Json.parse $ ← IO.FS.readFile (← reroutePath "data/full-tex.json") | panic! "Invalid JSON format"
let l : List (String × String) := js.fold (λ as s j => (s, j.getStr!) :: as) []
IO.mkRef $ HashMap.ofList l
/-- Replaces the TeX sequences in a string with their
corresponding Unicode characters using the `texcmds` list. -/
def teXToUnicode (s : String) : IO String := do
match s.splitOn "\\" with
| [] => return s
| h :: ls =>
-- filtering instances of `\\\\`
let ls' := ls.filter (· != "")
let us ← ls'.mapM $ fun l => do
let cmd := l.takeWhile (· ∉ teXDelimiters)
let s ← findUnicodeReplacement cmd
pure $ s ++ l.dropWhile (· ∉ teXDelimiters)
return .join (h :: us)
where
findUnicodeReplacement (cmd : String) : IO String := do
if let .some u :=
(← texCommandCache.get).find? cmd then
pure u else
pure <| "\\" ++ cmd
teXDelimiters := [' ', '_', '^', '{', '}', '[', ']', '(', ')']
namespace List
def alternate : List α → List α × List α
| [] => ([], [])
| a :: as =>
match alternate as with
| (odds, evens) => (a :: evens, odds)
def interleave : List α → List α → List α
| [], bs => bs
| as, [] => as
| a :: as, b :: bs =>
a :: b :: interleave as bs
theorem alternate_interleave : (l : List α) →
let (odds, evens) := l.alternate
.interleave odds evens = l
| [] => rfl
| [a] => rfl
| a :: a' :: as => by
dsimp only [alternate, interleave]
congr
apply alternate_interleave
#eval [1, 2, 3, 4, 5, 6].alternate
end List
def openAIKey : IO (Option String) := IO.getEnv "OPENAI_API_KEY"
/-- Query open-ai with given prompt and parameters -/
-- this is delibrately different from the one in `Translate.lean`
-- this is to keep everything at the `IO` level without disturbing the rest of the code
def openAIQuery (prompt : String)
(n : Nat := 1)
(temp : JsonNumber := ⟨2, 1⟩)
(stopTokens : Array String := #[":=", "-/"]) : IO Json := do
let .some key ← openAIKey | panic! "OPENAI_API_KEY not set"
let data := Json.mkObj [
("model", "code-davinci-002"),
("prompt", prompt),
("temperature", Json.num temp),
("n", n),
("max_tokens", 150),
("stop", Json.arr <| stopTokens |>.map Json.str)
] |>.pretty
let out ← IO.Process.output {
cmd:= "curl",
args:= #["https://api.openai.com/v1/completions",
"-X", "POST",
"-H", "Authorization: Bearer " ++ key,
"-H", "Content-Type: application/json",
"--data", data]}
IO.ofExcept $ Json.parse out.stdout
def makePrompt (formula : String) : IO String := do
let teXPromptsProcessed ← teXPrompts.mapM $ λ (teXFormula, leanFormula) => do
return s!"TeX: ${← teXToUnicode teXFormula}$\nLean: `{leanFormula}`\n\n"
let promptPrefix := String.join teXPromptsProcessed.toList
return s!"{promptPrefix}TeX: ${formula}$\nLean: `"
/-- Translates a string representing a TeX formula to the corresponding Lean code. -/
def teXToLean (s : String) : IO String := do
let t ← teXToUnicode s
-- needs a better heuristic for triggering Codex-based translation
if t.contains '\\' then
IO.println s!"Translating with Codex: {t}"
let prompt ← makePrompt s
let codexOutput ← openAIQuery prompt (stopTokens := #["$", "$$", "\\[", "\n"])
let translation := codexOutput["choices"]![0]!["text"]!.getStr!
return s!"`{translation}`"
else
IO.println s!"Translated via Unicode mapping: {t}"
return s!"`{t}`"
/-- Extracts the TeX formulas within `$` or `$$` in the given string,
translates them individually to Lean code, and then
replaces them back with `\`` (backticks). -/
def translateTeX : String → IO String :=
translateTeXAux "$$"
(translateTeXAux "$"
(translateTeXAux "`"
pure
pure)
teXToLean)
teXToLean
where
/-- Splits a string according to the delimiter.
The substrings in the odd positions are processed as text,
while those in the even positions are processed as formulas. -/
translateTeXAux (teXDelimiter : String)
(modText : String → IO String)
(modFormula : String → IO String) :
String → IO String := fun s => do
let (text, formulas) := s.splitOn teXDelimiter |>.alternate
let text' ← text.mapM modText
let formulas' ← formulas.mapM modFormula
let s' := .interleave text' formulas'
return .join s' |
\subsection{Small-$R$ jet selection}
If you want to use variables such as \verb|\fcut| you need to add the option
\texttt{jetetmiss} to \texttt{atlaspackage}.
\begin{table}[ht]
\caption{Jet reconstruction criteria.}%
\label{tab:object:jet1}
\centering
% \resizebox{\textwidth}{!}{
\begin{tabular}{ll}
\toprule
Feature & Criterion \\
\midrule
Algorithm & \Antikt \\
\(R\)-parameter & 0.4 \\
Input constituent & EMTopo \\
Analysis release number & 21.2.10 \\
%Calibration tag & JetCalibTools-00-04-76 \\
\texttt{CalibArea} tag & 00-04-81 \\
Calibration configuration & \texttt{JES\_data2017\_2016\_2015\_Recommendation\_Feb2018\_rel21.config} \\
Calibration sequence (Data) & \texttt{JetArea\_Residual\_EtaJES\_GSC\_Insitu} \\
Calibration sequence (MC) & \texttt{JetArea\_Residual\_EtaJES\_GSC} \\
%Calibration sequence (AFII) & \texttt{JetArea\_Residual\_EtaJES\_GSC} \\
\midrule
\multicolumn{2}{c}{Selection requirements} \\
\midrule
Observable & Requirement \\
\midrule
Jet cleaning & \texttt{LooseBad} \\
BatMan cleaning & No \\
\pT & \(> \SI[parse-numbers=false]{XX}{\GeV}\) \\
\(|\eta|\) & \(< X\) \\
JVT & (\emph{Update if needed}) \(>0.59\) for \(\pT < \SI{60}{\GeV}\), \(|\eta| < 0.4\)\\
\bottomrule
\end{tabular}
% }
\end{table}
\clearpage
\subsection{Large-$R$ jet selection}
\begin{table}[ht]
\caption{Large-\(R\) jet reconstruction criteria.}%
\label{tab:object:jet2}
\centering
% \resizebox{\textwidth}{!}{
\begin{tabular}{ll}
\toprule
Feature & Criterion \\
\midrule
Algorithm & \antikt \\
R-parameter & 1.0 \\
Input constituent & \texttt{LCTopo} \\
Grooming algorithm & Trimming \\
\fcut & 0.05 \\
\(R_{\text{trim}}\) & 0.2 \\
Analysis release number & 21.2.10 \\
%Calibration tag & JetCalibTools-00-04-76 \\
\texttt{CalibArea} tag & 00-04-81 \\
Calibration configuration & \texttt{JES\_MC16recommendation\_FatJet\_JMS\_comb\_19Jan2018.config} \\
Calibration sequence (Data) & \texttt{EtaJES\_JMS\_Insitu} \\
Calibration sequence (MC) & \texttt{EtaJES\_JMS} \\
\bottomrule
\multicolumn{2}{c}{Selection requirements} \\
\midrule
Observable & Requirement \\
\midrule
\pT & \(> \SI[parse-numbers=false]{XX}{\GeV}\) \\
\(|\eta|\) & \(< X\) \\
Mass & \(> \SI[parse-numbers=false]{XX}{\GeV}\) \\
\bottomrule
\multicolumn{2}{c}{Boosted object tagger} \\
\midrule
Object & Working point \\
\midrule
\(W\) / \(Z\) / top & 50\% / 80\% \\
\(X\rightarrow bb\) & single/double \btag with/without loose/tight mass \\
\bottomrule
\end{tabular}
% }
\end{table}
\subsection{\MET selection}
\begin{table}[ht]
\caption{\MET reconstruction criteria.}%
\label{tab:object:met}
\centering
\begin{tabular}{ll}
\toprule
Parameter & Value \\
\midrule
Algorithm & Calo-based \\
Soft term & Track-based (TST) \\
MET operating point & \texttt{Tight} \\
Analysis release & 21.2.16 \\
Calibration tag & \texttt{METUtilities-00-02-46} \\
\bottomrule
\multicolumn{2}{c}{Selection requirements} \\
\midrule
Observable & Requirement \\
\midrule
\MET & \(> \SI[parse-numbers=false]{XX}{\GeV}\) \\
\(\sum{\ET} / \MET\) & \(< X\) \\
Object-based \MET significance & \(> X\) \\
\bottomrule
\end{tabular}
\end{table}
|
function disp( prob, varargin )
cvx_display( cvx_validate( prob.index_, prob.id_ ), varargin{:} );
% Copyright 2005-2014 CVX Research, Inc.
% See the file LICENSE.txt for full copyright information.
% The command 'cvx_where' will show where this file is located.
|
[STATEMENT]
lemma isOK_update_error [simp]:
"isOK (m <+? f) \<longleftrightarrow> isOK m"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. isOK (try m catch (\<lambda>x. Inl (f x))) = isOK m
[PROOF STEP]
by (cases m) simp_all |
(* Sequent Calculus for First-Order Additive Linear Logic *)
From Coq Require Import Wf_nat Lia.
From Quantifiers Require Import foformulas_ext.
Set Implicit Arguments.
Parameter vatom : DecType.
Parameter tatom : Type.
Parameter fatom : Type.
Inductive Ncon := top_con.
Inductive Bcon := wth_con.
Inductive Qcon := frl_con.
Notation term := (@term vatom tatom nat).
Notation closed t := (tvars t = nil).
Notation rclosed r := (forall n, closed (r n)).
Notation "↑ r" := (felift (evar 0) r) (at level 25, format "↑ r").
Notation "v ⇓" := (fesubs v) (at level 18, format "v ⇓").
Notation "A ⟦ r ⟧" := (esubs r A) (at level 8, left associativity, format "A ⟦ r ⟧").
Notation "A [ u // x ]" := (subs x u A) (at level 8, format "A [ u // x ]").
Notation "⇑" := fup.
Notation "A ↑" := (A⟦⇑⟧) (at level 8, format "A ↑").
Notation "x ∈ A" := (In x (freevars A)) (at level 30).
Notation "x ∉ A" := (~ In x (freevars A)) (at level 30).
Notation formula := (@formula vatom tatom fatom Ncon Nocon Bcon Qcon nat).
(*
Notation top := (fnul nat top_con).
Notation wth := (fbin wth_con).
Notation frl := (fqtf frl_con).
*)
Notation "⟙" := (fnul nat top_con).
Infix "﹠" := (fbin wth_con) (at level 50).
Notation "∀" := (fqtf frl_con).
#[local] Hint Rewrite (@felift_esubs vatom tatom fatom Ncon Nocon Bcon Qcon) : term_db.
#[local] Hint Rewrite (@freevars_fup vatom tatom fatom Ncon Nocon Bcon Qcon) : term_db.
#[local] Hint Rewrite (@esubs_fup vatom tatom fatom Ncon Nocon Bcon Qcon) : term_db.
#[local] Hint Rewrite (@nfree_subs vatom tatom fatom Ncon Nocon Bcon Qcon nat) using intuition; fail : term_db.
#[local] Hint Resolve closed_fesubs : term_db.
#[local] Hint Resolve closed_felift : term_db.
#[local] Hint Rewrite (@subs_esubs vatom tatom fatom Ncon Nocon Bcon Qcon nat)
using try (intuition; fail);
try apply no_ecapture_not_egenerated; try (intuition; fail);
try apply closed_no_ecapture; intuition; fail : term_db.
(** * Proofs *)
(** Proofs *)
(** two-sided sequent calculus for first-order (additive) linear logic with connectives:
top, with, forall *)
Inductive prove : formula -> formula -> Type :=
| ax : forall A, prove A A
| topr : forall C, prove C ⟙
| wdgr { C A B } : prove C A -> prove C B -> prove C (A﹠B)
| wdgll { A C } : forall B, prove A C -> prove (A﹠B) C
| wdglr { A C } : forall B, prove A C -> prove (B﹠A) C
| frlr { x C A } : prove C↑ A↑[evar 0//x] -> prove C (∀x A)
| frll { x A C } : forall u, closed u -> prove A[u//x] C -> prove (∀x A) C.
#[local] Hint Constructors prove : term_db.
(** height of proofs *)
Fixpoint psize {A B} (pi : prove A B) : nat :=
match pi with
| ax _ => 1
| topr _ => 1
| wdgr pi1 pi2 => S (max (psize pi1) (psize pi2))
| wdgll _ pi1 => S (psize pi1)
| wdglr _ pi1 => S (psize pi1)
| frlr pi1 => S (psize pi1)
| frll _ _ pi1 => S (psize pi1)
end.
(** apply [r] in proof [pi] *)
Theorem pesubs r (Hc : rclosed r) C A (pi : prove C A) :
{ pi' : prove C⟦r⟧ A⟦r⟧ & psize pi' = psize pi }.
Proof.
revert r Hc; induction pi; intros r Hc;
try (destruct (IHpi r) as [pi' Hs]);
try (destruct (IHpi1 r) as [pi1' Hs1]);
try (destruct (IHpi2 r) as [pi2' Hs2]); intuition.
- now exists (ax _).
- now exists (topr _).
- exists (wdgr pi1' pi2') ; simpl ; auto.
- exists (wdgll _ pi') ; simpl ; auto.
- exists (wdglr _ pi') ; simpl ; auto.
- clear pi' Hs; destruct (IHpi (↑r)) as [pi' Hs]; intuition.
cbn. rewrite <- Hs. clear Hs.
rnow revert pi'.
exists (frlr pi'). reflexivity.
- cbn. rewrite <- Hs. clear Hs.
rnow revert pi'.
rewrite <- (tvars_tesubs_closed r _ Hc) in e.
exists (frll _ e pi'). reflexivity.
Qed.
(** * Cut Elimination *)
Theorem cutr : forall A B C, prove A B -> prove B C -> prove A C.
Proof.
enough (IH : forall n, forall A B C (pi1 : prove A B) (pi2 : prove B C),
n = psize pi1 + psize pi2 -> prove A C)
by (intros A B C pi1 pi2 ; apply (IH _ _ _ _ pi1 pi2 eq_refl)).
induction n as [n IH0] using lt_wf_rect; intros; subst.
assert (IH : forall A B C (pi1' : prove A B) (pi2' : prove B C),
psize pi1' + psize pi2' < psize pi1 + psize pi2 -> prove A C)
by (intros; eapply IH0; [ eassumption | reflexivity ]); clear IH0.
destruct pi2; intuition.
- apply wdgr.
+ apply (IH _ _ _ pi1 pi2_1). cbn. lia.
+ apply (IH _ _ _ pi1 pi2_2). cbn. lia.
- enough (forall A D (pi1 : prove A D) A0 B C (pi2 : prove A0 C)
(IH : forall A1 B0 C0 (pi1' : prove A1 B0) (pi2' : prove B0 C0),
psize pi1' + psize pi2' < psize pi1 + psize (wdgll B pi2) -> prove A1 C0),
D = A0﹠B -> prove A C)
as IH2 by (eapply IH2; [ eassumption | reflexivity ]); clear.
intros A D pi1; destruct pi1; intros; inversion H; subst;
try (constructor ; apply (IH _ _ _ pi1 (wdgll _ pi2)); cbn; lia).
+ now apply wdgll.
+ apply (IH _ _ _ pi1_1 pi2). cbn. lia.
+ apply (frll u); [ assumption | ].
apply (IH _ _ _ pi1 (wdgll _ pi2)). cbn. lia.
- enough (forall A D (pi1 : prove A D) A0 B C (pi2 : prove A0 C)
(IH : forall A1 B0 C0 (pi1' : prove A1 B0) (pi2' : prove B0 C0),
psize pi1' + psize pi2' < psize pi1 + psize (wdglr B pi2) -> prove A1 C0),
D = B﹠A0 -> prove A C)
as IH2 by (eapply IH2; [ eassumption | reflexivity ]); clear.
intros A D pi1; destruct pi1; intros; inversion H; subst;
try (constructor; apply (IH _ _ _ pi1 (wdglr _ pi2)); cbn; lia).
+ now apply wdglr.
+ apply (IH _ _ _ pi1_2 pi2). cbn. lia.
+ apply (frll u); [ assumption | ].
apply (IH _ _ _ pi1 (wdglr _ pi2)). cbn. lia.
- destruct (pesubs ⇑ closed_fup pi1) as [pi1' Hs].
apply frlr.
apply (IH _ _ _ pi1' pi2); simpl; lia.
- enough (forall A D (pi1 : prove A D) x A0 C u e (pi2 : prove A0[u//x] C)
(IH : forall A1 B C0 (pi1' : prove A1 B) (pi2' : prove B C0),
psize pi1' + psize pi2' < psize pi1 + psize (frll u e pi2) -> prove A1 C0),
D = ∀ x A0 -> prove A C)
as IH2 by (eapply IH2; [ eassumption | reflexivity ]); clear.
intros A D pi1; destruct pi1; intros; inversion H; subst;
try (constructor; apply (IH _ _ _ pi1 (frll _ e pi2)); simpl; lia).
+ now apply (frll u).
+ destruct (pesubs (u⇓) (closed_fesubs _ e) pi1) as [pi1' Hs].
simpl in IH; rewrite <- Hs in IH; clear Hs.
revert pi1' IH; rnow idtac.
apply (IH _ _ _ pi1' pi2); lia.
+ apply (frll u); [ assumption | ].
apply (IH _ _ _ pi1 (frll _ e0 pi2)). cbn. lia.
Qed.
(** * Hilbert style properties *)
Lemma frl_elim : forall A u x, closed u -> prove (∀ x A) A[u//x].
Proof. intros A u x Hc; apply (frll u); auto with term_db. Qed.
Lemma frl_wth : forall A B x, prove (∀ x (A﹠B)) (∀ x A ﹠ ∀ x B).
Proof.
intros A B x.
repeat constructor; simpl;
apply (frll (evar 0)); simpl; do 2 constructor.
Qed.
Lemma frl_nfree : forall A x, x ∉ A -> prove A (∀ x A).
Proof.
intros A x Hnf.
apply frlr.
rnow rewrite nfree_subs.
Qed.
(** * Other properties *)
(** Axiom expansion *)
Lemma ax_exp : forall A, prove A A.
Proof.
enough (Hn : forall n A, fsize A = n -> prove A A)
by (intros A; eapply Hn; reflexivity).
induction n as [n IH] using lt_wf_rect; intros; subst.
destruct A; [ | destruct n | destruct n | destruct b | destruct q ].
- apply ax.
- apply topr.
- apply wdgr; [ apply wdgll | apply wdglr ]; (eapply IH; [ | reflexivity ]); simpl; lia.
- apply frlr; rnow apply (frll (evar 0)).
Qed.
|
[STATEMENT]
lemma prime_product [forward]: "prime (p * q) \<Longrightarrow> p = 1 \<or> q = 1"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. prime (p * q) \<Longrightarrow> p = 1 \<or> q = 1
[PROOF STEP]
@proof
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. prime (p * q) \<Longrightarrow> p = 1 \<or> q = 1
[PROOF STEP]
@have "p dvd q * p"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. prime (p * q) \<Longrightarrow> p = 1 \<or> q = 1
[PROOF STEP]
@qed |
<a href="https://colab.research.google.com/github/fysixs/IsingModel/blob/master/Ising1D.ipynb" target="_parent"></a>
[comment]: <> (Written by Andrés Cárdenas)
[comment]: <> (July 2021)
[comment]: <> (www.fysixs.com)
[comment]: <> ([email protected])
<div class="row" align ="left">
<font face="Gill Sans" color = #667495> **Cool Stuff in Physics**
<br>
*Andrés Cárdenas, 2021*, <i><a href="https://www.fysixs.com">www.fysixs.com</a></i>
</font>
</div>
<hr size=5 color=#8D84B5 > </hr>
<div align="left">
<br>
# <font color = #667495 face="Gill Sans"> **The Ising Model**
## <font color = #667495 face="Gill Sans"> *One-D Treatment* </font>
<br>
</div>
<hr size=5 color=#8D84B5 > </hr>
<center>
---
<font size = 4 color=#AB63FA> **⟹** <font size = 4 color=#667495> ***To get started please run the cell below.*** <font size = 4 color=#AB63FA> **⟸** <br>
Use me to run a cell</font>
---
```
#@title <font size = 3 face="Verdana" color=9467BD> <b>START HERE: Environment Setup 💻
#################################################
#################################################
# IMPORTS
#################################################
#################################################
import subprocess
import numpy as np
import sympy as sp
import ipywidgets as widgets
import h5py
from scipy.constants import k
from IPython.display import clear_output
from scipy import stats
from google.colab import output
from IPython.display import Markdown as md
from IPython.display import IFrame
from ipywidgets import GridBox
from bokeh.io import output_notebook, curdoc
from bokeh.themes import Theme
from bokeh.events import DoubleTap
from bokeh.layouts import column, row, layout
from bokeh.models import CustomJS, Panel, Tabs, RangeTool, Spinner
from bokeh.models import Slider, TextInput, Select, Div, Button
from bokeh.models import PrintfTickFormatter, LinearAxis, LabelSet
from bokeh.models import Range1d, TapTool, NumericInput
from bokeh.models.widgets import DataTable, TableColumn, ScientificFormatter, NumberFormatter
from bokeh.plotting import ColumnDataSource, figure, show
from bokeh.transform import factor_cmap
output_notebook()
sp.init_printing(use_unicode=True)
#################################################
#################################################
# Definitions for the Notebook
#################################################
#################################################
# Plotting colors
plt_clr = {
"func" : "royalblue",
"pol" : "coral",
"func1": "royalblue",
"func2": "seagreen",
"fill" : "#0D70B9",
"te" : "#FFC300",
"te_m" : "#FBFF00",
"txt" : "#91899B",
}
plt_clr = ['rgb(95, 70, 144)',
'rgb(29, 105, 150)',
'rgb(56, 166, 165)',
'rgb(15, 133, 84)',
'rgb(115, 175, 72)',
'rgb(237, 173, 8)',
'rgb(225, 124, 5)',
'rgb(204, 80, 62)',
'rgb(148, 52, 110)',
'rgb(111, 64, 112)',
'rgb(102, 102, 102)']
# UI Colors
ui_clr = {
"button" : "#462770",
"slider" : "#8B78A6",
"txt" : "#91899B",
}
TOOLTIPS = [
("(x,y)", "($x, $y)"),
]
theme = Theme(json = {
"attrs": {
"Figure" : {
"background_fill_color": "#20262B",
"border_fill_color": "#15191C",
"outline_line_color": "#E0E0E0",
"outline_line_alpha": 0.25
},
"Grid": {
"grid_line_color": "#E0E0E0",
"grid_line_alpha": 0.25
},
"Axis": {
#"fixed_location": 0,
"major_tick_line_alpha": 0.8,
"major_tick_line_color": "lightgrey",
"minor_tick_line_alpha": 0.8,
"minor_tick_line_color": "lightgrey",
"axis_line_alpha": 0.8,
"axis_line_color": ui_clr['slider'],
"major_label_text_color": "lightgrey",
"major_label_text_font": "Helvetica",
"major_label_text_font_size": "8pt",
"axis_label_standoff": 10,
"axis_label_text_color": "#E0E0E0",
"axis_label_text_font": "Helvetica",
"axis_label_text_font_size": "1.25em",
"axis_label_text_font_style": "normal"
},
"Legend": {
"spacing": 8,
"glyph_width": 15,
"label_standoff": 8,
"label_text_color": "#E0E0E0",
"label_text_font": "Helvetica",
"label_text_font_size": "1.025em",
"border_line_alpha": 0,
"background_fill_alpha": 0.25,
"background_fill_color": "#20262B"
},
"ColorBar": {
"title_text_color": "#E0E0E0",
"title_text_font": "Helvetica",
"title_text_font_size": "1.025em",
"title_text_font_style": "normal",
"major_label_text_color": "#E0E0E0",
"major_label_text_font": "Helvetica",
"major_label_text_font_size": "1.025em",
"background_fill_color": "#15191C",
"major_tick_line_alpha": 0,
"bar_line_alpha": 0
},
"Title": {
"text_color": "#E0E0E0",
"text_font": "Helvetica",
"text_font_size": "1.15em"
}
}
})
curdoc().theme = theme
# ΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛ
# Plotting Defs
# ΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛ
def plot_spins(data, idx):
colors = [ "firebrick" if spin < 0 else "royalblue" for spin in data['spins'][idx,:] ]
nspins = len(colors)
cds = ColumnDataSource(data={'x':np.array(range(nspins)),
'top':np.ones(nspins),
'color':colors})
p_title = f"Spins at step {int((idx+1)*data['params'][4])}"
p = figure(plot_width=300, plot_height=100,
title=p_title,
toolbar_location=None, tools="")
p.vbar(x='x', top='top', color='color', source=cds)
p.xgrid.visible = False
p.ygrid.visible = False
p.xaxis.visible = False
p.yaxis.visible = False
return p
def plot_energy(data):
p = figure(plot_width=600, plot_height=300,
title=f"Energy @ T = {data['params'][2]}",
tooltips = [("(step, E)", "($x, $y)")],
tools = "box_zoom,reset", toolbar_location="right")
p.xaxis.axis_label="Step"
p.axis.axis_label_text_font_size = "10pt"
x = np.array(range(0,int(data['params'][3]),int(data['params'][4])))
cds = ColumnDataSource(data={'x':x,
'y':data['energy'][()]
})
p.line(x='x', y='y', source=cds, color=plt_clr[1], line_width = 2)
return p
def plot_mag(data):
M = data['mag'][()]
count, bins = np.histogram(data['mag'][()],
bins=np.arange(min(M),
max(M) + 1))
vzeros = np.zeros(len(bins)-1)
vmax = max(count)*1.1
# cds = ColumnDataSource(data={'x':bins[:-1],
# 'top':count})
hist = figure(plot_width=200, plot_height=300,
x_range=(0, vmax),
title='Histogram',
tooltips = [("(Mag, count)", "($y, $x)")],
tools = "box_zoom,reset", toolbar_location=None,
y_axis_location="right", min_border=10)
hist.yaxis.axis_label="Magnetization"
hist.xaxis.axis_label="Count"
hist.axis.axis_label_text_font_size = "10pt"
hist.quad(left=0, bottom=bins[:-1], top=bins[1:],
right=count, color=plt_clr[0])
hist.ygrid.visible = False
hist.xaxis.major_label_orientation = np.pi/4
hist.js_on_event(DoubleTap,
CustomJS(args=dict(p=hist), code='p.reset.emit()'))
p = figure(plot_width=600, plot_height=300,
title=f"Magnetization @ T = {data['params'][2]}",
tooltips = [("(step, Mag)", "($x, $y)")],
tools = "box_zoom,reset", toolbar_location="above")
p.xgrid.visible = False
p.xaxis.axis_label="Step"
p.axis.axis_label_text_font_size = "10pt"
x = np.array(range(0,int(data['params'][3]),int(data['params'][4])))
cds = ColumnDataSource(data={'x':x,
'y':data['mag'][()]
})
p.line(x='x', y='y', source=cds, color=plt_clr[4])
return row([p, hist])
def plot_corr(data):
correl = data['corr'][()]
nspins = len(data['spins'][0,:])
p = figure(plot_width=600, plot_height=300,
# title=f'Correlation Function',
tooltips = [("(r, corr)", "($x, $y)")],
tools = "box_zoom,reset", toolbar_location="right")
p.xaxis.axis_label = "Number of Spins Away"
p.yaxis.axis_label = "Correlation"
p.axis.axis_label_text_font_size = "10pt"
r = np.arange((nspins-1)//2)
p.line(x=r, y=correl, color=plt_clr[3], line_width=2, line_alpha = 0.9)
return p
# Clone the entire repo.
!git clone -l -s https://github.com/fysixs/IsingModel.git /content/Ising
clear_output()
md("<font size=3 color=9467BD> ***Environment Setup Complete! Please run the cell below if you are planning to use Julia for calculations.***")
```
```
#@title
#@markdown <font color=#8D84B5> ***Setup***
%%shell
set -e
#---------------------------------------------------#
JULIA_VERSION="1.6.2" # any version ≥ 0.7.0
JULIA_PACKAGES="HDF5 Statistics"
JULIA_PACKAGES_IF_GPU="CUDA" # or CuArrays for older Julia versions
JULIA_NUM_THREADS=2
#---------------------------------------------------#
if [ -n "$COLAB_GPU" ] && [ -z `which julia` ]; then
# Install Julia
JULIA_VER=`cut -d '.' -f -2 <<< "$JULIA_VERSION"`
echo "Installing Julia $JULIA_VERSION on the current Colab Runtime..."
BASE_URL="https://julialang-s3.julialang.org/bin/linux/x64"
URL="$BASE_URL/$JULIA_VER/julia-$JULIA_VERSION-linux-x86_64.tar.gz"
wget -nv $URL -O /tmp/julia.tar.gz # -nv means "not verbose"
tar -x -f /tmp/julia.tar.gz -C /usr/local --strip-components 1
rm /tmp/julia.tar.gz
# Install Packages
if [ "$COLAB_GPU" = "1" ]; then
JULIA_PACKAGES="$JULIA_PACKAGES $JULIA_PACKAGES_IF_GPU"
fi
for PKG in `echo $JULIA_PACKAGES`; do
echo "Installing Julia package $PKG..."
julia -e 'using Pkg; pkg"add '$PKG'; precompile;"' &> /dev/null
done
# # Launch the julia kernel in a detached tmux session
# echo "Starting julia kernel..."
# tmux new -s julia -d
# tmux send-keys -t julia.0 "julia -i" ENTER
echo ''
echo "Success!"
fi
```
<hr size=3 color=#8D84B5 > </hr>
<br>
### <font color = #667495 face="Gill Sans"> **1. Defining the basic model**</font>
> **Spins** = $\{\sigma_1, \sigma_2, \ldots, \sigma_n\, |\, \sigma_i = \pm 1\}$<br>
> **External Field** = Off <br>
> **Total Energy** = <br>
$$ \mathcal{H} = -\varepsilon \sum_{i, j \text{ neighbors}} \sigma_i \sigma_j $$
```
#@title <font size = 4 face="Verdana" color=667495> <b>Run Model
#@markdown Please make your selections below. <br> If running anything over $10^6$ iterations `julia` is the clear choice over `python`.
# ΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛ
# Data Defs
# ΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛ
"""
Data structure for the lattice
"""
class lattice:
# def __init__(self, nspins, eps, temp, pbc=True):
def __init__(self, params):
self.nspins = params['nspins']
self.eps = params['eps']
self.T = params['temp']
self.pbc = params['pbc']
self.E = 0.0
self.M = 0.0
probs = np.random.rand( self.nspins )
self.spins = np.array( [ -1 if prob < 0.5 else 1 for prob in probs ] )
def energy(self):
enrg = [ self.spins[i] * self.spins[i+1] for i in range(self.nspins-1) ]
if (self.pbc): enrg.append( self.spins[0] * self.spins[-1] )
self.E = -self.eps * sum(enrg)
return
def mag(self):
self.M = self.spins.sum()
return
# ΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛ
# Physics Defs
# ΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛ
"""
The Boltzmann factor for energy E in units of 𝜀,
temperature in units of 𝜀/k
"""
def boltz(E, T):
return np.exp( -E/(k*T) )
def corr(lattice):
if (lattice.pbc):
nspins = lattice.nspins
spins = lattice.spins
savg = spins.mean()
savg2 = savg*savg
coeff = 1 / ( 2 * nspins )
c = np.ones( (nspins-1)//2 )
for r in range(1, (nspins-1)//2):
for i in range(nspins):
c[r] += spins[i] * ( spins[(i + r)%nspins] + spins[(i - r)%nspins] )
c[r] *= coeff
c[r] -= savg2
return c
# ΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛ
# Algorithm Defs
# ΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛ
def MC_flip(lattice, idx):
nspins = lattice.nspins
spins = lattice.spins
# These are the calculations to obtain ΔE
# Ef = Ei + eps * ( spins[idx]*spins[idx-1] + spins[idx]*spins[idx+1] ) -
# ( (-1)*spins[idx]*spins[idx-1] + (-1)*spins[idx]*spins[idx+1] )
# Ef = Ei + 2 * ( spins[idx]*spins[idx-1] + spins[idx]*spins[idx+1] )
if lattice.pbc:
ΔE = 2 * spins[idx % nspins] * ( spins[(idx-1) % nspins]
+ spins[(idx+1) % nspins] )
else:
if idx == nspins-1:
ΔE = 2 * spins[idx] * spins[idx-1]
elif idx == 0:
ΔE = 2 * spins[idx] * spins[idx+1]
else:
ΔE = 2 * spins[idx] * ( spins[idx-1] + spins[idx+1] )
ΔM = - 2 * spins[idx]
return ΔE, ΔM
def MC_step(lattice):
nspins = lattice.nspins
idx = int( np.random.rand() * nspins )
ΔE, ΔM = MC_flip(lattice, idx)
if ΔE <= 0.0:
lattice.spins[idx] *= -1
lattice.E += ΔE
lattice.M += ΔM
else:
if ( np.random.rand() < boltz(ΔE, lattice.T) ):
lattice.spins[idx] *= -1
lattice.E += ΔE
lattice.M += ΔM
return
def MC_run(params, data, lattice):
lattice.energy()
lattice.mag()
iter = [params['iters'], params['wrt_it']]
Eavg = np.zeros(iter[1])
data['spins'][0,:] = lattice.spins.copy()
data['energy'][0] = lattice.E
data['mag'][0] = lattice.M
progPy = widgets.IntProgress(
value=0,
min=0,
max= iter[0] // iter[1] - 1,
step=1,
description='Calculating:',
bar_style='', # 'success', 'info', 'warning', 'danger' or ''
orientation='horizontal'
)
display(progPy)
i = 0
for step in range(iter[0]):
MC_step(lattice)
Eavg[i] = lattice.E
i += 1
if (step+1)%iter[1] == 0:
k = step//iter[1]
progPy.value = k
data['spins'][k,:] = lattice.spins.copy()
data['energy'][k] = Eavg.mean()
data['mag'][k] = lattice.M
i = 0
data['corr'][:] = corr(lattice)
return
def run_at_T():
# ΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛ
# Widgets
# ΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛ
# Energies in units of 𝜀,temperatures in units of 𝜀/k.
items_layout = widgets.Layout( width='auto')
nspins_input = widgets.BoundedFloatText(value=1e3,
min=10,
max=1e6,
step=1,
description='Spins:',
layout=items_layout)
eps_input = widgets.BoundedFloatText(value=1.0,
min=0,
max=1e2,
step=0.1,
description='ε:',
layout=items_layout)
temp_input = widgets.BoundedFloatText(value=1.0,
min=0,
max=20,
step=0.1,
description='Temp:',
layout=items_layout)
iters_input = widgets.BoundedFloatText(value=1e4,
min=1e3,
max=1e10,
step=1e3,
description='Iterations:',
layout=items_layout)
runPy_button = widgets.Button(description='ʀᴜɴ ᴏɴ ᴘʏᴛʜᴏɴ',
button_style='info', # 'success', 'info', 'warning', 'danger' or ''
tooltip='Click me',
icon='check',
)
runJu_button = widgets.Button(description='ʀᴜɴ ᴏɴ ᴊᴜʟɪᴀ',
button_style='warning', # 'success', 'info', 'warning', 'danger' or ''
tooltip='Click me',
icon='check'
)
output = widgets.Output()
# ΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛ
# Preparing Data
# ΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛ
def build_params():
params = {'nspins': int(nspins_input.value),
'eps' : float(eps_input.value),
'temp' : float(temp_input.value),
'pbc' : True,
'iters' : int(iters_input.value),
'wrt_it': int(1e3)
}
return params
def build_data(params):
nspins = params['nspins']
iters = params['iters']
wrt_it = params['wrt_it']
data = h5py.File("./Ising1D.hdf5", "w")
data.create_dataset('params',(5, ), dtype='f')
data['params'][0] = params['nspins']
data['params'][1] = params['eps']
data['params'][2] = params['temp']
data['params'][3] = params['iters']
data['params'][4] = params['wrt_it']
data.create_dataset('energy',
(iters // wrt_it, ), dtype='f')
data.create_dataset('mag',
(iters // wrt_it, ), dtype='f')
data.create_dataset('corr',
((nspins-1)//2, ), dtype='f')
data.create_dataset('spins',
(iters // wrt_it, nspins), dtype='f')
return data
# ΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛ
# Interface
# ΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛ
def runPy_button_clicked(b):
with output:
output.clear_output()
params = build_params()
data = build_data(params)
lattice_pbc = lattice(params)
MC_run(params, data, lattice_pbc)
display(md("<font size = 3 color=9467BD><b>Run complete!"))
data.close()
return
runPy_button.on_click(runPy_button_clicked)
def run(params):
julia_call = ['julia', '/content/Ising/MCRun1D.jl', str(params['nspins']),
str(params['eps']), str(params['temp']), str(params['iters']),
str(params['wrt_it'])]
prog = widgets.IntProgress(
value=0,
min=0,
max= params['iters'] // params['wrt_it'] - 1,
step=1,
description='Calculating:',
bar_style='', # 'success', 'info', 'warning', 'danger' or ''
orientation='horizontal'
)
display(prog)
with subprocess.Popen(julia_call, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) as process:
for line in process.stdout:
prog.value += 1
def runJu_button_clicked(b):
with output:
output.clear_output()
params = build_params()
run(params)
display(md("<font size = 3 color=9467BD><b>Run complete!"))
return
runJu_button.on_click(runJu_button_clicked)
# ΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛ
# UI
# ΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛΛ
UI = GridBox(children=[nspins_input, eps_input, runPy_button,
temp_input, iters_input, runJu_button],
layout=widgets.Layout(
width='70%',
grid_template_columns='200px 200px 100px',
grid_template_rows='30px 30px',
grid_gap='10px 10px')
)
# buttons = widgets.HBox([runPy_button, runJu_button])
display( UI )
display(output)
return
run_at_T()
```
```
#@title <font size = 4 face="Verdana" color=667495> <b>Visualize Output
#@markdown Please run this cell to visualize the calculations.
data = h5py.File("./Ising1D.hdf5", "r")
steps = len(data['energy'])
conf_i = plot_spins( data, 0)
conf_f = plot_spins( data, steps - 1)
enrg = plot_energy( data )
cor = plot_corr(data)
spinplots = row( conf_i, conf_f )
p1 = column( spinplots, enrg )
tab1 = Panel(child=p1, title="Spin Configutation & Energy")
p2 = column( spinplots, plot_mag( data ) )
tab2 = Panel(child=p2, title="Magnetization")
p3 = column(spinplots, cor)
tab3 = Panel(child=p3, title="Correlation")
# spinplots = row( conf_i, conf_f )
# plots = column( spinplots, enrg, mag[0], mag[1], cor )
# show(plots)
show(Tabs(tabs=[tab1, tab2, tab3]))
display(md(
f"<font size = 3 color=9467BD><b> Initial Energy = {data['energy'][0]}ε ⟶ Final Energy = {data['energy'][-1]}ε"
))
data.close()
```
<hr size=3 color=#8D84B5 align="left"> </hr>
# <font color = #667495 face="Gill Sans"> *References*</font>
<hr size=2 color=grey width=30% align="left"> </hr>
1. [An Introduction to Thermal Physics](https://www.amazon.com/Introduction-Thermal-Physics-Daniel-Schroeder/dp/0192895540) - Daniel V. Schroeder
|
Jack , meanwhile , has decided to abandon his double life . He arrives in full mourning and announces his brother 's death in Paris of a severe chill , a story undermined by Algernon 's presence in the guise of Ernest .
|
/-
Copyright (c) 2018 Kenny Lau. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Kenny Lau
! This file was ported from Lean 3 source module ring_theory.ideal.quotient_operations
! leanprover-community/mathlib commit d3acee0d776b15ffb8318f327325ff343cc8bdcc
! Please do not edit these lines, except to modify the commit id
! if you have ported upstream changes.
-/
import Mathbin.RingTheory.Ideal.Operations
import Mathbin.RingTheory.Ideal.Quotient
/-!
# More operations on modules and ideals related to quotients
-/
universe u v w
namespace RingHom
variable {R : Type u} {S : Type v} [CommRing R] [CommRing S] (f : R →+* S)
/-- The induced map from the quotient by the kernel to the codomain.
This is an isomorphism if `f` has a right inverse (`quotient_ker_equiv_of_right_inverse`) /
is surjective (`quotient_ker_equiv_of_surjective`).
-/
def kerLift (f : R →+* S) : R ⧸ f.ker →+* S :=
Ideal.Quotient.lift _ f fun r => f.mem_ker.mp
#align ring_hom.ker_lift RingHom.kerLift
@[simp]
theorem kerLift_mk (f : R →+* S) (r : R) : kerLift f (Ideal.Quotient.mk f.ker r) = f r :=
Ideal.Quotient.lift_mk _ _ _
#align ring_hom.ker_lift_mk RingHom.kerLift_mk
/-- The induced map from the quotient by the kernel is injective. -/
theorem kerLift_injective (f : R →+* S) : Function.Injective (kerLift f) := fun a b =>
Quotient.inductionOn₂' a b fun a b (h : f a = f b) =>
Ideal.Quotient.eq.2 <| show a - b ∈ ker f by rw [mem_ker, map_sub, h, sub_self]
#align ring_hom.ker_lift_injective RingHom.kerLift_injective
theorem lift_injective_of_ker_le_ideal (I : Ideal R) {f : R →+* S} (H : ∀ a : R, a ∈ I → f a = 0)
(hI : f.ker ≤ I) : Function.Injective (Ideal.Quotient.lift I f H) :=
by
rw [RingHom.injective_iff_ker_eq_bot, RingHom.ker_eq_bot_iff_eq_zero]
intro u hu
obtain ⟨v, rfl⟩ := Ideal.Quotient.mk_surjective u
rw [Ideal.Quotient.lift_mk] at hu
rw [Ideal.Quotient.eq_zero_iff_mem]
exact hI ((RingHom.mem_ker f).mpr hu)
#align ring_hom.lift_injective_of_ker_le_ideal RingHom.lift_injective_of_ker_le_ideal
variable {f}
/-- The **first isomorphism theorem** for commutative rings, computable version. -/
def quotientKerEquivOfRightInverse {g : S → R} (hf : Function.RightInverse g f) : R ⧸ f.ker ≃+* S :=
{ kerLift f with
toFun := kerLift f
invFun := Ideal.Quotient.mk f.ker ∘ g
left_inv := by
rintro ⟨x⟩
apply ker_lift_injective
simp [hf (f x)]
right_inv := hf }
#align ring_hom.quotient_ker_equiv_of_right_inverse RingHom.quotientKerEquivOfRightInverse
@[simp]
theorem quotientKerEquivOfRightInverse.apply {g : S → R} (hf : Function.RightInverse g f)
(x : R ⧸ f.ker) : quotientKerEquivOfRightInverse hf x = kerLift f x :=
rfl
#align ring_hom.quotient_ker_equiv_of_right_inverse.apply RingHom.quotientKerEquivOfRightInverse.apply
@[simp]
theorem quotientKerEquivOfRightInverse.Symm.apply {g : S → R} (hf : Function.RightInverse g f)
(x : S) : (quotientKerEquivOfRightInverse hf).symm x = Ideal.Quotient.mk f.ker (g x) :=
rfl
#align ring_hom.quotient_ker_equiv_of_right_inverse.symm.apply RingHom.quotientKerEquivOfRightInverse.Symm.apply
/-- The **first isomorphism theorem** for commutative rings. -/
noncomputable def quotientKerEquivOfSurjective (hf : Function.Surjective f) : R ⧸ f.ker ≃+* S :=
quotientKerEquivOfRightInverse (Classical.choose_spec hf.HasRightInverse)
#align ring_hom.quotient_ker_equiv_of_surjective RingHom.quotientKerEquivOfSurjective
end RingHom
namespace Ideal
variable {R : Type u} {S : Type v} {F : Type w} [CommRing R] [CommRing S]
@[simp]
theorem map_quotient_self (I : Ideal R) : map (Quotient.mk I) I = ⊥ :=
eq_bot_iff.2 <|
Ideal.map_le_iff_le_comap.2 fun x hx =>
(Submodule.mem_bot (R ⧸ I)).2 <| Ideal.Quotient.eq_zero_iff_mem.2 hx
#align ideal.map_quotient_self Ideal.map_quotient_self
@[simp]
theorem mk_ker {I : Ideal R} : (Quotient.mk I).ker = I := by
ext <;> rw [RingHom.ker, mem_comap, Submodule.mem_bot, quotient.eq_zero_iff_mem]
#align ideal.mk_ker Ideal.mk_ker
theorem map_mk_eq_bot_of_le {I J : Ideal R} (h : I ≤ J) : I.map J.Quotient.mk = ⊥ :=
by
rw [map_eq_bot_iff_le_ker, mk_ker]
exact h
#align ideal.map_mk_eq_bot_of_le Ideal.map_mk_eq_bot_of_le
theorem ker_quotient_lift {S : Type v} [CommRing S] {I : Ideal R} (f : R →+* S) (H : I ≤ f.ker) :
(Ideal.Quotient.lift I f H).ker = f.ker.map I.Quotient.mk :=
by
ext x
constructor
· intro hx
obtain ⟨y, hy⟩ := quotient.mk_surjective x
rw [RingHom.mem_ker, ← hy, Ideal.Quotient.lift_mk, ← RingHom.mem_ker] at hx
rw [← hy, mem_map_iff_of_surjective I.Quotient.mk quotient.mk_surjective]
exact ⟨y, hx, rfl⟩
· intro hx
rw [mem_map_iff_of_surjective I.Quotient.mk quotient.mk_surjective] at hx
obtain ⟨y, hy⟩ := hx
rw [RingHom.mem_ker, ← hy.right, Ideal.Quotient.lift_mk, ← RingHom.mem_ker f]
exact hy.left
#align ideal.ker_quotient_lift Ideal.ker_quotient_lift
@[simp]
theorem bot_quotient_isMaximal_iff (I : Ideal R) : (⊥ : Ideal (R ⧸ I)).IsMaximal ↔ I.IsMaximal :=
⟨fun hI =>
@mk_ker _ _ I ▸
@comap_isMaximal_of_surjective _ _ _ _ _ _ (Quotient.mk I) Quotient.mk_surjective ⊥ hI,
fun hI => by
skip
letI := quotient.field I
exact bot_is_maximal⟩
#align ideal.bot_quotient_is_maximal_iff Ideal.bot_quotient_isMaximal_iff
/-- See also `ideal.mem_quotient_iff_mem` in case `I ≤ J`. -/
@[simp]
theorem mem_quotient_iff_mem_sup {I J : Ideal R} {x : R} :
Quotient.mk I x ∈ J.map (Quotient.mk I) ↔ x ∈ J ⊔ I := by
rw [← mem_comap, comap_map_of_surjective (Quotient.mk' I) quotient.mk_surjective, ←
RingHom.ker_eq_comap_bot, mk_ker]
#align ideal.mem_quotient_iff_mem_sup Ideal.mem_quotient_iff_mem_sup
/-- See also `ideal.mem_quotient_iff_mem_sup` if the assumption `I ≤ J` is not available. -/
theorem mem_quotient_iff_mem {I J : Ideal R} (hIJ : I ≤ J) {x : R} :
Quotient.mk I x ∈ J.map (Quotient.mk I) ↔ x ∈ J := by
rw [mem_quotient_iff_mem_sup, sup_eq_left.mpr hIJ]
#align ideal.mem_quotient_iff_mem Ideal.mem_quotient_iff_mem
theorem comap_map_mk {I J : Ideal R} (h : I ≤ J) :
Ideal.comap (Ideal.Quotient.mk I) (Ideal.map (Ideal.Quotient.mk I) J) = J :=
by
ext
rw [← Ideal.mem_quotient_iff_mem h, Ideal.mem_comap]
#align ideal.comap_map_mk Ideal.comap_map_mk
section QuotientAlgebra
variable (R₁ R₂ : Type _) {A B : Type _}
variable [CommSemiring R₁] [CommSemiring R₂] [CommRing A] [CommRing B]
variable [Algebra R₁ A] [Algebra R₂ A] [Algebra R₁ B]
/-- The `R₁`-algebra structure on `A/I` for an `R₁`-algebra `A` -/
instance Quotient.algebra {I : Ideal A} : Algebra R₁ (A ⧸ I) :=
{
RingHom.comp (Ideal.Quotient.mk I)
(algebraMap R₁
A) with
toFun := fun x => Ideal.Quotient.mk I (algebraMap R₁ A x)
smul := (· • ·)
smul_def' := fun r x =>
Quotient.inductionOn' x fun x =>
((Quotient.mk I).congr_arg <| Algebra.smul_def _ _).trans (RingHom.map_mul _ _ _)
commutes' := fun _ _ => mul_comm _ _ }
#align ideal.quotient.algebra Ideal.Quotient.algebra
-- Lean can struggle to find this instance later if we don't provide this shortcut
instance Quotient.isScalarTower [SMul R₁ R₂] [IsScalarTower R₁ R₂ A] (I : Ideal A) :
IsScalarTower R₁ R₂ (A ⧸ I) := by infer_instance
#align ideal.quotient.is_scalar_tower Ideal.Quotient.isScalarTower
/-- The canonical morphism `A →ₐ[R₁] A ⧸ I` as morphism of `R₁`-algebras, for `I` an ideal of
`A`, where `A` is an `R₁`-algebra. -/
def Quotient.mkₐ (I : Ideal A) : A →ₐ[R₁] A ⧸ I :=
⟨fun a => Submodule.Quotient.mk a, rfl, fun _ _ => rfl, rfl, fun _ _ => rfl, fun _ => rfl⟩
#align ideal.quotient.mkₐ Ideal.Quotient.mkₐ
theorem Quotient.algHom_ext {I : Ideal A} {S} [Semiring S] [Algebra R₁ S] ⦃f g : A ⧸ I →ₐ[R₁] S⦄
(h : f.comp (Quotient.mkₐ R₁ I) = g.comp (Quotient.mkₐ R₁ I)) : f = g :=
AlgHom.ext fun x => Quotient.inductionOn' x <| AlgHom.congr_fun h
#align ideal.quotient.alg_hom_ext Ideal.Quotient.algHom_ext
theorem Quotient.alg_map_eq (I : Ideal A) :
algebraMap R₁ (A ⧸ I) = (algebraMap A (A ⧸ I)).comp (algebraMap R₁ A) :=
rfl
#align ideal.quotient.alg_map_eq Ideal.Quotient.alg_map_eq
theorem Quotient.mkₐ_toRingHom (I : Ideal A) :
(Quotient.mkₐ R₁ I).toRingHom = Ideal.Quotient.mk I :=
rfl
#align ideal.quotient.mkₐ_to_ring_hom Ideal.Quotient.mkₐ_toRingHom
@[simp]
theorem Quotient.mkₐ_eq_mk (I : Ideal A) : ⇑(Quotient.mkₐ R₁ I) = Ideal.Quotient.mk I :=
rfl
#align ideal.quotient.mkₐ_eq_mk Ideal.Quotient.mkₐ_eq_mk
@[simp]
theorem Quotient.algebraMap_eq (I : Ideal R) : algebraMap R (R ⧸ I) = I.Quotient.mk :=
rfl
#align ideal.quotient.algebra_map_eq Ideal.Quotient.algebraMap_eq
@[simp]
theorem Quotient.mk_comp_algebraMap (I : Ideal A) :
(Quotient.mk I).comp (algebraMap R₁ A) = algebraMap R₁ (A ⧸ I) :=
rfl
#align ideal.quotient.mk_comp_algebra_map Ideal.Quotient.mk_comp_algebraMap
@[simp]
theorem Quotient.mk_algebraMap (I : Ideal A) (x : R₁) :
Quotient.mk I (algebraMap R₁ A x) = algebraMap R₁ (A ⧸ I) x :=
rfl
#align ideal.quotient.mk_algebra_map Ideal.Quotient.mk_algebraMap
/-- The canonical morphism `A →ₐ[R₁] I.quotient` is surjective. -/
theorem Quotient.mkₐ_surjective (I : Ideal A) : Function.Surjective (Quotient.mkₐ R₁ I) :=
surjective_quot_mk _
#align ideal.quotient.mkₐ_surjective Ideal.Quotient.mkₐ_surjective
/-- The kernel of `A →ₐ[R₁] I.quotient` is `I`. -/
@[simp]
theorem Quotient.mkₐ_ker (I : Ideal A) : (Quotient.mkₐ R₁ I : A →+* A ⧸ I).ker = I :=
Ideal.mk_ker
#align ideal.quotient.mkₐ_ker Ideal.Quotient.mkₐ_ker
variable {R₁}
/-- `ideal.quotient.lift` as an `alg_hom`. -/
def Quotient.liftₐ (I : Ideal A) (f : A →ₐ[R₁] B) (hI : ∀ a : A, a ∈ I → f a = 0) :
A ⧸ I →ₐ[R₁] B :=
{-- this is is_scalar_tower.algebra_map_apply R₁ A (A ⧸ I) but the file `algebra.algebra.tower`
-- imports this file.
Ideal.Quotient.lift
I (f : A →+* B) hI with
commutes' := fun r =>
by
have : algebraMap R₁ (A ⧸ I) r = algebraMap A (A ⧸ I) (algebraMap R₁ A r) := by
simp_rw [Algebra.algebraMap_eq_smul_one, smul_assoc, one_smul]
rw [this, Ideal.Quotient.algebraMap_eq, RingHom.toFun_eq_coe, Ideal.Quotient.lift_mk,
AlgHom.coe_toRingHom, Algebra.algebraMap_eq_smul_one, Algebra.algebraMap_eq_smul_one,
map_smul, map_one] }
#align ideal.quotient.liftₐ Ideal.Quotient.liftₐ
@[simp]
theorem Quotient.liftₐ_apply (I : Ideal A) (f : A →ₐ[R₁] B) (hI : ∀ a : A, a ∈ I → f a = 0) (x) :
Ideal.Quotient.liftₐ I f hI x = Ideal.Quotient.lift I (f : A →+* B) hI x :=
rfl
#align ideal.quotient.liftₐ_apply Ideal.Quotient.liftₐ_apply
theorem Quotient.liftₐ_comp (I : Ideal A) (f : A →ₐ[R₁] B) (hI : ∀ a : A, a ∈ I → f a = 0) :
(Ideal.Quotient.liftₐ I f hI).comp (Ideal.Quotient.mkₐ R₁ I) = f :=
AlgHom.ext fun x => (Ideal.Quotient.lift_mk I (f : A →+* B) hI : _)
#align ideal.quotient.liftₐ_comp Ideal.Quotient.liftₐ_comp
theorem KerLift.map_smul (f : A →ₐ[R₁] B) (r : R₁) (x : A ⧸ f.toRingHom.ker) :
f.toRingHom.kerLift (r • x) = r • f.toRingHom.kerLift x :=
by
obtain ⟨a, rfl⟩ := quotient.mkₐ_surjective R₁ _ x
rw [← AlgHom.map_smul, quotient.mkₐ_eq_mk, RingHom.kerLift_mk]
exact f.map_smul _ _
#align ideal.ker_lift.map_smul Ideal.KerLift.map_smul
/-- The induced algebras morphism from the quotient by the kernel to the codomain.
This is an isomorphism if `f` has a right inverse (`quotient_ker_alg_equiv_of_right_inverse`) /
is surjective (`quotient_ker_alg_equiv_of_surjective`).
-/
def kerLiftAlg (f : A →ₐ[R₁] B) : A ⧸ f.toRingHom.ker →ₐ[R₁] B :=
AlgHom.mk' f.toRingHom.kerLift fun _ _ => KerLift.map_smul f _ _
#align ideal.ker_lift_alg Ideal.kerLiftAlg
@[simp]
theorem kerLiftAlg_mk (f : A →ₐ[R₁] B) (a : A) :
kerLiftAlg f (Quotient.mk f.toRingHom.ker a) = f a :=
rfl
#align ideal.ker_lift_alg_mk Ideal.kerLiftAlg_mk
@[simp]
theorem kerLiftAlg_toRingHom (f : A →ₐ[R₁] B) : (kerLiftAlg f).toRingHom = RingHom.kerLift f :=
rfl
#align ideal.ker_lift_alg_to_ring_hom Ideal.kerLiftAlg_toRingHom
/-- The induced algebra morphism from the quotient by the kernel is injective. -/
theorem kerLiftAlg_injective (f : A →ₐ[R₁] B) : Function.Injective (kerLiftAlg f) :=
RingHom.kerLift_injective f
#align ideal.ker_lift_alg_injective Ideal.kerLiftAlg_injective
/-- The **first isomorphism** theorem for algebras, computable version. -/
def quotientKerAlgEquivOfRightInverse {f : A →ₐ[R₁] B} {g : B → A}
(hf : Function.RightInverse g f) : (A ⧸ f.toRingHom.ker) ≃ₐ[R₁] B :=
{ RingHom.quotientKerEquivOfRightInverse fun x => show f.toRingHom (g x) = x from hf x,
kerLiftAlg f with }
#align ideal.quotient_ker_alg_equiv_of_right_inverse Ideal.quotientKerAlgEquivOfRightInverse
@[simp]
theorem quotientKerAlgEquivOfRightInverse.apply {f : A →ₐ[R₁] B} {g : B → A}
(hf : Function.RightInverse g f) (x : A ⧸ f.toRingHom.ker) :
quotientKerAlgEquivOfRightInverse hf x = kerLiftAlg f x :=
rfl
#align ideal.quotient_ker_alg_equiv_of_right_inverse.apply Ideal.quotientKerAlgEquivOfRightInverse.apply
@[simp]
theorem QuotientKerAlgEquivOfRightInverseSymm.apply {f : A →ₐ[R₁] B} {g : B → A}
(hf : Function.RightInverse g f) (x : B) :
(quotientKerAlgEquivOfRightInverse hf).symm x = Quotient.mkₐ R₁ f.toRingHom.ker (g x) :=
rfl
#align ideal.quotient_ker_alg_equiv_of_right_inverse_symm.apply Ideal.QuotientKerAlgEquivOfRightInverseSymm.apply
/-- The **first isomorphism theorem** for algebras. -/
noncomputable def quotientKerAlgEquivOfSurjective {f : A →ₐ[R₁] B} (hf : Function.Surjective f) :
(A ⧸ f.toRingHom.ker) ≃ₐ[R₁] B :=
quotientKerAlgEquivOfRightInverse (Classical.choose_spec hf.HasRightInverse)
#align ideal.quotient_ker_alg_equiv_of_surjective Ideal.quotientKerAlgEquivOfSurjective
/-- The ring hom `R/I →+* S/J` induced by a ring hom `f : R →+* S` with `I ≤ f⁻¹(J)` -/
def quotientMap {I : Ideal R} (J : Ideal S) (f : R →+* S) (hIJ : I ≤ J.comap f) : R ⧸ I →+* S ⧸ J :=
Quotient.lift I ((Quotient.mk J).comp f) fun _ ha => by
simpa [Function.comp_apply, RingHom.coe_comp, quotient.eq_zero_iff_mem] using hIJ ha
#align ideal.quotient_map Ideal.quotientMap
@[simp]
theorem quotientMap_mk {J : Ideal R} {I : Ideal S} {f : R →+* S} {H : J ≤ I.comap f} {x : R} :
quotientMap I f H (Quotient.mk J x) = Quotient.mk I (f x) :=
Quotient.lift_mk J _ _
#align ideal.quotient_map_mk Ideal.quotientMap_mk
@[simp]
theorem quotientMap_algebraMap {J : Ideal A} {I : Ideal S} {f : A →+* S} {H : J ≤ I.comap f}
{x : R₁} : quotientMap I f H (algebraMap R₁ (A ⧸ J) x) = Quotient.mk I (f (algebraMap _ _ x)) :=
Quotient.lift_mk J _ _
#align ideal.quotient_map_algebra_map Ideal.quotientMap_algebraMap
theorem quotientMap_comp_mk {J : Ideal R} {I : Ideal S} {f : R →+* S} (H : J ≤ I.comap f) :
(quotientMap I f H).comp (Quotient.mk J) = (Quotient.mk I).comp f :=
RingHom.ext fun x => by simp only [Function.comp_apply, RingHom.coe_comp, Ideal.quotientMap_mk]
#align ideal.quotient_map_comp_mk Ideal.quotientMap_comp_mk
/-- The ring equiv `R/I ≃+* S/J` induced by a ring equiv `f : R ≃+** S`, where `J = f(I)`. -/
@[simps]
def quotientEquiv (I : Ideal R) (J : Ideal S) (f : R ≃+* S) (hIJ : J = I.map (f : R →+* S)) :
R ⧸ I ≃+* S ⧸ J :=
{
quotientMap J (↑f)
(by
rw [hIJ]
exact
@le_comap_map _ S _ _ _ _ _
_) with
invFun :=
quotientMap I (↑f.symm)
(by
rw [hIJ]
exact le_of_eq (map_comap_of_equiv I f))
left_inv := by
rintro ⟨r⟩
simp
right_inv := by
rintro ⟨s⟩
simp }
#align ideal.quotient_equiv Ideal.quotientEquiv
@[simp]
theorem quotientEquiv_mk (I : Ideal R) (J : Ideal S) (f : R ≃+* S) (hIJ : J = I.map (f : R →+* S))
(x : R) : quotientEquiv I J f hIJ (Ideal.Quotient.mk I x) = Ideal.Quotient.mk J (f x) :=
rfl
#align ideal.quotient_equiv_mk Ideal.quotientEquiv_mk
@[simp]
theorem quotientEquiv_symm_mk (I : Ideal R) (J : Ideal S) (f : R ≃+* S)
(hIJ : J = I.map (f : R →+* S)) (x : S) :
(quotientEquiv I J f hIJ).symm (Ideal.Quotient.mk J x) = Ideal.Quotient.mk I (f.symm x) :=
rfl
#align ideal.quotient_equiv_symm_mk Ideal.quotientEquiv_symm_mk
/-- `H` and `h` are kept as separate hypothesis since H is used in constructing the quotient map. -/
theorem quotientMap_injective' {J : Ideal R} {I : Ideal S} {f : R →+* S} {H : J ≤ I.comap f}
(h : I.comap f ≤ J) : Function.Injective (quotientMap I f H) :=
by
refine' (injective_iff_map_eq_zero (QuotientMap I f H)).2 fun a ha => _
obtain ⟨r, rfl⟩ := quotient.mk_surjective a
rw [quotient_map_mk, quotient.eq_zero_iff_mem] at ha
exact quotient.eq_zero_iff_mem.mpr (h ha)
#align ideal.quotient_map_injective' Ideal.quotientMap_injective'
/-- If we take `J = I.comap f` then `quotient_map` is injective automatically. -/
theorem quotientMap_injective {I : Ideal S} {f : R →+* S} :
Function.Injective (quotientMap I f le_rfl) :=
quotientMap_injective' le_rfl
#align ideal.quotient_map_injective Ideal.quotientMap_injective
theorem quotientMap_surjective {J : Ideal R} {I : Ideal S} {f : R →+* S} {H : J ≤ I.comap f}
(hf : Function.Surjective f) : Function.Surjective (quotientMap I f H) := fun x =>
let ⟨x, hx⟩ := Quotient.mk_surjective x
let ⟨y, hy⟩ := hf x
⟨(Quotient.mk J) y, by simp [hx, hy]⟩
#align ideal.quotient_map_surjective Ideal.quotientMap_surjective
/-- Commutativity of a square is preserved when taking quotients by an ideal. -/
theorem comp_quotientMap_eq_of_comp_eq {R' S' : Type _} [CommRing R'] [CommRing S'] {f : R →+* S}
{f' : R' →+* S'} {g : R →+* R'} {g' : S →+* S'} (hfg : f'.comp g = g'.comp f) (I : Ideal S') :
(quotientMap I g' le_rfl).comp (quotientMap (I.comap g') f le_rfl) =
(quotientMap I f' le_rfl).comp
(quotientMap (I.comap f') g
(le_of_eq (trans (comap_comap f g') (hfg ▸ comap_comap g f')))) :=
by
refine' RingHom.ext fun a => _
obtain ⟨r, rfl⟩ := quotient.mk_surjective a
simp only [RingHom.comp_apply, quotient_map_mk]
exact congr_arg (Quotient.mk' I) (trans (g'.comp_apply f r).symm (hfg ▸ f'.comp_apply g r))
#align ideal.comp_quotient_map_eq_of_comp_eq Ideal.comp_quotientMap_eq_of_comp_eq
/-- The algebra hom `A/I →+* B/J` induced by an algebra hom `f : A →ₐ[R₁] B` with `I ≤ f⁻¹(J)`. -/
def quotientMapₐ {I : Ideal A} (J : Ideal B) (f : A →ₐ[R₁] B) (hIJ : I ≤ J.comap f) :
A ⧸ I →ₐ[R₁] B ⧸ J :=
{ quotientMap J (f : A →+* B) hIJ with commutes' := fun r => by simp }
#align ideal.quotient_mapₐ Ideal.quotientMapₐ
@[simp]
theorem quotient_map_mkₐ {I : Ideal A} (J : Ideal B) (f : A →ₐ[R₁] B) (H : I ≤ J.comap f) {x : A} :
quotientMapₐ J f H (Quotient.mk I x) = Quotient.mkₐ R₁ J (f x) :=
rfl
#align ideal.quotient_map_mkₐ Ideal.quotient_map_mkₐ
theorem quotient_map_comp_mkₐ {I : Ideal A} (J : Ideal B) (f : A →ₐ[R₁] B) (H : I ≤ J.comap f) :
(quotientMapₐ J f H).comp (Quotient.mkₐ R₁ I) = (Quotient.mkₐ R₁ J).comp f :=
AlgHom.ext fun x => by simp only [quotient_map_mkₐ, quotient.mkₐ_eq_mk, AlgHom.comp_apply]
#align ideal.quotient_map_comp_mkₐ Ideal.quotient_map_comp_mkₐ
/-- The algebra equiv `A/I ≃ₐ[R] B/J` induced by an algebra equiv `f : A ≃ₐ[R] B`,
where`J = f(I)`. -/
def quotientEquivAlg (I : Ideal A) (J : Ideal B) (f : A ≃ₐ[R₁] B) (hIJ : J = I.map (f : A →+* B)) :
(A ⧸ I) ≃ₐ[R₁] B ⧸ J :=
{ quotientEquiv I J (f : A ≃+* B) hIJ with commutes' := fun r => by simp }
#align ideal.quotient_equiv_alg Ideal.quotientEquivAlg
instance (priority := 100) quotientAlgebra {I : Ideal A} [Algebra R A] :
Algebra (R ⧸ I.comap (algebraMap R A)) (A ⧸ I) :=
(quotientMap I (algebraMap R A) (le_of_eq rfl)).toAlgebra
#align ideal.quotient_algebra Ideal.quotientAlgebra
theorem algebraMap_quotient_injective {I : Ideal A} [Algebra R A] :
Function.Injective (algebraMap (R ⧸ I.comap (algebraMap R A)) (A ⧸ I)) :=
by
rintro ⟨a⟩ ⟨b⟩ hab
replace hab := quotient.eq.mp hab
rw [← RingHom.map_sub] at hab
exact quotient.eq.mpr hab
#align ideal.algebra_map_quotient_injective Ideal.algebraMap_quotient_injective
variable (R₁)
/-- Quotienting by equal ideals gives equivalent algebras. -/
def quotientEquivAlgOfEq {I J : Ideal A} (h : I = J) : (A ⧸ I) ≃ₐ[R₁] A ⧸ J :=
quotientEquivAlg I J AlgEquiv.refl <| h ▸ (map_id I).symm
#align ideal.quotient_equiv_alg_of_eq Ideal.quotientEquivAlgOfEq
@[simp]
theorem quotientEquivAlgOfEq_mk {I J : Ideal A} (h : I = J) (x : A) :
quotientEquivAlgOfEq R₁ h (Ideal.Quotient.mk I x) = Ideal.Quotient.mk J x :=
rfl
#align ideal.quotient_equiv_alg_of_eq_mk Ideal.quotientEquivAlgOfEq_mk
@[simp]
theorem quotientEquivAlgOfEq_symm {I J : Ideal A} (h : I = J) :
(quotientEquivAlgOfEq R₁ h).symm = quotientEquivAlgOfEq R₁ h.symm := by ext <;> rfl
#align ideal.quotient_equiv_alg_of_eq_symm Ideal.quotientEquivAlgOfEq_symm
end QuotientAlgebra
end Ideal
namespace DoubleQuot
open Ideal
variable {R : Type u}
section
variable [CommRing R] (I J : Ideal R)
/-- The obvious ring hom `R/I → R/(I ⊔ J)` -/
def quotLeftToQuotSup : R ⧸ I →+* R ⧸ I ⊔ J :=
Ideal.Quotient.factor I (I ⊔ J) le_sup_left
#align double_quot.quot_left_to_quot_sup DoubleQuot.quotLeftToQuotSup
/-- The kernel of `quot_left_to_quot_sup` -/
theorem ker_quotLeftToQuotSup : (quotLeftToQuotSup I J).ker = J.map (Ideal.Quotient.mk I) := by
simp only [mk_ker, sup_idem, sup_comm, quot_left_to_quot_sup, quotient.factor, ker_quotient_lift,
map_eq_iff_sup_ker_eq_of_surjective I.Quotient.mk quotient.mk_surjective, ← sup_assoc]
#align double_quot.ker_quot_left_to_quot_sup DoubleQuot.ker_quotLeftToQuotSup
/-- The ring homomorphism `(R/I)/J' -> R/(I ⊔ J)` induced by `quot_left_to_quot_sup` where `J'`
is the image of `J` in `R/I`-/
def quotQuotToQuotSup : (R ⧸ I) ⧸ J.map (Ideal.Quotient.mk I) →+* R ⧸ I ⊔ J :=
Ideal.Quotient.lift (J.map (Ideal.Quotient.mk I)) (quot_left_to_quot_sup I J)
(ker_quot_left_to_quot_sup I J).symm.le
#align double_quot.quot_quot_to_quot_sup DoubleQuot.quotQuotToQuotSup
/-- The composite of the maps `R → (R/I)` and `(R/I) → (R/I)/J'` -/
def quotQuotMk : R →+* (R ⧸ I) ⧸ J.map I.Quotient.mk :=
(J.map I.Quotient.mk).Quotient.mk.comp I.Quotient.mk
#align double_quot.quot_quot_mk DoubleQuot.quotQuotMk
/-- The kernel of `quot_quot_mk` -/
theorem ker_quotQuotMk : (quotQuotMk I J).ker = I ⊔ J := by
rw [RingHom.ker_eq_comap_bot, quot_quot_mk, ← comap_comap, ← RingHom.ker, mk_ker,
comap_map_of_surjective (Ideal.Quotient.mk I) quotient.mk_surjective, ← RingHom.ker, mk_ker,
sup_comm]
#align double_quot.ker_quot_quot_mk DoubleQuot.ker_quotQuotMk
/-- The ring homomorphism `R/(I ⊔ J) → (R/I)/J' `induced by `quot_quot_mk` -/
def liftSupQuotQuotMk (I J : Ideal R) : R ⧸ I ⊔ J →+* (R ⧸ I) ⧸ J.map (Ideal.Quotient.mk I) :=
Ideal.Quotient.lift (I ⊔ J) (quotQuotMk I J) (ker_quotQuotMk I J).symm.le
#align double_quot.lift_sup_quot_quot_mk DoubleQuot.liftSupQuotQuotMk
/-- `quot_quot_to_quot_add` and `lift_sup_double_qot_mk` are inverse isomorphisms. In the case where
`I ≤ J`, this is the Third Isomorphism Theorem (see `quot_quot_equiv_quot_of_le`)-/
def quotQuotEquivQuotSup : (R ⧸ I) ⧸ J.map (Ideal.Quotient.mk I) ≃+* R ⧸ I ⊔ J :=
RingEquiv.ofHomInv (quotQuotToQuotSup I J) (liftSupQuotQuotMk I J)
(by
ext z
rfl)
(by
ext z
rfl)
#align double_quot.quot_quot_equiv_quot_sup DoubleQuot.quotQuotEquivQuotSup
@[simp]
theorem quotQuotEquivQuotSup_quotQuotMk (x : R) :
quotQuotEquivQuotSup I J (quotQuotMk I J x) = Ideal.Quotient.mk (I ⊔ J) x :=
rfl
#align double_quot.quot_quot_equiv_quot_sup_quot_quot_mk DoubleQuot.quotQuotEquivQuotSup_quotQuotMk
@[simp]
theorem quotQuotEquivQuotSup_symm_quotQuotMk (x : R) :
(quotQuotEquivQuotSup I J).symm (Ideal.Quotient.mk (I ⊔ J) x) = quotQuotMk I J x :=
rfl
#align double_quot.quot_quot_equiv_quot_sup_symm_quot_quot_mk DoubleQuot.quotQuotEquivQuotSup_symm_quotQuotMk
/-- The obvious isomorphism `(R/I)/J' → (R/J)/I' ` -/
def quotQuotEquivComm : (R ⧸ I) ⧸ J.map I.Quotient.mk ≃+* (R ⧸ J) ⧸ I.map J.Quotient.mk :=
((quotQuotEquivQuotSup I J).trans (quotEquivOfEq sup_comm)).trans (quotQuotEquivQuotSup J I).symm
#align double_quot.quot_quot_equiv_comm DoubleQuot.quotQuotEquivComm
@[simp]
theorem quotQuotEquivComm_quotQuotMk (x : R) :
quotQuotEquivComm I J (quotQuotMk I J x) = quotQuotMk J I x :=
rfl
#align double_quot.quot_quot_equiv_comm_quot_quot_mk DoubleQuot.quotQuotEquivComm_quotQuotMk
@[simp]
theorem quotQuotEquivComm_comp_quotQuotMk :
RingHom.comp (↑(quotQuotEquivComm I J)) (quotQuotMk I J) = quotQuotMk J I :=
RingHom.ext <| quotQuotEquivComm_quotQuotMk I J
#align double_quot.quot_quot_equiv_comm_comp_quot_quot_mk DoubleQuot.quotQuotEquivComm_comp_quotQuotMk
@[simp]
theorem quotQuotEquivComm_symm : (quotQuotEquivComm I J).symm = quotQuotEquivComm J I :=
rfl
#align double_quot.quot_quot_equiv_comm_symm DoubleQuot.quotQuotEquivComm_symm
variable {I J}
/-- **The Third Isomorphism theorem** for rings. See `quot_quot_equiv_quot_sup` for a version
that does not assume an inclusion of ideals. -/
def quotQuotEquivQuotOfLe (h : I ≤ J) : (R ⧸ I) ⧸ J.map I.Quotient.mk ≃+* R ⧸ J :=
(quotQuotEquivQuotSup I J).trans (Ideal.quotEquivOfEq <| sup_eq_right.mpr h)
#align double_quot.quot_quot_equiv_quot_of_le DoubleQuot.quotQuotEquivQuotOfLe
@[simp]
theorem quotQuotEquivQuotOfLe_quotQuotMk (x : R) (h : I ≤ J) :
quotQuotEquivQuotOfLe h (quotQuotMk I J x) = J.Quotient.mk x :=
rfl
#align double_quot.quot_quot_equiv_quot_of_le_quot_quot_mk DoubleQuot.quotQuotEquivQuotOfLe_quotQuotMk
@[simp]
theorem quotQuotEquivQuotOfLe_symm_mk (x : R) (h : I ≤ J) :
(quotQuotEquivQuotOfLe h).symm (J.Quotient.mk x) = quotQuotMk I J x :=
rfl
#align double_quot.quot_quot_equiv_quot_of_le_symm_mk DoubleQuot.quotQuotEquivQuotOfLe_symm_mk
theorem quotQuotEquivQuotOfLe_comp_quotQuotMk (h : I ≤ J) :
RingHom.comp (↑(quotQuotEquivQuotOfLe h)) (quotQuotMk I J) = J.Quotient.mk := by ext <;> rfl
#align double_quot.quot_quot_equiv_quot_of_le_comp_quot_quot_mk DoubleQuot.quotQuotEquivQuotOfLe_comp_quotQuotMk
theorem quotQuotEquivQuotOfLe_symm_comp_mk (h : I ≤ J) :
RingHom.comp (↑(quotQuotEquivQuotOfLe h).symm) J.Quotient.mk = quotQuotMk I J := by ext <;> rfl
#align double_quot.quot_quot_equiv_quot_of_le_symm_comp_mk DoubleQuot.quotQuotEquivQuotOfLe_symm_comp_mk
end
section Algebra
@[simp]
theorem quotQuotEquivComm_mk_mk [CommRing R] (I J : Ideal R) (x : R) :
quotQuotEquivComm I J (Ideal.Quotient.mk _ (Ideal.Quotient.mk _ x)) = algebraMap R _ x :=
rfl
#align double_quot.quot_quot_equiv_comm_mk_mk DoubleQuot.quotQuotEquivComm_mk_mk
variable [CommSemiring R] {A : Type v} [CommRing A] [Algebra R A] (I J : Ideal A)
@[simp]
theorem quotQuotEquivQuotSup_quot_quot_algebraMap (x : R) :
DoubleQuot.quotQuotEquivQuotSup I J (algebraMap R _ x) = algebraMap _ _ x :=
rfl
#align double_quot.quot_quot_equiv_quot_sup_quot_quot_algebra_map DoubleQuot.quotQuotEquivQuotSup_quot_quot_algebraMap
@[simp]
theorem quotQuotEquivComm_algebraMap (x : R) :
quotQuotEquivComm I J (algebraMap R _ x) = algebraMap _ _ x :=
rfl
#align double_quot.quot_quot_equiv_comm_algebra_map DoubleQuot.quotQuotEquivComm_algebraMap
end Algebra
end DoubleQuot
|
/*
* Copyright (c) CERN 2013
*
* Copyright (c) Members of the EMI Collaboration. 2011-2013
* See http://www.eu-emi.eu/partners for details on the copyright
* holders.
*
* Licensed under the Apache License, Version 2.0
* See the LICENSE file for further information
*
*/
/** @file LocationPlugin.hh
* @brief Base class for an UGR location plugin
* @author Fabrizio Furano
* @date Oct 2011
*/
#ifndef LOCATIONPLUGIN_HH
#define LOCATIONPLUGIN_HH
#include "Config.h"
#include "SimpleDebug.hh"
#include "LocationInfoHandler.hh"
#include "PluginInterface.hh"
#include <string>
#include <vector>
#include <map>
#include <functional>
#include <bitset>
#include <boost/thread.hpp>
class LocationInfoHandler;
class UgrConnector;
#define LocPluginLogInfo(lvl, where, what) do { \
if (UgrLogger::get()->getLevel() >= lvl && UgrLogger::get()->isLogged(pluglogmask)) \
{ \
std::ostringstream outs; \
outs << "UGR " << pluglogname << " " << where << " " << __func__ << " : " << what; \
UgrLogger::get()->log((UgrLogger::Level)lvl, outs.str()); \
} \
}while(0)
#define LocPluginLogInfoThr(lvl, where, what) do { \
if (UgrLogger::get()->getLevel() >= lvl && UgrLogger::get()->isLogged(pluglogmask)) \
{ \
std::ostringstream outs; \
outs << "UGR " << pluglogname << "[" << getID() << "] " << where << " " << __func__ << " : " << what; \
UgrLogger::get()->log((UgrLogger::Level)lvl, outs.str()); \
} \
}while(0)
#define LocPluginLogErr(where, what) do { \
std::ostringstream outs; \
outs << "UGR " << pluglogname << "[" << getID() << "] " << where << " !! " << __func__ << " : " << what; \
UgrLogger::get()->log((UgrLogger::Level)0, outs.str()); \
}while(0)
enum PluginEndpointState {
PLUGIN_ENDPOINT_UNKNOWN = 0,
PLUGIN_ENDPOINT_ONLINE,
PLUGIN_ENDPOINT_OFFLINE,
PLUGIN_ENDPOINT_TEMPORARY_OFFLINE,
PLUGIN_ENDPOINT_NOT_EXIST,
PLUGIN_ENDPOINT_OVERLOADED,
PLUGIN_ENDPOINT_ERROR_AUTH,
PLUGIN_ENDPOINT_ERROR_OTHER,
};
/// contains information about the availability of the plugin endpoint
class PluginEndpointStatus {
public:
/// current status of the plugin's endpoint
PluginEndpointState state;
/// average latency in ms
int latency_ms;
/// error code (e.g. the http one)
int errcode;
/// string description
std::string explanation;
/// when the status was checked last
time_t lastcheck;
/// We will like to be able to encode this info to a string, e.g. for external caching purposes
int encodeToString(std::string &str);
/// We will like to be able to encode this info to a string, e.g. for external caching purposes
int decode(void *data, int sz);
/// We will like to be able to encode this info to a string, e.g. for being monitored
/// This func actually appends it to a given string
int encodeToMonString(std::string &str);
PluginEndpointStatus() {
lastcheck = 0;
state = PLUGIN_ENDPOINT_UNKNOWN;
latency_ms = 0;
errcode = 0;
};
};
class PluginAvailabilityInfo {
public:
PluginAvailabilityInfo(int interval_ms = 5000, int latency_ms = 5000);
/// Do we do any status checking at all?
bool state_checking;
/// How often the check has to be made
int time_interval_ms;
/// The maximum allowed latency
int max_latency_ms;
virtual bool isOK() {
// A plugin can be used if it's ONLINE since 10 checks
return ((status.state <= PLUGIN_ENDPOINT_ONLINE) &&
(time(0)-lastchange > time_interval_ms/100));
}
bool getCheckRunning();
bool setCheckRunning(bool b);
bool isExpired(time_t timenow);
/// Gets the current status for this plugin/endpoint
virtual void getStatus(PluginEndpointStatus &st);
/// Sets the current status for this plugin/endpoint, set dirty
virtual void setStatus(PluginEndpointStatus &st, bool setdirty, char *logname);
virtual bool isDirty() {
return status_dirty;
}
virtual void setDirty(bool d) {
boost::unique_lock< boost::mutex > l(workmutex);
status_dirty = d;
}
private:
boost::mutex workmutex;
bool isCheckRunning;
/// The current status
PluginEndpointStatus status;
bool status_dirty;
/// when the status changed last time
time_t lastchange;
};
/** LocationPlugin
* Base class for a plugin which gathers info about files from some source. No assumption
* is made about what source is this.
* This base implementation acts as a default fake plugin, that puts test data
* as responses. Very useful for testing.
*
*/
class LocationPlugin : public PluginInterface {
private:
std::bitset<64> flags;
int nthreads;
/// Easy way to get threaded life
friend void pluginFunc(LocationPlugin *pl, int myidx);
friend void executor_findNewLocation(LocationPlugin* p, std::string new_lfn, std::shared_ptr<NewLocationHandler> handler);
friend void executor_deleteReplica(LocationPlugin* p, std::string new_lfn, std::shared_ptr<DeleteReplicaHandler> handler);
friend void executor_deleteDir(LocationPlugin* p, std::string new_lfn, std::shared_ptr<DeleteReplicaHandler> handler);
friend void executor_mkDirMinusPonSiteFN(LocationPlugin* p, std::string lfn, std::shared_ptr<HandlerTraits> handler);
public:
enum workOp {
wop_Nop = 0,
wop_Stat,
wop_Locate,
wop_List,
wop_Check,
wop_CheckReplica
};
enum Flag{
Readable=0,
Writable=1,
Listable=2
};
/// The description of an operation to be done asynchronously
struct worktoken {
/// FileInfo that refers to the file
UgrFileInfo *fi;
/// Operation to perform to gather info on the item
workOp wop;
LocationInfoHandler *handler;
/// Alternative replica name to check for the given file
std::string repl;
/// Alternative prefix to locally prepend to the string being searched
std::string altpfx;
/// alternative execution task
/// if operation is valid, execute only operation
std::function<void (void)> operation;
};
protected:
/// The name assigned to this plugin from the creation
std::string name;
/// We keep a private thread pool and a synchronized work queue, in order to provide
/// pure non blocking behaviour
std::vector< boost::thread * > workers;
/// Online/offline, etc
PluginAvailabilityInfo availInfo;
// Ext cache
ExtCacheHandler *extCache;
// Workaround for a bug in boost, where interrupt() hangs
bool exiting;
/// Tells us if this plugin is invoked directly by UgrConnector (slave=false) or by another plugin (slave=true)
bool slave;
/// Tells us if this plugin demands the validation of the replicas to the slave plugins
bool replicaXlator;
/// Queue of the pending operations
std::deque< struct worktoken *> workqueue;
/// Condvar for synchronizing the queue
boost::condition_variable workcondvar;
/// Mutex for protecting the queue
boost::mutex workmutex;
UgrLogger::bitmask pluglogmask;
UgrLogger::component pluglogname;
/// Push into the queue a new op to be performed, relative to an instance of UgrFileInfo
void pushOp(UgrFileInfo *fi, LocationInfoHandler *handler, workOp wop = wop_Nop, char *newpfx = 0);
/// Push generic operation to be performed
void pushOp(const std::function<void (void)> & operation);
void pushRepCheckOp(UgrFileInfo *fi, LocationInfoHandler *handler, std::string &rep);
/// Gets the next op to perform
struct worktoken *getOp();
/// The method that performs the operation
/// This has to be overridden in the true plugins
virtual void runsearch(struct worktoken *wtk, int myidx);
/// Implement the Checker at the plugin level
///
virtual void run_Check(int myidx);
/// execute a findNewLocation operation, need to be implemented by the plugin
/// @param fi UgrFileInfo instance to populate
/// @param handler the location info handler to write into
virtual int run_findNewLocation(const std::string & new_lfn, std::shared_ptr<NewLocationHandler> handler);
/// executes a deleteReplica operation, this need to be implemented by the plugin
///
virtual int run_deleteReplica(const std::string & lfn, std::shared_ptr<DeleteReplicaHandler> handler);
/// executes a deleteDir operation, this need to be implemented by the plugin
///
virtual int run_deleteDir(const std::string & lfn, std::shared_ptr<DeleteReplicaHandler> handler);
/// executes a 'mkdir -p' operation on a replica URL, this need to be implemented by the plugin
///
virtual int run_mkDirMinusPonSiteFN(const std::string &sitefn, std::shared_ptr<HandlerTraits> handler);
// The simple, default global name translation
std::vector<std::string> xlatepfx_from;
std::string xlatepfx_to;
// The prefix multiplier, to look for files in multiple dirs at once
std::vector<std::string> pfxmultiply;
/// Applies the plugin-specific name translation. This may depend also on the operation being requested.
virtual int doNameXlation(std::string &from, std::string &to, workOp op, std::string &altpfx);
/// Add parent directory if needed
bool doParentQueryCheck(std::string & from, struct worktoken *wtk, int myidx);
/// Invokes a full round of CheckReplica towards other slave plugins
virtual void req_checkreplica(UgrFileInfo *fi, std::string &repl);
public:
LocationPlugin(UgrConnector & c, std::vector<std::string> &parms);
virtual ~LocationPlugin();
virtual void stop();
virtual int start(ExtCacheHandler *c);
/// Gives life to the object
virtual int Tick(time_t timenow);
virtual int isOK() {
return availInfo.isOK();
}
virtual bool canDoChecksum() {
std::string pfx("locplugin.");
pfx += name;
pfx += ".candochecksum";
return UgrCFG->GetBool(pfx.c_str(), false);
}
/// Tells us if this plugin is invoked directly by UgrConnector (slave=false) or by another plugin (slave=true)
bool isSlave() {
return slave;
};
/// Tells us if this plugin demands the validation of the replicas to the slave plugins
bool isReplicaXlator() {
return replicaXlator;
}
bool getFlag(Flag flag_type){
return flags[static_cast<size_t>(flag_type)];
}
void setFlag(Flag flag_type, bool value){
flags[static_cast<size_t>(flag_type)] = value;
}
///
/// return the plugin name ( id )
///
virtual const std::string & get_Name() {
return name;
}
// Calls that characterize the behavior of the plugin
// In general:
// do_XXX triggers the start of an async task that gathers a specific kind of info
// it's not serialized, and it has to return immediately, exposing a non-blocking behavior
// do_waitXXX waits for the completion of the task that was triggered by the corresponding
// invokation of do_XXX. This is a blocking function, that must honour the timeout value that
// is given
// The async stat process will put (asynchronously) the required info directly in the data fields of
// the given instance of UgrFileInfo. Access to this data struct has to be properly protected, since it's
// a shared thing
/// Start the async stat process
/// @param fi UgrFileInfo instance to populate
/// @param handler the location info handler to write into
virtual int do_Stat(UgrFileInfo *fi, LocationInfoHandler *handler);
/// Waits max a number of seconds for a stat process to be complete
/// @param fi UgrFileInfo instance to wait for
/// @param tmout Timeout for waiting
virtual int do_waitStat(UgrFileInfo *fi, int tmout = 5);
/// Start the async location process
/// @param fi UgrFileInfo instance to populate
/// @param handler the location info handler to write into
virtual int do_Locate(UgrFileInfo *fi, LocationInfoHandler *handler);
/// Waits max a number of seconds for a locate process to be complete
/// @param fi UgrFileInfo instance to wait for
/// @param tmout Timeout for waiting
virtual int do_waitLocate(UgrFileInfo *fi, int tmout = 5);
/// Start the async listing process
/// @param fi UgrFileInfo instance to populate
/// @param handler the location info handler to write into
virtual int do_List(UgrFileInfo *fi, LocationInfoHandler *handler);
/// Waits max a number of seconds for a list process to be complete
/// @param fi UgrFileInfo instance to wait for
/// @param tmout Timeout for waiting
virtual int do_waitList(UgrFileInfo *fi, int tmout = 5);
///
/// \brief async_findNewLocation
/// \param new_lfn
/// \param handler
/// \return 0 if success, negative if plugin error
///
/// Execute a findNewLocation query on this plugin asynchronously. this call run_findNewLocation internally
///
int async_findNewLocation(const std::string & new_lfn, const std::shared_ptr<NewLocationHandler> & handler);
///
/// \brief async_deleteReplica
/// \param lfn
/// \param handler
/// \return 0 if success, negative if plugin error
///
/// Execute a delete operation on this plugin asynchronously. this call run_deleteReplica internally
///
int async_deleteReplica(const std::string & lfn, const std::shared_ptr<DeleteReplicaHandler> & handler);
///
/// \brief async_deleteDir
/// \param lfn
/// \param handler
/// \return 0 if success, negative if plugin error
///
/// Execute a delete operation on this plugin asynchronously. this call run_deleteDir internally
///
int async_deleteDir(const std::string & lfn, const std::shared_ptr<DeleteReplicaHandler> & handler);
///
/// \brief async_mkDirMinusPonSiteFN
/// \param lfn
/// \param handler
/// \return 0 if success, negative if plugin error
///
/// Execute a 'mkdir -p' operation on this plugin asynchronously. this call run_mkDirMinusPonSiteFN internally
///
int async_mkDirMinusPonSiteFN(const std::string & lfn, const std::shared_ptr<HandlerTraits> & handler);
/// Asynchronously check if this plugin knows about the given replica
/// Eventually add the replica
/// @param fi UgrFileInfo instance to populate
/// @param rep the replica to check
/// @param handler the location info handler to write into
virtual int do_CheckReplica(UgrFileInfo *fi, std::string &rep, LocationInfoHandler *handler);
/// Asynchronously check the plugin Status
void do_Check(int myidx);
void appendMonString(std::string &mons);
public:
static const std::string & getConfigPrefix();
};
#endif
|
lines = readlines(ARGS[1])
function check_boards(check_val, boards)
for (i, o) in enumerate(boards)
if board_wins(check_val, boards[i][1], boards[i][2])
return boards[i][1], boards[i][2]
else
continue
end
end
return nothing, nothing
end
function board_wins(check_val, check_board, result_board)
for (row_i, row_v) in enumerate(check_board)
for (col_i, col_v) in enumerate(row_v)
if col_v == check_val
result_board[row_i][col_i] = check_val
break
end
end
end
if check_rows(result_board)
return true
elseif check_columns(result_board)
return true
else
return false
end
end
function check_columns(result_board)
for (i, v) in enumerate(result_board[1])
if !isnothing(v)
if size([row[i] for row in result_board if row[i] != ""]) == (5,)
return true
end
end
end
return false
end
function check_rows(result_board)
for row in result_board
if size([x for x in row if x != ""]) == (5,)
return true
end
end
return false
end
function solution1(lines)
moves = nothing
boards = []
board = []
for (iter_val, line) in enumerate(lines)
if iter_val == 1
moves = split(line, ",")
elseif iter_val > 2
if line == ""
append!(boards, [(board, [["" for i in 1:5] for i in 1:5])])
board = []
else
append!(board, [split(line)])
end
else
continue
end
end
(win_board, win_positions) = (nothing, nothing)
skip = Int[]
for move in moves
for (i, o) in enumerate(boards)
if i in skip
continue
end
for (row_i, row_v) in enumerate(boards[i][1])
for (col_i, col_v) in enumerate(row_v)
if col_v == move
boards[i][2][row_i][col_i] = move
break
break
end
end
end
if check_rows(boards[i][2])
(win_board, win_positions) = boards[i]
append!(skip, i)
elseif check_columns(boards[i][2])
(win_board, win_positions) = boards[i]
append!(skip, i)
end
end
if isnothing(win_board)
continue
else
sum_val = 0
for (row_i, row_v) in enumerate(win_positions)
for (col_i, col_v) in enumerate(row_v)
if col_v == ""
sum_val += parse(Int, win_board[row_i][col_i])
end
end
end
println(sum_val*parse(Int, move))
end
(win_board, win_positions) = (nothing, nothing)
end
# moves = parse_moves(lines[1])
# lines = Array(lines)
# println(lines[3:size(lines)])
# boards = parse_games(lines[3:-1])
return nothing
end
# function solution2(lines)
# end
solution1(lines) |
"""
streamplot(f::function, xinterval, yinterval; kwargs...)
f must either accept `f(::Point)` or `f(x::Number, y::Number)`.
f must return a Point2.
Example:
```julia
v(x::Point2{T}) where T = Point2f(x[2], 4*x[1])
streamplot(v, -2..2, -2..2)
```
## Attributes
$(ATTRIBUTES)
## Implementation
See the function `Makie.streamplot_impl` for implementation details.
"""
@recipe(StreamPlot, f, limits) do scene
merge(
Attributes(
stepsize = 0.01,
gridsize = (32, 32, 32),
maxsteps = 500,
colormap = theme(scene, :colormap),
colorrange = Makie.automatic,
arrow_size = 10,
arrow_head = automatic,
density = 1.0,
quality = 16
),
default_theme(scene, Lines) # so that we can theme the lines as needed.
)
end
function convert_arguments(::Type{<: StreamPlot}, f::Function, xrange, yrange)
xmin, xmax = extrema(xrange)
ymin, ymax = extrema(yrange)
return (f, Rect(xmin, ymin, xmax - xmin, ymax - ymin))
end
function convert_arguments(::Type{<: StreamPlot}, f::Function, xrange, yrange, zrange)
xmin, xmax = extrema(xrange)
ymin, ymax = extrema(yrange)
zmin, zmax = extrema(zrange)
mini = Vec3f(xmin, ymin, zmin)
maxi = Vec3f(xmax, ymax, zmax)
return (f, Rect(mini, maxi .- mini))
end
function convert_arguments(::Type{<: StreamPlot}, f::Function, limits::Rect)
return (f, limits)
end
scatterfun(N) = N == 2 ? scatter! : meshscatter!
"""
streamplot_impl(CallType, f, limits::Rect{N, T}, resolutionND, stepsize)
Code adapted from an example implementation by Moritz Schauer (@mschauer)
from https://github.com/JuliaPlots/Makie.jl/issues/355#issuecomment-504449775
Background: The algorithm puts an arrow somewhere and extends the
streamline in both directions from there. Then, it chooses a new
position (from the remaining ones), repeating the the exercise until the
streamline gets blocked, from which on a new starting point, the process
repeats.
So, ideally, the new starting points for streamlines are not too close to
current streamlines.
Links:
[Quasirandom sequences](http://extremelearning.com.au/unreasonable-effectiveness-of-quasirandom-sequences/)
"""
function streamplot_impl(CallType, f, limits::Rect{N, T}, resolutionND, stepsize, maxsteps=500, dens=1.0) where {N, T}
resolution = to_ndim(Vec{N, Int}, resolutionND, last(resolutionND))
mask = trues(resolution...) # unvisited squares
arrow_pos = Point{N, Float32}[]
arrow_dir = Vec{N, Float32}[]
line_points = Point{N, Float32}[]
colors = Float64[]
line_colors = Float64[]
dt = Point{N, Float32}(stepsize)
mini, maxi = minimum(limits), maximum(limits)
r = ntuple(N) do i
LinRange(mini[i], maxi[i], resolution[i] + 1)
end
apply_f(x0, P) = if P <: Point
f(x0)
else
f(x0...)
end
# see http://extremelearning.com.au/unreasonable-effectiveness-of-quasirandom-sequences/
ϕ = (MathConstants.φ, 1.324717957244746, 1.2207440846057596)[N]
acoeff = ϕ.^(-(1:N))
n_points = 0 # count visited squares
ind = 0 # index of low discrepancy sequence
while n_points < prod(resolution)*min(one(dens), dens) # fill up to 100*dens% of mask
# next index from low discrepancy sequence
c = CartesianIndex(ntuple(N) do i
j = ceil(Int, ((0.5 + acoeff[i]*ind) % 1)*resolution[i])
clamp(j, 1, size(mask, i))
end)
ind += 1
if mask[c]
x0 = Point(ntuple(N) do i
first(r[i]) + (c[i] - 0.5) * step(r[i])
end)
point = apply_f(x0, CallType)
if !(point isa Point2 || point isa Point3)
error("Function passed to streamplot must return Point2 or Point3")
end
pnorm = norm(point)
push!(arrow_pos, x0)
push!(arrow_dir, point ./ pnorm)
push!(colors, pnorm)
mask[c] = false
n_points += 1
for d in (-1, 1)
n_linepoints = 1
x = x0
ccur = c
push!(line_points, Point{N, Float32}(NaN), x)
push!(line_colors, 0.0, pnorm)
while x in limits && n_linepoints < maxsteps
point = apply_f(x, CallType)
pnorm = norm(point)
x = x .+ d .* dt .* point ./ pnorm
if !(x in limits)
break
end
# WHAT? Why does point behave different from tuple in this
# broadcast
idx = CartesianIndex(searchsortedlast.(r, Tuple(x)))
if idx != ccur
if !mask[idx]
break
end
mask[idx] = false
n_points += 1
ccur = idx
end
push!(line_points, x)
push!(line_colors, pnorm)
n_linepoints += 1
end
end
end
end
return (
arrow_pos,
arrow_dir,
line_points,
colors,
line_colors,
)
end
function plot!(p::StreamPlot)
data = lift(p.f, p.limits, p.gridsize, p.stepsize, p.maxsteps, p.density) do f, limits, resolution, stepsize, maxsteps, density
P = if applicable(f, Point2f(0)) || applicable(f, Point3f(0))
Point
else
Number
end
streamplot_impl(P, f, limits, resolution, stepsize, maxsteps, density)
end
lines!(
p,
lift(x->x[3], data), color = lift(last, data), colormap = p.colormap, colorrange = p.colorrange,
linestyle = p.linestyle,
linewidth = p.linewidth,
inspectable = p.inspectable,
transparency = p.transparency
)
N = ndims(p.limits[])
if N == 2 # && scatterplot.markerspace[] == Pixel (default)
# Calculate arrow head rotations as angles. To avoid distortions from
# (extreme) aspect ratios we need to project to pixel space and renormalize.
scene = parent_scene(p)
rotations = lift(scene.camera.projectionview, scene.px_area, data) do pv, pxa, data
angles = map(data[1], data[2]) do pos, dir
pstart = project(scene, pos)
pstop = project(scene, pos .+ dir)
pdir = pstop - pstart
n = norm(pdir)
if n == 0
zero(n)
else
angle = acos(pdir[2] / n)
angle = ifelse(pdir[1] > 0, 2pi - angle, angle)
end
end
Billboard(angles)
end
else
rotations = map(x -> x[2], data)
end
scatterfun(N)(
p,
lift(first, data), markersize = p.arrow_size,
marker = @lift(arrow_head(N, $(p.arrow_head), $(p.quality))),
color = lift(x-> x[4], data), rotations = rotations,
colormap = p.colormap, colorrange = p.colorrange,
inspectable = p.inspectable, transparency = p.transparency
)
end
|
/-
Copyright (c) 2022 Yaël Dillies, Bhavik Mehta. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Yaël Dillies, Bhavik Mehta
-/
import combinatorics.simple_graph.basic
import order.partition.finpartition
import tactic.positivity
/-!
# Edge density
> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
> Any changes to this file require a corresponding PR to mathlib4.
This file defines the number and density of edges of a relation/graph.
## Main declarations
Between two finsets of vertices,
* `rel.interedges`: Finset of edges of a relation.
* `rel.edge_density`: Edge density of a relation.
* `simple_graph.interedges`: Finset of edges of a graph.
* `simple_graph.edge_density`: Edge density of a graph.
-/
open finset
open_locale big_operators
variables {𝕜 ι κ α β : Type*}
/-! ### Density of a relation -/
namespace rel
section asymmetric
variables [linear_ordered_field 𝕜] (r : α → β → Prop) [Π a, decidable_pred (r a)]
{s s₁ s₂ : finset α} {t t₁ t₂ : finset β} {a : α} {b : β} {δ : 𝕜}
/-- Finset of edges of a relation between two finsets of vertices. -/
def interedges (s : finset α) (t : finset β) : finset (α × β) := (s ×ˢ t).filter $ λ e, r e.1 e.2
/-- Edge density of a relation between two finsets of vertices. -/
def edge_density (s : finset α) (t : finset β) : ℚ := (interedges r s t).card / (s.card * t.card)
variables {r}
lemma mem_interedges_iff {x : α × β} : x ∈ interedges r s t ↔ x.1 ∈ s ∧ x.2 ∈ t ∧ r x.1 x.2 :=
by simp only [interedges, and_assoc, mem_filter, finset.mem_product]
lemma mk_mem_interedges_iff : (a, b) ∈ interedges r s t ↔ a ∈ s ∧ b ∈ t ∧ r a b :=
mem_interedges_iff
@[simp] lemma interedges_empty_left (t : finset β) : interedges r ∅ t = ∅ :=
by rw [interedges, finset.empty_product, filter_empty]
lemma interedges_mono (hs : s₂ ⊆ s₁) (ht : t₂ ⊆ t₁) : interedges r s₂ t₂ ⊆ interedges r s₁ t₁ :=
λ x, by { simp_rw mem_interedges_iff, exact λ h, ⟨hs h.1, ht h.2.1, h.2.2⟩ }
variables (r)
lemma card_interedges_add_card_interedges_compl (s : finset α) (t : finset β) :
(interedges r s t).card + (interedges (λ x y, ¬r x y) s t).card = s.card * t.card :=
begin
classical,
rw [←card_product, interedges, interedges, ←card_union_eq, filter_union_filter_neg_eq],
convert disjoint_filter.2 (λ x _, not_not.2),
end
lemma interedges_disjoint_left {s s' : finset α} (hs : disjoint s s') (t : finset β) :
disjoint (interedges r s t) (interedges r s' t) :=
begin
rw finset.disjoint_left at ⊢ hs,
rintro x hx hy,
rw [mem_interedges_iff] at hx hy,
exact hs hx.1 hy.1,
end
lemma interedges_disjoint_right (s : finset α) {t t' : finset β} (ht : disjoint t t') :
disjoint (interedges r s t) (interedges r s t') :=
begin
rw finset.disjoint_left at ⊢ ht,
rintro x hx hy,
rw [mem_interedges_iff] at hx hy,
exact ht hx.2.1 hy.2.1,
end
section decidable_eq
variables [decidable_eq α] [decidable_eq β]
lemma interedges_bUnion_left (s : finset ι) (t : finset β) (f : ι → finset α) :
interedges r (s.bUnion f) t = s.bUnion (λ a, interedges r (f a) t) :=
ext $ λ a, by simp only [mem_bUnion, mem_interedges_iff, exists_and_distrib_right]
lemma interedges_bUnion_right (s : finset α) (t : finset ι) (f : ι → finset β) :
interedges r s (t.bUnion f) = t.bUnion (λ b, interedges r s (f b)) :=
ext $ λ a, by simp only [mem_interedges_iff, mem_bUnion, ←exists_and_distrib_left,
←exists_and_distrib_right]
lemma interedges_bUnion (s : finset ι) (t : finset κ) (f : ι → finset α) (g : κ → finset β) :
interedges r (s.bUnion f) (t.bUnion g) =
(s ×ˢ t).bUnion (λ ab, interedges r (f ab.1) (g ab.2)) :=
by simp_rw [product_bUnion, interedges_bUnion_left, interedges_bUnion_right]
end decidable_eq
lemma card_interedges_le_mul (s : finset α) (t : finset β) :
(interedges r s t).card ≤ s.card * t.card :=
(card_filter_le _ _).trans (card_product _ _).le
lemma edge_density_nonneg (s : finset α) (t : finset β) : 0 ≤ edge_density r s t :=
by { apply div_nonneg; exact_mod_cast nat.zero_le _ }
lemma edge_density_le_one (s : finset α) (t : finset β) : edge_density r s t ≤ 1 :=
div_le_one_of_le (by exact_mod_cast (card_interedges_le_mul _ _ _)) $
by exact_mod_cast (nat.zero_le _)
lemma edge_density_add_edge_density_compl (hs : s.nonempty) (ht : t.nonempty) :
edge_density r s t + edge_density (λ x y, ¬r x y) s t = 1 :=
begin
rw [edge_density, edge_density, div_add_div_same, div_eq_one_iff_eq],
{ exact_mod_cast card_interedges_add_card_interedges_compl r s t },
{ exact_mod_cast (mul_pos hs.card_pos ht.card_pos).ne' }
end
@[simp] lemma edge_density_empty_left (t : finset β) : edge_density r ∅ t = 0 :=
by rw [edge_density, finset.card_empty, nat.cast_zero, zero_mul, div_zero]
@[simp] lemma edge_density_empty_right (s : finset α) : edge_density r s ∅ = 0 :=
by rw [edge_density, finset.card_empty, nat.cast_zero, mul_zero, div_zero]
lemma card_interedges_finpartition_right [decidable_eq β] (s : finset α) (P : finpartition t) :
(interedges r s t).card = ∑ b in P.parts, (interedges r s b).card :=
begin
classical,
simp_rw [←P.bUnion_parts, interedges_bUnion_right, id],
rw card_bUnion,
exact λ x hx y hy h, interedges_disjoint_right r _ (P.disjoint hx hy h),
end
lemma card_interedges_finpartition [decidable_eq α] [decidable_eq β] (P : finpartition s)
(Q : finpartition t) :
(interedges r s t).card = ∑ ab in P.parts ×ˢ Q.parts, (interedges r ab.1 ab.2).card :=
by simp_rw [card_interedges_finpartition_left _ P, card_interedges_finpartition_right _ _ Q,
sum_product]
lemma mul_edge_density_le_edge_density (hs : s₂ ⊆ s₁) (ht : t₂ ⊆ t₁) (hs₂ : s₂.nonempty)
(ht₂ : t₂.nonempty) :
(s₂.card : ℚ)/s₁.card * (t₂.card/t₁.card) * edge_density r s₂ t₂ ≤ edge_density r s₁ t₁ :=
begin
have hst : (s₂.card : ℚ) * t₂.card ≠ 0 := by simp [hs₂.ne_empty, ht₂.ne_empty],
rw [edge_density, edge_density, div_mul_div_comm, mul_comm, div_mul_div_cancel _ hst],
refine div_le_div_of_le (by exact_mod_cast (s₁.card * t₁.card).zero_le) _,
exact_mod_cast card_le_of_subset (interedges_mono hs ht),
end
lemma edge_density_sub_edge_density_le_one_sub_mul (hs : s₂ ⊆ s₁) (ht : t₂ ⊆ t₁) (hs₂ : s₂.nonempty)
(ht₂ : t₂.nonempty) :
edge_density r s₂ t₂ - edge_density r s₁ t₁ ≤ 1 - (s₂.card)/s₁.card * (t₂.card/t₁.card) :=
begin
refine (sub_le_sub_left (mul_edge_density_le_edge_density r hs ht hs₂ ht₂) _).trans _,
refine le_trans _ (mul_le_of_le_one_right _ (edge_density_le_one r s₂ t₂)),
{ rw [sub_mul, one_mul] },
refine sub_nonneg_of_le (mul_le_one _ (by positivity) _);
exact div_le_one_of_le (nat.cast_le.2 (card_le_of_subset ‹_›)) (nat.cast_nonneg _),
end
lemma abs_edge_density_sub_edge_density_le_one_sub_mul (hs : s₂ ⊆ s₁) (ht : t₂ ⊆ t₁)
(hs₂ : s₂.nonempty) (ht₂ : t₂.nonempty) :
|edge_density r s₂ t₂ - edge_density r s₁ t₁| ≤ 1 - s₂.card/s₁.card * (t₂.card/t₁.card) :=
begin
have habs : abs (edge_density r s₂ t₂ - edge_density r s₁ t₁) ≤ 1,
{ rw [abs_sub_le_iff, ←sub_zero (1 : ℚ)],
split; exact sub_le_sub (edge_density_le_one r _ _) (edge_density_nonneg r _ _) },
refine abs_sub_le_iff.2 ⟨edge_density_sub_edge_density_le_one_sub_mul r hs ht hs₂ ht₂, _⟩,
rw [←add_sub_cancel (edge_density r s₁ t₁) (edge_density (λ x y, ¬r x y) s₁ t₁),
←add_sub_cancel (edge_density r s₂ t₂) (edge_density (λ x y, ¬r x y) s₂ t₂),
edge_density_add_edge_density_compl _ (hs₂.mono hs) (ht₂.mono ht),
edge_density_add_edge_density_compl _ hs₂ ht₂, sub_sub_sub_cancel_left],
exact edge_density_sub_edge_density_le_one_sub_mul _ hs ht hs₂ ht₂,
end
lemma abs_edge_density_sub_edge_density_le_two_mul_sub_sq (hs : s₂ ⊆ s₁) (ht : t₂ ⊆ t₁)
(hδ₀ : 0 ≤ δ) (hδ₁ : δ < 1) (hs₂ : (1 - δ) * s₁.card ≤ s₂.card)
(ht₂ : (1 - δ) * t₁.card ≤ t₂.card) :
|(edge_density r s₂ t₂ : 𝕜) - edge_density r s₁ t₁| ≤ 2*δ - δ^2 :=
begin
have hδ' : 0 ≤ 2 * δ - δ ^ 2,
{ rw [sub_nonneg, sq],
exact mul_le_mul_of_nonneg_right (hδ₁.le.trans (by norm_num)) hδ₀ },
rw ←sub_pos at hδ₁,
obtain rfl | hs₂' := s₂.eq_empty_or_nonempty,
{ rw [finset.card_empty, nat.cast_zero] at hs₂,
simpa [edge_density, (nonpos_of_mul_nonpos_right hs₂ hδ₁).antisymm (nat.cast_nonneg _)]
using hδ' },
obtain rfl | ht₂' := t₂.eq_empty_or_nonempty,
{ rw [finset.card_empty, nat.cast_zero] at ht₂,
simpa [edge_density, (nonpos_of_mul_nonpos_right ht₂ hδ₁).antisymm (nat.cast_nonneg _)]
using hδ' },
rw [show 2 * δ - δ ^ 2 = 1 - (1 - δ) * (1 - δ), by ring],
norm_cast,
refine (rat.cast_le.2 $
abs_edge_density_sub_edge_density_le_one_sub_mul r hs ht hs₂' ht₂').trans _,
push_cast,
have := hs₂'.mono hs,
have := ht₂'.mono ht,
refine sub_le_sub_left (mul_le_mul ((le_div_iff _).2 hs₂) ((le_div_iff _).2 ht₂) hδ₁.le _) _;
positivity,
end
/-- If `s₂ ⊆ s₁`, `t₂ ⊆ t₁` and they take up all but a `δ`-proportion, then the difference in edge
densities is at most `2 * δ`. -/
lemma abs_edge_density_sub_edge_density_le_two_mul (hs : s₂ ⊆ s₁) (ht : t₂ ⊆ t₁) (hδ : 0 ≤ δ)
(hscard : (1 - δ) * s₁.card ≤ s₂.card) (htcard : (1 - δ) * t₁.card ≤ t₂.card) :
|(edge_density r s₂ t₂ : 𝕜) - edge_density r s₁ t₁| ≤ 2 * δ :=
begin
cases lt_or_le δ 1,
{ exact (abs_edge_density_sub_edge_density_le_two_mul_sub_sq r hs ht hδ h hscard htcard).trans
((sub_le_self_iff _).2 $ sq_nonneg δ) },
rw two_mul,
refine (abs_sub _ _).trans (add_le_add (le_trans _ h) (le_trans _ h));
{ rw abs_of_nonneg,
exact_mod_cast edge_density_le_one r _ _,
exact_mod_cast edge_density_nonneg r _ _ }
end
end asymmetric
section symmetric
variables (r : α → α → Prop) [decidable_rel r] {s s₁ s₂ t t₁ t₂ : finset α} {a b : α}
variables {r} (hr : symmetric r)
include hr
@[simp] lemma swap_mem_interedges_iff {x : α × α} :
x.swap ∈ interedges r s t ↔ x ∈ interedges r t s :=
by { rw [mem_interedges_iff, mem_interedges_iff, hr.iff], exact and.left_comm }
lemma mk_mem_interedges_comm : (a, b) ∈ interedges r s t ↔ (b, a) ∈ interedges r t s :=
@swap_mem_interedges_iff _ _ _ _ _ hr (b, a)
lemma card_interedges_comm (s t : finset α) : (interedges r s t).card = (interedges r t s).card :=
finset.card_congr (λ (x : α × α) _, x.swap) (λ x, (swap_mem_interedges_iff hr).2)
(λ _ _ _ _ h, prod.swap_injective h)
(λ x h, ⟨x.swap, (swap_mem_interedges_iff hr).2 h, x.swap_swap⟩)
lemma edge_density_comm (s t : finset α) : edge_density r s t = edge_density r t s :=
by rw [edge_density, mul_comm, card_interedges_comm hr, edge_density]
end symmetric
end rel
open rel
/-! ### Density of a graph -/
namespace simple_graph
variables (G : simple_graph α) [decidable_rel G.adj] {s s₁ s₂ t t₁ t₂ : finset α} {a b : α}
/-- Finset of edges of a relation between two finsets of vertices. -/
def interedges (s t : finset α) : finset (α × α) := interedges G.adj s t
/-- Density of edges of a graph between two finsets of vertices. -/
def edge_density : finset α → finset α → ℚ := edge_density G.adj
lemma interedges_def (s t : finset α) :
G.interedges s t = (s ×ˢ t).filter (λ e, G.adj e.1 e.2) := rfl
lemma edge_density_def (s t : finset α) :
G.edge_density s t = (G.interedges s t).card / (s.card * t.card) := rfl
@[simp] lemma card_interedges_div_card (s t : finset α) :
((G.interedges s t).card : ℚ) / (s.card * t.card) = G.edge_density s t := rfl
lemma mem_interedges_iff {x : α × α} : x ∈ G.interedges s t ↔ x.1 ∈ s ∧ x.2 ∈ t ∧ G.adj x.1 x.2 :=
mem_interedges_iff
lemma mk_mem_interedges_iff : (a, b) ∈ G.interedges s t ↔ a ∈ s ∧ b ∈ t ∧ G.adj a b :=
mk_mem_interedges_iff
@[simp] lemma interedges_empty_left (t : finset α) : G.interedges ∅ t = ∅ := interedges_empty_left _
lemma interedges_mono : s₂ ⊆ s₁ → t₂ ⊆ t₁ → G.interedges s₂ t₂ ⊆ G.interedges s₁ t₁ :=
interedges_mono
lemma interedges_disjoint_left (hs : disjoint s₁ s₂) (t : finset α) :
disjoint (G.interedges s₁ t) (G.interedges s₂ t) :=
interedges_disjoint_left _ hs _
lemma interedges_disjoint_right (s : finset α) (ht : disjoint t₁ t₂) :
disjoint (G.interedges s t₁) (G.interedges s t₂) :=
interedges_disjoint_right _ _ ht
section decidable_eq
variables [decidable_eq α]
lemma interedges_bUnion_left (s : finset ι) (t : finset α) (f : ι → finset α) :
G.interedges (s.bUnion f) t = s.bUnion (λ a, G.interedges (f a) t) :=
interedges_bUnion_left _ _ _ _
lemma interedges_bUnion_right (s : finset α) (t : finset ι) (f : ι → finset α) :
G.interedges s (t.bUnion f) = t.bUnion (λ b, G.interedges s (f b)) :=
interedges_bUnion_right _ _ _ _
lemma interedges_bUnion (s : finset ι) (t : finset κ) (f : ι → finset α) (g : κ → finset α) :
G.interedges (s.bUnion f) (t.bUnion g) =
(s ×ˢ t).bUnion (λ ab, G.interedges (f ab.1) (g ab.2)) :=
interedges_bUnion _ _ _ _ _
lemma card_interedges_add_card_interedges_compl (h : disjoint s t) :
(G.interedges s t).card + (Gᶜ.interedges s t).card = s.card * t.card :=
begin
rw [←card_product, interedges_def, interedges_def],
have : (s ×ˢ t).filter (λ e , Gᶜ.adj e.1 e.2) = (s ×ˢ t).filter (λ e , ¬ G.adj e.1 e.2),
{ refine filter_congr (λ x hx, _),
rw mem_product at hx,
rw [compl_adj, and_iff_right (h.forall_ne_finset hx.1 hx.2)] },
rw [this, ←card_union_eq, filter_union_filter_neg_eq],
exact disjoint_filter.2 (λ x _, not_not.2),
end
lemma edge_density_add_edge_density_compl (hs : s.nonempty) (ht : t.nonempty) (h : disjoint s t) :
G.edge_density s t + Gᶜ.edge_density s t = 1 :=
begin
rw [edge_density_def, edge_density_def, div_add_div_same, div_eq_one_iff_eq],
{ exact_mod_cast card_interedges_add_card_interedges_compl _ h },
{ positivity }
end
end decidable_eq
lemma card_interedges_le_mul (s t : finset α) : (G.interedges s t).card ≤ s.card * t.card :=
card_interedges_le_mul _ _ _
lemma edge_density_nonneg (s t : finset α) : 0 ≤ G.edge_density s t := edge_density_nonneg _ _ _
lemma edge_density_le_one (s t : finset α) : G.edge_density s t ≤ 1 := edge_density_le_one _ _ _
@[simp] lemma edge_density_empty_left (t : finset α) : G.edge_density ∅ t = 0 :=
edge_density_empty_left _ _
@[simp] lemma edge_density_empty_right (s : finset α) : G.edge_density s ∅ = 0 :=
edge_density_empty_right _ _
@[simp] lemma swap_mem_interedges_iff {x : α × α} :
x.swap ∈ G.interedges s t ↔ x ∈ G.interedges t s :=
swap_mem_interedges_iff G.symm
lemma mk_mem_interedges_comm : (a, b) ∈ G.interedges s t ↔ (b, a) ∈ G.interedges t s :=
mk_mem_interedges_comm G.symm
lemma edge_density_comm (s t : finset α) : G.edge_density s t = G.edge_density t s :=
edge_density_comm G.symm s t
end simple_graph
namespace tactic
open positivity
/-- Extension for the `positivity` tactic: `rel.edge_density` and `simple_graph.edge_density` are
always nonnegative. -/
@[positivity]
meta def positivity_edge_density : expr → tactic strictness
| `(rel.edge_density %%r %%s %%t) := nonnegative <$>
mk_mapp ``rel.edge_density_nonneg [none, none, r, none, s, t]
| `(simple_graph.edge_density %%G %%s %%t) := nonnegative <$>
mk_mapp ``simple_graph.edge_density_nonneg [none, G, none, s, t]
| e := pp e >>= fail ∘ format.bracket "The expression `"
"` isn't of the form `rel.edge_density r s t` nor `simple_graph.edge_density G s t`"
end tactic
|
Ruler 8 was the last of the successful warrior kings of Toniná . He celebrated a series of events between 789 and 806 , including the defeat of <unk> in 789 , and the capture of the ruler Ucha 'an Aj Chih , who appears to have been the vassal of B 'olon K 'awiil of Calakmul . In 799 he rededicated the tomb of Ruler 1 . Ruler 8 oversaw an extensive remodelling of the upper levels of the Acropolis . Ruler 8 erected a number of sculptures of bound prisoners of war and adopted the title aj b 'olon b 'aak , " He of Many Captives " . However , the lesser extent of Toniná 's power is evident from its victory over the site of Sak Tz 'i ' ( White Dog ) , an important city in the Lacandon region , an area which had once been dominated by Toniná .
|
## Author: Sergio García Prado
rm(list = ls())
y <- c(7, 6, 8, 16, 13)
k <- length(y)
n <- sum(y)
LogLikelihood <- function(p, y, k) {
sum(y[1:(k - 1)] * log(p)) + y[k] * log(1 - sum(p))
}
NegativeLogLikelihood <- function(...) {
- LogLikelihood(...)
}
p.hat.initial <- rep(1 / k, k - 1)
opt <- optim(p.hat.initial[1:(k - 1)], NegativeLogLikelihood, y = y, k = k, hessian = TRUE)
(p.hat <- opt$par)
# 0.139976175373378 0.120217883250931 0.159986995019396 0.319854212163691
(p.hat.var <- solve(opt$hessian))
# 0.0024070858 -0.0003370446 -0.0004477195 -0.0008948212
# -0.0003370446 0.0021183563 -0.0003852716 -0.0007700115
# -0.0004477195 -0.0003852716 0.0026874471 -0.0010228592
# -0.0008948212 -0.0007700115 -0.0010228592 0.0043497380
## a)
####
LogLikelihood1H0 <- function(theta, y, k) {
LogLikelihood(c(theta[1], theta[1], theta[1], theta[2]), y, k)
}
NegativeLogLikelihood1H0 <- function(...) {
- LogLikelihood1H0(...)
}
opt1.hzero <- optim(c(0.1, 0.1), NegativeLogLikelihood1H0, y = y, k = k, hessian = TRUE)
(LRT1 <- 2 * (LogLikelihood(p.hat, y, k) - LogLikelihood1H0(opt1.hzero$par, y, k)))
# 0.286670914555231
(LRT1.pvalue <- 1 - pchisq(LRT1, df = (k - 1) - 3))
# 0.59236182742952
## b)
####
g1 <- function(p) {
c(p[1] - p[2],
p[1] - p[3],
p[1] + p[2] + p[3] + 2 * p[4] - 1)
}
g1.derivative <- function(p) {
matrix(c(1, -1, 0, 0,
1, 0, -1, 0,
1, 1, 1, 2),
3, 4, byrow = TRUE)
}
(g1.hat <- g1(p.hat))
# 0.0197582921224479 -0.0200108196460179 0.059889477971087
(g1.hat.var <- g1.derivative(p.hat) %*% p.hat.var %*% t(g1.derivative(p.hat)))
# 5.199531e-03 2.806578e-03 -2.333792e-05
# 2.806578e-03 5.989972e-03 2.394155e-05
# -2.333792e-05 2.394155e-05 1.152100e-02
(W1 <- t(g1.hat - rep(0, 3)) %*% solve(g1.hat.var) %*% (g1.hat - rep(0, 3)))
# 0.6002303
(W1.pvalue <- 1 - pchisq(W1, df = (k - 1) - 3))
# 0.4384902
## c)
####
LogLikelihood2H0 <- function(theta, y, k) {
LogLikelihood(c(theta[1], 2 * theta[1], theta[2], theta[2]), y, k)
}
NegativeLogLikelihood2H0 <- function(...) {
- LogLikelihood2H0(...)
}
opt2.hzero <- optim(c(0.1, 0.1), NegativeLogLikelihood2H0, y = y, k = k, hessian = TRUE)
(LRT2 <- 2 * (LogLikelihood(p.hat, y, k) - LogLikelihood2H0(opt2.hzero$par, y, k)))
# 5.01968859661113
(LRT2.pvalue <- 1 - pchisq(LRT2, df = (k - 1) - 2))
# 0.0812808938285899
## d)
####
g2 <- function(p) {
c(p[2] - 2 * p[1],
p[3] - p[4])
}
g2.derivative <- function(p) {
matrix(c(-2, 1, 0, 0,
0, 1, -1, 0),
2, 4, byrow = TRUE)
}
(g2.hat <- g2(p.hat))
# -0.120217883250931 -0.159867217144294
(g2.hat.var <- g2.derivative(p.hat) %*% p.hat.var %*% t(g2.derivative(p.hat)))
# 0.013094878 0.002282278
# 0.002282278 0.005576347
(W2 <- t(g2.hat - rep(0, 2)) %*% solve(g2.hat.var) %*% (g2.hat - rep(0, 2)))
# 5.314512
(W2.pvalue <- 1 - pchisq(W2, df = (k - 1) - 2))
# 0.07014043
|
Require Import List ListSet basic Morphisms RelationClasses Equivalence.
Import ListNotations.
Section Definitions.
Definition union_fold {A B} (eq_dec : dec_type B) (f : A -> set B) (s : set A) (base : set B) : set B :=
set_fold_left (fun acc a => set_union eq_dec acc (f a)) s base.
Definition union_map {A B} (eq_dec : dec_type B) (f : A -> set B) (s : set A) : set B :=
union_fold eq_dec f s (empty_set _).
Definition triple_union_fold {A B C D}
(Beq_dec : dec_type B) (Ceq_dec : dec_type C) (Deq_dec : dec_type D)
(f : A -> (set B * set C * set D)) (l : set A) (base : set B * set C * set D) :
(set B * set C * set D) :=
set_fold_left
(fun (acc : (set B * set C * set D)) (a : A) =>
match acc with
(bs,cs,ds) =>
match f a with
(bs',cs',ds') =>
(set_union Beq_dec bs bs', set_union Ceq_dec cs cs', set_union Deq_dec ds ds')
end
end)
l base.
Definition triple_union_map {A B C D}
(Beq_dec : dec_type B) (Ceq_dec : dec_type C) (Deq_dec : dec_type D)
(f : A -> (set B * set C * set D)) (l : set A) : (set B * set C * set D) :=
triple_union_fold Beq_dec Ceq_dec Deq_dec f l ((empty_set _),(empty_set _),(empty_set _)).
Definition Subset {A} (s s' : set A) := forall x, In x s -> In x s'.
Definition Set_equiv {A} (s s' : set A) := Subset s s' /\ Subset s' s.
Fixpoint dedup {A} (eq_dec : dec_type A) (s : set A) :=
match s with
nil => nil
| a::s' => if set_mem eq_dec a s' then
dedup eq_dec s'
else
a::(dedup eq_dec s')
end.
Fixpoint set_remove_all {A} (eq_dec : dec_type A) (a : A) (s : set A) :=
match s with
nil => nil
| a'::s' => if eq_dec a a' then
set_remove_all eq_dec a s'
else
a'::(set_remove_all eq_dec a s')
end.
End Definitions.
Global Program Instance subset_refl {A} : Reflexive (@Subset A).
Next Obligation.
intros y Hin; auto.
Qed.
Hint Immediate subset_refl.
Global Program Instance subset_trans {A} : Transitive (@Subset A).
Next Obligation. intros w Hin; apply H,H0 in Hin; assumption.
Qed.
Global Program Instance set_equiv_equiv {A} : Equivalence (@Set_equiv A).
Next Obligation.
intro; split; reflexivity.
Qed.
Next Obligation.
intros ? ? [? ?]; split; auto.
Qed.
Next Obligation.
intros ? ? ? [H ?] [H1 ?]; split; intros ? ?;[apply H1,H|]; auto.
Qed.
Section Facts.
Variables (A : Type) (Aeq_dec : dec_type A).
Lemma set_add_elim_LEM : forall (s : set A) a b, set_In a (set_add Aeq_dec b s) ->
(a = b /\ ~ set_In a s) \/ set_In a s.
Proof.
intros s a ? H; destruct (set_add_elim _ _ _ _ H);
[destruct (set_In_dec Aeq_dec a s)|]; auto.
Qed.
Theorem set_union_elim_LEM : forall (s s' : set A) a, set_In a (set_union Aeq_dec s s') ->
set_In a s \/
(set_In a s' /\ ~ set_In a s).
Proof.
intros s ? a H; destruct (set_union_elim _ _ _ _ H);[|destruct (set_In_dec Aeq_dec a s)]; auto.
Qed.
Lemma set_add_nodup : forall (s : set A) a, NoDup s -> NoDup (set_add Aeq_dec a s).
Proof.
induction s as [|a' s IH]; intros; simpl;
[constructor; [intro bad; inversion bad|constructor]
|destruct (Aeq_dec a a');
[|inversion H as [|? ? Hnin Hdup]; subst;
specialize (IH a Hdup);
constructor;
[intro Hin; apply set_add_elim2 in Hin;[apply Hnin in Hin|]
|]]]; auto.
Qed.
Lemma set_union_nodup : forall (s s' : set A), NoDup s -> NoDup (set_union Aeq_dec s s').
Proof.
induction s'; intro nds; [|apply set_add_nodup];auto.
Qed.
Theorem set_remove_in : forall (s : set A) (a a' : A), set_In a (set_remove Aeq_dec a' s) -> set_In a s.
Proof.
induction s as [|a_ s IH]; intros a a' H;
[inversion H
|simpl in H;
destruct (Aeq_dec a' a_);
[right; auto
|inversion H; [subst; left|right; apply (IH a a')]; auto]].
Qed.
Theorem set_remove_all_in : forall (s : set A) (a a' : A), set_In a (set_remove_all Aeq_dec a' s) -> set_In a s.
Proof.
induction s as [|a_ s IH]; intros a a' H;
[inversion H
|simpl in H;
destruct (Aeq_dec a' a_);
[subst; right; apply (IH a a_); auto
|inversion H; [subst; left|right; apply (IH a a')]]]; auto.
Qed.
Theorem set_remove_all_neq : forall (s : set A) (a a' : A), set_In a (set_remove_all Aeq_dec a' s) -> a <> a'.
Proof.
induction s as [|a_ s IH]; intros a a' H;
[inversion H
|simpl in H;
destruct (Aeq_dec a' a_); [|inversion H];subst]; auto.
Qed.
Theorem set_remove_all_neq_in : forall (s : set A) (a a' : A), set_In a s -> a <> a' -> set_In a (set_remove_all Aeq_dec a' s).
Proof.
induction s as [|a_ s IH]; intros a a' Hin Hneq;
[inversion Hin
|simpl;
destruct (Aeq_dec a' a_);
inversion Hin;
subst; [bad_eq|apply IH |left |right; apply IH]]; auto.
Qed.
Theorem set_remove_all_notin : forall a (s : set A), ~ set_In a (set_remove_all Aeq_dec a s).
Proof.
induction s; [intros bad; inversion bad
|simpl; destruct (Aeq_dec a a0);
[subst|intro bad; inversion bad; [subst;bad_eq|]]; auto].
Qed.
Global Program Instance set_union_respects : Proper (Set_equiv ==> Set_equiv ==> Set_equiv) (set_union Aeq_dec).
Next Obligation.
intros x y H0 z w H1; split; intros u Hin;
(destruct (set_union_elim Aeq_dec _ _ _ Hin);
[apply set_union_intro1, H0
|apply set_union_intro2, H1]; auto).
Qed.
Global Program Instance set_remove_all_respects : Proper ((@eq A) ==> Set_equiv ==> Set_equiv) (set_remove_all Aeq_dec).
Next Obligation.
intros ? ? Heq s s' [Sub Sub']; split; intros u Hin;
(subst;
cut (In u s');
[cut (u <> y);
[intros Hin' Hneq; apply set_remove_all_neq_in; try apply Sub'
|apply (set_remove_all_neq _ _ _ Hin)]
|apply set_remove_all_in in Hin; (apply Sub in Hin || apply Sub' in Hin)]; auto).
Qed.
Global Program Instance set_add_respects : Proper ((@eq A) ==> Set_equiv ==> Set_equiv) (set_add Aeq_dec).
Next Obligation.
intros ? ? Heq s s' [Sub Sub']; subst; split; intros u Hin;
(destruct (set_add_elim Aeq_dec _ _ _ Hin) as [|Hin'];
[subst; apply set_add_intro2; reflexivity
|(apply Sub in Hin' || apply Sub' in Hin'); apply set_add_intro1]; auto).
Qed.
Global Program Instance set_diff_respects : Proper (Set_equiv ==> Set_equiv ==> Set_equiv) (set_diff Aeq_dec).
Next Obligation.
intros u v [Subv Subu] s s' [Subs Subs']; split; intros x Hin;
(pose (need0 := set_diff_elim1 _ _ _ _ Hin);
pose (need1 := set_diff_elim2 _ _ _ _ Hin);
(apply Subv in need0 || apply Subu in need0);
((cut (~ In x s');[intro; apply set_diff_intro; auto|intro xs'; apply Subs' in xs'; contradiction])
||(cut (~ In x s);[intro; apply set_diff_intro; auto|intro xs'; apply Subs in xs'; contradiction]))).
Qed.
Theorem dedup_notin : forall (s : set A) a, ~ set_In a s -> ~ set_In a (dedup Aeq_dec s).
Proof.
induction s; intros a' Hnin bad; [inversion bad|simpl in bad;case_eq (set_mem Aeq_dec a s); intro res; rewrite res in bad;[apply IHs in bad; [|intro bad'; apply Hnin; right]; auto|]].
inversion bad; [subst; apply Hnin; left; reflexivity|apply IHs in H; [|intro bad'; apply Hnin; right]]; auto.
Qed.
Theorem dedup_in : forall (s : set A) a, set_In a (dedup Aeq_dec s) -> set_In a s.
Proof.
induction s; intros a' Hin; [inversion Hin|simpl in Hin].
case_eq (set_mem Aeq_dec a s); intro res; rewrite res in Hin.
apply IHs in Hin; right; auto.
inversion Hin; [subst; left|apply IHs in H; right]; auto.
Qed.
Theorem in_dedup : forall (s : set A) a, set_In a s -> set_In a (dedup Aeq_dec s).
Proof.
induction s; intros a' Hin; [inversion Hin|simpl].
case_eq (set_mem Aeq_dec a s); intro res;
[apply set_mem_correct1 in res; apply IHs;
inversion Hin; subst; auto
|inversion Hin; subst; [left|right; apply IHs]; auto].
Qed.
Theorem dedup_nodup : forall (s : set A), NoDup (dedup Aeq_dec s).
Proof.
induction s;[constructor|simpl; case_eq (set_mem Aeq_dec a s);intro res;[auto|apply set_mem_complete1 in res]].
apply dedup_notin in res; constructor; auto.
Qed.
Global Program Instance dedup_respects : Proper (Set_equiv ==> Set_equiv) (dedup Aeq_dec).
Next Obligation.
intros s s' [Subs Subs']; split; intros ? ?; apply in_dedup; [apply Subs|apply Subs']; apply dedup_in; auto.
Qed.
Theorem fold_left_nodup : forall B (f: set A -> B -> set A) (fprop : forall X b, NoDup X -> NoDup (f X b))
(s : set B) (b : set A),
NoDup b -> NoDup (set_fold_left f s b).
Proof.
induction s; intros b ndb;[|apply IHs, fprop]; auto.
Qed.
Theorem union_map_nodup : forall B (f : B -> set A) s, NoDup (union_map Aeq_dec f s).
Proof.
intros; apply fold_left_nodup;
[intros; apply set_union_nodup; auto
|constructor].
Qed.
Theorem union_fold_base_subset : forall B (f: B -> set A) (s : set B) (base : set A),
Subset base (union_fold Aeq_dec f s base).
Proof.
induction s as [|b s IH]; intros base; simpl.
reflexivity.
transitivity (set_union Aeq_dec base (f b)); [intros ? ?; apply set_union_intro1; auto|apply IH].
Qed.
Theorem fold_left_subset : forall B (f: B -> set A) (s : set B) (base : set A),
Subset base (set_fold_left (fun acc b =>
set_union Aeq_dec acc (f b))
s base).
Proof.
induction s; intros b a' Hin.
auto.
simpl in *.
apply IHs.
apply set_union_intro1; auto.
Qed.
Theorem union_subset1 : forall {B} (Beq_dec : dec_type B) (s s' s'' : set B), Subset (set_union Beq_dec s s') s'' ->
Subset s s''.
Proof.
intros; intros x Hin; apply (set_union_intro1 Beq_dec _ _ s'),H in Hin; auto.
Qed.
Theorem union_subset2 : forall {B} (Beq_dec : dec_type B) (s s' s'' : set B), Subset (set_union Beq_dec s s') s'' ->
Subset s' s''.
Proof.
intros; intros x Hin; apply (set_union_intro2 Beq_dec _ _ s'),H in Hin; auto.
Qed.
Definition Triple_subset {A B C} (s s' : set A * set B * set C) : Prop :=
match s,s' with
(As,Bs,Cs),(As',Bs',Cs') => Subset As As' /\ Subset Bs Bs' /\ Subset Cs Cs'
end.
Theorem triple_union_fold_base_subset : forall B C D (Beq_dec : dec_type B) (Ceq_dec : dec_type C)
(f: D -> set A * set B * set C) (s : set D)
(base : set A * set B * set C),
Triple_subset base (triple_union_fold Aeq_dec Beq_dec Ceq_dec f s base).
Proof.
induction s; intros [[Bas Bbs] Bcs].
hnf; repeat split; reflexivity.
simpl.
specialize (IHs (let (p, ds') := f a in
let (bs', cs') := p in
(set_union Aeq_dec Bas bs', set_union Beq_dec Bbs cs',
set_union Ceq_dec Bcs ds'))).
destruct (f a) as [[bs' cs'] ds'].
destruct (triple_union_fold Aeq_dec Beq_dec Ceq_dec f s
(set_union Aeq_dec Bas bs', set_union Beq_dec Bbs cs',
set_union Ceq_dec Bcs ds')) as [[As' Bs'] Cs'].
destruct IHs as [X [Y Z]]; repeat split; solve [eapply union_subset1; eauto| eapply union_subset2; eauto].
Qed.
Theorem fold_left_subset_in : forall B (f: B -> set A) (s : set B) (base : set A) b,
In b s -> Subset (f b) (set_fold_left (fun acc b =>
set_union Aeq_dec acc (f b))
s base).
Proof.
induction s; intros base b Hin a' Hin'.
inversion Hin.
simpl in *.
inversion Hin as [Heq|Hrest].
subst; apply union_fold_base_subset,set_union_intro2; auto.
apply (IHs (set_union Aeq_dec base (f a)) b Hrest); auto.
Qed.
Theorem union_fold_subset_in : forall B (f: B -> set A) (s : set B) (base : set A) b,
In b s -> Subset (f b) (union_fold Aeq_dec f s base).
Proof.
intros; apply fold_left_subset_in; auto.
Qed.
Theorem triple_union_fold_subset_in : forall B C D
(Beq_dec : dec_type B) (Ceq_dec : dec_type C)
(f: D -> set A * set B * set C) (s : set D)
(base : set A * set B * set C) d,
In d s ->
Triple_subset (f d) (triple_union_fold Aeq_dec Beq_dec Ceq_dec f s base).
Proof.
induction s; intros base d Hin; inversion Hin; [subst|apply IHs; auto].
case_eq (triple_union_fold Aeq_dec Beq_dec Ceq_dec f s
(let (p, ds) := base in
let (bs, cs) := p in
let (p0, ds') := f d in
let (bs', cs') := p0 in
(set_union Aeq_dec bs bs', set_union Beq_dec cs cs',
set_union Ceq_dec ds ds'))).
intros [As' Bs'] Cs' peq.
pose (L := triple_union_fold_base_subset).
specialize (L _ _ _ Beq_dec Ceq_dec f s (let (p, ds) := base in
let (bs, cs) := p in
let (p0, ds') := f d in
let (bs', cs') := p0 in
(set_union Aeq_dec bs bs', set_union Beq_dec cs cs',
set_union Ceq_dec ds ds'))).
rewrite peq in L.
simpl; rewrite peq.
destruct base as [[bs cs] ds].
destruct (f d) as [[a b] c].
destruct L as [Asub [Bsub Csub]]; repeat split; solve [eapply union_subset1; eauto | eapply union_subset2; eauto].
Qed.
Theorem union_map_subset : forall B (f : B -> set A) s b, In b s -> Subset (f b) (union_map Aeq_dec f s).
Proof.
intros; apply union_fold_subset_in; auto.
Qed.
Theorem triple_union_map_subset : forall B C D (Beq_dec : dec_type B) (Ceq_dec : dec_type C)
(f : D -> (set A * set B * set C)) (s : set D) d,
set_In d s ->
Triple_subset (f d) (triple_union_map Aeq_dec Beq_dec Ceq_dec f s).
Proof.
intros; apply triple_union_fold_subset_in; auto.
Qed.
Lemma in_set_ind : forall A (P : set A -> Prop),
P nil ->
forall s',
(forall s a, P s /\ In a s' /\ Subset s s' -> P (a :: s)) ->
P s'.
induction s'; intros; auto.
apply H0; split. apply IHs'; intros ? ? [? [? ?]]. apply H0; repeat split; [|right|intros x X; apply H3 in X;right]; auto.
(* Todo *)
split;[left|right];auto.
Qed.
Theorem union_folded_property : forall B (f : B -> set A) (P : A -> Prop) s base
(fprop : forall b, set_In b s -> Forall P (f b)),
Forall P base ->
Forall P (union_fold Aeq_dec f s base).
Proof.
intros ? ? ? s;
apply (@in_set_ind _ (fun s =>
forall base (fprop : forall b, set_In b s -> Forall P (f b)),
Forall P base ->
Forall P (union_fold Aeq_dec f s base))).
intros base fprop allbase; auto.
intros s' a [IH [ains Hsub]] base fprop allbase.
simpl; apply IH.
intros b Hin; apply fprop; right; auto.
rewrite Forall_forall; intros x Hin; apply set_union_elim in Hin.
destruct Hin as [inbase|inf].
rewrite Forall_forall in allbase; apply allbase; auto.
specialize (fprop a (or_introl (eq_refl _))); rewrite Forall_forall in fprop; apply fprop; auto.
Qed.
(*
Inductive Forall3 {D B C} (P : D -> B -> C -> Prop) : list D -> list B -> list C -> Prop :=
nil_forall3 : Forall3 P nil nil nil
| cons_forall3 : forall d b c Ds Bs Cs, Forall3 P Ds Bs Cs -> P d b c -> Forall3 P (d::Ds) (b::Bs) (c::Cs).
Fixpoint In3 {D B C} (d : D) (b : B) (c : C) (Ds : list D) (Bs : list B) (Cs : list C) : Prop :=
length Ds = length Bs /\ length Bs = length Cs /\
match Ds,Bs,Cs with
d'::Ds,b'::Bs,c'::Cs => (d = d' /\ b' = b /\ c' = c) \/ (In3 d b c Ds Bs Cs)
| nil,nil,nil => False
| _,_,_ => True (* bad lists just make this meaningless *)
end.
Fixpoint list3 {D B C} (Ds : list D) (Bs : list B) (Cs : list C) : Prop :=
match Ds,Bs,Cs with
d'::Ds,b'::Bs,c'::Cs => (list3 Ds Bs Cs)
| _,_,_ => True
end.
Functional Scheme in3_ind := Induction for list3 Sort Prop.
Theorem Forall3_forall : forall D B C (P : D -> B -> C -> Prop) (Ds : list D) (Bs : list B) (Cs : list C),
(Forall3 P Ds Bs Cs) <-> (length Ds = length Bs /\ length Bs = length Cs /\ forall d b c, In3 d b c Ds Bs Cs -> P d b c).
Proof.
intros; split.
intro H; induction H; repeat split.
intros d b c Hin; inversion Hin.
intuition.
destruct IHForall3 as [len0 [len1 IH]]; simpl; auto.
destruct IHForall3 as [len0 [len1 IH]]; simpl; auto.
intros d' b' c' Hin.
inversion Hin as [len0 [len1 [[dd [bb cc]]|Hrest]]].
subst; auto.
apply IHForall3; auto.
apply (@in3_ind _ _ _ (fun Ds Bs Cs prp => prp -> length Ds = length Bs /\ length Bs = length Cs /\ (forall d b c, In3 d b c Ds Bs Cs -> P d b c) -> Forall3 P Ds Bs Cs)); intros; try solve [auto |contradiction|intuition; simpl in *; discriminate].
subst; intuition; simpl in *;
cut (Bs0 = []); [|destruct Bs0; [auto|discriminate]];
intro;
cut (Cs0 = []); [|destruct Cs0; [auto|subst; simpl in *; discriminate]];
intros; subst; constructor.
subst.
destruct H1 as [? [? ?]].
simpl in *.
injects H2; injects H1.
remember H3 as IH; clear HeqIH.
specialize (H3 _x _x0 _x1 (conj H1 (conj H2 (or_introl (conj (eq_refl _x) (conj (eq_refl _x0) (eq_refl _x1))))))).
constructor; auto.
apply H; auto.
repeat split; auto.
revert Bs Cs.
induction Ds; simpl; [auto|];
induction Bs; simpl; [auto|];
induction Cs; simpl; [auto|];
apply IHDs.
Qed.
*)
Theorem triple_union_folded_property : forall B C D (Beq_dec : dec_type B) (Ceq_dec : dec_type C)
(f : D -> set A * set B * set C)
(PA : A -> Prop) (PB : B -> Prop) (PC : C -> Prop) s
(base : set A * set B * set C)
(fprop : forall d, set_In d s -> match (f d) with (As,Bs,Cs) => Forall PA As /\ Forall PB Bs /\ Forall PC Cs end),
match base with (As,Bs,Cs) => Forall PA As /\ Forall PB Bs /\ Forall PC Cs end ->
(match (triple_union_fold Aeq_dec Beq_dec Ceq_dec f s base) with
(As,Bs,Cs) => Forall PA As /\ Forall PB Bs /\ Forall PC Cs end).
intros ? ? ? ? ? ? ? ? ? s;
apply (@in_set_ind _ (fun s => forall (base : set A * set B * set C)
(fprop : forall d, set_In d s -> match (f d) with (As,Bs,Cs) => Forall PA As /\ Forall PB Bs /\ Forall PC Cs end),
match base with (As,Bs,Cs) => Forall PA As /\ Forall PB Bs /\ Forall PC Cs end ->
(match (triple_union_fold Aeq_dec Beq_dec Ceq_dec f s base) with
(As,Bs,Cs) => Forall PA As /\ Forall PB Bs /\ Forall PC Cs end))).
auto.
intros s' a IH base fprop allbase.
simpl; apply IH.
intros d Hin; apply fprop; right; auto.
destruct base as [[ds bs] cs].
case_eq (f a); intros [bs' cs'] ds' Heq.
repeat rewrite Forall_forall; repeat split; intros x Hin;
specialize (fprop a (or_introl (eq_refl _)));
rewrite Heq in fprop;
repeat rewrite Forall_forall in *;
apply set_union_elim in Hin; destruct Hin as [inbase|inf];
try solve [apply allbase; auto|apply fprop;auto].
Qed.
Theorem length_add : forall s a, ~ set_In a s -> length (set_add Aeq_dec a s) = S (length s).
Proof.
induction s as [|a s IH]; intros a' H;
[|simpl;
destruct (Aeq_dec a' a);
[subst; elimtype False; apply H; left
|simpl; f_equal; apply IH; intro bad; apply H; right]]; auto.
Qed.
End Facts. |
# Simple Linear Regression
# Importing the dataset
dataset = read.csv('Salary_Data.csv')
# install.packages('caTools')
# install.packages('ggplot2')
library(caTools)
library(ggplot2)
set.seed(123)
# Splitting the dataset into training set and test set
split = sample.split(dataset$Salary, SplitRatio = 2/3)
training_set = subset(dataset, split == TRUE)
test_set = subset(dataset, split == FALSE)
# Fitting Simple Linear Regression to the Training set
regressor = lm(formula = Salary ~ YearsExperience,
data = training_set)
# Predicting the Test results
y_pred = predict(regressor, newdata = test_set)
# Visualising the Training set results
ggplot() +
geom_point(aes(x = training_set$YearsExperience, y = training_set$Salary),
colour = 'red') +
geom_line(aes(x = training_set$YearsExperience, y = predict(regressor, newdata = training_set)),
colour = 'blue') +
ggtitle('Salary vs Experience (Training Set)') +
xlab('Years of Experience') +
ylab('Salary')
ggplot() +
geom_point(aes(x = test_set$YearsExperience, y = test_set$Salary),
colour = 'red') +
geom_line(aes(x = training_set$YearsExperience, y = predict(regressor, newdata = training_set)),
colour = 'blue') +
ggtitle('Salary vs Experience (Test Set)') +
xlab('Years of Experience') +
ylab('Salary') |
program topo_ports
use mod_za ! HYCOM array I/O interface
implicit none
c
integer nchar
parameter (nchar=120)
integer mp
parameter (mp=1999)
c
integer, allocatable :: ip(:,:),iu(:,:),iv(:,:)
real, allocatable :: dh(:,:)
c
real hmaxa,hmaxb,hmina,hminb
character preambl(5)*79,cline*80
c
integer i,j,isec,ifrst,ilast,l,npf,npi,npl
character*3 char3
c
logical lfatal,lfatalp,lprint,lprold,linput
integer nports,kdport(mp),
& ifport(mp),ilport(mp),jfport(mp),jlport(mp),lnport(mp)
c
character*13 fmt
data fmt / '(i4,1x,120i1)' /
c
c --- error check and printout the location of hycom ports on a topography
c
call xcspmd !input idm,jdm
allocate( ip(-1:idm+2,0:jdm+1) )
allocate( iu(-1:idm+2,0:jdm+1) )
allocate( iv(-1:idm+2,0:jdm+1) )
allocate( dh(idm,jdm) )
c
call zhopen(51, 'formatted', 'old', 0)
read (51,'(a79)') preambl
read (51,'(a)') cline
close(unit=51)
write(6,'(a/(a))') 'header:',
& preambl,cline(1:len_trim(cline))
write(6,*)
c
i = index(cline,'=')
read (cline(i+1:),*) hminb,hmaxb
c
call zaiost
call zaiopn('old', 51)
call zaiord(dh,ip,.false., hmina,hmaxa, 51)
call zaiocl(51)
c
if (abs(hmina-hminb).gt.abs(hminb)*1.e-4 .or.
& abs(hmaxa-hmaxb).gt.abs(hmaxb)*1.e-4 ) then
write(6,'(/ a / a,1p3e14.6 / a,1p3e14.6 /)')
& 'error - .a and .b topography files not consistent:',
& '.a,.b min = ',hmina,hminb,hmina-hminb,
& '.a,.b max = ',hmaxa,hmaxb,hmaxa-hmaxb
call zhflsh(6)
stop
endif
c
c --- land/sea masks.
c
do j= 1,jdm
do i=1,idm
if (dh(i,j).lt.2.0**99) then
ip(i,j) = 1
else
ip(i,j) = 0
endif
enddo
enddo
do j= 0,jdm+1,jdm+1
do i=1,idm
ip(i,j) = 0
iu(i,j) = 0
iv(i,j) = 0
enddo
enddo
do j= 1,jdm
ip( -1,j) = ip(idm-1,j)
ip( 0,j) = ip(idm, j)
ip(idm+1,j) = ip( 1,j)
ip(idm+2,j) = ip( 2,j)
enddo
c
do j= 1,jdm
do i=1,idm
if (ip(i-1,j).gt.0.and.ip(i,j).gt.0) then
iu(i,j)=1
else
iu(i,j)=0
endif
if (ip(i,j-1).gt.0.and.ip(i,j).gt.0) then
iv(i,j)=1
else
iv(i,j)=0
endif
enddo
enddo
do j= 1,jdm
iu( -1,j) = iu(idm-1,j)
iu( 0,j) = iu(idm, j)
iu(idm+1,j) = iu( 1,j)
iu(idm+2,j) = iu( 2,j)
iv( -1,j) = iv(idm-1,j)
iv( 0,j) = iv(idm, j)
iv(idm+1,j) = iv( 1,j)
iv(idm+2,j) = iv( 2,j)
enddo
c
c --- ports.
c
open(unit=99,file='ports.input')
c
c --- 'nports' = number of boundary port sections.
call blkini_test(nports,'nports',linput)
if (.not.linput) then
c --- skipped sports
call blkini(nports,'nports')
endif
write(6,*)
if (nports.lt.0 .or. nports.gt.mp) then
write(6,*)
write(6,*) 'error in topo_ports - illegal nports value'
write(6,*)
stop '(topo_ports)'
endif
c
c --- read in the ports one at a time
c
do l= 1,nports
c
c --- port location is w.r.t. u (EW) or v (NS) grid
c --- and identifies the sea at the port
c --- the minimum index is 0
c
c --- 'kdport' = port orientation (1=N, 2=S, 3=E, 4=W)
c --- 'ifport' = first i-index
c --- 'ilport' = last i-index (=ifport for N or S orientation)
c --- 'jfport' = first j-index
c --- 'jlport' = last j-index (=jfport for E or W orientation)
c --- 'lnport' = port length (calculated, not input)
call blkini(kdport(l),'kdport')
call blkini(ifport(l),'ifport')
call blkini(ilport(l),'ilport')
call blkini(jfport(l),'jfport')
call blkini(jlport(l),'jlport')
write(6,*)
c
lnport(l) = ilport(l)-ifport(l)+jlport(l)-jfport(l)+1
c
c --- sanity check.
c
if (kdport(l).gt.2) then
if (ifport(l).ne.ilport(l)) then
write(6,*)
write(6,*) 'error in topo_ports - port direction',
& ' and orientation are not consistent'
write(6,*)
stop '(topo_ports)'
endif
else
if (jfport(l).ne.jlport(l)) then
write(6,*)
write(6,*) 'error in topo_ports - port direction',
& ' and orientation are not consistent'
write(6,*)
stop '(topo_ports)'
endif
endif
if (ifport(l).gt.ilport(l) .or.
& jfport(l).gt.jlport(l) ) then
write(6,*)
write(6,*) 'error in topo_ports - port',
& ' location is not consistent'
write(6,*)
stop '(topo_ports)'
endif
enddo
c
close(unit=99)
c
c --- check ports against masks,
c --- mark the port locations on masks and print them out.
c
lfatal = .false.
do l= 1,nports
lfatalp = .false.
c
if (kdport(l).eq.4) then
c
c western port
c
i = ifport(l)
do j= jfport(l),jlport(l)
if (i.lt.1 .or. i.gt.idm .or. ! assume periodic
& j.lt.1 .or. j.gt.jdm ) then
lfatalp = .true.
elseif (iu(i,j).ne.0) then
lfatalp = .true.
iu(i,j) = 9 !indicate an error
else
iu(i,j) = -1
endif
if (iu(i+1,j).ne.1 .or.
& iu(i+2,j).ne.1 ) then
lfatalp = .true.
iu(i,j) = 7 !indicate an error
endif
enddo
c
elseif (kdport(l).eq.3) then
c
c eastern port
c
i = ifport(l)
do j= jfport(l),jlport(l)
if (i.lt.1 .or. i.gt.idm .or.
& j.lt.1 .or. j.gt.jdm ) then
lfatalp = .true.
elseif (iu(i,j).ne.0) then
lfatalp = .true.
iu(i,j) = 9 !indicate an error
else
iu(i,j) = -1
endif
if (iu(i-1,j).ne.1 .or.
& iu(i-2,j).ne.1 ) then
lfatalp = .true.
iu(i,j) = 7 !indicate an error
endif
enddo
c
elseif (kdport(l).eq.1) then
c
c northern port
c
j = jfport(l)
do i= ifport(l),ilport(l)
if (i.lt.1 .or. i.gt.idm .or.
& j.lt.3 .or. j.gt.jdm ) then
lfatalp = .true.
elseif (iv(i,j).ne.0) then
lfatalp = .true.
iv(i,j) = 9 !indicate an error
else
iv(i,j) = -1
endif
if (iv(i,j-1).ne.1 .or.
& iv(i,j-2).ne.1 ) then
lfatalp = .true.
iv(i,j) = 7 !indicate an error
endif
enddo
c
elseif (kdport(l).eq.2) then
c
c southern port
c
j = jfport(l)
do i= ifport(l),ilport(l)
if (i.lt.1 .or. i.gt.idm .or.
& j.lt.1 .or. j.gt.jdm-2 ) then
lfatalp = .true.
elseif (iv(i,j).ne.0) then
lfatalp = .true.
iv(i,j) = 9 !indicate an error
else
iv(i,j) = -1
endif
if (iv(i,j+1).ne.1 .or.
& iv(i,j+2).ne.1 ) then
lfatalp = .true.
iv(i,j) = 7 !indicate an error
endif
enddo
c
endif
c
if (lfatalp) then
write(6,*)
write(6,*) 'error in topo_ports - port ',l,' mislocated'
write(6,*)
endif
lfatal = lfatal .or. lfatalp
enddo !l=1,nports
c
c --- write out -iu- and -iv- arrays,
c --- data are written in strips nchar points wide
c
isec=(idm-1)/nchar
do ifrst=0,nchar*isec,nchar
ilast=min(idm,ifrst+nchar)
write (char3,'(i3)') ilast-ifrst
fmt(8:10)=char3
write (6,'(a,i5,a,i5)')
& 'iu array, cols',ifrst+1,' --',ilast
lprint = .true.
do j= jdm,1,-1
lprold = lprint
if (j.eq.jdm .or. j.eq.1) then
lprint = .true.
else
lprint = maxval(iu( ifrst+1:ilast,
& max(j-2,1):min(j+2,jdm))).gt.1
& .or.
& minval(iu( ifrst+1:ilast,
& max(j-2,1):min(j+2,jdm))).lt.0
endif
if (lprint) then
if (.not.lprold) then
write(6,'(5x,120a1)') ('=',i=ifrst+1,ilast)
endif
write (6,fmt) j,(iu(i,j),i=ifrst+1,ilast)
endif
enddo !j
enddo
write (6,*)
c
isec=(idm-1)/nchar
do ifrst=0,nchar*isec,nchar
ilast=min(idm,ifrst+nchar)
write (char3,'(i3)') ilast-ifrst
fmt(8:10)=char3
write (6,'(a,i5,a,i5)')
& 'iv array, cols',ifrst+1,' --',ilast
lprint = .true.
do j= jdm,1,-1
lprold = lprint
if (j.eq.jdm .or. j.eq.1) then
lprint = .true.
else
lprint = maxval(iv( ifrst+1:ilast,
& max(j-2,1):min(j+2,jdm))).gt.1
& .or.
& minval(iv( ifrst+1:ilast,
& max(j-2,1):min(j+2,jdm))).lt.0
endif
if (lprint) then
if (.not.lprold) then
write(6,'(5x,120a1)') ('=',i=ifrst+1,ilast)
endif
write (6,fmt) j,(iv(i,j),i=ifrst+1,ilast)
endif
enddo !j
enddo
write (6,*)
c
if (lfatal) then
write(6,*)
write(6,*) 'error in topo_ports - bad port(s)'
write(6,*)
stop '(topo_ports)'
endif
end
subroutine blkini(ivar,cvar)
implicit none
c
integer ivar
character*6 cvar
c
c read in one integer value from stdin
c
character*6 cvarin
c
read(99,*) ivar,cvarin
write(6,6000) cvarin,ivar
c
if (cvar.ne.cvarin) then
write(6,*)
write(6,*) 'error in blkini - input ',cvarin,
+ ' but should be ',cvar
write(6,*)
stop
endif
return
6000 format('blkini: ',a6,' =',i6)
end
subroutine blkini_test(ivar,cvar,linput)
implicit none
c
integer ivar
character*6 cvar
logical linput
c
c read in one integer value from stdin
c linput is .true. on return if the read is successful
c linput is .false. on return if the read is not successful
c
character*6 cvarin
c
read(99,*) ivar,cvarin
linput = cvar.eq.cvarin
if (linput) then
write(6,6000) cvarin,ivar
endif
return
6000 format('blkini: ',a6,' =',i6)
end
|
State Before: C : Type u₁
inst✝ : Category C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
J J₂ : GrothendieckTopology C
x : FamilyOfElements P (generate R).arrows
t : FamilyOfElements.Compatible x
⊢ FamilyOfElements.sieveExtend (FamilyOfElements.restrict (_ : R ≤ (generate R).arrows) x) = x State After: C : Type u₁
inst✝ : Category C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
J J₂ : GrothendieckTopology C
x : FamilyOfElements P (generate R).arrows
t : FamilyOfElements.SieveCompatible x
⊢ FamilyOfElements.sieveExtend (FamilyOfElements.restrict (_ : R ≤ (generate R).arrows) x) = x Tactic: rw [compatible_iff_sieveCompatible] at t State Before: C : Type u₁
inst✝ : Category C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
J J₂ : GrothendieckTopology C
x : FamilyOfElements P (generate R).arrows
t : FamilyOfElements.SieveCompatible x
⊢ FamilyOfElements.sieveExtend (FamilyOfElements.restrict (_ : R ≤ (generate R).arrows) x) = x State After: case h.h.h
C : Type u₁
inst✝ : Category C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
J J₂ : GrothendieckTopology C
x : FamilyOfElements P (generate R).arrows
t : FamilyOfElements.SieveCompatible x
x✝¹ : C
x✝ : x✝¹ ⟶ X
h : (generate R).arrows x✝
⊢ FamilyOfElements.sieveExtend (FamilyOfElements.restrict (_ : R ≤ (generate R).arrows) x) x✝ h = x x✝ h Tactic: funext _ _ h State Before: case h.h.h
C : Type u₁
inst✝ : Category C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
J J₂ : GrothendieckTopology C
x : FamilyOfElements P (generate R).arrows
t : FamilyOfElements.SieveCompatible x
x✝¹ : C
x✝ : x✝¹ ⟶ X
h : (generate R).arrows x✝
⊢ FamilyOfElements.sieveExtend (FamilyOfElements.restrict (_ : R ≤ (generate R).arrows) x) x✝ h = x x✝ h State After: case h.h.h
C : Type u₁
inst✝ : Category C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
J J₂ : GrothendieckTopology C
x : FamilyOfElements P (generate R).arrows
t : FamilyOfElements.SieveCompatible x
x✝¹ : C
x✝ : x✝¹ ⟶ X
h : (generate R).arrows x✝
⊢ x
(Exists.choose (_ : ∃ h_1 g, R g ∧ h_1 ≫ g = x✝) ≫
Exists.choose (_ : ∃ g, R g ∧ Exists.choose (_ : ∃ h_1 g, R g ∧ h_1 ≫ g = x✝) ≫ g = x✝))
(_ :
(generate R).arrows
(Exists.choose (_ : ∃ h_1 g, R g ∧ h_1 ≫ g = x✝) ≫
Exists.choose (_ : ∃ g, R g ∧ Exists.choose (_ : ∃ h_1 g, R g ∧ h_1 ≫ g = x✝) ≫ g = x✝))) =
x x✝ h Tactic: apply (t _ _ _).symm.trans State Before: case h.h.h
C : Type u₁
inst✝ : Category C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
J J₂ : GrothendieckTopology C
x : FamilyOfElements P (generate R).arrows
t : FamilyOfElements.SieveCompatible x
x✝¹ : C
x✝ : x✝¹ ⟶ X
h : (generate R).arrows x✝
⊢ x
(Exists.choose (_ : ∃ h_1 g, R g ∧ h_1 ≫ g = x✝) ≫
Exists.choose (_ : ∃ g, R g ∧ Exists.choose (_ : ∃ h_1 g, R g ∧ h_1 ≫ g = x✝) ≫ g = x✝))
(_ :
(generate R).arrows
(Exists.choose (_ : ∃ h_1 g, R g ∧ h_1 ≫ g = x✝) ≫
Exists.choose (_ : ∃ g, R g ∧ Exists.choose (_ : ∃ h_1 g, R g ∧ h_1 ≫ g = x✝) ≫ g = x✝))) =
x x✝ h State After: case h.h.h.e_f
C : Type u₁
inst✝ : Category C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
J J₂ : GrothendieckTopology C
x : FamilyOfElements P (generate R).arrows
t : FamilyOfElements.SieveCompatible x
x✝¹ : C
x✝ : x✝¹ ⟶ X
h : (generate R).arrows x✝
⊢ Exists.choose (_ : ∃ h_1 g, R g ∧ h_1 ≫ g = x✝) ≫
Exists.choose (_ : ∃ g, R g ∧ Exists.choose (_ : ∃ h_1 g, R g ∧ h_1 ≫ g = x✝) ≫ g = x✝) =
x✝ Tactic: congr State Before: case h.h.h.e_f
C : Type u₁
inst✝ : Category C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
J J₂ : GrothendieckTopology C
x : FamilyOfElements P (generate R).arrows
t : FamilyOfElements.SieveCompatible x
x✝¹ : C
x✝ : x✝¹ ⟶ X
h : (generate R).arrows x✝
⊢ Exists.choose (_ : ∃ h_1 g, R g ∧ h_1 ≫ g = x✝) ≫
Exists.choose (_ : ∃ g, R g ∧ Exists.choose (_ : ∃ h_1 g, R g ∧ h_1 ≫ g = x✝) ≫ g = x✝) =
x✝ State After: no goals Tactic: exact h.choose_spec.choose_spec.choose_spec.2 |
The fundamental purpose of matter management is to manage costs and risk, and ensure performance and compliance. But it can be so much more. At Mosaic Consulting, we aim to help you unleash the capabilities of whatever matter management systems you use.
Our goal is to understand every aspect of your legal operations workflow and utilize our deep knowledge and experience to evaluate your processes and technology across the entire matter management lifecycle. Our consultants develop your customized program, leveraging technology and designing effective processes to drive efficiency in your legal matter management activities.
Using a matter management system inherently increases efficiency and saves you money. But how you use your matter management system can increase efficiency and save money as well. A system without well designed, thought out, integrated processes can deliver baseline improvements. We can help you go above and beyond the baseline.
There are many matter management systems available. Mosaic helps you weed through the possibilities and choose the system that fits your team’s needs by assessing your requirements and making recommendations that fit your operations. We quickly cut through the myriad of applications and solutions available to find the system that best meets all the requirements your team demands.
The success of an implementation can depend upon who is managing it. Our consultants have over 75 years of combined experience, having completed dozens of successful implementations. We know what it takes to perform a seamless implementation as well as how to avoid the pitfalls. You are in good hands with Mosaic managing your project.
No company wants to become bound to a consulting firm for an indefinite period of time in order to continue benefiting from a new system. The key to achieving reasonable self-sufficiency is documentation.
Standard end-user reference manuals provided by software vendors are rarely adequate to meet this objective. This is because the documentation does not address the client’s specific configuration, processes and use of the application.
Mosaic Consulting addresses this need by designing materials that speak to the specific workflows and procedures addressed in the development phase of your project.
The result is documentation that you can use to train new staff and that will serve as a reference to answer specific questions existing users might have as they continue enhancing their knowledge of your matter management program, workflows and technology.
Mosaic's IT team is all you will need to seamlessly integrate your matter management system with other legal and non-legal applications. Mosaic will identify the information your other applications need to receive; map the data; design and program the interface; and work with the required vendor to test and implement the new interface.
Mosaic has the skills and depth of knowledge to make your matter management initiatives exceed expectations.
The professionals at Mosaic are experts in matter management. And we provide a full suite of enterprise legal management services that will complement your matter management initiatives and round-out your legal operations program.
Mosaic's expertise in designing and delivering training will help your team maximize the benefits of the systems and processes you put in place. We will not only provide the technical training. Our training will cover your workflows and processes around the technology. |
/-
Copyright (c) 2021 Andrew Yang. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Andrew Yang
! This file was ported from Lean 3 source module algebraic_geometry.properties
! leanprover-community/mathlib commit d39590fc8728fbf6743249802486f8c91ffe07bc
! Please do not edit these lines, except to modify the commit id
! if you have ported upstream changes.
-/
import Mathbin.AlgebraicGeometry.AffineScheme
import Mathbin.RingTheory.Nilpotent
import Mathbin.Topology.Sheaves.SheafCondition.Sites
import Mathbin.Algebra.Category.Ring.Constructions
import Mathbin.RingTheory.LocalProperties
/-!
# Basic properties of schemes
We provide some basic properties of schemes
## Main definition
* `algebraic_geometry.is_integral`: A scheme is integral if it is nontrivial and all nontrivial
components of the structure sheaf are integral domains.
* `algebraic_geometry.is_reduced`: A scheme is reduced if all the components of the structure sheaf
is reduced.
-/
open TopologicalSpace Opposite CategoryTheory CategoryTheory.Limits TopCat
namespace AlgebraicGeometry
variable (X : Scheme)
instance : T0Space X.carrier :=
by
refine' T0Space.of_open_cover fun x => _
obtain ⟨U, R, ⟨e⟩⟩ := X.local_affine x
let e' : U.1 ≃ₜ PrimeSpectrum R :=
homeo_of_iso ((LocallyRingedSpace.forget_to_SheafedSpace ⋙ SheafedSpace.forget _).mapIso e)
exact ⟨U.1.1, U.2, U.1.2, e'.embedding.t0_space⟩
instance : QuasiSober X.carrier :=
by
apply (config := { instances := false })
quasiSober_of_open_cover (Set.range fun x => Set.range <| (X.affine_cover.map x).1.base)
· rintro ⟨_, i, rfl⟩
exact (X.affine_cover.is_open i).base_open.open_range
· rintro ⟨_, i, rfl⟩
exact
@OpenEmbedding.quasiSober _ _ _
(Homeomorph.ofEmbedding _
(X.affine_cover.is_open i).base_open.toEmbedding).symm.OpenEmbedding
PrimeSpectrum.quasiSober
· rw [Set.top_eq_univ, Set.unionₛ_range, Set.eq_univ_iff_forall]
intro x
exact ⟨_, ⟨_, rfl⟩, X.affine_cover.covers x⟩
/-- A scheme `X` is reduced if all `𝒪ₓ(U)` are reduced. -/
class IsReduced : Prop where
component_reduced : ∀ U, IsReduced (X.Presheaf.obj (op U)) := by infer_instance
#align algebraic_geometry.is_reduced AlgebraicGeometry.IsReduced
attribute [instance] is_reduced.component_reduced
theorem isReduced_of_stalk_isReduced [∀ x : X.carrier, IsReduced (X.Presheaf.stalk x)] :
IsReduced X := by
refine' ⟨fun U => ⟨fun s hs => _⟩⟩
apply presheaf.section_ext X.sheaf U s 0
intro x
rw [RingHom.map_zero]
change X.presheaf.germ x s = 0
exact (hs.map _).eq_zero
#align algebraic_geometry.is_reduced_of_stalk_is_reduced AlgebraicGeometry.isReduced_of_stalk_isReduced
instance stalk_isReduced_of_reduced [IsReduced X] (x : X.carrier) :
IsReduced (X.Presheaf.stalk x) := by
constructor
rintro g ⟨n, e⟩
obtain ⟨U, hxU, s, rfl⟩ := X.presheaf.germ_exist x g
rw [← map_pow, ← map_zero (X.presheaf.germ ⟨x, hxU⟩)] at e
obtain ⟨V, hxV, iU, iV, e'⟩ := X.presheaf.germ_eq x hxU hxU _ 0 e
rw [map_pow, map_zero] at e'
replace e' := (IsNilpotent.mk _ _ e').eq_zero
erw [← concrete_category.congr_hom (X.presheaf.germ_res iU ⟨x, hxV⟩) s]
rw [comp_apply, e', map_zero]
#align algebraic_geometry.stalk_is_reduced_of_reduced AlgebraicGeometry.stalk_isReduced_of_reduced
theorem isReduced_of_open_immersion {X Y : Scheme} (f : X ⟶ Y) [H : IsOpenImmersion f]
[IsReduced Y] : IsReduced X := by
constructor
intro U
have : U = (opens.map f.1.base).obj (H.base_open.is_open_map.functor.obj U) :=
by
ext1
exact (Set.preimage_image_eq _ H.base_open.inj).symm
rw [this]
exact
isReduced_of_injective (inv <| f.1.c.app (op <| H.base_open.is_open_map.functor.obj U))
(as_iso <| f.1.c.app (op <| H.base_open.is_open_map.functor.obj U) :
Y.presheaf.obj _ ≅ _).symm.commRingIsoToRingEquiv.Injective
#align algebraic_geometry.is_reduced_of_open_immersion AlgebraicGeometry.isReduced_of_open_immersion
instance {R : CommRingCat} [H : IsReduced R] : IsReduced (Scheme.spec.obj <| op R) :=
by
apply (config := { instances := false }) is_reduced_of_stalk_is_reduced
intro x
dsimp
have : _root_.is_reduced (CommRingCat.of <| Localization.AtPrime (PrimeSpectrum.asIdeal x)) :=
by
dsimp
infer_instance
exact
isReduced_of_injective (structure_sheaf.stalk_iso R x).Hom
(structure_sheaf.stalk_iso R x).commRingIsoToRingEquiv.Injective
theorem affine_isReduced_iff (R : CommRingCat) :
IsReduced (Scheme.spec.obj <| op R) ↔ IsReduced R :=
by
refine' ⟨_, fun h => inferInstance⟩
intro h
skip
have :
_root_.is_reduced (LocallyRingedSpace.Γ.obj (op <| Spec.to_LocallyRingedSpace.obj <| op R)) :=
by
change _root_.is_reduced ((Scheme.Spec.obj <| op R).Presheaf.obj <| op ⊤)
infer_instance
exact
isReduced_of_injective (to_Spec_Γ R) (as_iso <| to_Spec_Γ R).commRingIsoToRingEquiv.Injective
#align algebraic_geometry.affine_is_reduced_iff AlgebraicGeometry.affine_isReduced_iff
theorem isReduced_of_isAffine_isReduced [IsAffine X] [h : IsReduced (X.Presheaf.obj (op ⊤))] :
IsReduced X :=
haveI : IsReduced (Scheme.Spec.obj (op (Scheme.Γ.obj (op X)))) :=
by
rw [affine_is_reduced_iff]
exact h
is_reduced_of_open_immersion X.iso_Spec.hom
#align algebraic_geometry.is_reduced_of_is_affine_is_reduced AlgebraicGeometry.isReduced_of_isAffine_isReduced
/-- To show that a statement `P` holds for all open subsets of all schemes, it suffices to show that
1. In any scheme `X`, if `P` holds for an open cover of `U`, then `P` holds for `U`.
2. For an open immerison `f : X ⟶ Y`, if `P` holds for the entire space of `X`, then `P` holds for
the image of `f`.
3. `P` holds for the entire space of an affine scheme.
-/
theorem reduce_to_affine_global (P : ∀ (X : Scheme) (U : Opens X.carrier), Prop)
(h₁ :
∀ (X : Scheme) (U : Opens X.carrier),
(∀ x : U, ∃ (V : _)(h : x.1 ∈ V)(i : V ⟶ U), P X V) → P X U)
(h₂ :
∀ {X Y} (f : X ⟶ Y) [hf : IsOpenImmersion f],
∃ (U : Set X.carrier)(V : Set Y.carrier)(hU : U = ⊤)(hV : V = Set.range f.1.base),
P X ⟨U, hU.symm ▸ isOpen_univ⟩ → P Y ⟨V, hV.symm ▸ hf.base_open.open_range⟩)
(h₃ : ∀ R : CommRingCat, P (Scheme.spec.obj <| op R) ⊤) :
∀ (X : Scheme) (U : Opens X.carrier), P X U :=
by
intro X U
apply h₁
intro x
obtain ⟨_, ⟨j, rfl⟩, hx, i⟩ :=
X.affine_basis_cover_is_basis.exists_subset_of_mem_open (SetLike.mem_coe.2 x.prop) U.is_open
let U' : opens _ := ⟨_, (X.affine_basis_cover.is_open j).base_open.open_range⟩
let i' : U' ⟶ U := hom_of_le i
refine' ⟨U', hx, i', _⟩
obtain ⟨_, _, rfl, rfl, h₂'⟩ := h₂ (X.affine_basis_cover.map j)
apply h₂'
apply h₃
#align algebraic_geometry.reduce_to_affine_global AlgebraicGeometry.reduce_to_affine_global
theorem reduce_to_affine_nbhd (P : ∀ (X : Scheme) (x : X.carrier), Prop)
(h₁ : ∀ (R : CommRingCat) (x : PrimeSpectrum R), P (Scheme.spec.obj <| op R) x)
(h₂ : ∀ {X Y} (f : X ⟶ Y) [IsOpenImmersion f] (x : X.carrier), P X x → P Y (f.1.base x)) :
∀ (X : Scheme) (x : X.carrier), P X x := by
intro X x
obtain ⟨y, e⟩ := X.affine_cover.covers x
convert h₂ (X.affine_cover.map (X.affine_cover.f x)) y _
· rw [e]
apply h₁
#align algebraic_geometry.reduce_to_affine_nbhd AlgebraicGeometry.reduce_to_affine_nbhd
theorem eq_zero_of_basicOpen_eq_bot {X : Scheme} [hX : IsReduced X] {U : Opens X.carrier}
(s : X.Presheaf.obj (op U)) (hs : X.basicOpen s = ⊥) : s = 0 :=
by
apply TopCat.Presheaf.section_ext X.sheaf U
simp_rw [RingHom.map_zero]
revert X U hX s
refine' reduce_to_affine_global _ _ _ _
· intro X U hx hX s hs x
obtain ⟨V, hx, i, H⟩ := hx x
specialize H (X.presheaf.map i.op s)
erw [Scheme.basic_open_res] at H
rw [hs] at H
specialize H inf_bot_eq ⟨x, hx⟩
erw [TopCat.Presheaf.germ_res_apply] at H
exact H
· rintro X Y f hf
have e : f.val.base ⁻¹' Set.range ⇑f.val.base = Set.univ := by
rw [← Set.image_univ, Set.preimage_image_eq _ hf.base_open.inj]
refine' ⟨_, _, e, rfl, _⟩
rintro H hX s hs ⟨_, x, rfl⟩
haveI := is_reduced_of_open_immersion f
specialize
H (f.1.c.app _ s) _
⟨x, by
rw [opens.mem_mk, e]
trivial⟩
· rw [← Scheme.preimage_basic_open, hs]
ext1
simp [opens.map]
· erw [← PresheafedSpace.stalk_map_germ_apply f.1 ⟨_, _⟩ ⟨x, _⟩] at H
apply_fun inv <| PresheafedSpace.stalk_map f.val x at H
erw [CategoryTheory.IsIso.hom_inv_id_apply, map_zero] at H
exact H
· intro R hX s hs x
erw [basic_open_eq_of_affine', PrimeSpectrum.basicOpen_eq_bot_iff] at hs
replace hs := hs.map (Spec_Γ_identity.app R).inv
-- what the hell?!
replace hs := @IsNilpotent.eq_zero _ _ _ _ (show _ from _) hs
rw [iso.hom_inv_id_apply] at hs
rw [hs, map_zero]
exact @is_reduced.component_reduced hX ⊤
#align algebraic_geometry.eq_zero_of_basic_open_eq_bot AlgebraicGeometry.eq_zero_of_basicOpen_eq_bot
@[simp]
theorem basicOpen_eq_bot_iff {X : Scheme} [IsReduced X] {U : Opens X.carrier}
(s : X.Presheaf.obj <| op U) : X.basicOpen s = ⊥ ↔ s = 0 :=
by
refine' ⟨eq_zero_of_basic_open_eq_bot s, _⟩
rintro rfl
simp
#align algebraic_geometry.basic_open_eq_bot_iff AlgebraicGeometry.basicOpen_eq_bot_iff
/-- A scheme `X` is integral if its carrier is nonempty,
and `𝒪ₓ(U)` is an integral domain for each `U ≠ ∅`. -/
class IsIntegral : Prop where
Nonempty : Nonempty X.carrier := by infer_instance
component_integral : ∀ (U : Opens X.carrier) [Nonempty U], IsDomain (X.Presheaf.obj (op U)) := by
infer_instance
#align algebraic_geometry.is_integral AlgebraicGeometry.IsIntegral
attribute [instance] is_integral.component_integral is_integral.nonempty
instance [h : IsIntegral X] : IsDomain (X.Presheaf.obj (op ⊤)) :=
@IsIntegral.component_integral _ _ (by simp)
instance (priority := 900) isReduced_of_isIntegral [IsIntegral X] : IsReduced X :=
by
constructor
intro U
cases' U.1.eq_empty_or_nonempty with h h
· have : U = ⊥ := SetLike.ext' h
haveI := CommRingCat.subsingleton_of_isTerminal (X.sheaf.is_terminal_of_eq_empty this)
change _root_.is_reduced (X.sheaf.val.obj (op U))
infer_instance
· haveI : Nonempty U := by simpa
infer_instance
#align algebraic_geometry.is_reduced_of_is_integral AlgebraicGeometry.isReduced_of_isIntegral
instance is_irreducible_of_isIntegral [IsIntegral X] : IrreducibleSpace X.carrier :=
by
by_contra H
replace H : ¬IsPreirreducible (⊤ : Set X.carrier) := fun h =>
H { to_preirreducibleSpace := ⟨h⟩
to_nonempty := inferInstance }
simp_rw [isPreirreducible_iff_closed_union_closed, not_forall, not_or] at H
rcases H with ⟨S, T, hS, hT, h₁, h₂, h₃⟩
erw [not_forall] at h₂ h₃
simp_rw [not_forall] at h₂ h₃
haveI : Nonempty (⟨Sᶜ, hS.1⟩ : opens X.carrier) := ⟨⟨_, h₂.some_spec.some_spec⟩⟩
haveI : Nonempty (⟨Tᶜ, hT.1⟩ : opens X.carrier) := ⟨⟨_, h₃.some_spec.some_spec⟩⟩
haveI : Nonempty (⟨Sᶜ, hS.1⟩ ⊔ ⟨Tᶜ, hT.1⟩ : opens X.carrier) :=
⟨⟨_, Or.inl h₂.some_spec.some_spec⟩⟩
let e : X.presheaf.obj _ ≅ CommRingCat.of _ :=
(X.sheaf.is_product_of_disjoint ⟨_, hS.1⟩ ⟨_, hT.1⟩ _).conePointUniqueUpToIso
(CommRingCat.prodFanIsLimit _ _)
apply (config := { instances := false }) false_of_nontrivial_of_product_domain
· exact e.symm.CommRing_iso_to_ring_equiv.is_domain _
· apply X.to_LocallyRingedSpace.component_nontrivial
· apply X.to_LocallyRingedSpace.component_nontrivial
· ext x
constructor
· rintro ⟨hS, hT⟩
cases h₁ (show x ∈ ⊤ by trivial)
exacts[hS h, hT h]
· intro x
exact x.rec _
#align algebraic_geometry.is_irreducible_of_is_integral AlgebraicGeometry.is_irreducible_of_isIntegral
theorem isIntegral_of_is_irreducible_isReduced [IsReduced X] [H : IrreducibleSpace X.carrier] :
IsIntegral X := by
constructor
intro U hU
haveI := (@LocallyRingedSpace.component_nontrivial X.to_LocallyRingedSpace U hU).1
have :
NoZeroDivisors
(X.to_LocallyRingedSpace.to_SheafedSpace.to_PresheafedSpace.presheaf.obj (op U)) :=
by
refine' ⟨fun a b e => _⟩
simp_rw [← basic_open_eq_bot_iff, ← opens.not_nonempty_iff_eq_bot]
by_contra' h
obtain ⟨_, ⟨x, hx₁, rfl⟩, ⟨x, hx₂, e'⟩⟩ :=
@nonempty_preirreducible_inter _ H.1 (X.basic_open a).2 (X.basic_open b).2 h.1 h.2
replace e' := Subtype.eq e'
subst e'
replace e := congr_arg (X.presheaf.germ x) e
rw [RingHom.map_mul, RingHom.map_zero] at e
refine' zero_ne_one' (X.presheaf.stalk x.1) (isUnit_zero_iff.1 _)
convert hx₁.mul hx₂
exact e.symm
exact NoZeroDivisors.to_isDomain _
#align algebraic_geometry.is_integral_of_is_irreducible_is_reduced AlgebraicGeometry.isIntegral_of_is_irreducible_isReduced
theorem isIntegral_iff_is_irreducible_and_isReduced :
IsIntegral X ↔ IrreducibleSpace X.carrier ∧ IsReduced X :=
⟨fun _ => ⟨inferInstance, inferInstance⟩, fun ⟨_, _⟩ =>
is_integral_of_is_irreducible_is_reduced X⟩
#align algebraic_geometry.is_integral_iff_is_irreducible_and_is_reduced AlgebraicGeometry.isIntegral_iff_is_irreducible_and_isReduced
theorem isIntegral_of_open_immersion {X Y : Scheme} (f : X ⟶ Y) [H : IsOpenImmersion f]
[IsIntegral Y] [Nonempty X.carrier] : IsIntegral X :=
by
constructor
intro U hU
have : U = (opens.map f.1.base).obj (H.base_open.is_open_map.functor.obj U) :=
by
ext1
exact (Set.preimage_image_eq _ H.base_open.inj).symm
rw [this]
have : IsDomain (Y.presheaf.obj (op (H.base_open.is_open_map.functor.obj U))) :=
by
apply (config := { instances := false }) is_integral.component_integral
infer_instance
refine' ⟨⟨_, _, hU.some.prop, rfl⟩⟩
exact
(as_iso <| f.1.c.app (op <| H.base_open.is_open_map.functor.obj U) :
Y.presheaf.obj _ ≅ _).symm.commRingIsoToRingEquiv.IsDomain
_
#align algebraic_geometry.is_integral_of_open_immersion AlgebraicGeometry.isIntegral_of_open_immersion
instance {R : CommRingCat} [H : IsDomain R] : IsIntegral (Scheme.spec.obj <| op R) :=
by
apply (config := { instances := false }) is_integral_of_is_irreducible_is_reduced
· infer_instance
· dsimp [Spec.Top_obj]
infer_instance
theorem affine_isIntegral_iff (R : CommRingCat) :
IsIntegral (Scheme.spec.obj <| op R) ↔ IsDomain R :=
⟨fun h =>
RingEquiv.isDomain ((Scheme.Spec.obj <| op R).Presheaf.obj _)
(as_iso <| to_Spec_Γ R).commRingIsoToRingEquiv,
fun h => inferInstance⟩
#align algebraic_geometry.affine_is_integral_iff AlgebraicGeometry.affine_isIntegral_iff
theorem isIntegral_of_isAffine_isDomain [IsAffine X] [Nonempty X.carrier]
[h : IsDomain (X.Presheaf.obj (op ⊤))] : IsIntegral X :=
haveI : IsIntegral (Scheme.Spec.obj (op (Scheme.Γ.obj (op X)))) :=
by
rw [affine_is_integral_iff]
exact h
is_integral_of_open_immersion X.iso_Spec.hom
#align algebraic_geometry.is_integral_of_is_affine_is_domain AlgebraicGeometry.isIntegral_of_isAffine_isDomain
theorem map_injective_of_isIntegral [IsIntegral X] {U V : Opens X.carrier} (i : U ⟶ V)
[H : Nonempty U] : Function.Injective (X.Presheaf.map i.op) :=
by
rw [injective_iff_map_eq_zero]
intro x hx
rw [← basic_open_eq_bot_iff] at hx⊢
rw [Scheme.basic_open_res] at hx
revert hx
contrapose!
simp_rw [← opens.not_nonempty_iff_eq_bot, Classical.not_not]
apply nonempty_preirreducible_inter U.is_open (RingedSpace.basic_open _ _).IsOpen
simpa using H
#align algebraic_geometry.map_injective_of_is_integral AlgebraicGeometry.map_injective_of_isIntegral
end AlgebraicGeometry
|
<!-- dom:TITLE: Week 48: Support Vector Machines and Summary of course -->
# Week 48: Support Vector Machines and Summary of course
<!-- dom:AUTHOR: Morten Hjorth-Jensen at Department of Physics, University of Oslo & Department of Physics and Astronomy and National Superconducting Cyclotron Laboratory, Michigan State University -->
<!-- Author: -->
**Morten Hjorth-Jensen**, Department of Physics, University of Oslo and Department of Physics and Astronomy and National Superconducting Cyclotron Laboratory, Michigan State University
Date: **Nov 26, 2020**
Copyright 1999-2020, Morten Hjorth-Jensen. Released under CC Attribution-NonCommercial 4.0 license
## Overview of week 48
* **Thursday**: Support Vector Machines: Kernels, Classification and Regression
* **Friday**: Summary of course with perspectives for future studies
Geron's chapter 5. Chapter 12 (sections 12.1-12.3 are the most relevant ones) of Hastie et al contains also a good discussion.
## Thursday
We finalize our discussion on Support Vector Machines with an emphasis on kernel transformations and applications to regression. The following [video attempts at giving an overview on this part](https://www.youtube.com/watch?v=Toet3EiSFcM&ab_channel=StatQuestwithJoshStarmer). See also the [follow-up video](https://www.youtube.com/watch?v=Qc5IyLW_hns&ab_channel=StatQuestwithJoshStarmer).
## Friday
Friday's lecture is split in two parts. It starts with a summary of
what we have done this semester and continues with perspectives for future studies and
modern research projects in machine learning.
## Support Vector Machines, overarching aims
As discussed last week,
a Support Vector Machine (SVM) is a very powerful and versatile
Machine Learning method, capable of performing linear or nonlinear
classification, regression, and even outlier detection. It is one of
the most popular models in Machine Learning, and anyone interested in
Machine Learning should have it in their toolbox. SVMs are
particularly well suited for classification of complex but small-sized or
medium-sized datasets.
The case with two well-separated classes only can be understood in an
intuitive way in terms of lines in a two-dimensional space separating
the two classes.
The basic mathematics behind the SVM is however less familiar to most of us.
It relies on the definition of hyperplanes and the
definition of a **margin** which separates classes (in case of
classification problems) of variables. It is also used for regression
problems. I recommend you take a look at the lectures from last week on the binary classification problem.
## Kernels and non-linearity
The cases we studied last week were all characterized by two classes
with a close to linear separability. The classifiers we have described
so far find linear boundaries in our input feature space. It is
possible to make our procedure more flexible by exploring the feature
space using other basis expansions such as higher-order polynomials,
wavelets, splines etc.
If our feature space is not easy to separate, as shown in the figure
here generated by the code below (see also Figures 12.2 and 12.3 of [Hastie et al.](https://www.springer.com/gp/book/9780387848570)), we can achieve a better separation by introducing more complex
basis functions. The ideal would be (see Figures 12.2 and 12.3) to, via a specific transformation to
obtain a separation between the classes which is almost linear.
The change of basis, from $x\rightarrow z=\phi(x)$ leads to the same type of equations to be solved, except that
we need to introduce, for example, a polynomial transformation to a two-dimensional training set.
```python
%matplotlib inline
import numpy as np
import os
np.random.seed(42)
# To plot pretty figures
import matplotlib
import matplotlib.pyplot as plt
plt.rcParams['axes.labelsize'] = 14
plt.rcParams['xtick.labelsize'] = 12
plt.rcParams['ytick.labelsize'] = 12
from sklearn.svm import SVC
from sklearn import datasets
X1D = np.linspace(-4, 4, 9).reshape(-1, 1)
X2D = np.c_[X1D, X1D**2]
y = np.array([0, 0, 1, 1, 1, 1, 1, 0, 0])
plt.figure(figsize=(11, 4))
plt.subplot(121)
plt.grid(True, which='both')
plt.axhline(y=0, color='k')
plt.plot(X1D[:, 0][y==0], np.zeros(4), "bs")
plt.plot(X1D[:, 0][y==1], np.zeros(5), "g^")
plt.gca().get_yaxis().set_ticks([])
plt.xlabel(r"$x_1$", fontsize=20)
plt.axis([-4.5, 4.5, -0.2, 0.2])
plt.subplot(122)
plt.grid(True, which='both')
plt.axhline(y=0, color='k')
plt.axvline(x=0, color='k')
plt.plot(X2D[:, 0][y==0], X2D[:, 1][y==0], "bs")
plt.plot(X2D[:, 0][y==1], X2D[:, 1][y==1], "g^")
plt.xlabel(r"$x_1$", fontsize=20)
plt.ylabel(r"$x_2$", fontsize=20, rotation=0)
plt.gca().get_yaxis().set_ticks([0, 4, 8, 12, 16])
plt.plot([-4.5, 4.5], [6.5, 6.5], "r--", linewidth=3)
plt.axis([-4.5, 4.5, -1, 17])
plt.subplots_adjust(right=1)
plt.show()
```
## The equations
Suppose we define a polynomial transformation of degree two only. We define a vector $\boldsymbol{x}_i=[x_i,y_i]$ and have
$$
\boldsymbol{z}_i^T = \phi(\boldsymbol{x}_i)^T =\left[1, \sqrt{2}x_i, \sqrt{2}y_i, x_i^2, y_i^2, \sqrt{2}x_iy_i\right].
$$
With our new basis, the equations we solved earlier are basically the same, that is we have now (without the slack option for simplicity)
$$
{\cal L}=\sum_i\lambda_i-\frac{1}{2}\sum_{ij}^n\lambda_i\lambda_jy_iy_j\boldsymbol{z}_i^T\boldsymbol{z}_j,
$$
subject to the constraints $\lambda_i\geq 0$, $\sum_i\lambda_iy_i=0$, and for the support vectors
$$
y_i(\boldsymbol{z}_i^T\boldsymbol{w}+b)= 1 \hspace{0.1cm}\forall i,
$$
from which we also find $b$.
To compute $\boldsymbol{z}_i^T\boldsymbol{z}_j$ we define the kernel $K(\boldsymbol{x}_i,\boldsymbol{x}_j)$ as
$$
K(\boldsymbol{x}_i,\boldsymbol{x}_j)=\boldsymbol{z}_i^T\boldsymbol{z}_j= \phi(\boldsymbol{x}_i)^T\phi(\boldsymbol{x}_j).
$$
For the above example, the kernel reads
$$
K(\boldsymbol{x}_i,\boldsymbol{x}_j)=[1, \sqrt{2}x_i, \sqrt{2}y_i, x_i^2, y_i^2, \sqrt{2}x_iy_i]\begin{bmatrix} 1\\ \sqrt{2}x_j \\ \sqrt{2}y_j \\ x_j^2\\ y_i^2\\ \sqrt{2}x_jy_j \end{bmatrix}=1+2x_ix_j+2y_iy_j+(x_ix_j)^2+(y_iy_j)^2+2x_ix_jy_iy_j.
$$
We note that this dot product can be rewritten as
$$
K(\boldsymbol{x}_i,\boldsymbol{x}_j)=[1+\boldsymbol{x}_i^T\boldsymbol{x}_j]^d,
$$
where $d=2$ in our case and $\boldsymbol{x}_i=[x_i,y_i]$ and $\boldsymbol{x}_j=[x_j,y_j]$.
To compute the last equation is however inefficient from a computational stand.
Instead of computing the last equation for the kernel, we simply compute
the dot product $(\boldsymbol{x}_i^T\boldsymbol{x}_j)^2$.
This leads to the so-called
kernel trick.
## The problem to solve
Using our definition of the kernel, we can rewrite again the Lagrangian
$$
{\cal L}=\sum_i\lambda_i-\frac{1}{2}\sum_{ij}^n\lambda_i\lambda_jy_iy_j\boldsymbol{x}_i^T\boldsymbol{z}_j,
$$
subject to the constraints $\lambda_i\geq 0$, $\sum_i\lambda_iy_i=0$ in terms of a convex optimization problem
$$
\frac{1}{2} \boldsymbol{\lambda}^T\begin{bmatrix} y_1y_1K(\boldsymbol{x}_1,\boldsymbol{x}_1) & y_1y_2K(\boldsymbol{x}_1,\boldsymbol{x}_2) & \dots & \dots & y_1y_nK(\boldsymbol{x}_1,\boldsymbol{x}_n) \\
y_2y_1K(\boldsymbol{x}_2,\boldsymbol{x}_1) & y_2y_2(\boldsymbol{x}_2,\boldsymbol{x}_2) & \dots & \dots & y_1y_nK(\boldsymbol{x}_2,\boldsymbol{x}_n) \\
\dots & \dots & \dots & \dots & \dots \\
\dots & \dots & \dots & \dots & \dots \\
y_ny_1K(\boldsymbol{x}_n,\boldsymbol{x}_1) & y_ny_2K(\boldsymbol{x}_n\boldsymbol{x}_2) & \dots & \dots & y_ny_nK(\boldsymbol{x}_n,\boldsymbol{x}_n) \\
\end{bmatrix}\boldsymbol{\lambda}-\mathbb{1}\boldsymbol{\lambda},
$$
subject to $\boldsymbol{y}^T\boldsymbol{\lambda}=0$. Here we defined the vectors $\boldsymbol{\lambda} =[\lambda_1,\lambda_2,\dots,\lambda_n]$ and
$\boldsymbol{y}=[y_1,y_2,\dots,y_n]$.
If we add the slack constants this leads to the additional constraint $0\leq \lambda_i \leq C$.
## Tailoring the equations to the usage of CVXOPT
We can rewrite this (see the solutions below) in terms of a convex optimization problem of the type
$$
\begin{align*}
&\mathrm{min}_{\lambda}\hspace{0.2cm} \frac{1}{2}\boldsymbol{\lambda}^T\boldsymbol{P}\boldsymbol{\lambda}+\boldsymbol{q}^T\boldsymbol{\lambda},\\ \nonumber
&\mathrm{subject\hspace{0.1cm}to} \hspace{0.2cm} \boldsymbol{G}\boldsymbol{\lambda} \preceq \boldsymbol{h} \hspace{0.2cm} \wedge \boldsymbol{A}\boldsymbol{\lambda}=f.
\end{align*}
$$
Below we discuss how to solve these equations. Here we note that the matrix $\boldsymbol{P}$ has matrix elements $p_{ij}=y_iy_jK(\boldsymbol{x}_i,\boldsymbol{x}_j)$.
Given a kernel $K$ and the targets $y_i$ this matrix is easy to set up. The constraint $\boldsymbol{y}^T\boldsymbol{\lambda}=0$ leads to $f=0$ and $\boldsymbol{A}=\boldsymbol{y}$. How to set up the matrix $\boldsymbol{G}$ is discussed later. Here note that the inequalities $0\leq \lambda_i \leq C$ can be split up into
$0\leq \lambda_i$ and $\lambda_i \leq C$. These two inequalities define then the matrix $\boldsymbol{G}$ and the vector $\boldsymbol{h}$.
## Different kernels and Mercer's theorem
There are several popular kernels being used. These are
1. Linear: $K(\boldsymbol{x},\boldsymbol{y})=\boldsymbol{x}^T\boldsymbol{y}$,
2. Polynomial: $K(\boldsymbol{x},\boldsymbol{y})=(\boldsymbol{x}^T\boldsymbol{y}+\gamma)^d$,
3. Gaussian Radial Basis Function: $K(\boldsymbol{x},\boldsymbol{y})=\exp{\left(-\gamma\vert\vert\boldsymbol{x}-\boldsymbol{y}\vert\vert^2\right)}$,
4. Tanh: $K(\boldsymbol{x},\boldsymbol{y})=\tanh{(\boldsymbol{x}^T\boldsymbol{y}+\gamma)}$,
and many other ones.
An important theorem for us is [Mercer's
theorem](https://en.wikipedia.org/wiki/Mercer%27s_theorem). The
theorem states that if a kernel function $K$ is symmetric, continuous
and leads to a positive semi-definite matrix $\boldsymbol{P}$ then there
exists a function $\phi$ that maps $\boldsymbol{x}_i$ and $\boldsymbol{x}_j$ into
another space (possibly with much higher dimensions) such that
$$
K(\boldsymbol{x}_i,\boldsymbol{x}_j)=\phi(\boldsymbol{x}_i)^T\phi(\boldsymbol{x}_j).
$$
So you can use $K$ as a kernel since you know $\phi$ exists, even if
you don’t know what $\phi$ is.
Note that some frequently used kernels (such as the Sigmoid kernel)
don’t respect all of Mercer’s conditions, yet they generally work well
in practice.
## The moons example ([Adapted from Geron, chapter 5](https://www.oreilly.com/library/view/hands-on-machine-learning/9781492032632/))
```python
from __future__ import division, print_function, unicode_literals
import numpy as np
np.random.seed(42)
import matplotlib
import matplotlib.pyplot as plt
plt.rcParams['axes.labelsize'] = 14
plt.rcParams['xtick.labelsize'] = 12
plt.rcParams['ytick.labelsize'] = 12
from sklearn.svm import SVC
from sklearn import datasets
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import LinearSVC
from sklearn.datasets import make_moons
X, y = make_moons(n_samples=100, noise=0.15, random_state=42)
def plot_dataset(X, y, axes):
plt.plot(X[:, 0][y==0], X[:, 1][y==0], "bs")
plt.plot(X[:, 0][y==1], X[:, 1][y==1], "g^")
plt.axis(axes)
plt.grid(True, which='both')
plt.xlabel(r"$x_1$", fontsize=20)
plt.ylabel(r"$x_2$", fontsize=20, rotation=0)
plot_dataset(X, y, [-1.5, 2.5, -1, 1.5])
plt.show()
from sklearn.datasets import make_moons
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import PolynomialFeatures
polynomial_svm_clf = Pipeline([
("poly_features", PolynomialFeatures(degree=3)),
("scaler", StandardScaler()),
("svm_clf", LinearSVC(C=10, loss="hinge", random_state=42))
])
polynomial_svm_clf.fit(X, y)
def plot_predictions(clf, axes):
x0s = np.linspace(axes[0], axes[1], 100)
x1s = np.linspace(axes[2], axes[3], 100)
x0, x1 = np.meshgrid(x0s, x1s)
X = np.c_[x0.ravel(), x1.ravel()]
y_pred = clf.predict(X).reshape(x0.shape)
y_decision = clf.decision_function(X).reshape(x0.shape)
plt.contourf(x0, x1, y_pred, cmap=plt.cm.brg, alpha=0.2)
plt.contourf(x0, x1, y_decision, cmap=plt.cm.brg, alpha=0.1)
plot_predictions(polynomial_svm_clf, [-1.5, 2.5, -1, 1.5])
plot_dataset(X, y, [-1.5, 2.5, -1, 1.5])
plt.show()
from sklearn.svm import SVC
poly_kernel_svm_clf = Pipeline([
("scaler", StandardScaler()),
("svm_clf", SVC(kernel="poly", degree=3, coef0=1, C=5))
])
poly_kernel_svm_clf.fit(X, y)
poly100_kernel_svm_clf = Pipeline([
("scaler", StandardScaler()),
("svm_clf", SVC(kernel="poly", degree=10, coef0=100, C=5))
])
poly100_kernel_svm_clf.fit(X, y)
plt.figure(figsize=(11, 4))
plt.subplot(121)
plot_predictions(poly_kernel_svm_clf, [-1.5, 2.5, -1, 1.5])
plot_dataset(X, y, [-1.5, 2.5, -1, 1.5])
plt.title(r"$d=3, r=1, C=5$", fontsize=18)
plt.subplot(122)
plot_predictions(poly100_kernel_svm_clf, [-1.5, 2.5, -1, 1.5])
plot_dataset(X, y, [-1.5, 2.5, -1, 1.5])
plt.title(r"$d=10, r=100, C=5$", fontsize=18)
plt.show()
def gaussian_rbf(x, landmark, gamma):
return np.exp(-gamma * np.linalg.norm(x - landmark, axis=1)**2)
gamma = 0.3
x1s = np.linspace(-4.5, 4.5, 200).reshape(-1, 1)
x2s = gaussian_rbf(x1s, -2, gamma)
x3s = gaussian_rbf(x1s, 1, gamma)
XK = np.c_[gaussian_rbf(X1D, -2, gamma), gaussian_rbf(X1D, 1, gamma)]
yk = np.array([0, 0, 1, 1, 1, 1, 1, 0, 0])
plt.figure(figsize=(11, 4))
plt.subplot(121)
plt.grid(True, which='both')
plt.axhline(y=0, color='k')
plt.scatter(x=[-2, 1], y=[0, 0], s=150, alpha=0.5, c="red")
plt.plot(X1D[:, 0][yk==0], np.zeros(4), "bs")
plt.plot(X1D[:, 0][yk==1], np.zeros(5), "g^")
plt.plot(x1s, x2s, "g--")
plt.plot(x1s, x3s, "b:")
plt.gca().get_yaxis().set_ticks([0, 0.25, 0.5, 0.75, 1])
plt.xlabel(r"$x_1$", fontsize=20)
plt.ylabel(r"Similarity", fontsize=14)
plt.annotate(r'$\mathbf{x}$',
xy=(X1D[3, 0], 0),
xytext=(-0.5, 0.20),
ha="center",
arrowprops=dict(facecolor='black', shrink=0.1),
fontsize=18,
)
plt.text(-2, 0.9, "$x_2$", ha="center", fontsize=20)
plt.text(1, 0.9, "$x_3$", ha="center", fontsize=20)
plt.axis([-4.5, 4.5, -0.1, 1.1])
plt.subplot(122)
plt.grid(True, which='both')
plt.axhline(y=0, color='k')
plt.axvline(x=0, color='k')
plt.plot(XK[:, 0][yk==0], XK[:, 1][yk==0], "bs")
plt.plot(XK[:, 0][yk==1], XK[:, 1][yk==1], "g^")
plt.xlabel(r"$x_2$", fontsize=20)
plt.ylabel(r"$x_3$ ", fontsize=20, rotation=0)
plt.annotate(r'$\phi\left(\mathbf{x}\right)$',
xy=(XK[3, 0], XK[3, 1]),
xytext=(0.65, 0.50),
ha="center",
arrowprops=dict(facecolor='black', shrink=0.1),
fontsize=18,
)
plt.plot([-0.1, 1.1], [0.57, -0.1], "r--", linewidth=3)
plt.axis([-0.1, 1.1, -0.1, 1.1])
plt.subplots_adjust(right=1)
plt.show()
x1_example = X1D[3, 0]
for landmark in (-2, 1):
k = gaussian_rbf(np.array([[x1_example]]), np.array([[landmark]]), gamma)
print("Phi({}, {}) = {}".format(x1_example, landmark, k))
rbf_kernel_svm_clf = Pipeline([
("scaler", StandardScaler()),
("svm_clf", SVC(kernel="rbf", gamma=5, C=0.001))
])
rbf_kernel_svm_clf.fit(X, y)
from sklearn.svm import SVC
gamma1, gamma2 = 0.1, 5
C1, C2 = 0.001, 1000
hyperparams = (gamma1, C1), (gamma1, C2), (gamma2, C1), (gamma2, C2)
svm_clfs = []
for gamma, C in hyperparams:
rbf_kernel_svm_clf = Pipeline([
("scaler", StandardScaler()),
("svm_clf", SVC(kernel="rbf", gamma=gamma, C=C))
])
rbf_kernel_svm_clf.fit(X, y)
svm_clfs.append(rbf_kernel_svm_clf)
plt.figure(figsize=(11, 7))
for i, svm_clf in enumerate(svm_clfs):
plt.subplot(221 + i)
plot_predictions(svm_clf, [-1.5, 2.5, -1, 1.5])
plot_dataset(X, y, [-1.5, 2.5, -1, 1.5])
gamma, C = hyperparams[i]
plt.title(r"$\gamma = {}, C = {}$".format(gamma, C), fontsize=16)
plt.show()
```
## Mathematical optimization of convex functions
A mathematical (quadratic) optimization problem, or just optimization problem, has the form
$$
\begin{align*}
&\mathrm{min}_{\lambda}\hspace{0.2cm} \frac{1}{2}\boldsymbol{\lambda}^T\boldsymbol{P}\boldsymbol{\lambda}+\boldsymbol{q}^T\boldsymbol{\lambda},\\ \nonumber
&\mathrm{subject\hspace{0.1cm}to} \hspace{0.2cm} \boldsymbol{G}\boldsymbol{\lambda} \preceq \boldsymbol{h} \wedge \boldsymbol{A}\boldsymbol{\lambda}=f.
\end{align*}
$$
subject to some constraints for say a selected set $i=1,2,\dots, n$.
In our case we are optimizing with respect to the Lagrangian multipliers $\lambda_i$, and the
vector $\boldsymbol{\lambda}=[\lambda_1, \lambda_2,\dots, \lambda_n]$ is the optimization variable we are dealing with.
In our case we are particularly interested in a class of optimization problems called convex optmization problems.
In our discussion on gradient descent methods we discussed at length the definition of a convex function.
Convex optimization problems play a central role in applied mathematics and we recommend strongly [Boyd and Vandenberghe's text on the topics](http://web.stanford.edu/~boyd/cvxbook/).
## How do we solve these problems?
If we use Python as programming language and wish to venture beyond
**scikit-learn**, **tensorflow** and similar software which makes our
lives so much easier, we need to dive into the wonderful world of
quadratic programming. We can, if we wish, solve the minimization
problem using say standard gradient methods or conjugate gradient
methods. However, these methods tend to exhibit a rather slow
converge. So, welcome to the promised land of quadratic programming.
The functions we need are contained in the quadratic programming package **CVXOPT** and we need to import it together with **numpy** as
```python
import numpy
import cvxopt
```
This will make our life much easier. You don't need to write your own optimizer.
## A simple example
We remind ourselves about the general problem we want to solve
$$
\begin{align*}
&\mathrm{min}_{x}\hspace{0.2cm} \frac{1}{2}\boldsymbol{x}^T\boldsymbol{P}\boldsymbol{x}+\boldsymbol{q}^T\boldsymbol{x},\\ \nonumber
&\mathrm{s.t.} \hspace{0.2cm} \boldsymbol{G}\boldsymbol{x} \preceq \boldsymbol{h} \wedge \boldsymbol{A}\boldsymbol{x}=f.
\end{align*}
$$
Note: we use **s.t.** for subject to.
Let us show how to perform the optmization using a simple case. Assume we want to optimize the following problem
$$
\begin{align*}
&\mathrm{min}_{x}\hspace{0.2cm} \frac{1}{2}x^2+5x+3y \\ \nonumber
&\mathrm{subject to} \\ \nonumber
&x, y \geq 0 \\ \nonumber
&x+3y \geq 15 \\ \nonumber
&2x+5y \leq 100 \\ \nonumber
&3x+4y \leq 80. \\ \nonumber
\end{align*}
$$
The minimization problem can be rewritten in terms of vectors and matrices as (with $x$ and $y$ being the unknowns)
$$
\frac{1}{2}\begin{bmatrix} x\\ y \end{bmatrix}^T \begin{bmatrix} 1 & 0\\ 0 & 0 \end{bmatrix} \begin{bmatrix} x \\ y \end{bmatrix} + \begin{bmatrix}3\\ 4 \end{bmatrix}^T \begin{bmatrix}x \\ y \end{bmatrix}.
$$
Similarly, we can now set up the inequalities (we need to change $\geq$ to $\leq$ by multiplying with $-1$ on bot sides) as the following matrix-vector equation
$$
\begin{bmatrix} -1 & 0 \\ 0 & -1 \\ -1 & -3 \\ 2 & 5 \\ 3 & 4\end{bmatrix}\begin{bmatrix} x \\ y\end{bmatrix} \preceq \begin{bmatrix}0 \\ 0\\ -15 \\ 100 \\ 80\end{bmatrix}.
$$
We have collapsed all the inequalities into a single matrix $\boldsymbol{G}$. We see also that our matrix
$$
\boldsymbol{P} =\begin{bmatrix} 1 & 0\\ 0 & 0 \end{bmatrix}
$$
is clearly positive semi-definite (all eigenvalues larger or equal zero).
Finally, the vector $\boldsymbol{h}$ is defined as
$$
\boldsymbol{h} = \begin{bmatrix}0 \\ 0\\ -15 \\ 100 \\ 80\end{bmatrix}.
$$
Since we don't have any equalities the matrix $\boldsymbol{A}$ is set to zero
The following code solves the equations for us
```python
# Import the necessary packages
import numpy
from cvxopt import matrix
from cvxopt import solvers
P = matrix(numpy.diag([1,0]), tc='d')
q = matrix(numpy.array([3,4]), tc='d')
G = matrix(numpy.array([[-1,0],[0,-1],[-1,-3],[2,5],[3,4]]), tc='d')
h = matrix(numpy.array([0,0,-15,100,80]), tc='d')
# Construct the QP, invoke solver
sol = solvers.qp(P,q,G,h)
# Extract optimal value and solution
sol['x']
sol['primal objective']
```
## Back to the more realistic cases
We are now ready to return to our setup of the optmization problem for a more realistic case. Introducing the **slack** parameter $C$ we have
$$
\frac{1}{2} \boldsymbol{\lambda}^T\begin{bmatrix} y_1y_1K(\boldsymbol{x}_1,\boldsymbol{x}_1) & y_1y_2K(\boldsymbol{x}_1,\boldsymbol{x}_2) & \dots & \dots & y_1y_nK(\boldsymbol{x}_1,\boldsymbol{x}_n) \\
y_2y_1K(\boldsymbol{x}_2,\boldsymbol{x}_1) & y_2y_2K(\boldsymbol{x}_2,\boldsymbol{x}_2) & \dots & \dots & y_1y_nK(\boldsymbol{x}_2,\boldsymbol{x}_n) \\
\dots & \dots & \dots & \dots & \dots \\
\dots & \dots & \dots & \dots & \dots \\
y_ny_1K(\boldsymbol{x}_n,\boldsymbol{x}_1) & y_ny_2K(\boldsymbol{x}_n\boldsymbol{x}_2) & \dots & \dots & y_ny_nK(\boldsymbol{x}_n,\boldsymbol{x}_n) \\
\end{bmatrix}\boldsymbol{\lambda}-\mathbb{I}\boldsymbol{\lambda},
$$
subject to $\boldsymbol{y}^T\boldsymbol{\lambda}=0$. Here we defined the vectors $\boldsymbol{\lambda} =[\lambda_1,\lambda_2,\dots,\lambda_n]$ and
$\boldsymbol{y}=[y_1,y_2,\dots,y_n]$.
With the slack constants this leads to the additional constraint $0\leq \lambda_i \leq C$.
## Setting up the matrices and the problem
We have the general problem
$$
\begin{align*}
&\mathrm{min}_{\lambda}\hspace{0.2cm} \frac{1}{2}\boldsymbol{\lambda}^T\boldsymbol{P}\boldsymbol{\lambda}+\boldsymbol{q}^T\boldsymbol{\lambda},\\ \nonumber
&\mathrm{s.t.} \hspace{0.2cm} \boldsymbol{G}\boldsymbol{\lambda} \preceq \boldsymbol{h} \wedge \boldsymbol{A}\boldsymbol{\lambda}=f.
\end{align*}
$$
1. With a given kernel we can thus define the matrix $\boldsymbol{P}$.
2. The matrix $\boldsymbol{P}$ has matrix elements $p_{ij}=y_iy_jK(\boldsymbol{x}_i,\boldsymbol{x}_j)$. Given a kernel $K$ and the targets $y_i$ this matrix is easy to set up.
3. The vector $\boldsymbol{q}$ is zero.
4. The constraint $\boldsymbol{y}^T\boldsymbol{\lambda}=0$ leads to $f=0$ and $\boldsymbol{A}=\boldsymbol{y}$.
5. To set up the matrix $\boldsymbol{G}$ we note that the inequalities $0\leq \lambda_i \leq C$ can be split up into $0\leq \lambda_i$ and $\lambda_i \leq C$. These two inequalities define then the matrix $\boldsymbol{G}$ and the vector $\boldsymbol{h}$.
## Setting up $\boldsymbol{G}\boldsymbol{\lambda} \preceq \boldsymbol{h}$
We have two constraints, $0\le \lambda_i$ and $\lambda_i \le C$. To do this we multiply the ones with the contraint
$\ge$ with $-1$ in order to get $\le$. It means that the problem $\boldsymbol{G}\boldsymbol{\lambda} \preceq \boldsymbol{h}$
can be written as
$$
\begin{bmatrix} -1& 0 & 0 & \dots & 0 \\
0& -1 & 0 & \dots & 0 \\
0& 0 & -1 & \dots & 0 \\
\dots& \dots & \dots & \dots & \dots \\
0& 0 & 0 & \dots & -1 \\
1 & 0 & 0 & \dots & 0 \\
0& 1 & 0 & \dots & 0 \\
0& 0 & 1 & \dots & 0 \\
\dots& \dots & \dots & \dots & \dots \\
0& 0 & 0 & \dots & 1 \\
\end{bmatrix}
\begin{bmatrix} \lambda_1 \\
\lambda_2 \\
\lambda_3 \\
\dots \\
\lambda_n \\
\end{bmatrix}=
\begin{bmatrix} 0 \\
0 \\
0 \\
\dots \\
0 \\
C \\
C \\
C \\
\dots \\
C \\
\end{bmatrix}.
$$
And then we are ready to go.
## SVMs and Regression and multiclass classification
[See handwritten lectures from lecture November 26.](https://github.com/CompPhysics/MachineLearning/blob/master/doc/HandWrittenNotes/NotesNovember26.pdf). More text will be added here. See also [Hastie et al.](https://www.springer.com/gp/book/9780387848570) section 12.3.
## Summary of course
## What? Me worry? No final exam in this course!
<!-- dom:FIGURE: [figures/exam1.jpeg, width=500 frac=0.6] -->
<!-- begin figure -->
<p></p>
<!-- end figure -->
## Topics we have covered this year
The course has two central parts
1. Statistical analysis and optimization of data
2. Machine learning
## Statistical analysis and optimization of data
The following topics be covered
1. Basic concepts, expectation values, variance, covariance, correlation functions and errors;
2. Simpler models, binomial distribution, the Poisson distribution, simple and multivariate normal distributions;
3. Central elements from linear algebra
4. Gradient methods for data optimization
5. Estimation of errors using cross-validation, bootstrapping and jackknife methods;
6. Practical optimization using Singular-value decomposition and least squares for parameterizing data.
7. Principal Component Analysis.
## Machine learning
The following topics will be covered
1. Linear methods for regression and classification:
a. Ordinary Least Squares
b. Ridge regression
c. Lasso regression
d. Logistic regression
5. Neural networks and deep learning:
a. Feed Forward Neural Networks
b. Convolutional Neural Networks
c. Recurrent Neural Networks
4. Decisions trees and ensemble methods:
a. Decision trees
b. Bagging and voting
c. Random forests
d. Boosting and gradient boosting
5. Support vector machines
a. Binary classification and multiclass classification
b. Kernel methods
c. Regression
## Learning outcomes and overarching aims of this course
The course introduces a variety of central algorithms and methods
essential for studies of data analysis and machine learning. The
course is project based and through the various projects, normally
three, you will be exposed to fundamental research problems
in these fields, with the aim to reproduce state of the art scientific
results. The students will learn to develop and structure large codes
for studying these systems, get acquainted with computing facilities
and learn to handle large scientific projects. A good scientific and
ethical conduct is emphasized throughout the course.
* Understand linear methods for regression and classification;
* Learn about neural network;
* Learn about baggin, boosting and trees
* Support vector machines
* Learn about basic data analysis;
* Be capable of extending the acquired knowledge to other systems and cases;
* Have an understanding of central algorithms used in data analysis and machine learning;
* Work on numerical projects to illustrate the theory. The projects play a central role and you are expected to know modern programming languages like Python or C++.
## Perspective on Machine Learning
1. Rapidly emerging application area
2. Experiment AND theory are evolving in many many fields. Still many low-hanging fruits.
3. Requires education/retraining for more widespread adoption
4. A lot of “word-of-mouth” development methods
Huge amounts of data sets require automation, classical analysis tools often inadequate.
High energy physics hit this wall in the 90’s.
In 2009 single top quark production was determined via [Boosted decision trees, Bayesian
Neural Networks, etc.](https://arxiv.org/pdf/0903.0850.pdf)
## Machine Learning Research
Where to find recent results:
1. Conference proceedings, arXiv and blog posts!
2. **NIPS**: [Neural Information Processing Systems](https://papers.nips.cc)
3. **ICLR**: [International Conference on Learning Representations](https://openreview.net/group?id=ICLR.cc/2018/Conference#accepted-oral-papers)
4. **ICML**: International Conference on Machine Learning
5. [Journal of Machine Learning Research](http://www.jmlr.org/papers/v19/)
## Starting your Machine Learning Project
1. Identify problem type: classification, generation, regression
2. Consider your data carefully
3. Choose a simple model that fits 1. and 2.
4. Consider your data carefully again… data representation
5. Based on results, feedback loop to earliest possible point
## Choose a Model and Algorithm
1. Supervised?
2. Start with the simplest model that fits your problem
3. Start with minimal processing of data
## Preparing Your Data
1. Shuffle your data
2. Mean center your data
* Why?
3. Normalize the variance
* Why?
4. **Whitening**
* Decorrelates data
* Can be hit or miss
5. When to do train/test split?
## Which Activation and Weights to Choose in Neural Networks
1. RELU? ELU?
2. Sigmoid or Tanh?
3. Set all weights to 0?
* Terrible idea
4. Set all weights to random values?
* Small random values
## Optimization Methods and Hyperparameters
1. Stochastic gradient descent
a. Stochastic gradient descent + momentum
2. State-of-the-art approaches:
* RMSProp
* Adam
Which regularization and hyperparameters? $L_1$ or $L_2$, soft classifiers, depths of trees and many other. Need to explore a large set of hyperparameters and regularization methods.
## Resampling
When do we resample?
1. Bootstrap
2. Cross-validation
3. Jackknife and many other
## Other courses on Data science and Machine Learning at UiO
The link here <https://www.mn.uio.no/english/research/about/centre-focus/innovation/data-science/studies/> gives an excellent overview of courses on Machine learning at UiO.
1. [STK2100 Machine learning and statistical methods for prediction and classification](http://www.uio.no/studier/emner/matnat/math/STK2100/index-eng.html).
2. [IN3050/IN4050 Introduction to Artificial Intelligence and Machine Learning](https://www.uio.no/studier/emner/matnat/ifi/IN3050/index-eng.html). Introductory course in machine learning and AI with an algorithmic approach.
3. [STK-INF3000/4000 Selected Topics in Data Science](http://www.uio.no/studier/emner/matnat/math/STK-INF3000/index-eng.html). The course provides insight into selected contemporary relevant topics within Data Science.
4. [IN4080 Natural Language Processing](https://www.uio.no/studier/emner/matnat/ifi/IN4080/index.html). Probabilistic and machine learning techniques applied to natural language processing.
5. [STK-IN4300 – Statistical learning methods in Data Science](https://www.uio.no/studier/emner/matnat/math/STK-IN4300/index-eng.html). An advanced introduction to statistical and machine learning. For students with a good mathematics and statistics background.
6. [IN-STK5000 Adaptive Methods for Data-Based Decision Making](https://www.uio.no/studier/emner/matnat/ifi/IN-STK5000/index-eng.html). Methods for adaptive collection and processing of data based on machine learning techniques.
7. [IN5400/INF5860 – Machine Learning for Image Analysis](https://www.uio.no/studier/emner/matnat/ifi/IN5400/). An introduction to deep learning with particular emphasis on applications within Image analysis, but useful for other application areas too.
8. [TEK5040 – Dyp læring for autonome systemer](https://www.uio.no/studier/emner/matnat/its/TEK5040/). The course addresses advanced algorithms and architectures for deep learning with neural networks. The course provides an introduction to how deep-learning techniques can be used in the construction of key parts of advanced autonomous systems that exist in physical environments and cyber environments.
## Additional courses of interest
1. [STK4051 Computational Statistics](https://www.uio.no/studier/emner/matnat/math/STK4051/index-eng.html)
2. [STK4021 Applied Bayesian Analysis and Numerical Methods](https://www.uio.no/studier/emner/matnat/math/STK4021/index-eng.html)
## What's the future like?
Based on multi-layer nonlinear neural networks, deep learning can
learn directly from raw data, automatically extract and abstract
features from layer to layer, and then achieve the goal of regression,
classification, or ranking. Deep learning has made breakthroughs in
computer vision, speech processing and natural language, and reached
or even surpassed human level. The success of deep learning is mainly
due to the three factors: big data, big model, and big computing.
In the past few decades, many different architectures of deep neural
networks have been proposed, such as
1. Convolutional neural networks, which are mostly used in image and video data processing, and have also been applied to sequential data such as text processing;
2. Recurrent neural networks, which can process sequential data of variable length and have been widely used in natural language understanding and speech processing;
3. Encoder-decoder framework, which is mostly used for image or sequence generation, such as machine translation, text summarization, and image captioning.
## Types of Machine Learning, a repetition
The approaches to machine learning are many, but are often split into two main categories.
In *supervised learning* we know the answer to a problem,
and let the computer deduce the logic behind it. On the other hand, *unsupervised learning*
is a method for finding patterns and relationship in data sets without any prior knowledge of the system.
Some authours also operate with a third category, namely *reinforcement learning*. This is a paradigm
of learning inspired by behavioural psychology, where learning is achieved by trial-and-error,
solely from rewards and punishment.
Another way to categorize machine learning tasks is to consider the desired output of a system.
Some of the most common tasks are:
* Classification: Outputs are divided into two or more classes. The goal is to produce a model that assigns inputs into one of these classes. An example is to identify digits based on pictures of hand-written ones. Classification is typically supervised learning.
* Regression: Finding a functional relationship between an input data set and a reference data set. The goal is to construct a function that maps input data to continuous output values.
* Clustering: Data are divided into groups with certain common traits, without knowing the different groups beforehand. It is thus a form of unsupervised learning.
* Other unsupervised learning algortihms like **Boltzmann machines**
## Why Boltzmann machines?
What is known as restricted Boltzmann Machines (RMB) have received a lot of attention lately.
One of the major reasons is that they can be stacked layer-wise to build deep neural networks that capture complicated statistics.
The original RBMs had just one visible layer and a hidden layer, but recently so-called Gaussian-binary RBMs have gained quite some popularity in imaging since they are capable of modeling continuous data that are common to natural images.
Furthermore, they have been used to solve complicated [quantum mechanical many-particle problems or classical statistical physics problems like the Ising and Potts classes of models](https://journals.aps.org/rmp/abstract/10.1103/RevModPhys.91.045002).
## Boltzmann Machines
Why use a generative model rather than the more well known discriminative deep neural networks (DNN)?
* Discriminitave methods have several limitations: They are mainly supervised learning methods, thus requiring labeled data. And there are tasks they cannot accomplish, like drawing new examples from an unknown probability distribution.
* A generative model can learn to represent and sample from a probability distribution. The core idea is to learn a parametric model of the probability distribution from which the training data was drawn. As an example
a. A model for images could learn to draw new examples of cats and dogs, given a training dataset of images of cats and dogs.
b. Generate a sample of an ordered or disordered phase, having been given samples of such phases.
c. Model the trial function for [Monte Carlo calculations](https://journals.aps.org/rmp/abstract/10.1103/RevModPhys.91.045002).
## Some similarities and differences from DNNs
1. Both use gradient-descent based learning procedures for minimizing cost functions
2. Energy based models don't use backpropagation and automatic differentiation for computing gradients, instead turning to Markov Chain Monte Carlo methods.
3. DNNs often have several hidden layers. A restricted Boltzmann machine has only one hidden layer, however several RBMs can be stacked to make up Deep Belief Networks, of which they constitute the building blocks.
History: The RBM was developed by amongst others [Geoffrey Hinton](https://en.wikipedia.org/wiki/Geoffrey_Hinton), called by some the "Godfather of Deep Learning", working with the University of Toronto and Google.
## Boltzmann machines (BM)
A BM is what we would call an undirected probabilistic graphical model
with stochastic continuous or discrete units.
It is interpreted as a stochastic recurrent neural network where the
state of each unit(neurons/nodes) depends on the units it is connected
to. The weights in the network represent thus the strength of the
interaction between various units/nodes.
It turns into a Hopfield network if we choose deterministic rather
than stochastic units. In contrast to a Hopfield network, a BM is a
so-called generative model. It allows us to generate new samples from
the learned distribution.
## A standard BM setup
A standard BM network is divided into a set of observable and visible units $\hat{x}$ and a set of unknown hidden units/nodes $\hat{h}$.
Additionally there can be bias nodes for the hidden and visible layers. These biases are normally set to $1$.
BMs are stackable, meaning they cwe can train a BM which serves as input to another BM. We can construct deep networks for learning complex PDFs. The layers can be trained one after another, a feature which makes them popular in deep learning
However, they are often hard to train. This leads to the introduction of so-called restricted BMs, or RBMS.
Here we take away all lateral connections between nodes in the visible layer as well as connections between nodes in the hidden layer. The network is illustrated in the figure below.
## The structure of the RBM network
<!-- dom:FIGURE: [figures/RBM.png, width=800 frac=1.0] -->
<!-- begin figure -->
<p></p>
<!-- end figure -->
## The network
**The network layers**:
1. A function $\mathbf{x}$ that represents the visible layer, a vector of $M$ elements (nodes). This layer represents both what the RBM might be given as training input, and what we want it to be able to reconstruct. This might for example be given by the pixels of an image or coefficients representing speech, or the coordinates of a quantum mechanical state function.
2. The function $\mathbf{h}$ represents the hidden, or latent, layer. A vector of $N$ elements (nodes). Also called "feature detectors".
## Goals
The goal of the hidden layer is to increase the model's expressive
power. We encode complex interactions between visible variables by
introducing additional, hidden variables that interact with visible
degrees of freedom in a simple manner, yet still reproduce the complex
correlations between visible degrees in the data once marginalized
over (integrated out).
**The network parameters, to be optimized/learned**:
1. $\mathbf{a}$ represents the visible bias, a vector of same length as $\mathbf{x}$.
2. $\mathbf{b}$ represents the hidden bias, a vector of same lenght as $\mathbf{h}$.
3. $W$ represents the interaction weights, a matrix of size $M\times N$.
## Joint distribution
The restricted Boltzmann machine is described by a Bolztmann distribution
<!-- Equation labels as ordinary links -->
<div id="_auto1"></div>
$$
\begin{equation}
P_{rbm}(\mathbf{x},\mathbf{h}) = \frac{1}{Z} e^{-\frac{1}{T_0}E(\mathbf{x},\mathbf{h})},
\label{_auto1} \tag{1}
\end{equation}
$$
where $Z$ is the normalization constant or partition function, defined as
<!-- Equation labels as ordinary links -->
<div id="_auto2"></div>
$$
\begin{equation}
Z = \int \int e^{-\frac{1}{T_0}E(\mathbf{x},\mathbf{h})} d\mathbf{x} d\mathbf{h}.
\label{_auto2} \tag{2}
\end{equation}
$$
It is common to ignore $T_0$ by setting it to one.
## Network Elements, the energy function
The function $E(\mathbf{x},\mathbf{h})$ gives the **energy** of a
configuration (pair of vectors) $(\mathbf{x}, \mathbf{h})$. The lower
the energy of a configuration, the higher the probability of it. This
function also depends on the parameters $\mathbf{a}$, $\mathbf{b}$ and
$W$. Thus, when we adjust them during the learning procedure, we are
adjusting the energy function to best fit our problem.
An expression for the energy function is
$$
E(\hat{x},\hat{h}) = -\sum_{ia}^{NA}b_i^a \alpha_i^a(x_i)-\sum_{jd}^{MD}c_j^d \beta_j^d(h_j)-\sum_{ijad}^{NAMD}b_i^a \alpha_i^a(x_i)c_j^d \beta_j^d(h_j)w_{ij}^{ad}.
$$
Here $\beta_j^d(h_j)$ and $\alpha_i^a(x_j)$ are so-called transfer functions that map a given input value to a desired feature value. The labels $a$ and $d$ denote that there can be multiple transfer functions per variable. The first sum depends only on the visible units. The second on the hidden ones. **Note** that there is no connection between nodes in a layer.
The quantities $b$ and $c$ can be interpreted as the visible and hidden biases, respectively.
The connection between the nodes in the two layers is given by the weights $w_{ij}$.
## Defining different types of RBMs
There are different variants of RBMs, and the differences lie in the types of visible and hidden units we choose as well as in the implementation of the energy function $E(\mathbf{x},\mathbf{h})$.
**Binary-Binary RBM:**
RBMs were first developed using binary units in both the visible and hidden layer. The corresponding energy function is defined as follows:
<!-- Equation labels as ordinary links -->
<div id="_auto3"></div>
$$
\begin{equation}
E(\mathbf{x}, \mathbf{h}) = - \sum_i^M x_i a_i- \sum_j^N b_j h_j - \sum_{i,j}^{M,N} x_i w_{ij} h_j,
\label{_auto3} \tag{3}
\end{equation}
$$
where the binary values taken on by the nodes are most commonly 0 and 1.
**Gaussian-Binary RBM:**
Another varient is the RBM where the visible units are Gaussian while the hidden units remain binary:
<!-- Equation labels as ordinary links -->
<div id="_auto4"></div>
$$
\begin{equation}
E(\mathbf{x}, \mathbf{h}) = \sum_i^M \frac{(x_i - a_i)^2}{2\sigma_i^2} - \sum_j^N b_j h_j - \sum_{i,j}^{M,N} \frac{x_i w_{ij} h_j}{\sigma_i^2}.
\label{_auto4} \tag{4}
\end{equation}
$$
## More about RBMs
1. Useful when we model continuous data (i.e., we wish $\mathbf{x}$ to be continuous)
2. Requires a smaller learning rate, since there's no upper bound to the value a component might take in the reconstruction
Other types of units include:
1. Softmax and multinomial units
2. Gaussian visible and hidden units
3. Binomial units
4. Rectified linear units
## Autoencoders: Overarching view
Autoencoders are artificial neural networks capable of learning
efficient representations of the input data (these representations are called codings) without
any supervision (i.e., the training set is unlabeled). These codings
typically have a much lower dimensionality than the input data, making
autoencoders useful for dimensionality reduction.
More importantly, autoencoders act as powerful feature detectors, and
they can be used for unsupervised pretraining of deep neural networks.
Lastly, they are capable of randomly generating new data that looks
very similar to the training data; this is called a generative
model. For example, you could train an autoencoder on pictures of
faces, and it would then be able to generate new faces. Surprisingly,
autoencoders work by simply learning to copy their inputs to their
outputs. This may sound like a trivial task, but we will see that
constraining the network in various ways can make it rather
difficult. For example, you can limit the size of the internal
representation, or you can add noise to the inputs and train the
network to recover the original inputs. These constraints prevent the
autoencoder from trivially copying the inputs directly to the outputs,
which forces it to learn efficient ways of representing the data. In
short, the codings are byproducts of the autoencoder’s attempt to
learn the identity function under some constraints.
[Video on autoencoders](https://www.coursera.org/lecture/building-deep-learning-models-with-tensorflow/autoencoders-1U4L3)
See also A. Geron's textbook, chapter 15.
## Bayesian Machine Learning
This is an important topic if we aim at extracting a probability
distribution. This gives us also a confidence interval and error
estimates.
Bayesian machine learning allows us to encode our prior beliefs about
what those models should look like, independent of what the data tells
us. This is especially useful when we don’t have a ton of data to
confidently learn our model.
[Video on Bayesian deep learning](https://www.youtube.com/watch?v=E1qhGw8QxqY&ab_channel=AndrewGordonWilson)
See also the [slides here](https://github.com/CompPhysics/MachineLearning/blob/master/doc/Articles/lec03.pdf).
## Reinforcement Learning
Reinforcement Learning (RL) is one of the most exciting fields of
Machine Learning today, and also one of the oldest. It has been around
since the 1950s, producing many interesting applications over the
years.
It studies
how agents take actions based on trial and error, so as to maximize
some notion of cumulative reward in a dynamic system or
environment. Due to its generality, the problem has also been studied
in many other disciplines, such as game theory, control theory,
operations research, information theory, multi-agent systems, swarm
intelligence, statistics, and genetic algorithms.
In March 2016, AlphaGo, a computer program that plays the board game
Go, beat Lee Sedol in a five-game match. This was the first time a
computer Go program had beaten a 9-dan (highest rank) professional
without handicaps. AlphaGo is based on deep convolutional neural
networks and reinforcement learning. AlphaGo’s victory was a major
milestone in artificial intelligence and it has also made
reinforcement learning a hot research area in the field of machine
learning.
[Lecture on Reinforcement Learning](https://www.youtube.com/watch?v=FgzM3zpZ55o&ab_channel=stanfordonline).
See also A. Geron's textbook, chapter 16.
## Transfer learning
The goal of transfer learning is to transfer the model or knowledge
obtained from a source task to the target task, in order to resolve
the issues of insufficient training data in the target task. The
rationality of doing so lies in that usually the source and target
tasks have inter-correlations, and therefore either the features,
samples, or models in the source task might provide useful information
for us to better solve the target task. Transfer learning is a hot
research topic in recent years, with many problems still waiting to be studied.
[Lecture on transfer learning](https://www.ias.edu/video/machinelearning/2020/0331-SamoryKpotufe).
## Adversarial learning
The conventional deep generative model has a potential problem: the
model tends to generate extreme instances to maximize the
probabilistic likelihood, which will hurt its performance. Adversarial
learning utilizes the adversarial behaviors (e.g., generating
adversarial instances or training an adversarial model) to enhance the
robustness of the model and improve the quality of the generated
data. In recent years, one of the most promising unsupervised learning
technologies, generative adversarial networks (GAN), has already been
successfully applied to image, speech, and text.
[Lecture on adversial learning](https://www.youtube.com/watch?v=CIfsB_EYsVI&ab_channel=StanfordUniversitySchoolofEngineering).
## Dual learning
Dual learning is a new learning paradigm, the basic idea of which is
to use the primal-dual structure between machine learning tasks to
obtain effective feedback/regularization, and guide and strengthen the
learning process, thus reducing the requirement of large-scale labeled
data for deep learning. The idea of dual learning has been applied to
many problems in machine learning, including machine translation,
image style conversion, question answering and generation, image
classification and generation, text classification and generation,
image-to-text, and text-to-image.
## Distributed machine learning
Distributed computation will speed up machine learning algorithms,
significantly improve their efficiency, and thus enlarge their
application. When distributed meets machine learning, more than just
implementing the machine learning algorithms in parallel is required.
## Meta learning
Meta learning is an emerging research direction in machine
learning. Roughly speaking, meta learning concerns learning how to
learn, and focuses on the understanding and adaptation of the learning
itself, instead of just completing a specific learning task. That is,
a meta learner needs to be able to evaluate its own learning methods
and adjust its own learning methods according to specific learning
tasks.
## The Challenges Facing Machine Learning
While there has been much progress in machine learning, there are also challenges.
For example, the mainstream machine learning technologies are
black-box approaches, making us concerned about their potential
risks. To tackle this challenge, we may want to make machine learning
more explainable and controllable. As another example, the
computational complexity of machine learning algorithms is usually
very high and we may want to invent lightweight algorithms or
implementations. Furthermore, in many domains such as physics,
chemistry, biology, and social sciences, people usually seek elegantly
simple equations (e.g., the Schrödinger equation) to uncover the
underlying laws behind various phenomena. In the field of machine
learning, can we reveal simple laws instead of designing more complex
models for data fitting? Although there are many challenges, we are
still very optimistic about the future of machine learning. As we look
forward to the future, here are what we think the research hotspots in
the next ten years will be.
## Explainable machine learning
Machine learning, especially deep learning, evolves rapidly. The
ability gap between machine and human on many complex cognitive tasks
becomes narrower and narrower. However, we are still in the very early
stage in terms of explaining why those effective models work and how
they work.
**What is missing: the gap between correlation and causation**. Standard Machine Learning is based on what e have called a frequentist approach.
Most
machine learning techniques, especially the statistical ones, depend
highly on correlations in data sets to make predictions and analyses. In
contrast, rational humans tend to reply on clear and trustworthy
causality relations obtained via logical reasoning on real and clear
facts. It is one of the core goals of explainable machine learning to
transition from solving problems by data correlation to solving
problems by logical reasoning. Bayesian Machine Learning is one of the exciting research directions in this field.
## Quantum machine learning
Quantum machine learning is an emerging interdisciplinary research
area at the intersection of quantum computing and machine learning.
Quantum computers use effects such as quantum coherence and quantum
entanglement to process information, which is fundamentally different
from classical computers. Quantum algorithms have surpassed the best
classical algorithms in several problems (e.g., searching for an
unsorted database, inverting a sparse matrix), which we call quantum
acceleration.
When quantum computing meets machine learning, it can be a mutually
beneficial and reinforcing process, as it allows us to take advantage
of quantum computing to improve the performance of classical machine
learning algorithms. In addition, we can also use the machine learning
algorithms (on classic computers) to analyze and improve quantum
computing systems.
[Lecture on Quantum ML](https://www.youtube.com/watch?v=Xh9pUu3-WxM&ab_channel=InstituteforPure%26AppliedMathematics%28IPAM%29).
[Read interview with Maria Schuld on her work on Quantum Machine Learning](https://physics.aps.org/articles/v13/179?utm_campaign=weekly&utm_medium=email&utm_source=emailalert). See also [her recent textbook](https://www.springer.com/gp/book/9783319964232).
## Quantum machine learning algorithms based on linear algebra
Many quantum machine learning algorithms are based on variants of
quantum algorithms for solving linear equations, which can efficiently
solve N-variable linear equations with complexity of O(log2 N) under
certain conditions. The quantum matrix inversion algorithm can
accelerate many machine learning methods, such as least square linear
regression, least square version of support vector machine, Gaussian
process, and more. The training of these algorithms can be simplified
to solve linear equations. The key bottleneck of this type of quantum
machine learning algorithms is data input—that is, how to initialize
the quantum system with the entire data set. Although efficient
data-input algorithms exist for certain situations, how to efficiently
input data into a quantum system is as yet unknown for most cases.
## Quantum reinforcement learning
In quantum reinforcement learning, a quantum agent interacts with the
classical environment to obtain rewards from the environment, so as to
adjust and improve its behavioral strategies. In some cases, it
achieves quantum acceleration by the quantum processing capabilities
of the agent or the possibility of exploring the environment through
quantum superposition. Such algorithms have been proposed in
superconducting circuits and systems of trapped ions.
## Quantum deep learning
Dedicated quantum information processors, such as quantum annealers
and programmable photonic circuits, are well suited for building deep
quantum networks. The simplest deep quantum network is the Boltzmann
machine. The classical Boltzmann machine consists of bits with tunable
interactions and is trained by adjusting the interaction of these bits
so that the distribution of its expression conforms to the statistics
of the data. To quantize the Boltzmann machine, the neural network can
simply be represented as a set of interacting quantum spins that
correspond to an adjustable Ising model. Then, by initializing the
input neurons in the Boltzmann machine to a fixed state and allowing
the system to heat up, we can read out the output qubits to get the
result.
## Social machine learning
Machine learning aims to imitate how humans
learn. While we have developed successful machine learning algorithms,
until now we have ignored one important fact: humans are social. Each
of us is one part of the total society and it is difficult for us to
live, learn, and improve ourselves, alone and isolated. Therefore, we
should design machines with social properties. Can we let machines
evolve by imitating human society so as to achieve more effective,
intelligent, interpretable “social machine learning”?
And much more.
## The last words?
Early computer scientist Alan Kay said, **The best way to predict the
future is to create it**. Therefore, all machine learning
practitioners, whether scholars or engineers, professors or students,
need to work together to advance these important research
topics. Together, we will not just predict the future, but create it.
## Best wishes to you all and thanks so much for your heroic efforts this semester
<!-- dom:FIGURE: [figures/Nebbdyr2.png, width=500 frac=0.6] -->
<!-- begin figure -->
<p></p>
<!-- end figure -->
|
open import Everything
module Test.Functor where
List = List⟨_⟩
module _
{a b} {A : Set a} {B : Set b}
where
map-list : (A → B) → List A → List B
map-list f ∅ = ∅
map-list f (x , xs) = f x , map-list f xs
instance
SurjtranscommutativityList : ∀ {ℓ} → Surjtranscommutativity.class Function⟦ ℓ ⟧ (MFunction List) _≡̇_ map-list transitivity transitivity
SurjtranscommutativityList .⋆ f g ∅ = ∅
SurjtranscommutativityList .⋆ f g (x , xs) rewrite SurjtranscommutativityList .⋆ f g xs = ∅
SurjextensionalityList : ∀ {ℓ} → Surjextensionality.class Function⟦ ℓ ⟧ _≡̇_ (MFunction List) _≡̇_ _ map-list
SurjextensionalityList .⋆ _ _ f₁ f₂ f₁≡̇f₂ ∅ = ∅
SurjextensionalityList .⋆ _ _ f₁ f₂ f₁≡̇f₂ (x , xs) rewrite SurjextensionalityList .⋆ _ _ f₁ f₂ f₁≡̇f₂ xs | f₁≡̇f₂ x = ∅
SurjidentityList : ∀ {ℓ} → Surjidentity.class Function⟦ ℓ ⟧ (MFunction List) _≡̇_ map-list ε ε
SurjidentityList .⋆ ∅ = ∅
SurjidentityList .⋆ (x , xs) rewrite SurjidentityList .⋆ xs = ∅
test-isprecategory-1 : ∀ {ℓ} → IsPrecategory {𝔒 = Ø ℓ} Function⟦ ℓ ⟧ _≡̇_ (flip _∘′_)
test-isprecategory-1 {ℓ} = IsPrecategoryExtension {A = Ø ℓ} {B = ¡}
test-isprecategory-2 : ∀ {ℓ} → IsPrecategory {𝔒 = Ø ℓ} Function⟦ ℓ ⟧ _≡̇_ (flip _∘′_)
test-isprecategory-2 {ℓ} = IsPrecategoryFunction {𝔬 = ℓ}
test-isprecategory-1a : ∀ {ℓ} → IsPrecategory {𝔒 = Ø ℓ} (Extension (¡ {𝔒 = Ø ℓ})) _≡̇_ (flip _∘′_)
test-isprecategory-1a {ℓ} = IsPrecategoryExtension {A = Ø ℓ} {B = ¡}
test-isprecategory-2a : ∀ {ℓ} → IsPrecategory {𝔒 = Ø ℓ} (Extension (¡ {𝔒 = Ø ℓ})) _≡̇_ (flip _∘′_)
test-isprecategory-2a {ℓ} = IsPrecategoryFunction {𝔬 = ℓ}
test-isprecategory-1b : IsPrecategory {𝔒 = ¶} (Extension (Term.Term ¶)) _≡̇_ (flip _∘′_)
test-isprecategory-1b = IsPrecategoryExtension {A = ¶} {B = Term.Term ¶}
-- test-isprecategory-2b : IsPrecategory {𝔒 = ¶} (Extension (Term.Term ¶)) _≡̇_ (flip _∘′_)
-- test-isprecategory-2b = {!!} -- IsPrecategoryFunction {𝔬 = ?}
instance
HmapList : ∀ {a} → Hmap.class Function⟦ a ⟧ (MFunction List)
HmapList = ∁ λ _ _ → map-list
instance
isPrefunctorList : ∀ {ℓ} → IsPrefunctor (λ (x y : Ø ℓ) → x → y)
Proposextensequality
transitivity
(λ (x y : Ø ℓ) → List x → List y)
Proposextensequality
transitivity
smap
isPrefunctorList = ∁
isFunctorList : ∀ {ℓ} → IsFunctor (λ (x y : Ø ℓ) → x → y)
Proposextensequality
ε
transitivity
(λ (x y : Ø ℓ) → List x → List y)
Proposextensequality
ε
transitivity
smap
isFunctorList = ∁
instance
FmapList : ∀ {ℓ} → Fmap (List {ℓ})
FmapList = ∁ smap
module _
{a} {A : Set a} {B : Set a}
where
test-smap-list : (A → B) → List A → List B
test-smap-list = smap
module _
{a} {A : Set a} {B : Set a}
where
test-fmap-list : (A → B) → List A → List B
test-fmap-list = fmap -- the intention here is to try to say "I want to invoke a functoral mapping, so that I can be sure that, for example, that `test-map-list ε₁ ≡ ε₂`.
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.