control.lawful_fix
⟷
Mathlib.Control.LawfulFix
The following section lists changes to this file in mathlib3 and mathlib4 that occured after the initial port. Most recent changes are shown first. Hovering over a commit will show all commits associated with the same mathlib3 commit.
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(last sync)
wlog
(#16495)
Benefits:
Downside:
Zulip thread: https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/wlog/near/296996966
Co-authored-by: Yury G. Kudryashov <urkud@urkud.name> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>
@@ -74,7 +74,8 @@ begin
suffices : y = b, subst this, exact h₁,
cases hh with i hh,
revert h₁, generalize : (succ (nat.find h₀)) = j, intro,
- wlog : i ≤ j := le_total i j using [i j b y,j i y b],
+ wlog case : i ≤ j,
+ { cases le_total i j with H H; [skip, symmetry]; apply_assumption; assumption },
replace hh := approx_mono f case _ _ hh,
apply part.mem_unique h₁ hh },
{ simp only [fix_def' ⇑f h₀, not_exists, false_iff, not_mem_none],
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(no changes)
(first ported)
mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83
@@ -85,7 +85,7 @@ theorem mem_iff (a : α) (b : β a) : b ∈ Part.fix f a ↔ ∃ i, b ∈ approx
· simp only [Part.fix_def f h₀]
constructor <;> intro hh; exact ⟨_, hh⟩
have h₁ := Nat.find_spec h₀
- rw [dom_iff_mem] at h₁
+ rw [dom_iff_mem] at h₁
cases' h₁ with y h₁
replace h₁ := approx_mono' f _ _ h₁
suffices : y = b; subst this; exact h₁
@@ -96,7 +96,7 @@ theorem mem_iff (a : α) (b : β a) : b ∈ Part.fix f a ↔ ∃ i, b ∈ approx
replace hh := approx_mono f case _ _ hh
apply Part.mem_unique h₁ hh
· simp only [fix_def' (⇑f) h₀, not_exists, false_iff_iff, not_mem_none]
- simp only [dom_iff_mem, not_exists] at h₀
+ simp only [dom_iff_mem, not_exists] at h₀
intro; apply h₀
#align part.fix.mem_iff Part.Fix.mem_iff
-/
@@ -116,9 +116,9 @@ theorem exists_fix_le_approx (x : α) : ∃ i, Part.fix f x ≤ approx f i x :=
have hb' := approx_le_fix f i _ _ hb
obtain rfl := Part.mem_unique h' hb'
exact hb
- · simp only [not_exists] at hh ; exists 0
+ · simp only [not_exists] at hh; exists 0
intro b' h'
- simp only [mem_iff f] at h'
+ simp only [mem_iff f] at h'
cases' h' with i h'
cases hh _ _ h'
#align part.fix.exists_fix_le_approx Part.Fix.exists_fix_le_approx
mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83
@@ -308,7 +308,7 @@ theorem uncurry_curry_continuous :
end Curry
-#print Pi.Pi.lawfulFix' /-
+#print Pi.lawfulFix' /-
instance Pi.lawfulFix' [LawfulFix <| ∀ x : Sigma β, γ x.1 x.2] : LawfulFix (∀ x y, γ x y)
where fix_eq f hc := by
dsimp [fix]
@@ -316,7 +316,7 @@ instance Pi.lawfulFix' [LawfulFix <| ∀ x : Sigma β, γ x.1 x.2] : LawfulFix (
lhs
erw [LawfulFix.fix_eq (uncurry_curry_continuous hc)]
rfl
-#align pi.pi.lawful_fix' Pi.Pi.lawfulFix'
+#align pi.pi.lawful_fix' Pi.lawfulFix'
-/
end Pi
mathlib commit https://github.com/leanprover-community/mathlib/commit/b1abe23ae96fef89ad30d9f4362c307f72a55010
@@ -142,7 +142,7 @@ theorem le_f_of_mem_approx {x} : x ∈ approxChain f → x ≤ f x :=
#print Part.Fix.approx_mem_approxChain /-
theorem approx_mem_approxChain {i} : approx f i ∈ approxChain f :=
- Stream'.mem_of_nth_eq rfl
+ Stream'.mem_of_get_eq rfl
#align part.fix.approx_mem_approx_chain Part.Fix.approx_mem_approxChain
-/
mathlib commit https://github.com/leanprover-community/mathlib/commit/ce64cd319bb6b3e82f31c2d38e79080d377be451
@@ -3,10 +3,10 @@ Copyright (c) 2020 Simon Hudon. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Simon Hudon
-/
-import Mathbin.Data.Stream.Init
-import Mathbin.Tactic.Apply
-import Mathbin.Control.Fix
-import Mathbin.Order.OmegaCompletePartialOrder
+import Data.Stream.Init
+import Tactic.Apply
+import Control.Fix
+import Order.OmegaCompletePartialOrder
#align_import control.lawful_fix from "leanprover-community/mathlib"@"f47581155c818e6361af4e4fda60d27d020c226b"
mathlib commit https://github.com/leanprover-community/mathlib/commit/63721b2c3eba6c325ecf8ae8cca27155a4f6306f
@@ -172,7 +172,7 @@ theorem fix_eq_ωSup : Part.fix f = ωSup (approxChain f) :=
apply le_ωSup_of_le i.succ
dsimp [approx]; rfl
· apply ωSup_le _ _ _
- simp only [fix.approx_chain, OrderHom.coe_fun_mk]
+ simp only [fix.approx_chain, OrderHom.coe_mk]
intro y x; apply approx_le_fix f
#align part.fix_eq_ωSup Part.fix_eq_ωSup
-/
@@ -182,7 +182,7 @@ theorem fix_le {X : ∀ a, Part <| β a} (hX : f X ≤ X) : Part.fix f ≤ X :=
by
rw [fix_eq_ωSup f]
apply ωSup_le _ _ _
- simp only [fix.approx_chain, OrderHom.coe_fun_mk]
+ simp only [fix.approx_chain, OrderHom.coe_mk]
intro i
induction i; dsimp [fix.approx]; apply bot_le
trans f X; apply f.monotone i_ih
mathlib commit https://github.com/leanprover-community/mathlib/commit/8ea5598db6caeddde6cb734aa179cc2408dbd345
@@ -2,17 +2,14 @@
Copyright (c) 2020 Simon Hudon. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Simon Hudon
-
-! This file was ported from Lean 3 source module control.lawful_fix
-! leanprover-community/mathlib commit f47581155c818e6361af4e4fda60d27d020c226b
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
-/
import Mathbin.Data.Stream.Init
import Mathbin.Tactic.Apply
import Mathbin.Control.Fix
import Mathbin.Order.OmegaCompletePartialOrder
+#align_import control.lawful_fix from "leanprover-community/mathlib"@"f47581155c818e6361af4e4fda60d27d020c226b"
+
/-!
# Lawful fixed point operators
mathlib commit https://github.com/leanprover-community/mathlib/commit/2a0ce625dbb0ffbc7d1316597de0b25c1ec75303
@@ -276,13 +276,13 @@ variable [∀ x y, OmegaCompletePartialOrder <| γ x y]
open OmegaCompletePartialOrder.Chain
#print Pi.continuous_curry /-
-theorem continuous_curry : Continuous <| monotoneCurry α β γ := fun c => by ext (x y);
+theorem continuous_curry : Continuous <| monotoneCurry α β γ := fun c => by ext x y;
dsimp [curry, ωSup]; rw [map_comp, map_comp]; rfl
#align pi.continuous_curry Pi.continuous_curry
-/
#print Pi.continuous_uncurry /-
-theorem continuous_uncurry : Continuous <| monotoneUncurry α β γ := fun c => by ext (x y);
+theorem continuous_uncurry : Continuous <| monotoneUncurry α β γ := fun c => by ext x y;
dsimp [uncurry, ωSup]; rw [map_comp, map_comp]; rfl
#align pi.continuous_uncurry Pi.continuous_uncurry
-/
mathlib commit https://github.com/leanprover-community/mathlib/commit/9fb8964792b4237dac6200193a0d533f1b3f7423
@@ -64,19 +64,24 @@ namespace Fix
variable (f : (∀ a, Part <| β a) →o ∀ a, Part <| β a)
+#print Part.Fix.approx_mono' /-
theorem approx_mono' {i : ℕ} : Fix.approx f i ≤ Fix.approx f (succ i) :=
by
induction i; dsimp [approx]; apply @bot_le _ _ _ (f ⊥)
intro; apply f.monotone; apply i_ih
#align part.fix.approx_mono' Part.Fix.approx_mono'
+-/
+#print Part.Fix.approx_mono /-
theorem approx_mono ⦃i j : ℕ⦄ (hij : i ≤ j) : approx f i ≤ approx f j :=
by
induction' j with j ih; · cases hij; exact le_rfl
cases hij; · exact le_rfl
exact le_trans (ih ‹_›) (approx_mono' f)
#align part.fix.approx_mono Part.Fix.approx_mono
+-/
+#print Part.Fix.mem_iff /-
theorem mem_iff (a : α) (b : β a) : b ∈ Part.fix f a ↔ ∃ i, b ∈ approx f i a :=
by
by_cases h₀ : ∃ i : ℕ, (approx f i a).Dom
@@ -97,11 +102,15 @@ theorem mem_iff (a : α) (b : β a) : b ∈ Part.fix f a ↔ ∃ i, b ∈ approx
simp only [dom_iff_mem, not_exists] at h₀
intro; apply h₀
#align part.fix.mem_iff Part.Fix.mem_iff
+-/
+#print Part.Fix.approx_le_fix /-
theorem approx_le_fix (i : ℕ) : approx f i ≤ Part.fix f := fun a b hh => by rw [mem_iff f];
exact ⟨_, hh⟩
#align part.fix.approx_le_fix Part.Fix.approx_le_fix
+-/
+#print Part.Fix.exists_fix_le_approx /-
theorem exists_fix_le_approx (x : α) : ∃ i, Part.fix f x ≤ approx f i x :=
by
by_cases hh : ∃ i b, b ∈ approx f i x
@@ -116,24 +125,29 @@ theorem exists_fix_le_approx (x : α) : ∃ i, Part.fix f x ≤ approx f i x :=
cases' h' with i h'
cases hh _ _ h'
#align part.fix.exists_fix_le_approx Part.Fix.exists_fix_le_approx
+-/
-include f
-
+#print Part.Fix.approxChain /-
/-- The series of approximations of `fix f` (see `approx`) as a `chain` -/
def approxChain : Chain (∀ a, Part <| β a) :=
⟨approx f, approx_mono f⟩
#align part.fix.approx_chain Part.Fix.approxChain
+-/
+#print Part.Fix.le_f_of_mem_approx /-
theorem le_f_of_mem_approx {x} : x ∈ approxChain f → x ≤ f x :=
by
simp only [(· ∈ ·), forall_exists_index]
rintro i rfl
apply approx_mono'
#align part.fix.le_f_of_mem_approx Part.Fix.le_f_of_mem_approx
+-/
+#print Part.Fix.approx_mem_approxChain /-
theorem approx_mem_approxChain {i} : approx f i ∈ approxChain f :=
Stream'.mem_of_nth_eq rfl
#align part.fix.approx_mem_approx_chain Part.Fix.approx_mem_approxChain
+-/
end Fix
@@ -151,6 +165,7 @@ open Nat
open Nat.Upto OmegaCompletePartialOrder
+#print Part.fix_eq_ωSup /-
theorem fix_eq_ωSup : Part.fix f = ωSup (approxChain f) :=
by
apply le_antisymm
@@ -163,7 +178,9 @@ theorem fix_eq_ωSup : Part.fix f = ωSup (approxChain f) :=
simp only [fix.approx_chain, OrderHom.coe_fun_mk]
intro y x; apply approx_le_fix f
#align part.fix_eq_ωSup Part.fix_eq_ωSup
+-/
+#print Part.fix_le /-
theorem fix_le {X : ∀ a, Part <| β a} (hX : f X ≤ X) : Part.fix f ≤ X :=
by
rw [fix_eq_ωSup f]
@@ -174,11 +191,11 @@ theorem fix_le {X : ∀ a, Part <| β a} (hX : f X ≤ X) : Part.fix f ≤ X :=
trans f X; apply f.monotone i_ih
apply hX
#align part.fix_le Part.fix_le
+-/
variable {f} (hc : Continuous f)
-include hc
-
+#print Part.fix_eq /-
theorem fix_eq : Part.fix f = f (Part.fix f) :=
by
rw [fix_eq_ωSup f, hc]
@@ -190,11 +207,13 @@ theorem fix_eq : Part.fix f = f (Part.fix f) :=
· apply ωSup_le_ωSup_of_le _
intro i; exists i.succ; rfl
#align part.fix_eq Part.fix_eq
+-/
end Part
namespace Part
+#print Part.toUnitMono /-
/-- `to_unit` as a monotone function -/
@[simps]
def toUnitMono (f : Part α →o Part α) : (Unit → Part α) →o Unit → Part α
@@ -202,13 +221,16 @@ def toUnitMono (f : Part α →o Part α) : (Unit → Part α) →o Unit → Par
toFun x u := f (x u)
monotone' x y (h : x ≤ y) u := f.Monotone <| h u
#align part.to_unit_mono Part.toUnitMono
+-/
+#print Part.to_unit_cont /-
theorem to_unit_cont (f : Part α →o Part α) (hc : Continuous f) : Continuous (toUnitMono f)
| c => by
ext ⟨⟩ : 1
dsimp [OmegaCompletePartialOrder.ωSup]
erw [hc, chain.map_comp]; rfl
#align part.to_unit_cont Part.to_unit_cont
+-/
instance : LawfulFix (Part α) :=
⟨fun f hc => show Part.fix (toUnitMono f) () = _ by rw [Part.fix_eq (to_unit_cont f hc)] <;> rfl⟩
@@ -253,13 +275,17 @@ variable [∀ x y, OmegaCompletePartialOrder <| γ x y]
open OmegaCompletePartialOrder.Chain
+#print Pi.continuous_curry /-
theorem continuous_curry : Continuous <| monotoneCurry α β γ := fun c => by ext (x y);
dsimp [curry, ωSup]; rw [map_comp, map_comp]; rfl
#align pi.continuous_curry Pi.continuous_curry
+-/
+#print Pi.continuous_uncurry /-
theorem continuous_uncurry : Continuous <| monotoneUncurry α β γ := fun c => by ext (x y);
dsimp [uncurry, ωSup]; rw [map_comp, map_comp]; rfl
#align pi.continuous_uncurry Pi.continuous_uncurry
+-/
end Monotone
@@ -276,10 +302,12 @@ variable {f : (∀ (x) (y : β x), γ x y) →o ∀ (x) (y : β x), γ x y}
variable (hc : Continuous f)
+#print Pi.uncurry_curry_continuous /-
theorem uncurry_curry_continuous :
Continuous <| (monotoneUncurry α β γ).comp <| f.comp <| monotoneCurry α β γ :=
continuous_comp _ _ (continuous_comp _ _ (continuous_curry _ _ _) hc) (continuous_uncurry _ _ _)
#align pi.uncurry_curry_continuous Pi.uncurry_curry_continuous
+-/
end Curry
mathlib commit https://github.com/leanprover-community/mathlib/commit/cca40788df1b8755d5baf17ab2f27dacc2e17acb
@@ -67,7 +67,7 @@ variable (f : (∀ a, Part <| β a) →o ∀ a, Part <| β a)
theorem approx_mono' {i : ℕ} : Fix.approx f i ≤ Fix.approx f (succ i) :=
by
induction i; dsimp [approx]; apply @bot_le _ _ _ (f ⊥)
- intro ; apply f.monotone; apply i_ih
+ intro; apply f.monotone; apply i_ih
#align part.fix.approx_mono' Part.Fix.approx_mono'
theorem approx_mono ⦃i j : ℕ⦄ (hij : i ≤ j) : approx f i ≤ approx f j :=
@@ -83,19 +83,19 @@ theorem mem_iff (a : α) (b : β a) : b ∈ Part.fix f a ↔ ∃ i, b ∈ approx
· simp only [Part.fix_def f h₀]
constructor <;> intro hh; exact ⟨_, hh⟩
have h₁ := Nat.find_spec h₀
- rw [dom_iff_mem] at h₁
+ rw [dom_iff_mem] at h₁
cases' h₁ with y h₁
replace h₁ := approx_mono' f _ _ h₁
suffices : y = b; subst this; exact h₁
cases' hh with i hh
revert h₁; generalize succ (Nat.find h₀) = j; intro
wlog case : i ≤ j
- · cases' le_total i j with H H <;> [skip;symm] <;> apply_assumption <;> assumption
+ · cases' le_total i j with H H <;> [skip; symm] <;> apply_assumption <;> assumption
replace hh := approx_mono f case _ _ hh
apply Part.mem_unique h₁ hh
· simp only [fix_def' (⇑f) h₀, not_exists, false_iff_iff, not_mem_none]
- simp only [dom_iff_mem, not_exists] at h₀
- intro ; apply h₀
+ simp only [dom_iff_mem, not_exists] at h₀
+ intro; apply h₀
#align part.fix.mem_iff Part.Fix.mem_iff
theorem approx_le_fix (i : ℕ) : approx f i ≤ Part.fix f := fun a b hh => by rw [mem_iff f];
@@ -110,9 +110,9 @@ theorem exists_fix_le_approx (x : α) : ∃ i, Part.fix f x ≤ approx f i x :=
have hb' := approx_le_fix f i _ _ hb
obtain rfl := Part.mem_unique h' hb'
exact hb
- · simp only [not_exists] at hh; exists 0
+ · simp only [not_exists] at hh ; exists 0
intro b' h'
- simp only [mem_iff f] at h'
+ simp only [mem_iff f] at h'
cases' h' with i h'
cases hh _ _ h'
#align part.fix.exists_fix_le_approx Part.Fix.exists_fix_le_approx
@@ -231,7 +231,7 @@ variable (α β γ)
#print Pi.monotoneCurry /-
/-- `sigma.curry` as a monotone function. -/
@[simps]
-def monotoneCurry [∀ x y, Preorder <| γ x y] : (∀ x : Σa, β a, γ x.1 x.2) →o ∀ (a) (b : β a), γ a b
+def monotoneCurry [∀ x y, Preorder <| γ x y] : (∀ x : Σ a, β a, γ x.1 x.2) →o ∀ (a) (b : β a), γ a b
where
toFun := curry
monotone' x y h a b := h ⟨a, b⟩
@@ -242,7 +242,7 @@ def monotoneCurry [∀ x y, Preorder <| γ x y] : (∀ x : Σa, β a, γ x.1 x.2
/-- `sigma.uncurry` as a monotone function. -/
@[simps]
def monotoneUncurry [∀ x y, Preorder <| γ x y] :
- (∀ (a) (b : β a), γ a b) →o ∀ x : Σa, β a, γ x.1 x.2
+ (∀ (a) (b : β a), γ a b) →o ∀ x : Σ a, β a, γ x.1 x.2
where
toFun := uncurry
monotone' x y h a := h a.1 a.2
mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb
@@ -31,7 +31,7 @@ omega complete partial orders (ωCPO). Proofs of the lawfulness of all `has_fix`
universe u v
-open Classical
+open scoped Classical
variable {α : Type _} {β : α → Type _}
@@ -283,6 +283,7 @@ theorem uncurry_curry_continuous :
end Curry
+#print Pi.Pi.lawfulFix' /-
instance Pi.lawfulFix' [LawfulFix <| ∀ x : Sigma β, γ x.1 x.2] : LawfulFix (∀ x y, γ x y)
where fix_eq f hc := by
dsimp [fix]
@@ -291,6 +292,7 @@ instance Pi.lawfulFix' [LawfulFix <| ∀ x : Sigma β, γ x.1 x.2] : LawfulFix (
erw [LawfulFix.fix_eq (uncurry_curry_continuous hc)]
rfl
#align pi.pi.lawful_fix' Pi.Pi.lawfulFix'
+-/
end Pi
mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb
@@ -64,24 +64,12 @@ namespace Fix
variable (f : (∀ a, Part <| β a) →o ∀ a, Part <| β a)
-/- warning: part.fix.approx_mono' -> Part.Fix.approx_mono' is a dubious translation:
-lean 3 declaration is
- forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) {i : Nat}, LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toHasLe.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) i) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) (Nat.succ i))
-but is expected to have type
- forall {α : Type.{u2}} {β : α -> Type.{u1}} (f : OrderHom.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) {i : Nat}, LE.le.{max u2 u1} (forall (a : α), Part.{u1} (β a)) (Pi.hasLe.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => Preorder.toLE.{u1} (Part.{u1} (β i)) (PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) (Part.Fix.approx.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f) i) (Part.Fix.approx.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f) (Nat.succ i))
-Case conversion may be inaccurate. Consider using '#align part.fix.approx_mono' Part.Fix.approx_mono'ₓ'. -/
theorem approx_mono' {i : ℕ} : Fix.approx f i ≤ Fix.approx f (succ i) :=
by
induction i; dsimp [approx]; apply @bot_le _ _ _ (f ⊥)
intro ; apply f.monotone; apply i_ih
#align part.fix.approx_mono' Part.Fix.approx_mono'
-/- warning: part.fix.approx_mono -> Part.Fix.approx_mono is a dubious translation:
-lean 3 declaration is
- forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) {{i : Nat}} {{j : Nat}}, (LE.le.{0} Nat Nat.hasLe i j) -> (LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toHasLe.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) i) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) j))
-but is expected to have type
- forall {α : Type.{u2}} {β : α -> Type.{u1}} (f : OrderHom.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) {{i : Nat}} {{j : Nat}}, (LE.le.{0} Nat instLENat i j) -> (LE.le.{max u2 u1} (forall (a : α), Part.{u1} (β a)) (Pi.hasLe.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => Preorder.toLE.{u1} (Part.{u1} (β i)) (PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) (Part.Fix.approx.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f) i) (Part.Fix.approx.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f) j))
-Case conversion may be inaccurate. Consider using '#align part.fix.approx_mono Part.Fix.approx_monoₓ'. -/
theorem approx_mono ⦃i j : ℕ⦄ (hij : i ≤ j) : approx f i ≤ approx f j :=
by
induction' j with j ih; · cases hij; exact le_rfl
@@ -89,12 +77,6 @@ theorem approx_mono ⦃i j : ℕ⦄ (hij : i ≤ j) : approx f i ≤ approx f j
exact le_trans (ih ‹_›) (approx_mono' f)
#align part.fix.approx_mono Part.Fix.approx_mono
-/- warning: part.fix.mem_iff -> Part.Fix.mem_iff is a dubious translation:
-lean 3 declaration is
- forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (a : α) (b : β a), Iff (Membership.Mem.{u2, u2} (β a) (Part.{u2} (β a)) (Part.hasMem.{u2} (β a)) b (Part.fix.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) a)) (Exists.{1} Nat (fun (i : Nat) => Membership.Mem.{u2, u2} (β a) (Part.{u2} (β a)) (Part.hasMem.{u2} (β a)) b (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) i a)))
-but is expected to have type
- forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) (a : α) (b : β a), Iff (Membership.mem.{u2, u2} (β a) (Part.{u2} (β a)) (Part.instMembershipPart.{u2} (β a)) b (Part.fix.{u1, u2} α (fun (a : α) => β a) (OrderHom.toFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) f) a)) (Exists.{1} Nat (fun (i : Nat) => Membership.mem.{u2, u2} (β a) (Part.{u2} (β a)) (Part.instMembershipPart.{u2} (β a)) b (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (OrderHom.toFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) f) i a)))
-Case conversion may be inaccurate. Consider using '#align part.fix.mem_iff Part.Fix.mem_iffₓ'. -/
theorem mem_iff (a : α) (b : β a) : b ∈ Part.fix f a ↔ ∃ i, b ∈ approx f i a :=
by
by_cases h₀ : ∃ i : ℕ, (approx f i a).Dom
@@ -116,22 +98,10 @@ theorem mem_iff (a : α) (b : β a) : b ∈ Part.fix f a ↔ ∃ i, b ∈ approx
intro ; apply h₀
#align part.fix.mem_iff Part.Fix.mem_iff
-/- warning: part.fix.approx_le_fix -> Part.Fix.approx_le_fix is a dubious translation:
-lean 3 declaration is
- forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (i : Nat), LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toHasLe.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) i) (Part.fix.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f))
-but is expected to have type
- forall {α : Type.{u2}} {β : α -> Type.{u1}} (f : OrderHom.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) (i : Nat), LE.le.{max u2 u1} (forall (a : α), Part.{u1} (β a)) (Pi.hasLe.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => Preorder.toLE.{u1} (Part.{u1} (β i)) (PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) (Part.Fix.approx.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f) i) (Part.fix.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f))
-Case conversion may be inaccurate. Consider using '#align part.fix.approx_le_fix Part.Fix.approx_le_fixₓ'. -/
theorem approx_le_fix (i : ℕ) : approx f i ≤ Part.fix f := fun a b hh => by rw [mem_iff f];
exact ⟨_, hh⟩
#align part.fix.approx_le_fix Part.Fix.approx_le_fix
-/- warning: part.fix.exists_fix_le_approx -> Part.Fix.exists_fix_le_approx is a dubious translation:
-lean 3 declaration is
- forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (x : α), Exists.{1} Nat (fun (i : Nat) => LE.le.{u2} (Part.{u2} (β x)) (Preorder.toHasLe.{u2} (Part.{u2} (β x)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β x)) (Part.partialOrder.{u2} (β x)))) (Part.fix.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) x) (Part.Fix.approx.{u1, u2} α β (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) i x))
-but is expected to have type
- forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) (x : α), Exists.{1} Nat (fun (i : Nat) => LE.le.{u2} (Part.{u2} (β x)) (Preorder.toLE.{u2} (Part.{u2} (β x)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β x)) (Part.instPartialOrderPart.{u2} (β x)))) (Part.fix.{u1, u2} α (fun (a : α) => β a) (OrderHom.toFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) f) x) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (OrderHom.toFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) f) i x))
-Case conversion may be inaccurate. Consider using '#align part.fix.exists_fix_le_approx Part.Fix.exists_fix_le_approxₓ'. -/
theorem exists_fix_le_approx (x : α) : ∃ i, Part.fix f x ≤ approx f i x :=
by
by_cases hh : ∃ i b, b ∈ approx f i x
@@ -149,23 +119,11 @@ theorem exists_fix_le_approx (x : α) : ∃ i, Part.fix f x ≤ approx f i x :=
include f
-/- warning: part.fix.approx_chain -> Part.Fix.approxChain is a dubious translation:
-lean 3 declaration is
- forall {α : Type.{u1}} {β : α -> Type.{u2}}, (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) -> (OmegaCompletePartialOrder.Chain.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))))
-but is expected to have type
- forall {α : Type.{u1}} {β : α -> Type.{u2}}, (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) -> (OmegaCompletePartialOrder.Chain.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))))
-Case conversion may be inaccurate. Consider using '#align part.fix.approx_chain Part.Fix.approxChainₓ'. -/
/-- The series of approximations of `fix f` (see `approx`) as a `chain` -/
def approxChain : Chain (∀ a, Part <| β a) :=
⟨approx f, approx_mono f⟩
#align part.fix.approx_chain Part.Fix.approxChain
-/- warning: part.fix.le_f_of_mem_approx -> Part.Fix.le_f_of_mem_approx is a dubious translation:
-lean 3 declaration is
- forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) {x : forall (a : α), Part.{u2} (β a)}, (Membership.Mem.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (OmegaCompletePartialOrder.Chain.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (OmegaCompletePartialOrder.Chain.hasMem.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) x (Part.Fix.approxChain.{u1, u2} α (fun (a : α) => β a) f)) -> (LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toHasLe.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) x (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f x))
-but is expected to have type
- forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) {x : forall (a : α), Part.{u2} (β a)}, (Membership.mem.{max u1 u2, max u2 u1} (forall (a : α), Part.{u2} (β a)) (OmegaCompletePartialOrder.Chain.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) (OmegaCompletePartialOrder.Chain.instMembershipChain.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) x (Part.Fix.approxChain.{u1, u2} α (fun (a : α) => β a) f)) -> (LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toLE.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) x (OrderHom.toFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) f x))
-Case conversion may be inaccurate. Consider using '#align part.fix.le_f_of_mem_approx Part.Fix.le_f_of_mem_approxₓ'. -/
theorem le_f_of_mem_approx {x} : x ∈ approxChain f → x ≤ f x :=
by
simp only [(· ∈ ·), forall_exists_index]
@@ -173,12 +131,6 @@ theorem le_f_of_mem_approx {x} : x ∈ approxChain f → x ≤ f x :=
apply approx_mono'
#align part.fix.le_f_of_mem_approx Part.Fix.le_f_of_mem_approx
-/- warning: part.fix.approx_mem_approx_chain -> Part.Fix.approx_mem_approxChain is a dubious translation:
-lean 3 declaration is
- forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) {i : Nat}, Membership.Mem.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (OmegaCompletePartialOrder.Chain.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (OmegaCompletePartialOrder.Chain.hasMem.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) i) (Part.Fix.approxChain.{u1, u2} α (fun (a : α) => β a) f)
-but is expected to have type
- forall {α : Type.{u2}} {β : α -> Type.{u1}} (f : OrderHom.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) {i : Nat}, Membership.mem.{max u2 u1, max u1 u2} (forall (a : α), Part.{u1} (β a)) (OmegaCompletePartialOrder.Chain.{max u2 u1} (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) (OmegaCompletePartialOrder.Chain.instMembershipChain.{max u2 u1} (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) (Part.Fix.approx.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f) i) (Part.Fix.approxChain.{u2, u1} α (fun (a : α) => β a) f)
-Case conversion may be inaccurate. Consider using '#align part.fix.approx_mem_approx_chain Part.Fix.approx_mem_approxChainₓ'. -/
theorem approx_mem_approxChain {i} : approx f i ∈ approxChain f :=
Stream'.mem_of_nth_eq rfl
#align part.fix.approx_mem_approx_chain Part.Fix.approx_mem_approxChain
@@ -199,12 +151,6 @@ open Nat
open Nat.Upto OmegaCompletePartialOrder
-/- warning: part.fix_eq_ωSup -> Part.fix_eq_ωSup is a dubious translation:
-lean 3 declaration is
- forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))), Eq.{max (succ u1) (succ u2)} (forall (x : α), Part.{u2} (β x)) (Part.fix.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f)) (OmegaCompletePartialOrder.ωSup.{max u1 u2} (forall (x : α), Part.{u2} (β x)) (Pi.omegaCompletePartialOrder.{u1, u2} α (fun (x : α) => Part.{u2} (β x)) (fun (a : α) => Part.omegaCompletePartialOrder.{u2} (β a))) (Part.Fix.approxChain.{u1, u2} α (fun (x : α) => β x) f))
-but is expected to have type
- forall {α : Type.{u2}} {β : α -> Type.{u1}} (f : OrderHom.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))), Eq.{max (succ u2) (succ u1)} (forall (x : α), Part.{u1} (β x)) (Part.fix.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f)) (OmegaCompletePartialOrder.ωSup.{max u1 u2} (forall (x : α), Part.{u1} (β x)) (Pi.instOmegaCompletePartialOrderForAll.{u2, u1} α (fun (x : α) => Part.{u1} (β x)) (fun (a : α) => Part.omegaCompletePartialOrder.{u1} (β a))) (Part.Fix.approxChain.{u2, u1} α (fun (x : α) => β x) f))
-Case conversion may be inaccurate. Consider using '#align part.fix_eq_ωSup Part.fix_eq_ωSupₓ'. -/
theorem fix_eq_ωSup : Part.fix f = ωSup (approxChain f) :=
by
apply le_antisymm
@@ -218,12 +164,6 @@ theorem fix_eq_ωSup : Part.fix f = ωSup (approxChain f) :=
intro y x; apply approx_le_fix f
#align part.fix_eq_ωSup Part.fix_eq_ωSup
-/- warning: part.fix_le -> Part.fix_le is a dubious translation:
-lean 3 declaration is
- forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) {X : forall (a : α), Part.{u2} (β a)}, (LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toHasLe.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f X) X) -> (LE.le.{max u1 u2} (forall (x : α), Part.{u2} (β x)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toHasLe.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (Part.fix.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f)) X)
-but is expected to have type
- forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) {X : forall (a : α), Part.{u2} (β a)}, (LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toLE.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) (OrderHom.toFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) f X) X) -> (LE.le.{max u1 u2} (forall (x : α), Part.{u2} (β x)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toLE.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) (Part.fix.{u1, u2} α (fun (a : α) => β a) (OrderHom.toFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) f)) X)
-Case conversion may be inaccurate. Consider using '#align part.fix_le Part.fix_leₓ'. -/
theorem fix_le {X : ∀ a, Part <| β a} (hX : f X ≤ X) : Part.fix f ≤ X :=
by
rw [fix_eq_ωSup f]
@@ -239,12 +179,6 @@ variable {f} (hc : Continuous f)
include hc
-/- warning: part.fix_eq -> Part.fix_eq is a dubious translation:
-lean 3 declaration is
- forall {α : Type.{u1}} {β : α -> Type.{u2}} {f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))}, (OmegaCompletePartialOrder.Continuous.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.omegaCompletePartialOrder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (a : α) => Part.omegaCompletePartialOrder.{u2} (β a))) (Pi.omegaCompletePartialOrder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (a : α) => Part.omegaCompletePartialOrder.{u2} (β a))) f) -> (Eq.{max (succ u1) (succ u2)} (forall (x : α), Part.{u2} (β x)) (Part.fix.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f)) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f (Part.fix.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f))))
-but is expected to have type
- forall {α : Type.{u2}} {β : α -> Type.{u1}} {f : OrderHom.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))}, (OmegaCompletePartialOrder.Continuous.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.instOmegaCompletePartialOrderForAll.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (a : α) => Part.omegaCompletePartialOrder.{u1} (β a))) (Pi.instOmegaCompletePartialOrderForAll.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (a : α) => Part.omegaCompletePartialOrder.{u1} (β a))) f) -> (Eq.{max (succ u2) (succ u1)} (forall (x : α), Part.{u1} (β x)) (Part.fix.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f)) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f (Part.fix.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f))))
-Case conversion may be inaccurate. Consider using '#align part.fix_eq Part.fix_eqₓ'. -/
theorem fix_eq : Part.fix f = f (Part.fix f) :=
by
rw [fix_eq_ωSup f, hc]
@@ -261,12 +195,6 @@ end Part
namespace Part
-/- warning: part.to_unit_mono -> Part.toUnitMono is a dubious translation:
-lean 3 declaration is
- forall {α : Type.{u1}}, (OrderHom.{u1, u1} (Part.{u1} α) (Part.{u1} α) (PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.partialOrder.{u1} α)) (PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.partialOrder.{u1} α))) -> (OrderHom.{u1, u1} (Unit -> (Part.{u1} α)) (Unit -> (Part.{u1} α)) (Pi.preorder.{0, u1} Unit (fun (ᾰ : Unit) => Part.{u1} α) (fun (i : Unit) => PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.partialOrder.{u1} α))) (Pi.preorder.{0, u1} Unit (fun (ᾰ : Unit) => Part.{u1} α) (fun (i : Unit) => PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.partialOrder.{u1} α))))
-but is expected to have type
- forall {α : Type.{u1}}, (OrderHom.{u1, u1} (Part.{u1} α) (Part.{u1} α) (PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.instPartialOrderPart.{u1} α)) (PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.instPartialOrderPart.{u1} α))) -> (OrderHom.{u1, u1} (Unit -> (Part.{u1} α)) (Unit -> (Part.{u1} α)) (Pi.preorder.{0, u1} Unit (fun (ᾰ : Unit) => Part.{u1} α) (fun (i : Unit) => PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.instPartialOrderPart.{u1} α))) (Pi.preorder.{0, u1} Unit (fun (ᾰ : Unit) => Part.{u1} α) (fun (i : Unit) => PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.instPartialOrderPart.{u1} α))))
-Case conversion may be inaccurate. Consider using '#align part.to_unit_mono Part.toUnitMonoₓ'. -/
/-- `to_unit` as a monotone function -/
@[simps]
def toUnitMono (f : Part α →o Part α) : (Unit → Part α) →o Unit → Part α
@@ -275,12 +203,6 @@ def toUnitMono (f : Part α →o Part α) : (Unit → Part α) →o Unit → Par
monotone' x y (h : x ≤ y) u := f.Monotone <| h u
#align part.to_unit_mono Part.toUnitMono
-/- warning: part.to_unit_cont -> Part.to_unit_cont is a dubious translation:
-lean 3 declaration is
- forall {α : Type.{u1}} (f : OrderHom.{u1, u1} (Part.{u1} α) (Part.{u1} α) (PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.partialOrder.{u1} α)) (PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.partialOrder.{u1} α))), (OmegaCompletePartialOrder.Continuous.{u1, u1} (Part.{u1} α) (Part.{u1} α) (Part.omegaCompletePartialOrder.{u1} α) (Part.omegaCompletePartialOrder.{u1} α) f) -> (OmegaCompletePartialOrder.Continuous.{u1, u1} (Unit -> (Part.{u1} α)) (Unit -> (Part.{u1} α)) (Pi.omegaCompletePartialOrder.{0, u1} Unit (fun (ᾰ : Unit) => Part.{u1} α) (fun (a : Unit) => Part.omegaCompletePartialOrder.{u1} α)) (Pi.omegaCompletePartialOrder.{0, u1} Unit (fun (ᾰ : Unit) => Part.{u1} α) (fun (a : Unit) => Part.omegaCompletePartialOrder.{u1} α)) (Part.toUnitMono.{u1} α f))
-but is expected to have type
- forall {α : Type.{u1}} (f : OrderHom.{u1, u1} (Part.{u1} α) (Part.{u1} α) (PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.instPartialOrderPart.{u1} α)) (PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.instPartialOrderPart.{u1} α))), (OmegaCompletePartialOrder.Continuous.{u1, u1} (Part.{u1} α) (Part.{u1} α) (Part.omegaCompletePartialOrder.{u1} α) (Part.omegaCompletePartialOrder.{u1} α) f) -> (OmegaCompletePartialOrder.Continuous.{u1, u1} (Unit -> (Part.{u1} α)) (Unit -> (Part.{u1} α)) (Pi.instOmegaCompletePartialOrderForAll.{0, u1} Unit (fun (ᾰ : Unit) => Part.{u1} α) (fun (a : Unit) => Part.omegaCompletePartialOrder.{u1} α)) (Pi.instOmegaCompletePartialOrderForAll.{0, u1} Unit (fun (ᾰ : Unit) => Part.{u1} α) (fun (a : Unit) => Part.omegaCompletePartialOrder.{u1} α)) (Part.toUnitMono.{u1} α f))
-Case conversion may be inaccurate. Consider using '#align part.to_unit_cont Part.to_unit_contₓ'. -/
theorem to_unit_cont (f : Part α →o Part α) (hc : Continuous f) : Continuous (toUnitMono f)
| c => by
ext ⟨⟩ : 1
@@ -331,22 +253,10 @@ variable [∀ x y, OmegaCompletePartialOrder <| γ x y]
open OmegaCompletePartialOrder.Chain
-/- warning: pi.continuous_curry -> Pi.continuous_curry is a dubious translation:
-lean 3 declaration is
- forall (α : Type.{u1}) (β : α -> Type.{u2}) (γ : forall (a : α), (β a) -> Type.{u3}) [_inst_1 : forall (x : α) (y : β x), OmegaCompletePartialOrder.{u3} (γ x y)], OmegaCompletePartialOrder.Continuous.{max (max u1 u2) u3, max u1 u2 u3} (forall (x : Sigma.{u1, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (forall (a : α) (b : β a), γ a b) (Pi.omegaCompletePartialOrder.{max u1 u2, u3} (Sigma.{u1, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u1, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u1, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u1, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) a))) (Pi.omegaCompletePartialOrder.{u1, max u2 u3} α (fun (a : α) => forall (b : β a), γ a b) (fun (a : α) => Pi.omegaCompletePartialOrder.{u2, u3} (β a) (fun (b : β a) => γ a b) (fun (a_1 : β a) => _inst_1 a a_1))) (Pi.monotoneCurry.{u1, u2, u3} α β γ (fun (x : α) (y : β x) => PartialOrder.toPreorder.{u3} (γ x y) (OmegaCompletePartialOrder.toPartialOrder.{u3} (γ x y) (_inst_1 x y))))
-but is expected to have type
- forall (α : Type.{u3}) (β : α -> Type.{u2}) (γ : forall (a : α), (β a) -> Type.{u1}) [_inst_1 : forall (x : α) (y : β x), OmegaCompletePartialOrder.{u1} (γ x y)], OmegaCompletePartialOrder.Continuous.{max (max u3 u2) u1, max (max u3 u2) u1} (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (forall (a : α) (b : β a), γ a b) (Pi.instOmegaCompletePartialOrderForAll.{max u3 u2, u1} (Sigma.{u3, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u3, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u3, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u3, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) a))) (Pi.instOmegaCompletePartialOrderForAll.{u3, max u2 u1} α (fun (a : α) => forall (b : β a), γ a b) (fun (a : α) => Pi.instOmegaCompletePartialOrderForAll.{u2, u1} (β a) (fun (b : β a) => γ a b) (fun (a_1 : β a) => _inst_1 a a_1))) (Pi.monotoneCurry.{u3, u2, u1} α β γ (fun (x : α) (y : β x) => PartialOrder.toPreorder.{u1} (γ x y) (OmegaCompletePartialOrder.toPartialOrder.{u1} (γ x y) (_inst_1 x y))))
-Case conversion may be inaccurate. Consider using '#align pi.continuous_curry Pi.continuous_curryₓ'. -/
theorem continuous_curry : Continuous <| monotoneCurry α β γ := fun c => by ext (x y);
dsimp [curry, ωSup]; rw [map_comp, map_comp]; rfl
#align pi.continuous_curry Pi.continuous_curry
-/- warning: pi.continuous_uncurry -> Pi.continuous_uncurry is a dubious translation:
-lean 3 declaration is
- forall (α : Type.{u1}) (β : α -> Type.{u2}) (γ : forall (a : α), (β a) -> Type.{u3}) [_inst_1 : forall (x : α) (y : β x), OmegaCompletePartialOrder.{u3} (γ x y)], OmegaCompletePartialOrder.Continuous.{max u1 u2 u3, max (max u1 u2) u3} (forall (a : α) (b : β a), γ a b) (forall (x : Sigma.{u1, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (Pi.omegaCompletePartialOrder.{u1, max u2 u3} α (fun (a : α) => forall (b : β a), γ a b) (fun (a : α) => Pi.omegaCompletePartialOrder.{u2, u3} (β a) (fun (b : β a) => γ a b) (fun (a_1 : β a) => _inst_1 a a_1))) (Pi.omegaCompletePartialOrder.{max u1 u2, u3} (Sigma.{u1, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u1, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u1, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u1, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) a))) (Pi.monotoneUncurry.{u1, u2, u3} α β γ (fun (x : α) (y : β x) => PartialOrder.toPreorder.{u3} (γ x y) (OmegaCompletePartialOrder.toPartialOrder.{u3} (γ x y) (_inst_1 x y))))
-but is expected to have type
- forall (α : Type.{u3}) (β : α -> Type.{u2}) (γ : forall (a : α), (β a) -> Type.{u1}) [_inst_1 : forall (x : α) (y : β x), OmegaCompletePartialOrder.{u1} (γ x y)], OmegaCompletePartialOrder.Continuous.{max (max u3 u2) u1, max (max u3 u2) u1} (forall (a : α) (b : β a), γ a b) (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (Pi.instOmegaCompletePartialOrderForAll.{u3, max u2 u1} α (fun (a : α) => forall (b : β a), γ a b) (fun (a : α) => Pi.instOmegaCompletePartialOrderForAll.{u2, u1} (β a) (fun (b : β a) => γ a b) (fun (a_1 : β a) => _inst_1 a a_1))) (Pi.instOmegaCompletePartialOrderForAll.{max u3 u2, u1} (Sigma.{u3, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u3, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u3, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u3, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) a))) (Pi.monotoneUncurry.{u3, u2, u1} α β γ (fun (x : α) (y : β x) => PartialOrder.toPreorder.{u1} (γ x y) (OmegaCompletePartialOrder.toPartialOrder.{u1} (γ x y) (_inst_1 x y))))
-Case conversion may be inaccurate. Consider using '#align pi.continuous_uncurry Pi.continuous_uncurryₓ'. -/
theorem continuous_uncurry : Continuous <| monotoneUncurry α β γ := fun c => by ext (x y);
dsimp [uncurry, ωSup]; rw [map_comp, map_comp]; rfl
#align pi.continuous_uncurry Pi.continuous_uncurry
@@ -366,9 +276,6 @@ variable {f : (∀ (x) (y : β x), γ x y) →o ∀ (x) (y : β x), γ x y}
variable (hc : Continuous f)
-/- warning: pi.uncurry_curry_continuous -> Pi.uncurry_curry_continuous is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align pi.uncurry_curry_continuous Pi.uncurry_curry_continuousₓ'. -/
theorem uncurry_curry_continuous :
Continuous <| (monotoneUncurry α β γ).comp <| f.comp <| monotoneCurry α β γ :=
continuous_comp _ _ (continuous_comp _ _ (continuous_curry _ _ _) hc) (continuous_uncurry _ _ _)
@@ -376,12 +283,6 @@ theorem uncurry_curry_continuous :
end Curry
-/- warning: pi.pi.lawful_fix' -> Pi.Pi.lawfulFix' is a dubious translation:
-lean 3 declaration is
- forall {α : Type.{u1}} {β : α -> Type.{u2}} {γ : forall (a : α), (β a) -> Type.{u3}} [_inst_1 : forall (x : α) (y : β x), OmegaCompletePartialOrder.{u3} (γ x y)] [_inst_2 : LawfulFix.{max (max u1 u2) u3} (forall (x : Sigma.{u1, u2} α β), γ (Sigma.fst.{u1, u2} α β x) (Sigma.snd.{u1, u2} α β x)) (Pi.omegaCompletePartialOrder.{max u1 u2, u3} (Sigma.{u1, u2} α β) (fun (x : Sigma.{u1, u2} α β) => γ (Sigma.fst.{u1, u2} α β x) (Sigma.snd.{u1, u2} α β x)) (fun (a : Sigma.{u1, u2} α β) => _inst_1 (Sigma.fst.{u1, u2} α β a) (Sigma.snd.{u1, u2} α β a)))], LawfulFix.{max u1 u2 u3} (forall (x : α) (y : β x), γ x y) (Pi.omegaCompletePartialOrder.{u1, max u2 u3} α (fun (x : α) => forall (y : β x), γ x y) (fun (a : α) => Pi.omegaCompletePartialOrder.{u2, u3} (β a) (fun (y : β a) => γ a y) (fun (a_1 : β a) => _inst_1 a a_1)))
-but is expected to have type
- forall {α : Type.{u1}} {β : α -> Type.{u2}} {γ : forall (a : α), (β a) -> Type.{u3}} [_inst_1 : forall (x : α) (y : β x), OmegaCompletePartialOrder.{u3} (γ x y)] [_inst_2 : LawfulFix.{max (max u1 u2) u3} (forall (x : Sigma.{u1, u2} α β), γ (Sigma.fst.{u1, u2} α β x) (Sigma.snd.{u1, u2} α β x)) (Pi.instOmegaCompletePartialOrderForAll.{max u1 u2, u3} (Sigma.{u1, u2} α β) (fun (x : Sigma.{u1, u2} α β) => γ (Sigma.fst.{u1, u2} α β x) (Sigma.snd.{u1, u2} α β x)) (fun (a : Sigma.{u1, u2} α β) => _inst_1 (Sigma.fst.{u1, u2} α β a) (Sigma.snd.{u1, u2} α β a)))], LawfulFix.{max (max u1 u2) u3} (forall (x : α) (y : β x), γ x y) (Pi.instOmegaCompletePartialOrderForAll.{u1, max u2 u3} α (fun (x : α) => forall (y : β x), γ x y) (fun (a : α) => Pi.instOmegaCompletePartialOrderForAll.{u2, u3} (β a) (fun (y : β a) => γ a y) (fun (a_1 : β a) => _inst_1 a a_1)))
-Case conversion may be inaccurate. Consider using '#align pi.pi.lawful_fix' Pi.Pi.lawfulFix'ₓ'. -/
instance Pi.lawfulFix' [LawfulFix <| ∀ x : Sigma β, γ x.1 x.2] : LawfulFix (∀ x y, γ x y)
where fix_eq f hc := by
dsimp [fix]
mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb
@@ -84,9 +84,7 @@ but is expected to have type
Case conversion may be inaccurate. Consider using '#align part.fix.approx_mono Part.Fix.approx_monoₓ'. -/
theorem approx_mono ⦃i j : ℕ⦄ (hij : i ≤ j) : approx f i ≤ approx f j :=
by
- induction' j with j ih;
- · cases hij
- exact le_rfl
+ induction' j with j ih; · cases hij; exact le_rfl
cases hij; · exact le_rfl
exact le_trans (ih ‹_›) (approx_mono' f)
#align part.fix.approx_mono Part.Fix.approx_mono
@@ -101,27 +99,21 @@ theorem mem_iff (a : α) (b : β a) : b ∈ Part.fix f a ↔ ∃ i, b ∈ approx
by
by_cases h₀ : ∃ i : ℕ, (approx f i a).Dom
· simp only [Part.fix_def f h₀]
- constructor <;> intro hh
- exact ⟨_, hh⟩
+ constructor <;> intro hh; exact ⟨_, hh⟩
have h₁ := Nat.find_spec h₀
rw [dom_iff_mem] at h₁
cases' h₁ with y h₁
replace h₁ := approx_mono' f _ _ h₁
- suffices : y = b
- subst this
- exact h₁
+ suffices : y = b; subst this; exact h₁
cases' hh with i hh
- revert h₁
- generalize succ (Nat.find h₀) = j
- intro
+ revert h₁; generalize succ (Nat.find h₀) = j; intro
wlog case : i ≤ j
· cases' le_total i j with H H <;> [skip;symm] <;> apply_assumption <;> assumption
replace hh := approx_mono f case _ _ hh
apply Part.mem_unique h₁ hh
· simp only [fix_def' (⇑f) h₀, not_exists, false_iff_iff, not_mem_none]
simp only [dom_iff_mem, not_exists] at h₀
- intro
- apply h₀
+ intro ; apply h₀
#align part.fix.mem_iff Part.Fix.mem_iff
/- warning: part.fix.approx_le_fix -> Part.Fix.approx_le_fix is a dubious translation:
@@ -130,9 +122,7 @@ lean 3 declaration is
but is expected to have type
forall {α : Type.{u2}} {β : α -> Type.{u1}} (f : OrderHom.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) (i : Nat), LE.le.{max u2 u1} (forall (a : α), Part.{u1} (β a)) (Pi.hasLe.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => Preorder.toLE.{u1} (Part.{u1} (β i)) (PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) (Part.Fix.approx.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f) i) (Part.fix.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f))
Case conversion may be inaccurate. Consider using '#align part.fix.approx_le_fix Part.Fix.approx_le_fixₓ'. -/
-theorem approx_le_fix (i : ℕ) : approx f i ≤ Part.fix f := fun a b hh =>
- by
- rw [mem_iff f]
+theorem approx_le_fix (i : ℕ) : approx f i ≤ Part.fix f := fun a b hh => by rw [mem_iff f];
exact ⟨_, hh⟩
#align part.fix.approx_le_fix Part.Fix.approx_le_fix
@@ -145,14 +135,12 @@ Case conversion may be inaccurate. Consider using '#align part.fix.exists_fix_le
theorem exists_fix_le_approx (x : α) : ∃ i, Part.fix f x ≤ approx f i x :=
by
by_cases hh : ∃ i b, b ∈ approx f i x
- · rcases hh with ⟨i, b, hb⟩
- exists i
+ · rcases hh with ⟨i, b, hb⟩; exists i
intro b' h'
have hb' := approx_le_fix f i _ _ hb
obtain rfl := Part.mem_unique h' hb'
exact hb
- · simp only [not_exists] at hh
- exists 0
+ · simp only [not_exists] at hh; exists 0
intro b' h'
simp only [mem_iff f] at h'
cases' h' with i h'
@@ -220,19 +208,14 @@ Case conversion may be inaccurate. Consider using '#align part.fix_eq_ωSup Part
theorem fix_eq_ωSup : Part.fix f = ωSup (approxChain f) :=
by
apply le_antisymm
- · intro x
- cases' exists_fix_le_approx f x with i hx
+ · intro x; cases' exists_fix_le_approx f x with i hx
trans approx f i.succ x
- · trans
- apply hx
- apply approx_mono' f
+ · trans; apply hx; apply approx_mono' f
apply le_ωSup_of_le i.succ
- dsimp [approx]
- rfl
+ dsimp [approx]; rfl
· apply ωSup_le _ _ _
simp only [fix.approx_chain, OrderHom.coe_fun_mk]
- intro y x
- apply approx_le_fix f
+ intro y x; apply approx_le_fix f
#align part.fix_eq_ωSup Part.fix_eq_ωSup
/- warning: part.fix_le -> Part.fix_le is a dubious translation:
@@ -267,15 +250,11 @@ theorem fix_eq : Part.fix f = f (Part.fix f) :=
rw [fix_eq_ωSup f, hc]
apply le_antisymm
· apply ωSup_le_ωSup_of_le _
- intro i
- exists i
- intro x
+ intro i; exists i; intro x
-- intros x y hx,
apply le_f_of_mem_approx _ ⟨i, rfl⟩
· apply ωSup_le_ωSup_of_le _
- intro i
- exists i.succ
- rfl
+ intro i; exists i.succ; rfl
#align part.fix_eq Part.fix_eq
end Part
@@ -358,12 +337,8 @@ lean 3 declaration is
but is expected to have type
forall (α : Type.{u3}) (β : α -> Type.{u2}) (γ : forall (a : α), (β a) -> Type.{u1}) [_inst_1 : forall (x : α) (y : β x), OmegaCompletePartialOrder.{u1} (γ x y)], OmegaCompletePartialOrder.Continuous.{max (max u3 u2) u1, max (max u3 u2) u1} (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (forall (a : α) (b : β a), γ a b) (Pi.instOmegaCompletePartialOrderForAll.{max u3 u2, u1} (Sigma.{u3, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u3, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u3, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u3, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) a))) (Pi.instOmegaCompletePartialOrderForAll.{u3, max u2 u1} α (fun (a : α) => forall (b : β a), γ a b) (fun (a : α) => Pi.instOmegaCompletePartialOrderForAll.{u2, u1} (β a) (fun (b : β a) => γ a b) (fun (a_1 : β a) => _inst_1 a a_1))) (Pi.monotoneCurry.{u3, u2, u1} α β γ (fun (x : α) (y : β x) => PartialOrder.toPreorder.{u1} (γ x y) (OmegaCompletePartialOrder.toPartialOrder.{u1} (γ x y) (_inst_1 x y))))
Case conversion may be inaccurate. Consider using '#align pi.continuous_curry Pi.continuous_curryₓ'. -/
-theorem continuous_curry : Continuous <| monotoneCurry α β γ := fun c =>
- by
- ext (x y)
- dsimp [curry, ωSup]
- rw [map_comp, map_comp]
- rfl
+theorem continuous_curry : Continuous <| monotoneCurry α β γ := fun c => by ext (x y);
+ dsimp [curry, ωSup]; rw [map_comp, map_comp]; rfl
#align pi.continuous_curry Pi.continuous_curry
/- warning: pi.continuous_uncurry -> Pi.continuous_uncurry is a dubious translation:
@@ -372,12 +347,8 @@ lean 3 declaration is
but is expected to have type
forall (α : Type.{u3}) (β : α -> Type.{u2}) (γ : forall (a : α), (β a) -> Type.{u1}) [_inst_1 : forall (x : α) (y : β x), OmegaCompletePartialOrder.{u1} (γ x y)], OmegaCompletePartialOrder.Continuous.{max (max u3 u2) u1, max (max u3 u2) u1} (forall (a : α) (b : β a), γ a b) (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (Pi.instOmegaCompletePartialOrderForAll.{u3, max u2 u1} α (fun (a : α) => forall (b : β a), γ a b) (fun (a : α) => Pi.instOmegaCompletePartialOrderForAll.{u2, u1} (β a) (fun (b : β a) => γ a b) (fun (a_1 : β a) => _inst_1 a a_1))) (Pi.instOmegaCompletePartialOrderForAll.{max u3 u2, u1} (Sigma.{u3, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u3, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u3, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u3, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) a))) (Pi.monotoneUncurry.{u3, u2, u1} α β γ (fun (x : α) (y : β x) => PartialOrder.toPreorder.{u1} (γ x y) (OmegaCompletePartialOrder.toPartialOrder.{u1} (γ x y) (_inst_1 x y))))
Case conversion may be inaccurate. Consider using '#align pi.continuous_uncurry Pi.continuous_uncurryₓ'. -/
-theorem continuous_uncurry : Continuous <| monotoneUncurry α β γ := fun c =>
- by
- ext (x y)
- dsimp [uncurry, ωSup]
- rw [map_comp, map_comp]
- rfl
+theorem continuous_uncurry : Continuous <| monotoneUncurry α β γ := fun c => by ext (x y);
+ dsimp [uncurry, ωSup]; rw [map_comp, map_comp]; rfl
#align pi.continuous_uncurry Pi.continuous_uncurry
end Monotone
mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb
@@ -396,10 +396,7 @@ variable {f : (∀ (x) (y : β x), γ x y) →o ∀ (x) (y : β x), γ x y}
variable (hc : Continuous f)
/- warning: pi.uncurry_curry_continuous -> Pi.uncurry_curry_continuous is a dubious translation:
-lean 3 declaration is
- forall {α : Type.{u1}} {β : α -> Type.{u2}} {γ : forall (a : α), (β a) -> Type.{u3}} [_inst_1 : forall (x : α) (y : β x), OmegaCompletePartialOrder.{u3} (γ x y)] {f : OrderHom.{max u1 u2 u3, max u1 u2 u3} (forall (x : α) (y : β x), γ x y) (forall (x : α) (y : β x), γ x y) (Pi.preorder.{u1, max u2 u3} α (fun (x : α) => forall (y : β x), γ x y) (fun (i : α) => Pi.preorder.{u2, u3} (β i) (fun (y : β i) => γ i y) (fun (i_1 : β i) => PartialOrder.toPreorder.{u3} (γ i i_1) (OmegaCompletePartialOrder.toPartialOrder.{u3} (γ i i_1) (_inst_1 i i_1))))) (Pi.preorder.{u1, max u2 u3} α (fun (x : α) => forall (y : β x), γ x y) (fun (i : α) => Pi.preorder.{u2, u3} (β i) (fun (y : β i) => γ i y) (fun (i_1 : β i) => PartialOrder.toPreorder.{u3} (γ i i_1) (OmegaCompletePartialOrder.toPartialOrder.{u3} (γ i i_1) (_inst_1 i i_1)))))}, (OmegaCompletePartialOrder.Continuous.{max u1 u2 u3, max u1 u2 u3} (forall (x : α) (y : β x), γ x y) (forall (x : α) (y : β x), γ x y) (Pi.omegaCompletePartialOrder.{u1, max u2 u3} α (fun (x : α) => forall (y : β x), γ x y) (fun (a : α) => Pi.omegaCompletePartialOrder.{u2, u3} (β a) (fun (y : β a) => γ a y) (fun (a_1 : β a) => _inst_1 a a_1))) (Pi.omegaCompletePartialOrder.{u1, max u2 u3} α (fun (x : α) => forall (y : β x), γ x y) (fun (a : α) => Pi.omegaCompletePartialOrder.{u2, u3} (β a) (fun (y : β a) => γ a y) (fun (a_1 : β a) => _inst_1 a a_1))) f) -> (OmegaCompletePartialOrder.Continuous.{max (max u1 u2) u3, max (max u1 u2) u3} (forall (x : Sigma.{u1, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (forall (x : Sigma.{u1, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (Pi.omegaCompletePartialOrder.{max u1 u2, u3} (Sigma.{u1, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u1, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u1, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u1, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) a))) (Pi.omegaCompletePartialOrder.{max u1 u2, u3} (Sigma.{u1, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u1, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u1, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u1, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) a))) (OrderHom.comp.{max (max u1 u2) u3, max u1 u2 u3, max (max u1 u2) u3} (forall (x : Sigma.{u1, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (forall (a : α) (b : β a), γ a b) (forall (x : Sigma.{u1, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (PartialOrder.toPreorder.{max (max u1 u2) u3} (forall (x : Sigma.{u1, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (OmegaCompletePartialOrder.toPartialOrder.{max (max u1 u2) u3} (forall (x : Sigma.{u1, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (Pi.omegaCompletePartialOrder.{max u1 u2, u3} (Sigma.{u1, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u1, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u1, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u1, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) a))))) (Pi.preorder.{u1, max u2 u3} α (fun (a : α) => forall (b : β a), γ a b) (fun (i : α) => Pi.preorder.{u2, u3} (β i) (fun (b : β i) => γ i b) (fun (i_1 : β i) => (fun (x : α) (y : β x) => PartialOrder.toPreorder.{u3} (γ x y) (OmegaCompletePartialOrder.toPartialOrder.{u3} (γ x y) (_inst_1 x y))) i i_1))) (Pi.preorder.{max u1 u2, u3} (Sigma.{u1, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u1, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (fun (i : Sigma.{u1, u2} α (fun (a : α) => β a)) => (fun (x : α) (y : β x) => PartialOrder.toPreorder.{u3} (γ x y) (OmegaCompletePartialOrder.toPartialOrder.{u3} (γ x y) (_inst_1 x y))) (Sigma.fst.{u1, u2} α (fun (a : α) => β a) i) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) i))) (Pi.monotoneUncurry.{u1, u2, u3} α β γ (fun (x : α) (y : β x) => PartialOrder.toPreorder.{u3} (γ x y) (OmegaCompletePartialOrder.toPartialOrder.{u3} (γ x y) (_inst_1 x y)))) (OrderHom.comp.{max (max u1 u2) u3, max u1 u2 u3, max u1 u2 u3} (forall (x : Sigma.{u1, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (forall (x : α) (y : β x), γ x y) (forall (x : α) (y : β x), γ x y) (PartialOrder.toPreorder.{max (max u1 u2) u3} (forall (x : Sigma.{u1, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (OmegaCompletePartialOrder.toPartialOrder.{max (max u1 u2) u3} (forall (x : Sigma.{u1, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (Pi.omegaCompletePartialOrder.{max u1 u2, u3} (Sigma.{u1, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u1, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u1, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u1, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) a))))) (Pi.preorder.{u1, max u2 u3} α (fun (x : α) => forall (y : β x), γ x y) (fun (i : α) => Pi.preorder.{u2, u3} (β i) (fun (y : β i) => γ i y) (fun (i_1 : β i) => PartialOrder.toPreorder.{u3} (γ i i_1) (OmegaCompletePartialOrder.toPartialOrder.{u3} (γ i i_1) (_inst_1 i i_1))))) (Pi.preorder.{u1, max u2 u3} α (fun (x : α) => forall (y : β x), γ x y) (fun (i : α) => Pi.preorder.{u2, u3} (β i) (fun (y : β i) => γ i y) (fun (i_1 : β i) => PartialOrder.toPreorder.{u3} (γ i i_1) (OmegaCompletePartialOrder.toPartialOrder.{u3} (γ i i_1) (_inst_1 i i_1))))) f (Pi.monotoneCurry.{u1, u2, u3} α β γ (fun (x : α) (y : β x) => PartialOrder.toPreorder.{u3} (γ x y) (OmegaCompletePartialOrder.toPartialOrder.{u3} (γ x y) (_inst_1 x y)))))))
-but is expected to have type
- forall {α : Type.{u3}} {β : α -> Type.{u2}} {γ : forall (a : α), (β a) -> Type.{u1}} [_inst_1 : forall (x : α) (y : β x), OmegaCompletePartialOrder.{u1} (γ x y)] {f : OrderHom.{max (max u3 u2) u1, max (max u3 u2) u1} (forall (x : α) (y : β x), γ x y) (forall (x : α) (y : β x), γ x y) (Pi.preorder.{u3, max u2 u1} α (fun (x : α) => forall (y : β x), γ x y) (fun (i : α) => Pi.preorder.{u2, u1} (β i) (fun (y : β i) => γ i y) (fun (i_1 : β i) => PartialOrder.toPreorder.{u1} (γ i i_1) (OmegaCompletePartialOrder.toPartialOrder.{u1} (γ i i_1) (_inst_1 i i_1))))) (Pi.preorder.{u3, max u2 u1} α (fun (x : α) => forall (y : β x), γ x y) (fun (i : α) => Pi.preorder.{u2, u1} (β i) (fun (y : β i) => γ i y) (fun (i_1 : β i) => PartialOrder.toPreorder.{u1} (γ i i_1) (OmegaCompletePartialOrder.toPartialOrder.{u1} (γ i i_1) (_inst_1 i i_1)))))}, (OmegaCompletePartialOrder.Continuous.{max (max u3 u2) u1, max (max u3 u2) u1} (forall (x : α) (y : β x), γ x y) (forall (x : α) (y : β x), γ x y) (Pi.instOmegaCompletePartialOrderForAll.{u3, max u2 u1} α (fun (x : α) => forall (y : β x), γ x y) (fun (a : α) => Pi.instOmegaCompletePartialOrderForAll.{u2, u1} (β a) (fun (y : β a) => γ a y) (fun (a_1 : β a) => _inst_1 a a_1))) (Pi.instOmegaCompletePartialOrderForAll.{u3, max u2 u1} α (fun (x : α) => forall (y : β x), γ x y) (fun (a : α) => Pi.instOmegaCompletePartialOrderForAll.{u2, u1} (β a) (fun (y : β a) => γ a y) (fun (a_1 : β a) => _inst_1 a a_1))) f) -> (OmegaCompletePartialOrder.Continuous.{max (max u3 u2) u1, max (max u3 u2) u1} (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (Pi.instOmegaCompletePartialOrderForAll.{max u3 u2, u1} (Sigma.{u3, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u3, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u3, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u3, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) a))) (Pi.instOmegaCompletePartialOrderForAll.{max u3 u2, u1} (Sigma.{u3, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u3, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u3, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u3, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) a))) (OrderHom.comp.{max (max u3 u2) u1, max (max u3 u2) u1, max (max u3 u2) u1} (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (forall (a : α) (b : β a), γ a b) (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (PartialOrder.toPreorder.{max (max u3 u2) u1} (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (OmegaCompletePartialOrder.toPartialOrder.{max (max u3 u2) u1} (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (Pi.instOmegaCompletePartialOrderForAll.{max u3 u2, u1} (Sigma.{u3, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u3, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u3, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u3, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) a))))) (Pi.preorder.{u3, max u2 u1} α (fun (a : α) => forall (b : β a), γ a b) (fun (i : α) => Pi.preorder.{u2, u1} (β i) (fun (b : β i) => γ i b) (fun (i_1 : β i) => PartialOrder.toPreorder.{u1} (γ i i_1) (OmegaCompletePartialOrder.toPartialOrder.{u1} (γ i i_1) (_inst_1 i i_1))))) (Pi.preorder.{max u3 u2, u1} (Sigma.{u3, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u3, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (fun (i : Sigma.{u3, u2} α (fun (a : α) => β a)) => PartialOrder.toPreorder.{u1} (γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) i) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) i)) (OmegaCompletePartialOrder.toPartialOrder.{u1} (γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) i) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) i)) (_inst_1 (Sigma.fst.{u3, u2} α (fun (a : α) => β a) i) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) i))))) (Pi.monotoneUncurry.{u3, u2, u1} α β γ (fun (x : α) (y : β x) => PartialOrder.toPreorder.{u1} (γ x y) (OmegaCompletePartialOrder.toPartialOrder.{u1} (γ x y) (_inst_1 x y)))) (OrderHom.comp.{max (max u3 u2) u1, max (max u3 u2) u1, max (max u3 u2) u1} (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (forall (x : α) (y : β x), γ x y) (forall (x : α) (y : β x), γ x y) (PartialOrder.toPreorder.{max (max u3 u2) u1} (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (OmegaCompletePartialOrder.toPartialOrder.{max (max u3 u2) u1} (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (Pi.instOmegaCompletePartialOrderForAll.{max u3 u2, u1} (Sigma.{u3, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u3, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u3, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u3, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) a))))) (Pi.preorder.{u3, max u2 u1} α (fun (x : α) => forall (y : β x), γ x y) (fun (i : α) => Pi.preorder.{u2, u1} (β i) (fun (y : β i) => γ i y) (fun (i_1 : β i) => PartialOrder.toPreorder.{u1} (γ i i_1) (OmegaCompletePartialOrder.toPartialOrder.{u1} (γ i i_1) (_inst_1 i i_1))))) (Pi.preorder.{u3, max u2 u1} α (fun (x : α) => forall (y : β x), γ x y) (fun (i : α) => Pi.preorder.{u2, u1} (β i) (fun (y : β i) => γ i y) (fun (i_1 : β i) => PartialOrder.toPreorder.{u1} (γ i i_1) (OmegaCompletePartialOrder.toPartialOrder.{u1} (γ i i_1) (_inst_1 i i_1))))) f (Pi.monotoneCurry.{u3, u2, u1} α β γ (fun (x : α) (y : β x) => PartialOrder.toPreorder.{u1} (γ x y) (OmegaCompletePartialOrder.toPartialOrder.{u1} (γ x y) (_inst_1 x y)))))))
+<too large>
Case conversion may be inaccurate. Consider using '#align pi.uncurry_curry_continuous Pi.uncurry_curry_continuousₓ'. -/
theorem uncurry_curry_continuous :
Continuous <| (monotoneUncurry α β γ).comp <| f.comp <| monotoneCurry α β γ :=
mathlib commit https://github.com/leanprover-community/mathlib/commit/8d33f09cd7089ecf074b4791907588245aec5d1b
@@ -115,7 +115,7 @@ theorem mem_iff (a : α) (b : β a) : b ∈ Part.fix f a ↔ ∃ i, b ∈ approx
generalize succ (Nat.find h₀) = j
intro
wlog case : i ≤ j
- · cases' le_total i j with H H <;> [skip, symm] <;> apply_assumption <;> assumption
+ · cases' le_total i j with H H <;> [skip;symm] <;> apply_assumption <;> assumption
replace hh := approx_mono f case _ _ hh
apply Part.mem_unique h₁ hh
· simp only [fix_def' (⇑f) h₀, not_exists, false_iff_iff, not_mem_none]
mathlib commit https://github.com/leanprover-community/mathlib/commit/0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8
@@ -66,7 +66,7 @@ variable (f : (∀ a, Part <| β a) →o ∀ a, Part <| β a)
/- warning: part.fix.approx_mono' -> Part.Fix.approx_mono' is a dubious translation:
lean 3 declaration is
- forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) {i : Nat}, LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toLE.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) i) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) (Nat.succ i))
+ forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) {i : Nat}, LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toHasLe.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) i) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) (Nat.succ i))
but is expected to have type
forall {α : Type.{u2}} {β : α -> Type.{u1}} (f : OrderHom.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) {i : Nat}, LE.le.{max u2 u1} (forall (a : α), Part.{u1} (β a)) (Pi.hasLe.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => Preorder.toLE.{u1} (Part.{u1} (β i)) (PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) (Part.Fix.approx.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f) i) (Part.Fix.approx.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f) (Nat.succ i))
Case conversion may be inaccurate. Consider using '#align part.fix.approx_mono' Part.Fix.approx_mono'ₓ'. -/
@@ -78,7 +78,7 @@ theorem approx_mono' {i : ℕ} : Fix.approx f i ≤ Fix.approx f (succ i) :=
/- warning: part.fix.approx_mono -> Part.Fix.approx_mono is a dubious translation:
lean 3 declaration is
- forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) {{i : Nat}} {{j : Nat}}, (LE.le.{0} Nat Nat.hasLe i j) -> (LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toLE.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) i) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) j))
+ forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) {{i : Nat}} {{j : Nat}}, (LE.le.{0} Nat Nat.hasLe i j) -> (LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toHasLe.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) i) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) j))
but is expected to have type
forall {α : Type.{u2}} {β : α -> Type.{u1}} (f : OrderHom.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) {{i : Nat}} {{j : Nat}}, (LE.le.{0} Nat instLENat i j) -> (LE.le.{max u2 u1} (forall (a : α), Part.{u1} (β a)) (Pi.hasLe.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => Preorder.toLE.{u1} (Part.{u1} (β i)) (PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) (Part.Fix.approx.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f) i) (Part.Fix.approx.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f) j))
Case conversion may be inaccurate. Consider using '#align part.fix.approx_mono Part.Fix.approx_monoₓ'. -/
@@ -126,7 +126,7 @@ theorem mem_iff (a : α) (b : β a) : b ∈ Part.fix f a ↔ ∃ i, b ∈ approx
/- warning: part.fix.approx_le_fix -> Part.Fix.approx_le_fix is a dubious translation:
lean 3 declaration is
- forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (i : Nat), LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toLE.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) i) (Part.fix.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f))
+ forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (i : Nat), LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toHasLe.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) i) (Part.fix.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f))
but is expected to have type
forall {α : Type.{u2}} {β : α -> Type.{u1}} (f : OrderHom.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) (i : Nat), LE.le.{max u2 u1} (forall (a : α), Part.{u1} (β a)) (Pi.hasLe.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => Preorder.toLE.{u1} (Part.{u1} (β i)) (PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) (Part.Fix.approx.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f) i) (Part.fix.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f))
Case conversion may be inaccurate. Consider using '#align part.fix.approx_le_fix Part.Fix.approx_le_fixₓ'. -/
@@ -138,7 +138,7 @@ theorem approx_le_fix (i : ℕ) : approx f i ≤ Part.fix f := fun a b hh =>
/- warning: part.fix.exists_fix_le_approx -> Part.Fix.exists_fix_le_approx is a dubious translation:
lean 3 declaration is
- forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (x : α), Exists.{1} Nat (fun (i : Nat) => LE.le.{u2} (Part.{u2} (β x)) (Preorder.toLE.{u2} (Part.{u2} (β x)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β x)) (Part.partialOrder.{u2} (β x)))) (Part.fix.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) x) (Part.Fix.approx.{u1, u2} α β (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) i x))
+ forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (x : α), Exists.{1} Nat (fun (i : Nat) => LE.le.{u2} (Part.{u2} (β x)) (Preorder.toHasLe.{u2} (Part.{u2} (β x)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β x)) (Part.partialOrder.{u2} (β x)))) (Part.fix.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) x) (Part.Fix.approx.{u1, u2} α β (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) i x))
but is expected to have type
forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) (x : α), Exists.{1} Nat (fun (i : Nat) => LE.le.{u2} (Part.{u2} (β x)) (Preorder.toLE.{u2} (Part.{u2} (β x)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β x)) (Part.instPartialOrderPart.{u2} (β x)))) (Part.fix.{u1, u2} α (fun (a : α) => β a) (OrderHom.toFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) f) x) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (OrderHom.toFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) f) i x))
Case conversion may be inaccurate. Consider using '#align part.fix.exists_fix_le_approx Part.Fix.exists_fix_le_approxₓ'. -/
@@ -174,7 +174,7 @@ def approxChain : Chain (∀ a, Part <| β a) :=
/- warning: part.fix.le_f_of_mem_approx -> Part.Fix.le_f_of_mem_approx is a dubious translation:
lean 3 declaration is
- forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) {x : forall (a : α), Part.{u2} (β a)}, (Membership.Mem.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (OmegaCompletePartialOrder.Chain.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (OmegaCompletePartialOrder.Chain.hasMem.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) x (Part.Fix.approxChain.{u1, u2} α (fun (a : α) => β a) f)) -> (LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toLE.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) x (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f x))
+ forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) {x : forall (a : α), Part.{u2} (β a)}, (Membership.Mem.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (OmegaCompletePartialOrder.Chain.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (OmegaCompletePartialOrder.Chain.hasMem.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) x (Part.Fix.approxChain.{u1, u2} α (fun (a : α) => β a) f)) -> (LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toHasLe.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) x (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f x))
but is expected to have type
forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) {x : forall (a : α), Part.{u2} (β a)}, (Membership.mem.{max u1 u2, max u2 u1} (forall (a : α), Part.{u2} (β a)) (OmegaCompletePartialOrder.Chain.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) (OmegaCompletePartialOrder.Chain.instMembershipChain.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) x (Part.Fix.approxChain.{u1, u2} α (fun (a : α) => β a) f)) -> (LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toLE.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) x (OrderHom.toFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) f x))
Case conversion may be inaccurate. Consider using '#align part.fix.le_f_of_mem_approx Part.Fix.le_f_of_mem_approxₓ'. -/
@@ -237,7 +237,7 @@ theorem fix_eq_ωSup : Part.fix f = ωSup (approxChain f) :=
/- warning: part.fix_le -> Part.fix_le is a dubious translation:
lean 3 declaration is
- forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) {X : forall (a : α), Part.{u2} (β a)}, (LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toLE.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f X) X) -> (LE.le.{max u1 u2} (forall (x : α), Part.{u2} (β x)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toLE.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (Part.fix.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f)) X)
+ forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) {X : forall (a : α), Part.{u2} (β a)}, (LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toHasLe.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f X) X) -> (LE.le.{max u1 u2} (forall (x : α), Part.{u2} (β x)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toHasLe.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (Part.fix.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f)) X)
but is expected to have type
forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) {X : forall (a : α), Part.{u2} (β a)}, (LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toLE.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) (OrderHom.toFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) f X) X) -> (LE.le.{max u1 u2} (forall (x : α), Part.{u2} (β x)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toLE.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) (Part.fix.{u1, u2} α (fun (a : α) => β a) (OrderHom.toFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) f)) X)
Case conversion may be inaccurate. Consider using '#align part.fix_le Part.fix_leₓ'. -/
@@ -408,7 +408,12 @@ theorem uncurry_curry_continuous :
end Curry
-#print Pi.Pi.lawfulFix' /-
+/- warning: pi.pi.lawful_fix' -> Pi.Pi.lawfulFix' is a dubious translation:
+lean 3 declaration is
+ forall {α : Type.{u1}} {β : α -> Type.{u2}} {γ : forall (a : α), (β a) -> Type.{u3}} [_inst_1 : forall (x : α) (y : β x), OmegaCompletePartialOrder.{u3} (γ x y)] [_inst_2 : LawfulFix.{max (max u1 u2) u3} (forall (x : Sigma.{u1, u2} α β), γ (Sigma.fst.{u1, u2} α β x) (Sigma.snd.{u1, u2} α β x)) (Pi.omegaCompletePartialOrder.{max u1 u2, u3} (Sigma.{u1, u2} α β) (fun (x : Sigma.{u1, u2} α β) => γ (Sigma.fst.{u1, u2} α β x) (Sigma.snd.{u1, u2} α β x)) (fun (a : Sigma.{u1, u2} α β) => _inst_1 (Sigma.fst.{u1, u2} α β a) (Sigma.snd.{u1, u2} α β a)))], LawfulFix.{max u1 u2 u3} (forall (x : α) (y : β x), γ x y) (Pi.omegaCompletePartialOrder.{u1, max u2 u3} α (fun (x : α) => forall (y : β x), γ x y) (fun (a : α) => Pi.omegaCompletePartialOrder.{u2, u3} (β a) (fun (y : β a) => γ a y) (fun (a_1 : β a) => _inst_1 a a_1)))
+but is expected to have type
+ forall {α : Type.{u1}} {β : α -> Type.{u2}} {γ : forall (a : α), (β a) -> Type.{u3}} [_inst_1 : forall (x : α) (y : β x), OmegaCompletePartialOrder.{u3} (γ x y)] [_inst_2 : LawfulFix.{max (max u1 u2) u3} (forall (x : Sigma.{u1, u2} α β), γ (Sigma.fst.{u1, u2} α β x) (Sigma.snd.{u1, u2} α β x)) (Pi.instOmegaCompletePartialOrderForAll.{max u1 u2, u3} (Sigma.{u1, u2} α β) (fun (x : Sigma.{u1, u2} α β) => γ (Sigma.fst.{u1, u2} α β x) (Sigma.snd.{u1, u2} α β x)) (fun (a : Sigma.{u1, u2} α β) => _inst_1 (Sigma.fst.{u1, u2} α β a) (Sigma.snd.{u1, u2} α β a)))], LawfulFix.{max (max u1 u2) u3} (forall (x : α) (y : β x), γ x y) (Pi.instOmegaCompletePartialOrderForAll.{u1, max u2 u3} α (fun (x : α) => forall (y : β x), γ x y) (fun (a : α) => Pi.instOmegaCompletePartialOrderForAll.{u2, u3} (β a) (fun (y : β a) => γ a y) (fun (a_1 : β a) => _inst_1 a a_1)))
+Case conversion may be inaccurate. Consider using '#align pi.pi.lawful_fix' Pi.Pi.lawfulFix'ₓ'. -/
instance Pi.lawfulFix' [LawfulFix <| ∀ x : Sigma β, γ x.1 x.2] : LawfulFix (∀ x y, γ x y)
where fix_eq f hc := by
dsimp [fix]
@@ -417,7 +422,6 @@ instance Pi.lawfulFix' [LawfulFix <| ∀ x : Sigma β, γ x.1 x.2] : LawfulFix (
erw [LawfulFix.fix_eq (uncurry_curry_continuous hc)]
rfl
#align pi.pi.lawful_fix' Pi.Pi.lawfulFix'
--/
end Pi
mathlib commit https://github.com/leanprover-community/mathlib/commit/21e3562c5e12d846c7def5eff8cdbc520d7d4936
@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
Authors: Simon Hudon
! This file was ported from Lean 3 source module control.lawful_fix
-! leanprover-community/mathlib commit 92ca63f0fb391a9ca5f22d2409a6080e786d99f7
+! leanprover-community/mathlib commit f47581155c818e6361af4e4fda60d27d020c226b
! Please do not edit these lines, except to modify the commit id
! if you have ported upstream changes.
-/
@@ -16,6 +16,9 @@ import Mathbin.Order.OmegaCompletePartialOrder
/-!
# Lawful fixed point operators
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
This module defines the laws required of a `has_fix` instance, using the theory of
omega complete partial orders (ωCPO). Proofs of the lawfulness of all `has_fix` instances in
`control.fix` are provided.
mathlib commit https://github.com/leanprover-community/mathlib/commit/195fcd60ff2bfe392543bceb0ec2adcdb472db4c
@@ -34,6 +34,7 @@ variable {α : Type _} {β : α → Type _}
open OmegaCompletePartialOrder
+#print LawfulFix /-
/-- Intuitively, a fixed point operator `fix` is lawful if it satisfies `fix f = f (fix f)` for all
`f`, but this is inconsistent / uninteresting in most cases due to the existence of "exotic"
functions `f`, such as the function that is defined iff its argument is not, familiar from the
@@ -43,11 +44,14 @@ sense of `ω`-complete partial orders, which excludes the example because it is
class LawfulFix (α : Type _) [OmegaCompletePartialOrder α] extends Fix α where
fix_eq : ∀ {f : α →o α}, Continuous f → Fix.fix f = f (Fix.fix f)
#align lawful_fix LawfulFix
+-/
+#print LawfulFix.fix_eq' /-
theorem LawfulFix.fix_eq' {α} [OmegaCompletePartialOrder α] [LawfulFix α] {f : α → α}
(hf : Continuous' f) : Fix.fix f = f (Fix.fix f) :=
LawfulFix.fix_eq (hf.to_bundled _)
#align lawful_fix.fix_eq' LawfulFix.fix_eq'
+-/
namespace Part
@@ -57,12 +61,24 @@ namespace Fix
variable (f : (∀ a, Part <| β a) →o ∀ a, Part <| β a)
+/- warning: part.fix.approx_mono' -> Part.Fix.approx_mono' is a dubious translation:
+lean 3 declaration is
+ forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) {i : Nat}, LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toLE.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) i) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) (Nat.succ i))
+but is expected to have type
+ forall {α : Type.{u2}} {β : α -> Type.{u1}} (f : OrderHom.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) {i : Nat}, LE.le.{max u2 u1} (forall (a : α), Part.{u1} (β a)) (Pi.hasLe.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => Preorder.toLE.{u1} (Part.{u1} (β i)) (PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) (Part.Fix.approx.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f) i) (Part.Fix.approx.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f) (Nat.succ i))
+Case conversion may be inaccurate. Consider using '#align part.fix.approx_mono' Part.Fix.approx_mono'ₓ'. -/
theorem approx_mono' {i : ℕ} : Fix.approx f i ≤ Fix.approx f (succ i) :=
by
induction i; dsimp [approx]; apply @bot_le _ _ _ (f ⊥)
intro ; apply f.monotone; apply i_ih
-#align part.fix.approx_mono' Part.fix.approx_mono'
-
+#align part.fix.approx_mono' Part.Fix.approx_mono'
+
+/- warning: part.fix.approx_mono -> Part.Fix.approx_mono is a dubious translation:
+lean 3 declaration is
+ forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) {{i : Nat}} {{j : Nat}}, (LE.le.{0} Nat Nat.hasLe i j) -> (LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toLE.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) i) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) j))
+but is expected to have type
+ forall {α : Type.{u2}} {β : α -> Type.{u1}} (f : OrderHom.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) {{i : Nat}} {{j : Nat}}, (LE.le.{0} Nat instLENat i j) -> (LE.le.{max u2 u1} (forall (a : α), Part.{u1} (β a)) (Pi.hasLe.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => Preorder.toLE.{u1} (Part.{u1} (β i)) (PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) (Part.Fix.approx.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f) i) (Part.Fix.approx.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f) j))
+Case conversion may be inaccurate. Consider using '#align part.fix.approx_mono Part.Fix.approx_monoₓ'. -/
theorem approx_mono ⦃i j : ℕ⦄ (hij : i ≤ j) : approx f i ≤ approx f j :=
by
induction' j with j ih;
@@ -70,8 +86,14 @@ theorem approx_mono ⦃i j : ℕ⦄ (hij : i ≤ j) : approx f i ≤ approx f j
exact le_rfl
cases hij; · exact le_rfl
exact le_trans (ih ‹_›) (approx_mono' f)
-#align part.fix.approx_mono Part.fix.approx_mono
-
+#align part.fix.approx_mono Part.Fix.approx_mono
+
+/- warning: part.fix.mem_iff -> Part.Fix.mem_iff is a dubious translation:
+lean 3 declaration is
+ forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (a : α) (b : β a), Iff (Membership.Mem.{u2, u2} (β a) (Part.{u2} (β a)) (Part.hasMem.{u2} (β a)) b (Part.fix.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) a)) (Exists.{1} Nat (fun (i : Nat) => Membership.Mem.{u2, u2} (β a) (Part.{u2} (β a)) (Part.hasMem.{u2} (β a)) b (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) i a)))
+but is expected to have type
+ forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) (a : α) (b : β a), Iff (Membership.mem.{u2, u2} (β a) (Part.{u2} (β a)) (Part.instMembershipPart.{u2} (β a)) b (Part.fix.{u1, u2} α (fun (a : α) => β a) (OrderHom.toFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) f) a)) (Exists.{1} Nat (fun (i : Nat) => Membership.mem.{u2, u2} (β a) (Part.{u2} (β a)) (Part.instMembershipPart.{u2} (β a)) b (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (OrderHom.toFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) f) i a)))
+Case conversion may be inaccurate. Consider using '#align part.fix.mem_iff Part.Fix.mem_iffₓ'. -/
theorem mem_iff (a : α) (b : β a) : b ∈ Part.fix f a ↔ ∃ i, b ∈ approx f i a :=
by
by_cases h₀ : ∃ i : ℕ, (approx f i a).Dom
@@ -97,14 +119,26 @@ theorem mem_iff (a : α) (b : β a) : b ∈ Part.fix f a ↔ ∃ i, b ∈ approx
simp only [dom_iff_mem, not_exists] at h₀
intro
apply h₀
-#align part.fix.mem_iff Part.fix.mem_iff
-
+#align part.fix.mem_iff Part.Fix.mem_iff
+
+/- warning: part.fix.approx_le_fix -> Part.Fix.approx_le_fix is a dubious translation:
+lean 3 declaration is
+ forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (i : Nat), LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toLE.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) i) (Part.fix.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f))
+but is expected to have type
+ forall {α : Type.{u2}} {β : α -> Type.{u1}} (f : OrderHom.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) (i : Nat), LE.le.{max u2 u1} (forall (a : α), Part.{u1} (β a)) (Pi.hasLe.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => Preorder.toLE.{u1} (Part.{u1} (β i)) (PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) (Part.Fix.approx.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f) i) (Part.fix.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f))
+Case conversion may be inaccurate. Consider using '#align part.fix.approx_le_fix Part.Fix.approx_le_fixₓ'. -/
theorem approx_le_fix (i : ℕ) : approx f i ≤ Part.fix f := fun a b hh =>
by
rw [mem_iff f]
exact ⟨_, hh⟩
-#align part.fix.approx_le_fix Part.fix.approx_le_fix
-
+#align part.fix.approx_le_fix Part.Fix.approx_le_fix
+
+/- warning: part.fix.exists_fix_le_approx -> Part.Fix.exists_fix_le_approx is a dubious translation:
+lean 3 declaration is
+ forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (x : α), Exists.{1} Nat (fun (i : Nat) => LE.le.{u2} (Part.{u2} (β x)) (Preorder.toLE.{u2} (Part.{u2} (β x)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β x)) (Part.partialOrder.{u2} (β x)))) (Part.fix.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) x) (Part.Fix.approx.{u1, u2} α β (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) i x))
+but is expected to have type
+ forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) (x : α), Exists.{1} Nat (fun (i : Nat) => LE.le.{u2} (Part.{u2} (β x)) (Preorder.toLE.{u2} (Part.{u2} (β x)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β x)) (Part.instPartialOrderPart.{u2} (β x)))) (Part.fix.{u1, u2} α (fun (a : α) => β a) (OrderHom.toFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) f) x) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (OrderHom.toFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) f) i x))
+Case conversion may be inaccurate. Consider using '#align part.fix.exists_fix_le_approx Part.Fix.exists_fix_le_approxₓ'. -/
theorem exists_fix_le_approx (x : α) : ∃ i, Part.fix f x ≤ approx f i x :=
by
by_cases hh : ∃ i b, b ∈ approx f i x
@@ -120,25 +154,43 @@ theorem exists_fix_le_approx (x : α) : ∃ i, Part.fix f x ≤ approx f i x :=
simp only [mem_iff f] at h'
cases' h' with i h'
cases hh _ _ h'
-#align part.fix.exists_fix_le_approx Part.fix.exists_fix_le_approx
+#align part.fix.exists_fix_le_approx Part.Fix.exists_fix_le_approx
include f
+/- warning: part.fix.approx_chain -> Part.Fix.approxChain is a dubious translation:
+lean 3 declaration is
+ forall {α : Type.{u1}} {β : α -> Type.{u2}}, (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) -> (OmegaCompletePartialOrder.Chain.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))))
+but is expected to have type
+ forall {α : Type.{u1}} {β : α -> Type.{u2}}, (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) -> (OmegaCompletePartialOrder.Chain.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))))
+Case conversion may be inaccurate. Consider using '#align part.fix.approx_chain Part.Fix.approxChainₓ'. -/
/-- The series of approximations of `fix f` (see `approx`) as a `chain` -/
def approxChain : Chain (∀ a, Part <| β a) :=
⟨approx f, approx_mono f⟩
-#align part.fix.approx_chain Part.fix.approxChain
-
+#align part.fix.approx_chain Part.Fix.approxChain
+
+/- warning: part.fix.le_f_of_mem_approx -> Part.Fix.le_f_of_mem_approx is a dubious translation:
+lean 3 declaration is
+ forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) {x : forall (a : α), Part.{u2} (β a)}, (Membership.Mem.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (OmegaCompletePartialOrder.Chain.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (OmegaCompletePartialOrder.Chain.hasMem.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) x (Part.Fix.approxChain.{u1, u2} α (fun (a : α) => β a) f)) -> (LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toLE.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) x (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f x))
+but is expected to have type
+ forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) {x : forall (a : α), Part.{u2} (β a)}, (Membership.mem.{max u1 u2, max u2 u1} (forall (a : α), Part.{u2} (β a)) (OmegaCompletePartialOrder.Chain.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) (OmegaCompletePartialOrder.Chain.instMembershipChain.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) x (Part.Fix.approxChain.{u1, u2} α (fun (a : α) => β a) f)) -> (LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toLE.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) x (OrderHom.toFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) f x))
+Case conversion may be inaccurate. Consider using '#align part.fix.le_f_of_mem_approx Part.Fix.le_f_of_mem_approxₓ'. -/
theorem le_f_of_mem_approx {x} : x ∈ approxChain f → x ≤ f x :=
by
simp only [(· ∈ ·), forall_exists_index]
rintro i rfl
apply approx_mono'
-#align part.fix.le_f_of_mem_approx Part.fix.le_f_of_mem_approx
-
+#align part.fix.le_f_of_mem_approx Part.Fix.le_f_of_mem_approx
+
+/- warning: part.fix.approx_mem_approx_chain -> Part.Fix.approx_mem_approxChain is a dubious translation:
+lean 3 declaration is
+ forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) {i : Nat}, Membership.Mem.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (OmegaCompletePartialOrder.Chain.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (OmegaCompletePartialOrder.Chain.hasMem.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (Part.Fix.approx.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f) i) (Part.Fix.approxChain.{u1, u2} α (fun (a : α) => β a) f)
+but is expected to have type
+ forall {α : Type.{u2}} {β : α -> Type.{u1}} (f : OrderHom.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) {i : Nat}, Membership.mem.{max u2 u1, max u1 u2} (forall (a : α), Part.{u1} (β a)) (OmegaCompletePartialOrder.Chain.{max u2 u1} (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) (OmegaCompletePartialOrder.Chain.instMembershipChain.{max u2 u1} (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))) (Part.Fix.approx.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f) i) (Part.Fix.approxChain.{u2, u1} α (fun (a : α) => β a) f)
+Case conversion may be inaccurate. Consider using '#align part.fix.approx_mem_approx_chain Part.Fix.approx_mem_approxChainₓ'. -/
theorem approx_mem_approxChain {i} : approx f i ∈ approxChain f :=
Stream'.mem_of_nth_eq rfl
-#align part.fix.approx_mem_approx_chain Part.fix.approx_mem_approxChain
+#align part.fix.approx_mem_approx_chain Part.Fix.approx_mem_approxChain
end Fix
@@ -156,6 +208,12 @@ open Nat
open Nat.Upto OmegaCompletePartialOrder
+/- warning: part.fix_eq_ωSup -> Part.fix_eq_ωSup is a dubious translation:
+lean 3 declaration is
+ forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))), Eq.{max (succ u1) (succ u2)} (forall (x : α), Part.{u2} (β x)) (Part.fix.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f)) (OmegaCompletePartialOrder.ωSup.{max u1 u2} (forall (x : α), Part.{u2} (β x)) (Pi.omegaCompletePartialOrder.{u1, u2} α (fun (x : α) => Part.{u2} (β x)) (fun (a : α) => Part.omegaCompletePartialOrder.{u2} (β a))) (Part.Fix.approxChain.{u1, u2} α (fun (x : α) => β x) f))
+but is expected to have type
+ forall {α : Type.{u2}} {β : α -> Type.{u1}} (f : OrderHom.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))), Eq.{max (succ u2) (succ u1)} (forall (x : α), Part.{u1} (β x)) (Part.fix.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f)) (OmegaCompletePartialOrder.ωSup.{max u1 u2} (forall (x : α), Part.{u1} (β x)) (Pi.instOmegaCompletePartialOrderForAll.{u2, u1} α (fun (x : α) => Part.{u1} (β x)) (fun (a : α) => Part.omegaCompletePartialOrder.{u1} (β a))) (Part.Fix.approxChain.{u2, u1} α (fun (x : α) => β x) f))
+Case conversion may be inaccurate. Consider using '#align part.fix_eq_ωSup Part.fix_eq_ωSupₓ'. -/
theorem fix_eq_ωSup : Part.fix f = ωSup (approxChain f) :=
by
apply le_antisymm
@@ -174,6 +232,12 @@ theorem fix_eq_ωSup : Part.fix f = ωSup (approxChain f) :=
apply approx_le_fix f
#align part.fix_eq_ωSup Part.fix_eq_ωSup
+/- warning: part.fix_le -> Part.fix_le is a dubious translation:
+lean 3 declaration is
+ forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) {X : forall (a : α), Part.{u2} (β a)}, (LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toLE.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f X) X) -> (LE.le.{max u1 u2} (forall (x : α), Part.{u2} (β x)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toLE.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (Part.fix.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f)) X)
+but is expected to have type
+ forall {α : Type.{u1}} {β : α -> Type.{u2}} (f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) {X : forall (a : α), Part.{u2} (β a)}, (LE.le.{max u1 u2} (forall (a : α), Part.{u2} (β a)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toLE.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) (OrderHom.toFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) f X) X) -> (LE.le.{max u1 u2} (forall (x : α), Part.{u2} (β x)) (Pi.hasLe.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => Preorder.toLE.{u2} (Part.{u2} (β i)) (PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i))))) (Part.fix.{u1, u2} α (fun (a : α) => β a) (OrderHom.toFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.instPartialOrderPart.{u2} (β i)))) f)) X)
+Case conversion may be inaccurate. Consider using '#align part.fix_le Part.fix_leₓ'. -/
theorem fix_le {X : ∀ a, Part <| β a} (hX : f X ≤ X) : Part.fix f ≤ X :=
by
rw [fix_eq_ωSup f]
@@ -189,6 +253,12 @@ variable {f} (hc : Continuous f)
include hc
+/- warning: part.fix_eq -> Part.fix_eq is a dubious translation:
+lean 3 declaration is
+ forall {α : Type.{u1}} {β : α -> Type.{u2}} {f : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))}, (OmegaCompletePartialOrder.Continuous.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.omegaCompletePartialOrder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (a : α) => Part.omegaCompletePartialOrder.{u2} (β a))) (Pi.omegaCompletePartialOrder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (a : α) => Part.omegaCompletePartialOrder.{u2} (β a))) f) -> (Eq.{max (succ u1) (succ u2)} (forall (x : α), Part.{u2} (β x)) (Part.fix.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f)) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f (Part.fix.{u1, u2} α (fun (a : α) => β a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) (fun (_x : OrderHom.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) => (forall (a : α), Part.{u2} (β a)) -> (forall (a : α), Part.{u2} (β a))) (OrderHom.hasCoeToFun.{max u1 u2, max u1 u2} (forall (a : α), Part.{u2} (β a)) (forall (a : α), Part.{u2} (β a)) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i)))) (Pi.preorder.{u1, u2} α (fun (a : α) => Part.{u2} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u2} (Part.{u2} (β i)) (Part.partialOrder.{u2} (β i))))) f))))
+but is expected to have type
+ forall {α : Type.{u2}} {β : α -> Type.{u1}} {f : OrderHom.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i))))}, (OmegaCompletePartialOrder.Continuous.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.instOmegaCompletePartialOrderForAll.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (a : α) => Part.omegaCompletePartialOrder.{u1} (β a))) (Pi.instOmegaCompletePartialOrderForAll.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (a : α) => Part.omegaCompletePartialOrder.{u1} (β a))) f) -> (Eq.{max (succ u2) (succ u1)} (forall (x : α), Part.{u1} (β x)) (Part.fix.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f)) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f (Part.fix.{u2, u1} α (fun (a : α) => β a) (OrderHom.toFun.{max u2 u1, max u2 u1} (forall (a : α), Part.{u1} (β a)) (forall (a : α), Part.{u1} (β a)) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) (Pi.preorder.{u2, u1} α (fun (a : α) => Part.{u1} (β a)) (fun (i : α) => PartialOrder.toPreorder.{u1} (Part.{u1} (β i)) (Part.instPartialOrderPart.{u1} (β i)))) f))))
+Case conversion may be inaccurate. Consider using '#align part.fix_eq Part.fix_eqₓ'. -/
theorem fix_eq : Part.fix f = f (Part.fix f) :=
by
rw [fix_eq_ωSup f, hc]
@@ -209,6 +279,12 @@ end Part
namespace Part
+/- warning: part.to_unit_mono -> Part.toUnitMono is a dubious translation:
+lean 3 declaration is
+ forall {α : Type.{u1}}, (OrderHom.{u1, u1} (Part.{u1} α) (Part.{u1} α) (PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.partialOrder.{u1} α)) (PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.partialOrder.{u1} α))) -> (OrderHom.{u1, u1} (Unit -> (Part.{u1} α)) (Unit -> (Part.{u1} α)) (Pi.preorder.{0, u1} Unit (fun (ᾰ : Unit) => Part.{u1} α) (fun (i : Unit) => PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.partialOrder.{u1} α))) (Pi.preorder.{0, u1} Unit (fun (ᾰ : Unit) => Part.{u1} α) (fun (i : Unit) => PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.partialOrder.{u1} α))))
+but is expected to have type
+ forall {α : Type.{u1}}, (OrderHom.{u1, u1} (Part.{u1} α) (Part.{u1} α) (PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.instPartialOrderPart.{u1} α)) (PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.instPartialOrderPart.{u1} α))) -> (OrderHom.{u1, u1} (Unit -> (Part.{u1} α)) (Unit -> (Part.{u1} α)) (Pi.preorder.{0, u1} Unit (fun (ᾰ : Unit) => Part.{u1} α) (fun (i : Unit) => PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.instPartialOrderPart.{u1} α))) (Pi.preorder.{0, u1} Unit (fun (ᾰ : Unit) => Part.{u1} α) (fun (i : Unit) => PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.instPartialOrderPart.{u1} α))))
+Case conversion may be inaccurate. Consider using '#align part.to_unit_mono Part.toUnitMonoₓ'. -/
/-- `to_unit` as a monotone function -/
@[simps]
def toUnitMono (f : Part α →o Part α) : (Unit → Part α) →o Unit → Part α
@@ -217,6 +293,12 @@ def toUnitMono (f : Part α →o Part α) : (Unit → Part α) →o Unit → Par
monotone' x y (h : x ≤ y) u := f.Monotone <| h u
#align part.to_unit_mono Part.toUnitMono
+/- warning: part.to_unit_cont -> Part.to_unit_cont is a dubious translation:
+lean 3 declaration is
+ forall {α : Type.{u1}} (f : OrderHom.{u1, u1} (Part.{u1} α) (Part.{u1} α) (PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.partialOrder.{u1} α)) (PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.partialOrder.{u1} α))), (OmegaCompletePartialOrder.Continuous.{u1, u1} (Part.{u1} α) (Part.{u1} α) (Part.omegaCompletePartialOrder.{u1} α) (Part.omegaCompletePartialOrder.{u1} α) f) -> (OmegaCompletePartialOrder.Continuous.{u1, u1} (Unit -> (Part.{u1} α)) (Unit -> (Part.{u1} α)) (Pi.omegaCompletePartialOrder.{0, u1} Unit (fun (ᾰ : Unit) => Part.{u1} α) (fun (a : Unit) => Part.omegaCompletePartialOrder.{u1} α)) (Pi.omegaCompletePartialOrder.{0, u1} Unit (fun (ᾰ : Unit) => Part.{u1} α) (fun (a : Unit) => Part.omegaCompletePartialOrder.{u1} α)) (Part.toUnitMono.{u1} α f))
+but is expected to have type
+ forall {α : Type.{u1}} (f : OrderHom.{u1, u1} (Part.{u1} α) (Part.{u1} α) (PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.instPartialOrderPart.{u1} α)) (PartialOrder.toPreorder.{u1} (Part.{u1} α) (Part.instPartialOrderPart.{u1} α))), (OmegaCompletePartialOrder.Continuous.{u1, u1} (Part.{u1} α) (Part.{u1} α) (Part.omegaCompletePartialOrder.{u1} α) (Part.omegaCompletePartialOrder.{u1} α) f) -> (OmegaCompletePartialOrder.Continuous.{u1, u1} (Unit -> (Part.{u1} α)) (Unit -> (Part.{u1} α)) (Pi.instOmegaCompletePartialOrderForAll.{0, u1} Unit (fun (ᾰ : Unit) => Part.{u1} α) (fun (a : Unit) => Part.omegaCompletePartialOrder.{u1} α)) (Pi.instOmegaCompletePartialOrderForAll.{0, u1} Unit (fun (ᾰ : Unit) => Part.{u1} α) (fun (a : Unit) => Part.omegaCompletePartialOrder.{u1} α)) (Part.toUnitMono.{u1} α f))
+Case conversion may be inaccurate. Consider using '#align part.to_unit_cont Part.to_unit_contₓ'. -/
theorem to_unit_cont (f : Part α →o Part α) (hc : Continuous f) : Continuous (toUnitMono f)
| c => by
ext ⟨⟩ : 1
@@ -242,6 +324,7 @@ section Monotone
variable (α β γ)
+#print Pi.monotoneCurry /-
/-- `sigma.curry` as a monotone function. -/
@[simps]
def monotoneCurry [∀ x y, Preorder <| γ x y] : (∀ x : Σa, β a, γ x.1 x.2) →o ∀ (a) (b : β a), γ a b
@@ -249,7 +332,9 @@ def monotoneCurry [∀ x y, Preorder <| γ x y] : (∀ x : Σa, β a, γ x.1 x.2
toFun := curry
monotone' x y h a b := h ⟨a, b⟩
#align pi.monotone_curry Pi.monotoneCurry
+-/
+#print Pi.monotoneUncurry /-
/-- `sigma.uncurry` as a monotone function. -/
@[simps]
def monotoneUncurry [∀ x y, Preorder <| γ x y] :
@@ -258,11 +343,18 @@ def monotoneUncurry [∀ x y, Preorder <| γ x y] :
toFun := uncurry
monotone' x y h a := h a.1 a.2
#align pi.monotone_uncurry Pi.monotoneUncurry
+-/
variable [∀ x y, OmegaCompletePartialOrder <| γ x y]
open OmegaCompletePartialOrder.Chain
+/- warning: pi.continuous_curry -> Pi.continuous_curry is a dubious translation:
+lean 3 declaration is
+ forall (α : Type.{u1}) (β : α -> Type.{u2}) (γ : forall (a : α), (β a) -> Type.{u3}) [_inst_1 : forall (x : α) (y : β x), OmegaCompletePartialOrder.{u3} (γ x y)], OmegaCompletePartialOrder.Continuous.{max (max u1 u2) u3, max u1 u2 u3} (forall (x : Sigma.{u1, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (forall (a : α) (b : β a), γ a b) (Pi.omegaCompletePartialOrder.{max u1 u2, u3} (Sigma.{u1, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u1, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u1, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u1, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) a))) (Pi.omegaCompletePartialOrder.{u1, max u2 u3} α (fun (a : α) => forall (b : β a), γ a b) (fun (a : α) => Pi.omegaCompletePartialOrder.{u2, u3} (β a) (fun (b : β a) => γ a b) (fun (a_1 : β a) => _inst_1 a a_1))) (Pi.monotoneCurry.{u1, u2, u3} α β γ (fun (x : α) (y : β x) => PartialOrder.toPreorder.{u3} (γ x y) (OmegaCompletePartialOrder.toPartialOrder.{u3} (γ x y) (_inst_1 x y))))
+but is expected to have type
+ forall (α : Type.{u3}) (β : α -> Type.{u2}) (γ : forall (a : α), (β a) -> Type.{u1}) [_inst_1 : forall (x : α) (y : β x), OmegaCompletePartialOrder.{u1} (γ x y)], OmegaCompletePartialOrder.Continuous.{max (max u3 u2) u1, max (max u3 u2) u1} (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (forall (a : α) (b : β a), γ a b) (Pi.instOmegaCompletePartialOrderForAll.{max u3 u2, u1} (Sigma.{u3, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u3, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u3, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u3, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) a))) (Pi.instOmegaCompletePartialOrderForAll.{u3, max u2 u1} α (fun (a : α) => forall (b : β a), γ a b) (fun (a : α) => Pi.instOmegaCompletePartialOrderForAll.{u2, u1} (β a) (fun (b : β a) => γ a b) (fun (a_1 : β a) => _inst_1 a a_1))) (Pi.monotoneCurry.{u3, u2, u1} α β γ (fun (x : α) (y : β x) => PartialOrder.toPreorder.{u1} (γ x y) (OmegaCompletePartialOrder.toPartialOrder.{u1} (γ x y) (_inst_1 x y))))
+Case conversion may be inaccurate. Consider using '#align pi.continuous_curry Pi.continuous_curryₓ'. -/
theorem continuous_curry : Continuous <| monotoneCurry α β γ := fun c =>
by
ext (x y)
@@ -271,6 +363,12 @@ theorem continuous_curry : Continuous <| monotoneCurry α β γ := fun c =>
rfl
#align pi.continuous_curry Pi.continuous_curry
+/- warning: pi.continuous_uncurry -> Pi.continuous_uncurry is a dubious translation:
+lean 3 declaration is
+ forall (α : Type.{u1}) (β : α -> Type.{u2}) (γ : forall (a : α), (β a) -> Type.{u3}) [_inst_1 : forall (x : α) (y : β x), OmegaCompletePartialOrder.{u3} (γ x y)], OmegaCompletePartialOrder.Continuous.{max u1 u2 u3, max (max u1 u2) u3} (forall (a : α) (b : β a), γ a b) (forall (x : Sigma.{u1, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (Pi.omegaCompletePartialOrder.{u1, max u2 u3} α (fun (a : α) => forall (b : β a), γ a b) (fun (a : α) => Pi.omegaCompletePartialOrder.{u2, u3} (β a) (fun (b : β a) => γ a b) (fun (a_1 : β a) => _inst_1 a a_1))) (Pi.omegaCompletePartialOrder.{max u1 u2, u3} (Sigma.{u1, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u1, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u1, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u1, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) a))) (Pi.monotoneUncurry.{u1, u2, u3} α β γ (fun (x : α) (y : β x) => PartialOrder.toPreorder.{u3} (γ x y) (OmegaCompletePartialOrder.toPartialOrder.{u3} (γ x y) (_inst_1 x y))))
+but is expected to have type
+ forall (α : Type.{u3}) (β : α -> Type.{u2}) (γ : forall (a : α), (β a) -> Type.{u1}) [_inst_1 : forall (x : α) (y : β x), OmegaCompletePartialOrder.{u1} (γ x y)], OmegaCompletePartialOrder.Continuous.{max (max u3 u2) u1, max (max u3 u2) u1} (forall (a : α) (b : β a), γ a b) (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (Pi.instOmegaCompletePartialOrderForAll.{u3, max u2 u1} α (fun (a : α) => forall (b : β a), γ a b) (fun (a : α) => Pi.instOmegaCompletePartialOrderForAll.{u2, u1} (β a) (fun (b : β a) => γ a b) (fun (a_1 : β a) => _inst_1 a a_1))) (Pi.instOmegaCompletePartialOrderForAll.{max u3 u2, u1} (Sigma.{u3, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u3, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u3, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u3, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) a))) (Pi.monotoneUncurry.{u3, u2, u1} α β γ (fun (x : α) (y : β x) => PartialOrder.toPreorder.{u1} (γ x y) (OmegaCompletePartialOrder.toPartialOrder.{u1} (γ x y) (_inst_1 x y))))
+Case conversion may be inaccurate. Consider using '#align pi.continuous_uncurry Pi.continuous_uncurryₓ'. -/
theorem continuous_uncurry : Continuous <| monotoneUncurry α β γ := fun c =>
by
ext (x y)
@@ -294,6 +392,12 @@ variable {f : (∀ (x) (y : β x), γ x y) →o ∀ (x) (y : β x), γ x y}
variable (hc : Continuous f)
+/- warning: pi.uncurry_curry_continuous -> Pi.uncurry_curry_continuous is a dubious translation:
+lean 3 declaration is
+ forall {α : Type.{u1}} {β : α -> Type.{u2}} {γ : forall (a : α), (β a) -> Type.{u3}} [_inst_1 : forall (x : α) (y : β x), OmegaCompletePartialOrder.{u3} (γ x y)] {f : OrderHom.{max u1 u2 u3, max u1 u2 u3} (forall (x : α) (y : β x), γ x y) (forall (x : α) (y : β x), γ x y) (Pi.preorder.{u1, max u2 u3} α (fun (x : α) => forall (y : β x), γ x y) (fun (i : α) => Pi.preorder.{u2, u3} (β i) (fun (y : β i) => γ i y) (fun (i_1 : β i) => PartialOrder.toPreorder.{u3} (γ i i_1) (OmegaCompletePartialOrder.toPartialOrder.{u3} (γ i i_1) (_inst_1 i i_1))))) (Pi.preorder.{u1, max u2 u3} α (fun (x : α) => forall (y : β x), γ x y) (fun (i : α) => Pi.preorder.{u2, u3} (β i) (fun (y : β i) => γ i y) (fun (i_1 : β i) => PartialOrder.toPreorder.{u3} (γ i i_1) (OmegaCompletePartialOrder.toPartialOrder.{u3} (γ i i_1) (_inst_1 i i_1)))))}, (OmegaCompletePartialOrder.Continuous.{max u1 u2 u3, max u1 u2 u3} (forall (x : α) (y : β x), γ x y) (forall (x : α) (y : β x), γ x y) (Pi.omegaCompletePartialOrder.{u1, max u2 u3} α (fun (x : α) => forall (y : β x), γ x y) (fun (a : α) => Pi.omegaCompletePartialOrder.{u2, u3} (β a) (fun (y : β a) => γ a y) (fun (a_1 : β a) => _inst_1 a a_1))) (Pi.omegaCompletePartialOrder.{u1, max u2 u3} α (fun (x : α) => forall (y : β x), γ x y) (fun (a : α) => Pi.omegaCompletePartialOrder.{u2, u3} (β a) (fun (y : β a) => γ a y) (fun (a_1 : β a) => _inst_1 a a_1))) f) -> (OmegaCompletePartialOrder.Continuous.{max (max u1 u2) u3, max (max u1 u2) u3} (forall (x : Sigma.{u1, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (forall (x : Sigma.{u1, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (Pi.omegaCompletePartialOrder.{max u1 u2, u3} (Sigma.{u1, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u1, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u1, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u1, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) a))) (Pi.omegaCompletePartialOrder.{max u1 u2, u3} (Sigma.{u1, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u1, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u1, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u1, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) a))) (OrderHom.comp.{max (max u1 u2) u3, max u1 u2 u3, max (max u1 u2) u3} (forall (x : Sigma.{u1, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (forall (a : α) (b : β a), γ a b) (forall (x : Sigma.{u1, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (PartialOrder.toPreorder.{max (max u1 u2) u3} (forall (x : Sigma.{u1, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (OmegaCompletePartialOrder.toPartialOrder.{max (max u1 u2) u3} (forall (x : Sigma.{u1, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (Pi.omegaCompletePartialOrder.{max u1 u2, u3} (Sigma.{u1, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u1, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u1, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u1, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) a))))) (Pi.preorder.{u1, max u2 u3} α (fun (a : α) => forall (b : β a), γ a b) (fun (i : α) => Pi.preorder.{u2, u3} (β i) (fun (b : β i) => γ i b) (fun (i_1 : β i) => (fun (x : α) (y : β x) => PartialOrder.toPreorder.{u3} (γ x y) (OmegaCompletePartialOrder.toPartialOrder.{u3} (γ x y) (_inst_1 x y))) i i_1))) (Pi.preorder.{max u1 u2, u3} (Sigma.{u1, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u1, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (fun (i : Sigma.{u1, u2} α (fun (a : α) => β a)) => (fun (x : α) (y : β x) => PartialOrder.toPreorder.{u3} (γ x y) (OmegaCompletePartialOrder.toPartialOrder.{u3} (γ x y) (_inst_1 x y))) (Sigma.fst.{u1, u2} α (fun (a : α) => β a) i) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) i))) (Pi.monotoneUncurry.{u1, u2, u3} α β γ (fun (x : α) (y : β x) => PartialOrder.toPreorder.{u3} (γ x y) (OmegaCompletePartialOrder.toPartialOrder.{u3} (γ x y) (_inst_1 x y)))) (OrderHom.comp.{max (max u1 u2) u3, max u1 u2 u3, max u1 u2 u3} (forall (x : Sigma.{u1, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (forall (x : α) (y : β x), γ x y) (forall (x : α) (y : β x), γ x y) (PartialOrder.toPreorder.{max (max u1 u2) u3} (forall (x : Sigma.{u1, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (OmegaCompletePartialOrder.toPartialOrder.{max (max u1 u2) u3} (forall (x : Sigma.{u1, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (Pi.omegaCompletePartialOrder.{max u1 u2, u3} (Sigma.{u1, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u1, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u1, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u1, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u1, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u1, u2} α (fun (a : α) => β a) a))))) (Pi.preorder.{u1, max u2 u3} α (fun (x : α) => forall (y : β x), γ x y) (fun (i : α) => Pi.preorder.{u2, u3} (β i) (fun (y : β i) => γ i y) (fun (i_1 : β i) => PartialOrder.toPreorder.{u3} (γ i i_1) (OmegaCompletePartialOrder.toPartialOrder.{u3} (γ i i_1) (_inst_1 i i_1))))) (Pi.preorder.{u1, max u2 u3} α (fun (x : α) => forall (y : β x), γ x y) (fun (i : α) => Pi.preorder.{u2, u3} (β i) (fun (y : β i) => γ i y) (fun (i_1 : β i) => PartialOrder.toPreorder.{u3} (γ i i_1) (OmegaCompletePartialOrder.toPartialOrder.{u3} (γ i i_1) (_inst_1 i i_1))))) f (Pi.monotoneCurry.{u1, u2, u3} α β γ (fun (x : α) (y : β x) => PartialOrder.toPreorder.{u3} (γ x y) (OmegaCompletePartialOrder.toPartialOrder.{u3} (γ x y) (_inst_1 x y)))))))
+but is expected to have type
+ forall {α : Type.{u3}} {β : α -> Type.{u2}} {γ : forall (a : α), (β a) -> Type.{u1}} [_inst_1 : forall (x : α) (y : β x), OmegaCompletePartialOrder.{u1} (γ x y)] {f : OrderHom.{max (max u3 u2) u1, max (max u3 u2) u1} (forall (x : α) (y : β x), γ x y) (forall (x : α) (y : β x), γ x y) (Pi.preorder.{u3, max u2 u1} α (fun (x : α) => forall (y : β x), γ x y) (fun (i : α) => Pi.preorder.{u2, u1} (β i) (fun (y : β i) => γ i y) (fun (i_1 : β i) => PartialOrder.toPreorder.{u1} (γ i i_1) (OmegaCompletePartialOrder.toPartialOrder.{u1} (γ i i_1) (_inst_1 i i_1))))) (Pi.preorder.{u3, max u2 u1} α (fun (x : α) => forall (y : β x), γ x y) (fun (i : α) => Pi.preorder.{u2, u1} (β i) (fun (y : β i) => γ i y) (fun (i_1 : β i) => PartialOrder.toPreorder.{u1} (γ i i_1) (OmegaCompletePartialOrder.toPartialOrder.{u1} (γ i i_1) (_inst_1 i i_1)))))}, (OmegaCompletePartialOrder.Continuous.{max (max u3 u2) u1, max (max u3 u2) u1} (forall (x : α) (y : β x), γ x y) (forall (x : α) (y : β x), γ x y) (Pi.instOmegaCompletePartialOrderForAll.{u3, max u2 u1} α (fun (x : α) => forall (y : β x), γ x y) (fun (a : α) => Pi.instOmegaCompletePartialOrderForAll.{u2, u1} (β a) (fun (y : β a) => γ a y) (fun (a_1 : β a) => _inst_1 a a_1))) (Pi.instOmegaCompletePartialOrderForAll.{u3, max u2 u1} α (fun (x : α) => forall (y : β x), γ x y) (fun (a : α) => Pi.instOmegaCompletePartialOrderForAll.{u2, u1} (β a) (fun (y : β a) => γ a y) (fun (a_1 : β a) => _inst_1 a a_1))) f) -> (OmegaCompletePartialOrder.Continuous.{max (max u3 u2) u1, max (max u3 u2) u1} (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (Pi.instOmegaCompletePartialOrderForAll.{max u3 u2, u1} (Sigma.{u3, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u3, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u3, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u3, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) a))) (Pi.instOmegaCompletePartialOrderForAll.{max u3 u2, u1} (Sigma.{u3, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u3, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u3, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u3, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) a))) (OrderHom.comp.{max (max u3 u2) u1, max (max u3 u2) u1, max (max u3 u2) u1} (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (forall (a : α) (b : β a), γ a b) (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (PartialOrder.toPreorder.{max (max u3 u2) u1} (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (OmegaCompletePartialOrder.toPartialOrder.{max (max u3 u2) u1} (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (Pi.instOmegaCompletePartialOrderForAll.{max u3 u2, u1} (Sigma.{u3, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u3, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u3, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u3, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) a))))) (Pi.preorder.{u3, max u2 u1} α (fun (a : α) => forall (b : β a), γ a b) (fun (i : α) => Pi.preorder.{u2, u1} (β i) (fun (b : β i) => γ i b) (fun (i_1 : β i) => PartialOrder.toPreorder.{u1} (γ i i_1) (OmegaCompletePartialOrder.toPartialOrder.{u1} (γ i i_1) (_inst_1 i i_1))))) (Pi.preorder.{max u3 u2, u1} (Sigma.{u3, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u3, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (fun (i : Sigma.{u3, u2} α (fun (a : α) => β a)) => PartialOrder.toPreorder.{u1} (γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) i) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) i)) (OmegaCompletePartialOrder.toPartialOrder.{u1} (γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) i) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) i)) (_inst_1 (Sigma.fst.{u3, u2} α (fun (a : α) => β a) i) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) i))))) (Pi.monotoneUncurry.{u3, u2, u1} α β γ (fun (x : α) (y : β x) => PartialOrder.toPreorder.{u1} (γ x y) (OmegaCompletePartialOrder.toPartialOrder.{u1} (γ x y) (_inst_1 x y)))) (OrderHom.comp.{max (max u3 u2) u1, max (max u3 u2) u1, max (max u3 u2) u1} (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (forall (x : α) (y : β x), γ x y) (forall (x : α) (y : β x), γ x y) (PartialOrder.toPreorder.{max (max u3 u2) u1} (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (OmegaCompletePartialOrder.toPartialOrder.{max (max u3 u2) u1} (forall (x : Sigma.{u3, u2} α (fun (a : α) => β a)), γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (Pi.instOmegaCompletePartialOrderForAll.{max u3 u2, u1} (Sigma.{u3, u2} α (fun (a : α) => β a)) (fun (x : Sigma.{u3, u2} α (fun (a : α) => β a)) => γ (Sigma.fst.{u3, u2} α (fun (a : α) => β a) x) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) x)) (fun (a : Sigma.{u3, u2} α (fun (a : α) => β a)) => _inst_1 (Sigma.fst.{u3, u2} α (fun (a : α) => β a) a) (Sigma.snd.{u3, u2} α (fun (a : α) => β a) a))))) (Pi.preorder.{u3, max u2 u1} α (fun (x : α) => forall (y : β x), γ x y) (fun (i : α) => Pi.preorder.{u2, u1} (β i) (fun (y : β i) => γ i y) (fun (i_1 : β i) => PartialOrder.toPreorder.{u1} (γ i i_1) (OmegaCompletePartialOrder.toPartialOrder.{u1} (γ i i_1) (_inst_1 i i_1))))) (Pi.preorder.{u3, max u2 u1} α (fun (x : α) => forall (y : β x), γ x y) (fun (i : α) => Pi.preorder.{u2, u1} (β i) (fun (y : β i) => γ i y) (fun (i_1 : β i) => PartialOrder.toPreorder.{u1} (γ i i_1) (OmegaCompletePartialOrder.toPartialOrder.{u1} (γ i i_1) (_inst_1 i i_1))))) f (Pi.monotoneCurry.{u3, u2, u1} α β γ (fun (x : α) (y : β x) => PartialOrder.toPreorder.{u1} (γ x y) (OmegaCompletePartialOrder.toPartialOrder.{u1} (γ x y) (_inst_1 x y)))))))
+Case conversion may be inaccurate. Consider using '#align pi.uncurry_curry_continuous Pi.uncurry_curry_continuousₓ'. -/
theorem uncurry_curry_continuous :
Continuous <| (monotoneUncurry α β γ).comp <| f.comp <| monotoneCurry α β γ :=
continuous_comp _ _ (continuous_comp _ _ (continuous_curry _ _ _) hc) (continuous_uncurry _ _ _)
@@ -301,6 +405,7 @@ theorem uncurry_curry_continuous :
end Curry
+#print Pi.Pi.lawfulFix' /-
instance Pi.lawfulFix' [LawfulFix <| ∀ x : Sigma β, γ x.1 x.2] : LawfulFix (∀ x y, γ x y)
where fix_eq f hc := by
dsimp [fix]
@@ -309,6 +414,7 @@ instance Pi.lawfulFix' [LawfulFix <| ∀ x : Sigma β, γ x.1 x.2] : LawfulFix (
erw [LawfulFix.fix_eq (uncurry_curry_continuous hc)]
rfl
#align pi.pi.lawful_fix' Pi.Pi.lawfulFix'
+-/
end Pi
mathlib commit https://github.com/leanprover-community/mathlib/commit/bd9851ca476957ea4549eb19b40e7b5ade9428cc
@@ -148,8 +148,8 @@ theorem fix_eq_ωSup : Part.fix f = ωSup (approxChain f) := by
cases' exists_fix_le_approx f x with i hx
trans approx f i.succ x
· trans
- apply hx
- apply approx_mono' f
+ · apply hx
+ · apply approx_mono' f
apply le_ωSup_of_le i.succ
dsimp [approx]
rfl
@@ -166,7 +166,10 @@ theorem fix_le {X : (a : _) → Part <| β a} (hX : f X ≤ X) : Part.fix f ≤
intro i
induction i with
| zero => dsimp [Fix.approx]; apply bot_le
- | succ _ i_ih => trans f X; apply f.monotone i_ih; apply hX
+ | succ _ i_ih =>
+ trans f X
+ · apply f.monotone i_ih
+ · apply hX
#align part.fix_le Part.fix_le
variable {f} (hc : Continuous f)
Empty lines were removed by executing the following Python script twice
import os
import re
# Loop through each file in the repository
for dir_path, dirs, files in os.walk('.'):
for filename in files:
if filename.endswith('.lean'):
file_path = os.path.join(dir_path, filename)
# Open the file and read its contents
with open(file_path, 'r') as file:
content = file.read()
# Use a regular expression to replace sequences of "variable" lines separated by empty lines
# with sequences without empty lines
modified_content = re.sub(r'(variable.*\n)\n(variable(?! .* in))', r'\1\2', content)
# Write the modified content back to the file
with open(file_path, 'w') as file:
file.write(modified_content)
@@ -132,7 +132,6 @@ end Fix
open Fix
variable {α : Type*}
-
variable (f : ((a : _) → Part <| β a) →o (a : _) → Part <| β a)
open OmegaCompletePartialOrder
@@ -272,7 +271,6 @@ variable [∀ x y, OmegaCompletePartialOrder <| γ x y]
section Curry
variable {f : ((x : _) → (y : β x) → γ x y) →o (x : _) → (y : β x) → γ x y}
-
variable (hc : Continuous f)
theorem uncurry_curry_continuous :
open Classical
(#11199)
We remove all but one open Classical
s, instead preferring to use open scoped Classical
. The only real side-effect this led to is moving a couple declarations to use Exists.choose
instead of Classical.choose
.
The first few commits are explicitly labelled regex replaces for ease of review.
@@ -24,7 +24,7 @@ omega complete partial orders (ωCPO). Proofs of the lawfulness of all `Fix` ins
universe u v
-open Classical
+open scoped Classical
variable {α : Type*} {β : α → Type*}
@@ -282,13 +282,13 @@ theorem uncurry_curry_continuous :
end Curry
-instance Pi.lawfulFix' [LawfulFix <| (x : Sigma β) → γ x.1 x.2] :
+instance lawfulFix' [LawfulFix <| (x : Sigma β) → γ x.1 x.2] :
LawfulFix ((x y : _) → γ x y) where
fix_eq {_f} hc := by
dsimp [fix]
conv =>
lhs
erw [LawfulFix.fix_eq (uncurry_curry_continuous hc)]
-#align pi.pi.lawful_fix' Pi.Pi.lawfulFix'
+#align pi.pi.lawful_fix' Pi.lawfulFix'
end Pi
cases'
(#9171)
I literally went through and regex'd some uses of cases'
, replacing them with rcases
; this is meant to be a low effort PR as I hope that tools can do this in the future.
rcases
is an easier replacement than cases
, though with better tools we could in future do a second pass converting simple rcases
added here (and existing ones) to cases
.
@@ -83,7 +83,7 @@ theorem mem_iff (a : α) (b : β a) : b ∈ Part.fix f a ↔ ∃ i, b ∈ approx
cases' hh with i hh
revert h₁; generalize succ (Nat.find h₀) = j; intro h₁
wlog case : i ≤ j
- · cases' le_total i j with H H <;> [skip; symm] <;> apply_assumption <;> assumption
+ · rcases le_total i j with H | H <;> [skip; symm] <;> apply_assumption <;> assumption
replace hh := approx_mono f case _ _ hh
apply Part.mem_unique h₁ hh
· simp only [fix_def' (⇑f) h₀, not_exists, false_iff_iff, not_mem_none]
Stream'.nth
to Stream'.get
(#7514)
Many of nth
(e.g. list.nth
, stream.seq.nth
) are renamed to get?
in Mathlib 4, but Stream'.nth
had been remained as it.
@@ -124,7 +124,7 @@ theorem le_f_of_mem_approx {x} : x ∈ approxChain f → x ≤ f x := by
#align part.fix.le_f_of_mem_approx Part.Fix.le_f_of_mem_approx
theorem approx_mem_approxChain {i} : approx f i ∈ approxChain f :=
- Stream'.mem_of_nth_eq rfl
+ Stream'.mem_of_get_eq rfl
#align part.fix.approx_mem_approx_chain Part.Fix.approx_mem_approxChain
end Fix
Many proofs use the "stream of consciousness" style from Lean 3, rather than have ... :=
or suffices ... from/by
.
This PR updates a fraction of these to the preferred Lean 4 style.
I think a good goal would be to delete the "deferred" versions of have
, suffices
, and let
at the bottom of Mathlib.Tactic.Have
(Anyone who would like to contribute more cleanup is welcome to push directly to this branch.)
Co-authored-by: Scott Morrison <scott.morrison@gmail.com>
@@ -77,8 +77,8 @@ theorem mem_iff (a : α) (b : β a) : b ∈ Part.fix f a ↔ ∃ i, b ∈ approx
rw [dom_iff_mem] at h₁
cases' h₁ with y h₁
replace h₁ := approx_mono' f _ _ h₁
- suffices : y = b
- · subst this
+ suffices y = b by
+ subst this
exact h₁
cases' hh with i hh
revert h₁; generalize succ (Nat.find h₀) = j; intro h₁
Type _
and Sort _
(#6499)
We remove all possible occurences of Type _
and Sort _
in favor of Type*
and Sort*
.
This has nice performance benefits.
@@ -26,7 +26,7 @@ universe u v
open Classical
-variable {α : Type _} {β : α → Type _}
+variable {α : Type*} {β : α → Type*}
open OmegaCompletePartialOrder
@@ -37,7 +37,7 @@ functions `f`, such as the function that is defined iff its argument is not, fam
halting problem. Instead, this requirement is limited to only functions that are `Continuous` in the
sense of `ω`-complete partial orders, which excludes the example because it is not monotone
(making the input argument less defined can make `f` more defined). -/
-class LawfulFix (α : Type _) [OmegaCompletePartialOrder α] extends Fix α where
+class LawfulFix (α : Type*) [OmegaCompletePartialOrder α] extends Fix α where
fix_eq : ∀ {f : α →o α}, Continuous f → Fix.fix f = f (Fix.fix f)
#align lawful_fix LawfulFix
@@ -131,7 +131,7 @@ end Fix
open Fix
-variable {α : Type _}
+variable {α : Type*}
variable (f : ((a : _) → Part <| β a) →o (a : _) → Part <| β a)
@@ -219,7 +219,7 @@ instance lawfulFix {β} : LawfulFix (α → Part β) :=
⟨fun {_f} ↦ Part.fix_eq⟩
#align pi.lawful_fix Pi.lawfulFix
-variable {γ : ∀ a : α, β a → Type _}
+variable {γ : ∀ a : α, β a → Type*}
section Monotone
FunLike
for OrderHom
(#5805)
Co-authored-by: Jujian Zhang <jujian.zhang1998@outlook.com> Co-authored-by: Oliver Nash <github@olivernash.org>
@@ -155,7 +155,7 @@ theorem fix_eq_ωSup : Part.fix f = ωSup (approxChain f) := by
dsimp [approx]
rfl
· apply ωSup_le _ _ _
- simp only [Fix.approxChain, OrderHom.coe_fun_mk]
+ simp only [Fix.approxChain, OrderHom.coe_mk]
intro y x
apply approx_le_fix f
#align part.fix_eq_ωSup Part.fix_eq_ωSup
@@ -163,7 +163,7 @@ theorem fix_eq_ωSup : Part.fix f = ωSup (approxChain f) := by
theorem fix_le {X : (a : _) → Part <| β a} (hX : f X ≤ X) : Part.fix f ≤ X := by
rw [fix_eq_ωSup f]
apply ωSup_le _ _ _
- simp only [Fix.approxChain, OrderHom.coe_fun_mk]
+ simp only [Fix.approxChain, OrderHom.coe_mk]
intro i
induction i with
| zero => dsimp [Fix.approx]; apply bot_le
@@ -2,17 +2,14 @@
Copyright (c) 2020 Simon Hudon. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Simon Hudon
-
-! This file was ported from Lean 3 source module control.lawful_fix
-! leanprover-community/mathlib commit 92ca63f0fb391a9ca5f22d2409a6080e786d99f7
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
-/
import Mathlib.Data.Stream.Init
import Mathlib.Tactic.ApplyFun
import Mathlib.Control.Fix
import Mathlib.Order.OmegaCompletePartialOrder
+#align_import control.lawful_fix from "leanprover-community/mathlib"@"92ca63f0fb391a9ca5f22d2409a6080e786d99f7"
+
/-!
# Lawful fixed point operators
This is the second half of the changes originally in #5699, removing all occurrences of ;
after a space and implementing a linter rule to enforce it.
In most cases this 2-character substring has a space after it, so the following command was run first:
find . -type f -name "*.lean" -exec sed -i -E 's/ ; /; /g' {} \;
The remaining cases were few enough in number that they were done manually.
@@ -60,7 +60,7 @@ variable (f : ((a : _) → Part <| β a) →o (a : _) → Part <| β a)
theorem approx_mono' {i : ℕ} : Fix.approx f i ≤ Fix.approx f (succ i) := by
induction i with
| zero => dsimp [approx]; apply @bot_le _ _ _ (f ⊥)
- | succ _ i_ih => intro ; apply f.monotone; apply i_ih
+ | succ _ i_ih => intro; apply f.monotone; apply i_ih
#align part.fix.approx_mono' Part.Fix.approx_mono'
theorem approx_mono ⦃i j : ℕ⦄ (hij : i ≤ j) : approx f i ≤ approx f j := by
@@ -170,7 +170,7 @@ theorem fix_le {X : (a : _) → Part <| β a} (hX : f X ≤ X) : Part.fix f ≤
intro i
induction i with
| zero => dsimp [Fix.approx]; apply bot_le
- | succ _ i_ih => trans f X; apply f.monotone i_ih ; apply hX
+ | succ _ i_ih => trans f X; apply f.monotone i_ih; apply hX
#align part.fix_le Part.fix_le
variable {f} (hc : Continuous f)
ext
(#5258)
Co-authored-by: Xavier Roblot <46200072+xroblot@users.noreply.github.com> Co-authored-by: Joël Riou <joel.riou@universite-paris-saclay.fr> Co-authored-by: Riccardo Brasca <riccardo.brasca@gmail.com> Co-authored-by: Yury G. Kudryashov <urkud@urkud.name> Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au> Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Jeremy Tan Jie Rui <reddeloostw@gmail.com> Co-authored-by: Pol'tta / Miyahara Kō <pol_tta@outlook.jp> Co-authored-by: Jason Yuen <jason_yuen2007@hotmail.com> Co-authored-by: Mario Carneiro <di.gama@gmail.com> Co-authored-by: Jireh Loreaux <loreaujy@gmail.com> Co-authored-by: Ruben Van de Velde <65514131+Ruben-VandeVelde@users.noreply.github.com> Co-authored-by: Kyle Miller <kmill31415@gmail.com> Co-authored-by: Heather Macbeth <25316162+hrmacbeth@users.noreply.github.com> Co-authored-by: Jujian Zhang <jujian.zhang1998@outlook.com> Co-authored-by: Yaël Dillies <yael.dillies@gmail.com>
@@ -249,7 +249,7 @@ variable [(x y : _) → OmegaCompletePartialOrder <| γ x y]
open OmegaCompletePartialOrder.Chain
theorem continuous_curry : Continuous <| monotoneCurry α β γ := fun c ↦ by
- ext (x y)
+ ext x y
dsimp [curry, ωSup]
rw [map_comp, map_comp]
rfl
Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Mario Carneiro <di.gama@gmail.com> Co-authored-by: Floris van Doorn <fpvdoorn@gmail.com> Co-authored-by: Jeremy Tan Jie Rui <reddeloostw@gmail.com> Co-authored-by: Alex J Best <alex.j.best@gmail.com>
@@ -256,7 +256,7 @@ theorem continuous_curry : Continuous <| monotoneCurry α β γ := fun c ↦ by
#align pi.continuous_curry Pi.continuous_curry
theorem continuous_uncurry : Continuous <| monotoneUncurry α β γ := fun c ↦ by
- ext (x y)
+ ext ⟨x, y⟩
dsimp [uncurry, ωSup]
rw [map_comp, map_comp]
rfl
fix-comments.py
on all files.@@ -37,7 +37,7 @@ open OmegaCompletePartialOrder
/-- Intuitively, a fixed point operator `fix` is lawful if it satisfies `fix f = f (fix f)` for all
`f`, but this is inconsistent / uninteresting in most cases due to the existence of "exotic"
functions `f`, such as the function that is defined iff its argument is not, familiar from the
-halting problem. Instead, this requirement is limited to only functions that are `continuous` in the
+halting problem. Instead, this requirement is limited to only functions that are `Continuous` in the
sense of `ω`-complete partial orders, which excludes the example because it is not monotone
(making the input argument less defined can make `f` more defined). -/
class LawfulFix (α : Type _) [OmegaCompletePartialOrder α] extends Fix α where
The main breaking change is that tac <;> [t1, t2]
is now written tac <;> [t1; t2]
, to avoid clashing with tactics like cases
and use
that take comma-separated lists.
@@ -86,7 +86,7 @@ theorem mem_iff (a : α) (b : β a) : b ∈ Part.fix f a ↔ ∃ i, b ∈ approx
cases' hh with i hh
revert h₁; generalize succ (Nat.find h₀) = j; intro h₁
wlog case : i ≤ j
- · cases' le_total i j with H H <;> [skip, symm] <;> apply_assumption <;> assumption
+ · cases' le_total i j with H H <;> [skip; symm] <;> apply_assumption <;> assumption
replace hh := approx_mono f case _ _ hh
apply Part.mem_unique h₁ hh
· simp only [fix_def' (⇑f) h₀, not_exists, false_iff_iff, not_mem_none]
This makes a mathlib4 version of mathlib3's tactic.basic
, now called Mathlib.Tactic.Common
, which imports all tactics which do not have significant theory requirements, and then is imported all across the base of the hierarchy.
This ensures that all common tactics are available nearly everywhere in the library, rather than having to be imported one-by-one as you need them.
Co-authored-by: Scott Morrison <scott.morrison@gmail.com>
@@ -12,7 +12,6 @@ import Mathlib.Data.Stream.Init
import Mathlib.Tactic.ApplyFun
import Mathlib.Control.Fix
import Mathlib.Order.OmegaCompletePartialOrder
-import Mathlib.Tactic.WLOG
/-!
# Lawful fixed point operators
Acc.rec
and many related defs computable (#3535)
Lean 4 code generator has had no native supports for Acc.rec
.
This PR makes Acc.rec
computable.
This change makes many defs computable. Especially, computable PFun.fix
and Part.hasFix
enables us to reason about partial
functions.
This PR also renames some instances and gives PFun.lift
@[coe]
attr.
@@ -208,9 +208,7 @@ theorem to_unit_cont (f : Part α →o Part α) (hc : Continuous f) : Continuous
erw [hc, Chain.map_comp]; rfl
#align part.to_unit_cont Part.to_unit_cont
--- Porting note: `noncomputable` is required because the code generator does not support recursor
--- `Acc.rec` yet.
-noncomputable instance lawfulFix : LawfulFix (Part α) :=
+instance lawfulFix : LawfulFix (Part α) :=
⟨fun {f : Part α →o Part α} hc ↦ show Part.fix (toUnitMono f) () = _ by
rw [Part.fix_eq (to_unit_cont f hc)]; rfl⟩
#align part.lawful_fix Part.lawfulFix
@@ -221,9 +219,7 @@ open Sigma
namespace Pi
--- Porting note: `noncomputable` is required because the code generator does not support recursor
--- `Acc.rec` yet.
-noncomputable instance lawfulFix {β} : LawfulFix (α → Part β) :=
+instance lawfulFix {β} : LawfulFix (α → Part β) :=
⟨fun {_f} ↦ Part.fix_eq⟩
#align pi.lawful_fix Pi.lawfulFix
The only change here comes from a change in wlog
in mathlib3.The change is already present in mathlib4.
@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
Authors: Simon Hudon
! This file was ported from Lean 3 source module control.lawful_fix
-! leanprover-community/mathlib commit 1126441d6bccf98c81214a0780c73d499f6721fe
+! leanprover-community/mathlib commit 92ca63f0fb391a9ca5f22d2409a6080e786d99f7
! Please do not edit these lines, except to modify the commit id
! if you have ported upstream changes.
-/
@@ -65,7 +65,7 @@ theorem approx_mono' {i : ℕ} : Fix.approx f i ≤ Fix.approx f (succ i) := by
#align part.fix.approx_mono' Part.Fix.approx_mono'
theorem approx_mono ⦃i j : ℕ⦄ (hij : i ≤ j) : approx f i ≤ approx f j := by
- induction' j with j ih;
+ induction' j with j ih
· cases hij
exact le_rfl
cases hij; · exact le_rfl
@@ -76,14 +76,14 @@ theorem mem_iff (a : α) (b : β a) : b ∈ Part.fix f a ↔ ∃ i, b ∈ approx
by_cases h₀ : ∃ i : ℕ, (approx f i a).Dom
· simp only [Part.fix_def f h₀]
constructor <;> intro hh
- exact ⟨_, hh⟩
+ · exact ⟨_, hh⟩
have h₁ := Nat.find_spec h₀
rw [dom_iff_mem] at h₁
cases' h₁ with y h₁
replace h₁ := approx_mono' f _ _ h₁
suffices : y = b
- subst this
- exact h₁
+ · subst this
+ exact h₁
cases' hh with i hh
revert h₁; generalize succ (Nat.find h₀) = j; intro h₁
wlog case : i ≤ j
@@ -196,8 +196,7 @@ namespace Part
/-- `toUnit` as a monotone function -/
@[simps]
-def toUnitMono (f : Part α →o Part α) : (Unit → Part α) →o Unit → Part α
- where
+def toUnitMono (f : Part α →o Part α) : (Unit → Part α) →o Unit → Part α where
toFun x u := f (x u)
monotone' x y (h : x ≤ y) u := f.monotone <| h u
#align part.to_unit_mono Part.toUnitMono