text
stringlengths 0
3.34M
|
|---|
State Before: z : ℂ
h : z ≠ 0
⊢ z * z⁻¹ = 1 State After: no goals Tactic: rw [inv_def, ← mul_assoc, mul_conj, ← ofReal_mul, mul_inv_cancel (mt normSq_eq_zero.1 h),
ofReal_one] |
data A : Set where
consA : A → A
A-false : {Y : Set} → A → Y
A-false (consA b) = A-false b
data Nat : Set where
zero : Nat
suc : Nat → Nat
A-on-Nat : A → Nat → Nat
A-on-Nat σ zero = A-false σ
A-on-Nat σ (suc t) = suc (A-on-Nat σ t)
module _
(any : {X : Set} → X)
(P : Nat → Set)
(p : (n : Nat) → P n → P (suc n))
(eternity : (a : A) (n : Nat) → P (A-on-Nat (A-false a) n))
where
A-loop-term : (a : A) (n : Nat) → P (A-on-Nat a n)
A-loop-term a zero = any
A-loop-term a (suc n) = p _ (eternity _ n)
|
import Mathlib
import Mathlib.Tactic.Basic
import LeanCodePrompts.CheckParse
import LeanCodePrompts.ThmInfo
universe u v u_1 u_2
/-- Every Nat.Prime that is `1` greater than a multiple of `4` can be expressed as the sum of two squares. -/
theorem fermat_two_square0 : (∀ {p : ℕ}, p % 4 = 1 → Nat.Prime p → ∃ a b, a ^ 2 + b ^ 2 = p) → (∀ p : ℕ, Nat.Prime p → (p % 4 = 1) → ∃ a b : ℕ, a ^ 2 + b ^ 2 = p) := by
intros h
intros
apply h <;> assumption
theorem fermat_two_square1 : (∀ p : ℕ, Nat.Prime p → (p % 4 = 1) → ∃ a b : ℕ, a ^ 2 + b ^ 2 = p) → (∀ {p : ℕ}, p % 4 = 1 → Nat.Prime p → ∃ a b, a ^ 2 + b ^ 2 = p) := by
intro h
intros
apply h <;> assumption
/-- The product of two numbers, each of which is the sum of four squares, is itself a sum of four squares. -/
theorem euler_four_square_identity0 : (∀ {a b : ℤ}, ∃ x y z w, a = x ^ 2 + y ^ 2 + z ^ 2 + w ^ 2 ∧ ∃ x y z w, b = x ^ 2 + y ^ 2 + z ^ 2 + w ^ 2 → ∃ x y z w, (a * b) = x ^ 2 + y ^ 2 + z ^ 2 + w ^ 2) → (let is_sum_of_four_squares : ℕ → Prop := λ n : ℕ => ∃ (a b c d : ℕ), n = a^2 + b^2 + c^2 + d^2;
∀ (x y : ℕ), is_sum_of_four_squares x → is_sum_of_four_squares y → is_sum_of_four_squares (x * y)) := sorry
theorem euler_four_square_identity1 : (let is_sum_of_four_squares : ℕ → Prop := λ n : ℕ => ∃ (a b c d : ℕ), n = a^2 + b^2 + c^2 + d^2;
∀ (x y : ℕ), is_sum_of_four_squares x → is_sum_of_four_squares y → is_sum_of_four_squares (x * y)) → (∀ {a b : ℤ}, ∃ x y z w, a = x ^ 2 + y ^ 2 + z ^ 2 + w ^ 2 ∧ b = x ^ 2 + y ^ 2 + z ^ 2 + w ^ 2 → ∃ x y z w, (a * b) = x ^ 2 + y ^ 2 + z ^ 2 + w ^ 2) := sorry
/-- A ring with all elements idempotent is commutative. -/
example : ({R : Type u} → [inst : CommRing R] → (∀ (x : R), (x * x) = x) → CommRing R) → ({R : Type u} → [Ring R] → (∀ x : R, (x * x) = x) → CommRing R) := by
intro h R RRing hyp
-- the typeclasses seem to be causing issues
haveI : CommRing R := sorry
apply h
intro x
sorry -- apply hyp
example : ({R : Type u} → [Ring R] → (∀ x : R, (x * x) = 1)) → ({R : Type u} → [inst : CommRing R] → (∀ (x : R), (x * x) = x) → CommRing R) := sorry
/-- There are infinitely many pairs of Nat.Primes that differ exactly by `2`. -/
example : (∀ (n : ℕ), ∃ p₁ p₂, Nat.Prime p₁ ∧ Nat.Prime p₂ ∧ p₁ + 2 = p₂ ∧ (2 + n) < p₂) → (∀ n : ℕ, ∃ p : ℕ, p > n ∧ Nat.Prime p ∧ Nat.Prime (p + 2)) := by
intro h n
let ⟨p₁, p₂, Prime_p₁, Prime_p₂, hyp₁, hyp₂⟩ := h n
use p₁
apply And.intro -- `split` does not appear to exist yet
sorry -- needs `linarith` or `norm_num`
apply And.intro
exact Prime_p₁
rw [hyp₁]
exact Prime_p₂
example : (∀ n : ℕ, ∃ p : ℕ, p > n ∧ Nat.Prime p ∧ Nat.Prime (p + 2)) → (∀ (n : ℕ), ∃ p₁ p₂, Nat.Prime p₁ ∧ Nat.Prime p₂ ∧ p₁ + 2 = p₂ ∧ 2 + n < p₂) := by
intro h n
let ⟨p, hpn, Prime_p, Prime_pp2⟩ := h n
use p
use p + 2
have : (2 + n) < p + 2 := sorry -- linarith
exact ⟨Prime_p, Prime_pp2, rfl, this⟩
/-- Every non-empty poset in which every chain has an upper bound contains a maximal element. -/
example : (∀ {α : Type u_1} {r : α → α → Prop} [inst : Preorder α], (∀ (c : Set α) (a : IsChain r c), ∃ ub, ∀ (a : α), a ∈ c → r a ub) → ∀ [inst : Nonempty α], ∃ m, ∀ (a : α), r m a → r a m) → ({α : Type u} → [PartialOrder α] → [Nonempty α] → (∀ c : Set α, IsChain LE.le c → (∃ b : α, ∀ a ∈ c, a ≤ b)) → (∃ m : α, ∀ a : α, m ≤ a → a = m)) := sorry
example : ({α : Type u} → [PartialOrder α] → [Nonempty α] → (∀ c : Set α, IsChain LE.le c → (∃ b : α, ∀ a ∈ c, a ≤ b)) → (∃ m : α, ∀ a : α, m ≤ a → a = m)) → (∀ {α : Type u_1} {r : α → α → Prop} [inst : Preorder α], (∀ (c : Set α) (a : IsChain r c), ∃ ub, ∀ (a : α), a ∈ c → r a ub) → ∀ [inst : Nonempty α], ∃ m, ∀ (a : α), r m a → r a m) := sorry
/-- A uniformly continuous function of a uniformly continuous function is uniformly continuous. -/
example : (∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : UniformSpace α] [inst_1 : UniformSpace β] [inst_2 : UniformSpace γ] {f : α → β} {g : β → γ}, UniformContinuous f → UniformContinuous g → UniformContinuous (g ∘ f)) → ({α β γ : Type u} → [UniformSpace α] → [UniformSpace β] → [UniformSpace γ] → (f : α → β) → (g : β → γ) → UniformContinuous f → UniformContinuous g → UniformContinuous (g ∘ f)) := sorry
example : ({α β γ : Type u} → [UniformSpace α] → [UniformSpace β] → [UniformSpace γ] → (f : α → β) → (g : β → γ) → UniformContinuous f → UniformContinuous g → UniformContinuous (g ∘ f)) → (∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : UniformSpace α] [inst_1 : UniformSpace β] [inst_2 : UniformSpace γ] {f : α → β} {g : β → γ}, UniformContinuous f → UniformContinuous g → UniformContinuous (g ∘ f)) := sorry
/-- A terminal object in a category is unique up to unique isomorphism. -/
example : (∀ {C : Type u₁} [inst : CategoryTheory.Category C] [inst_1 : CategoryTheory.Limits.HasTerminal C] {T T' : C} (t : CategoryTheory.Limits.IsTerminal T), CategoryTheory.Limits.IsTerminal T' → CategoryTheory.IsIso (CategoryTheory.Limits.IsTerminal.from t T')) → ({C : Type _} → [CategoryTheory.Category C] → ∀ T₁ T₂ : C, CategoryTheory.Limits.IsTerminal T₁ → CategoryTheory.Limits.IsTerminal T₂ → (∃ ι : CategoryTheory.Iso T₁ T₂, ∀ ι' : CategoryTheory.Iso T₁ T₂, ι = ι')) := sorry
example : ({C : Type _} → [CategoryTheory.Category C] → ∀ T₁ T₂ : C, CategoryTheory.Limits.IsTerminal T₁ → CategoryTheory.Limits.IsTerminal T₂ → (∃ ι : CategoryTheory.Iso T₁ T₂, ∀ ι' : CategoryTheory.Iso T₁ T₂, ι = ι')) → (∀ {C : Type u₁} [inst : CategoryTheory.Category C] [inst_1 : CategoryTheory.Limits.HasTerminal C] {T T' : C} (t : CategoryTheory.Limits.IsTerminal T), CategoryTheory.Limits.IsTerminal T' → CategoryTheory.IsIso (CategoryTheory.Limits.IsTerminal.from t T')) := sorry
/-- The sum of the cubes of two positive integers is never equal to the cube of a third integer. -/
example : (∀ (a b c : ℤ), a ^ 3 + b ^ 3 ≠ c ^ 3) → (∀ a b c : ℕ, a > 0 → b > 0 → ¬(a^3 + b^3 = c^3)) := sorry
example : (∀ a b c : ℕ, a > 0 → b > 0 → ¬(a^3 + b^3 = c^3)) → (∀ (a b c : ℤ), a ^ 3 + b ^ 3 ≠ c ^ 3) := sorry
/-- If every element of a group `G` has order `2`, then every pair of elements of `G` commutes. -/
example : (∀ {G : Type u_1} [inst : Group G], (∀ (x : G), x ^ 2 = 1) → ∀ {x y : G}, Commute x y) → ({G: Type u} → [Group G] → (∀ x y : G, (x * x) = 1) → (∀ x y : G, Commute x y)) := sorry
example : ({G: Type u} → [Group G] → (∀ x y : G, (x * x) = 1) → (∀ x y : G, Commute x y)) → (∀ {G : Type u_1} [inst : Group G], (∀ (x : G), x ^ 2 = 1) → ∀ {x y : G}, Commute x y) := sorry
/-- The product of two consecutive natural numbers is even. -/
example : (∀ {p q : ℕ}, p = q + 1 → Even (p * q)) → ((n: Nat) → Even <| n * (n + 1)) := sorry
example : ((n: Nat) → Even <| n * (n + 1)) → (∀ {p q : ℕ}, p = q + 1 → Even (p * q)) := sorry
/-- Every free group is torsion free. -/
example : (∀ (α : Type u), Monoid.IsTorsionFree (FreeGroup α)) → ({α : Type u} → Monoid.IsTorsionFree (FreeGroup α)) := sorry
example : ({α : Type u} → Monoid.IsTorsionFree (FreeGroup α)) → (∀ (α : Type u), Monoid.IsTorsionFree (FreeGroup α)) := sorry
/-- Every natural number greater than `1` is divisible by a Nat.Prime number. -/
example : (∀ {n : ℕ}, 1 < n → ∃ p, Nat.Prime p ∧ p ∣ n) → ((n: ℕ) →
n > 1 → ∃ p: ℕ, Nat.Prime p ∧ (∃ d: ℕ, (p * d) = n)) := sorry
example : ((n: ℕ) → n > 1 → ∃ p: ℕ, Nat.Prime p ∧ (∃ d: ℕ, (p * d) = n)) → (∀ {n : ℕ}, 1 < n → ∃ p, Nat.Prime p ∧ p ∣ n) := sorry
/-- A finite torsion-free group is trivial -/
example : (∀ {G : Type u} [inst : Group G] [inst_1 : Fintype G], Monoid.IsTorsionFree G → Fintype.card G = 1) → ({G: Type u} → [Group G] → [Finite G] → Monoid.IsTorsionFree G → IsSubgroup.Trivial G) := sorry
example : ({G: Type u} → [Group G] → [Finite G] → Monoid.IsTorsionFree G → IsSubgroup.Trivial G) → (∀ {G : Type u} [inst : Group G] [inst_1 : Fintype G], Monoid.IsTorsionFree G → Fintype.card G = 1) := sorry
/-- Every surjective homomorphism from a finitely generated free group to itself is injective -/
example : (∀ {α : Type u_1} {β : Type u_2} [inst : Group α] [inst_1 : Group β] [inst_2 : Fintype α] [inst_3 : Fintype β] {f : α → β}, IsGroupHom f → Function.Surjective f → Function.Injective f) → ({α : Type u} → [Finite α] → (f: FreeGroup α → FreeGroup α) → (IsGroupHom f) → f.Surjective → f.Injective) := sorry
example : ({α : Type u} → [Finite α] → (f: FreeGroup α → FreeGroup α) → (IsGroupHom f) → f.Surjective → f.Injective) → (∀ {α : Type u_1} {β : Type u_2} [inst : Group α] [inst_1 : Group β] [inst_2 : Fintype α] [inst_3 : Fintype β] {f : α → β}, IsGroupHom f → Function.Surjective f → Function.Injective f) := sorry
/-- Every positive even integer can be written as the sum of two Nat.Primes. -/
example : (∀ {n : ℕ}, 0 < n → Even n → ∃ p q, Nat.Prime p ∧ Nat.Prime q ∧ p + q = n) → (∀ n : ℕ, n > 0 → Even n → ∃ p q : ℕ, Nat.Prime p → Nat.Prime q → n = p + q) := sorry
example : (∀ n : ℕ, n > 0 → Even n → ∃ p q : ℕ, Nat.Prime p → Nat.Prime q → n = p + q) → (∀ {n : ℕ}, 0 < n → Even n → ∃ p q, Nat.Prime p ∧ Nat.Prime q ∧ p + q = n) := sorry
/-- If the square of a number is even, the number itself is even. -/
example : (∀ {M : Type u} [inst : Semiring M] [inst_1 : DecidableEq M] (a : M), Even (a * a) → Even a) → (∀ n : ℕ, Even (n^2) → Even n) := sorry
example : (∀ n : ℕ, Even (n^2) → Even n) → (∀ {M : Type u} [inst : Semiring M] [inst_1 : DecidableEq M] (a : M), Even (a * a) → Even a) := sorry
/-- If every point of a subset of a topological space is contained in some open set, the subset itself is open. -/
example : (∀ {α : Type u} [inst : TopologicalSpace α] {s : Set α}, (∀ (x : α), x ∈ s → ∃ t, IsOpen t ∧ x ∈ t) → IsOpen s) → ({X : Type u} → [TopologicalSpace X] → (S : Set X) → (∀ x ∈ S, ∃ U : Set X, IsOpen U) → IsOpen S) := sorry
example : ({X : Type u} → [TopologicalSpace X] → (S : Set X) → (∀ x ∈ S, ∃ U : Set X, IsOpen U) → IsOpen S) → (∀ {α : Type u} [inst : TopologicalSpace α] {s : Set α}, (∀ (x : α), x ∈ s → ∃ t, IsOpen t ∧ x ∈ t) → IsOpen s) := sorry
/-- Every non-identity element of a free group is of infinite order. -/
example : (∀ {α : Type u} [inst : DecidableEq α] {x : FreeGroup α}, x ≠ 1 → ¬IsOfFinOrder x) → ({G : Type u} → [Group G] → FreeGroup G → (∀ g : G, g ≠ 1 → orderOf g = 0)) := sorry
example : ({G : Type u} → [Group G] → FreeGroup G → (∀ g : G, g ≠ 1 → orderOf g = 0)) → (∀ {α : Type u} [inst : DecidableEq α] {x : FreeGroup α}, x ≠ 1 → ¬IsOfFinOrder x) := sorry
/-- For any two relatively Nat.Prime positive integers $a$ and $b$, every sufficiently large natural number $N$ can be written as a linear combination $ax + by$ of $a$ and $b$, where both $x$ and $y$ are natural numbers. -/
example : (∀ {m n : ℕ}, 0 < m → 0 < n → Nat.gcd m n = 1 → ∀ (N : ℕ), N > (m * n) → ∃ x y, N = (m * x) + (n * y)) → (∀ a b : ℕ, a > 0 → b > 0 → Nat.coprime a b → ∃ m : ℕ, ∀ N : ℕ, N > m → ∃ x y : ℕ, N = (a*x) + (b*y)) := sorry
example : (∀ a b : ℕ, a > 0 → b > 0 → Nat.coprime a b → ∃ m : ℕ, ∀ N : ℕ, N > m → ∃ x y : ℕ, N = (a*x) + (b*y)) → (∀ {m n : ℕ}, 0 < m → 0 < n → Nat.gcd m n = 1 → ∀ (N : ℕ), N > (m * n) → ∃ x y, N = (m * x) + (n * y)) := sorry
-- The ones below had no model answers
/-- The set of units in a ring forms a group. -/
example : ((R : Type u_1) → [inst : Ring R] → AddGroup (Units R)) → (Unit) := sorry
example : (Unit) → ((R : Type u_1) → [inst : Ring R] → AddGroup (Units R)) := sorry
/-- If the direct product of two groups is torsion free then each of the groups is torsion free. -/
example : (∀ {η : Type u_1} (G : Type u_2) [inst : Group G] {Γ : Type u_3} [inst_1 : Group Γ], Monoid.IsTorsionFree (G × Γ) → Monoid.IsTorsionFree G ∧ Monoid.IsTorsionFree Γ) → (Unit) := sorry
example : (Unit) → (∀ {η : Type u_1} (G : Type u_2) [inst : Group G] {Γ : Type u_3} [inst_1 : Group Γ], Monoid.IsTorsionFree (G × Γ) → Monoid.IsTorsionFree G ∧ Monoid.IsTorsionFree Γ) := sorry
-- #eval do
-- let l ← getFileThmInfo
-- --let l' := l.map Prod.fst |>.map Lean.Name.toString |>.qsort
-- -- return l'.groupBy $ λ s s' => s.dropRight 1 == s'.dropRight 1
-- return 1
-- #eval [1, 1, 2, 2].groupBy (· = ·)
-- #eval (Lean.Name.toString `fermat_two_square0).dropRight 1 |
lemma components_empty [simp]: "components {} = {}" |
[GOAL]
n : ℕ
h : 0 < n
m : ℕ := n / 2
⊢ m < n
[PROOFSTEP]
apply Nat.div_lt_self h
[GOAL]
n : ℕ
h : 0 < n
m : ℕ := n / 2
⊢ 1 < 2
[PROOFSTEP]
decide
[GOAL]
n : ℕ
⊢ Fin.ofNat 0 ≤ Fin.ofNat __do_lift✝
[PROOFSTEP]
simp [Fin.ofNat, LE.le]
[GOAL]
n : ℕ
⊢ 0 ≤ __do_lift✝ % (n + 1)
[PROOFSTEP]
exact Nat.zero_le _
[GOAL]
⊢ 0 < List.length (String.toList " 0123abcABC:,;`\\/")
[PROOFSTEP]
decide
|
[STATEMENT]
lemma composite_simps [simp]:
shows "src (\<mu> \<star> \<nu> \<star> \<pi>) = src \<pi>"
and "src ((\<mu> \<star> \<nu>) \<star> \<pi>) = src \<pi>"
and "trg (\<mu> \<star> \<nu> \<star> \<pi>) = trg \<mu>"
and "trg ((\<mu> \<star> \<nu>) \<star> \<pi>) = trg \<mu>"
and "dom (\<mu> \<star> \<nu> \<star> \<pi>) = dom \<mu> \<star> dom \<nu> \<star> dom \<pi>"
and "dom ((\<mu> \<star> \<nu>) \<star> \<pi>) = (dom \<mu> \<star> dom \<nu>) \<star> dom \<pi>"
and "cod (\<mu> \<star> \<nu> \<star> \<pi>) = cod \<mu> \<star> cod \<nu> \<star> cod \<pi>"
and "cod ((\<mu> \<star> \<nu>) \<star> \<pi>) = (cod \<mu> \<star> cod \<nu>) \<star> cod \<pi>"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. ((src (\<mu> \<star> \<nu> \<star> \<pi>) = src \<pi> &&& src ((\<mu> \<star> \<nu>) \<star> \<pi>) = src \<pi>) &&& trg (\<mu> \<star> \<nu> \<star> \<pi>) = trg \<mu> &&& trg ((\<mu> \<star> \<nu>) \<star> \<pi>) = trg \<mu>) &&& (local.dom (\<mu> \<star> \<nu> \<star> \<pi>) = local.dom \<mu> \<star> local.dom \<nu> \<star> local.dom \<pi> &&& local.dom ((\<mu> \<star> \<nu>) \<star> \<pi>) = (local.dom \<mu> \<star> local.dom \<nu>) \<star> local.dom \<pi>) &&& cod (\<mu> \<star> \<nu> \<star> \<pi>) = cod \<mu> \<star> cod \<nu> \<star> cod \<pi> &&& cod ((\<mu> \<star> \<nu>) \<star> \<pi>) = (cod \<mu> \<star> cod \<nu>) \<star> cod \<pi>
[PROOF STEP]
by (auto simp add: \<mu>\<nu>.composable \<nu>\<pi>.composable) |
[GOAL]
f : ℂ[X]
hf : 0 < degree f
⊢ ∃ z, IsRoot f z
[PROOFSTEP]
contrapose! hf
[GOAL]
f : ℂ[X]
hf : ∀ (z : ℂ), ¬IsRoot f z
⊢ degree f ≤ 0
[PROOFSTEP]
have : Metric.Bounded (Set.range (eval · f)⁻¹)
[GOAL]
case this
f : ℂ[X]
hf : ∀ (z : ℂ), ¬IsRoot f z
⊢ Metric.Bounded (Set.range (fun x => eval x f)⁻¹)
[PROOFSTEP]
obtain ⟨z₀, h₀⟩ := f.exists_forall_norm_le
[GOAL]
case this.intro
f : ℂ[X]
hf : ∀ (z : ℂ), ¬IsRoot f z
z₀ : ℂ
h₀ : ∀ (y : ℂ), ‖eval z₀ f‖ ≤ ‖eval y f‖
⊢ Metric.Bounded (Set.range (fun x => eval x f)⁻¹)
[PROOFSTEP]
simp only [Pi.inv_apply, bounded_iff_forall_norm_le, Set.forall_range_iff, norm_inv]
[GOAL]
case this.intro
f : ℂ[X]
hf : ∀ (z : ℂ), ¬IsRoot f z
z₀ : ℂ
h₀ : ∀ (y : ℂ), ‖eval z₀ f‖ ≤ ‖eval y f‖
⊢ ∃ C, ∀ (i : ℂ), ‖eval i f‖⁻¹ ≤ C
[PROOFSTEP]
exact ⟨‖eval z₀ f‖⁻¹, fun z => inv_le_inv_of_le (norm_pos_iff.2 <| hf z₀) (h₀ z)⟩
[GOAL]
f : ℂ[X]
hf : ∀ (z : ℂ), ¬IsRoot f z
this : Metric.Bounded (Set.range (fun x => eval x f)⁻¹)
⊢ degree f ≤ 0
[PROOFSTEP]
obtain ⟨c, hc⟩ := (f.differentiable.inv hf).exists_const_forall_eq_of_bounded this
[GOAL]
case intro
f : ℂ[X]
hf : ∀ (z : ℂ), ¬IsRoot f z
this : Metric.Bounded (Set.range (fun x => eval x f)⁻¹)
c : ℂ
hc : ∀ (z : ℂ), (eval z f)⁻¹ = c
⊢ degree f ≤ 0
[PROOFSTEP]
obtain rfl : f = C c⁻¹ := Polynomial.funext fun z => by rw [eval_C, ← hc z, inv_inv]
[GOAL]
f : ℂ[X]
hf : ∀ (z : ℂ), ¬IsRoot f z
this : Metric.Bounded (Set.range (fun x => eval x f)⁻¹)
c : ℂ
hc : ∀ (z : ℂ), (eval z f)⁻¹ = c
z : ℂ
⊢ eval z f = eval z (↑C c⁻¹)
[PROOFSTEP]
rw [eval_C, ← hc z, inv_inv]
[GOAL]
case intro
c : ℂ
hf : ∀ (z : ℂ), ¬IsRoot (↑C c⁻¹) z
this : Metric.Bounded (Set.range (fun x => eval x (↑C c⁻¹))⁻¹)
hc : ∀ (z : ℂ), (eval z (↑C c⁻¹))⁻¹ = c
⊢ degree (↑C c⁻¹) ≤ 0
[PROOFSTEP]
exact degree_C_le
|
module Issue1148 where
foo : Set → Set
foo = {!!}
|
theory Check
imports Submission
begin
theorem SQUARE_correct: "\<turnstile> {\<lambda>s. s ''n'' \<ge> 0 \<and> s=s\<^sub>0} SQUARE {\<lambda>s. s ''a'' = s\<^sub>0 ''n'' * s\<^sub>0 ''n''}"
by (rule Submission.SQUARE_correct)
end |
function results = vl_test_slic(varargin)
% VL_TEST_SLIC
vl_test_init ;
function s = setup()
s.im = im2single(vl_impattern('roofs1')) ;
function test_slic(s)
segmentation = vl_slic(s.im, 10, 0.1) ;
|
open classical
variables {A B C : Prop}
-- Prove ¬ (A ∧ B) → ¬ A ∨ ¬ B by replacing the sorry's below
-- by proofs.
lemma step1 (h1 : ¬ (A ∧ B)) (h2 : A) : ¬ A ∨ ¬ B :=
have ¬ B, from (assume g1 : B, show false, from h1 (and.intro h2 g1)),
show ¬ A ∨ ¬ B, from or.inr this
lemma step2 (h1 : ¬ (A ∧ B)) (h2 : ¬ (¬ A ∨ ¬ B)) : false :=
have ¬ A, from
assume : A,
have ¬ A ∨ ¬ B, from step1 h1 ‹A›,
show false, from h2 this,
show false, from h2 (or.inl this)
theorem step3 (h : ¬ (A ∧ B)) : ¬ A ∨ ¬ B :=
by_contradiction
(assume h' : ¬ (¬ A ∨ ¬ B),
show false, from step2 h h')
example (h : ¬ B → ¬ A) : A → B :=
assume ha : A,
by_contradiction
(assume hnb : ¬ B,
have hna : ¬ A, from h hnb,
show false, from hna ha)
example (h : A → B) : ¬ A ∨ B :=
have t : A ∨ ¬ A, from em A,
or.elim t
(assume ha : A,
have hb : B, from h ha,
show ¬ A ∨ B, from or.inr hb)
(assume hna : ¬ A, show ¬ A ∨ B, from or.inl hna)
|
import category_theory.equivalence
open category_theory
variables {C : Type*} [category C]
variables {D : Type*} [category D]
lemma equiv_reflects_mono {X Y : C} (f : X ⟶ Y) (e : C ≌ D)
(hef : mono (e.functor.map f)) : mono f :=
begin
split,
intros Z g h w,
apply e.functor.map_injective,
rw ← cancel_mono (e.functor.map f),
apply e.inverse.map_injective,
-- That's ugly! In fact, so ugly that surely `simp` can clean things up from here.
sorry
end
|
opaque f (x y : Nat) : Nat
opaque g (x : Nat) : Nat
theorem ex1 (x : Nat) (h₁ : f x x = g x) (h₂ : g x = x) : f x (f x x) = x := by
simp
simp [*]
theorem ex2 (x : Nat) (h₁ : f x x = g x) (h₂ : g x = x) : f x (f x x) = x := by
simp [*]
axiom g_ax (x : Nat) : g x = 0
theorem ex3 (x y : Nat) (h₁ : f x x = g x) (h₂ : f x x < 5) : f x x + f x x = 0 := by
simp [*] at *
trace_state
have aux₁ : f x x = g x := h₁
have aux₂ : g x < 5 := h₂
simp [g_ax]
|
(* ** License
* -----------------------------------------------------------------------
* Copyright 2016--2017 IMDEA Software Institute
* Copyright 2016--2017 Inria
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
* ----------------------------------------------------------------------- *)
(* ** Imports and settings *)
Require Import oseq.
Require Export ZArith Setoid Morphisms.
From mathcomp Require Import all_ssreflect all_algebra.
From CoqWord Require Import ssrZ.
Require Export strings word utils type var global sem_type x86_decl x86_instr_decl.
Require Import xseq.
Import Utf8 ZArith.
Set Implicit Arguments.
Unset Strict Implicit.
Unset Printing Implicit Defensive.
Local Unset Elimination Schemes.
(* ** Operators
* -------------------------------------------------------------------- *)
(* *** Summary
Operators represent several constructs in the Ocaml compiler:
- const-op: compile-time expressions (constexpr in C++)
- list-op: argument and result lists
- arr-op: reading and writing arrays
- cpu-op: CPU instructions such as addition with carry
*)
Variant cmp_kind :=
| Cmp_int
| Cmp_w of signedness & wsize.
Variant op_kind :=
| Op_int
| Op_w of wsize.
Variant sop1 :=
| Oword_of_int of wsize (* int → word *)
| Oint_of_word of wsize (* word → unsigned int *)
| Osignext of wsize & wsize (* Sign-extension: output-size, input-size *)
| Ozeroext of wsize & wsize (* Zero-extension: output-size, input-size *)
| Onot (* Boolean negation *)
| Olnot of wsize (* Bitwize not: 1s’ complement *)
| Oneg of op_kind (* Arithmetic negation *)
.
Variant sop2 :=
| Oand (* const : sbool -> sbool -> sbool *)
| Oor (* const : sbool -> sbool -> sbool *)
| Oadd of op_kind
| Omul of op_kind
| Osub of op_kind
| Odiv of cmp_kind
| Omod of cmp_kind
| Oland of wsize
| Olor of wsize
| Olxor of wsize
| Olsr of wsize
| Olsl of wsize
| Oasr of wsize
| Oeq of op_kind
| Oneq of op_kind
| Olt of cmp_kind
| Ole of cmp_kind
| Ogt of cmp_kind
| Oge of cmp_kind
(* vector operation *)
| Ovadd of velem & wsize (* VPADD *)
| Ovsub of velem & wsize (* VPSUB *)
| Ovmul of velem & wsize (* VPMULLW *)
| Ovlsr of velem & wsize
| Ovlsl of velem & wsize
| Ovasr of velem & wsize
.
(* N-ary operators *)
Variant opN :=
| Opack of wsize & pelem (* Pack words of size pelem into one word of wsize *)
.
Variant sopn : Set :=
(* Generic operation *)
| Omulu of wsize (* cpu : [sword; sword] -> [sword;sword] *)
| Oaddcarry of wsize (* cpu : [sword; sword; sbool] -> [sbool;sword] *)
| Osubcarry of wsize (* cpu : [sword; sword; sbool] -> [sbool;sword] *)
(* Low level x86 operations *)
| Oset0 of wsize (* set register + flags to 0 (implemented using XOR x x or VPXOR x x) *)
| Ox86MOVZX32
| Ox86 of asm_op (* x86 instruction *)
.
Scheme Equality for sop1.
(* Definition sop1_beq : sop1 -> sop1 -> bool *)
Lemma sop1_eq_axiom : Equality.axiom sop1_beq.
Proof.
move=> x y;apply:(iffP idP).
+ by apply: internal_sop1_dec_bl.
by apply: internal_sop1_dec_lb.
Qed.
Definition sop1_eqMixin := Equality.Mixin sop1_eq_axiom.
Canonical sop1_eqType := Eval hnf in EqType sop1 sop1_eqMixin.
Scheme Equality for sop2.
(* Definition sop2_beq : sop2 -> sop2 -> bool *)
Lemma sop2_eq_axiom : Equality.axiom sop2_beq.
Proof.
move=> x y;apply:(iffP idP).
+ by apply: internal_sop2_dec_bl.
by apply: internal_sop2_dec_lb.
Qed.
Definition sop2_eqMixin := Equality.Mixin sop2_eq_axiom.
Canonical sop2_eqType := Eval hnf in EqType sop2 sop2_eqMixin.
Scheme Equality for opN.
Lemma opN_eq_axiom : Equality.axiom opN_beq.
Proof.
move=> x y;apply:(iffP idP).
+ by apply: internal_opN_dec_bl.
by apply: internal_opN_dec_lb.
Qed.
Definition opN_eqMixin := Equality.Mixin opN_eq_axiom.
Canonical opN_eqType := Eval hnf in EqType opN opN_eqMixin.
Scheme Equality for sopn.
(* Definition sopn_beq : sopn -> sopn -> bool *)
Lemma sopn_eq_axiom : Equality.axiom sopn_beq.
Proof.
move=> x y;apply:(iffP idP).
+ by apply: internal_sopn_dec_bl.
by apply: internal_sopn_dec_lb.
Qed.
Definition sopn_eqMixin := Equality.Mixin sopn_eq_axiom.
Canonical sopn_eqType := Eval hnf in EqType sopn sopn_eqMixin.
(* ----------------------------------------------------------------------------- *)
Record instruction := mkInstruction {
str : unit -> string;
tin : list stype;
i_in : seq arg_desc;
tout : list stype;
i_out : seq arg_desc;
semi : sem_prod tin (exec (sem_tuple tout));
tin_narr : all is_not_sarr tin;
wsizei : wsize;
i_safe : seq safe_cond;
}.
Notation mk_instr str tin i_in tout i_out semi wsizei safe:=
{| str := str;
tin := tin;
i_in := i_in;
tout := tout;
i_out := i_out;
semi := semi;
tin_narr := refl_equal;
wsizei := wsizei;
i_safe := safe;
|}.
(* ----------------------------------------------------------------------------- *)
Definition Omulu_instr sz :=
mk_instr (pp_sz "mulu" sz)
(w2_ty sz sz) [:: R RAX; E 0]
(w2_ty sz sz) [:: R RDX; R RAX] (fun x y => ok (@wumul sz x y)) sz [::].
Definition Oaddcarry_instr sz :=
mk_instr (pp_sz "addc" sz)
[::sword sz; sword sz; sbool]
[::E 0; E 1; F CF]
(sbool :: (w_ty sz))
[:: F CF; E 0]
(fun x y c => let p := @waddcarry sz x y c in ok (Some p.1, p.2))
sz [::].
Definition Osubcarry_instr sz:=
mk_instr (pp_sz "subc" sz)
[::sword sz; sword sz; sbool] [::E 0; E 1; F CF]
(sbool :: (w_ty sz)) [:: F CF; E 0]
(fun x y c => let p := @wsubcarry sz x y c in ok (Some p.1, p.2))
sz [::].
Definition Oset0_instr sz :=
let name := pp_sz "set0" sz in
if (sz <= U64)%CMP then
mk_instr name
[::] [::]
(b5w_ty sz) (implicit_flags ++ [::E 0])
(let vf := Some false in
ok (::vf, vf, vf, vf, Some true & (0%R: word sz)))
sz [::]
else
mk_instr name
[::] [::]
(w_ty sz) [::E 0]
(ok (0%R: word sz)) sz [::].
Definition Ox86MOVZX32_instr :=
mk_instr (pp_s "MOVZX32")
[:: sword32] [:: E 1]
[:: sword64] [:: E 0]
(λ x : u32, ok (zero_extend U64 x))
U32 [::].
Definition get_instr o :=
match o with
| Omulu sz => Omulu_instr sz
| Oaddcarry sz => Oaddcarry_instr sz
| Osubcarry sz => Osubcarry_instr sz
| Oset0 sz => Oset0_instr sz
| Ox86MOVZX32 => Ox86MOVZX32_instr
| Ox86 instr =>
let id := instr_desc instr in
{|
str := id.(id_str_jas);
tin := id.(id_tin);
i_in := id.(id_in);
i_out := id.(id_out);
tout := id.(id_tout);
semi := id.(id_semi);
tin_narr := id.(id_tin_narr);
wsizei := id.(id_wsize);
i_safe := id.(id_safe)
|}
end.
Definition string_of_sopn o : string := str (get_instr o) tt.
Definition sopn_tin o : list stype := tin (get_instr o).
Definition sopn_tout o : list stype := tout (get_instr o).
Definition sopn_sem o := semi (get_instr o).
Definition wsize_of_sopn o : wsize := wsizei (get_instr o).
(* Type of unany operators: input, output *)
Definition type_of_op1 (o: sop1) : stype * stype :=
match o with
| Oword_of_int sz => (sint, sword sz)
| Oint_of_word sz => (sword sz, sint)
| Osignext szo szi
| Ozeroext szo szi
=> (sword szi, sword szo)
| Onot => (sbool, sbool)
| Olnot sz
| Oneg (Op_w sz)
=> let t := sword sz in (t, t)
| Oneg Op_int => (sint, sint)
end.
(* Type of binany operators: inputs, output *)
Definition type_of_op2 (o: sop2) : stype * stype * stype :=
match o with
| Oand | Oor => (sbool, sbool, sbool)
| Oadd Op_int
| Omul Op_int
| Osub Op_int
| Odiv Cmp_int | Omod Cmp_int
=> (sint, sint, sint)
| Oadd (Op_w s)
| Omul (Op_w s)
| Osub (Op_w s)
| Odiv (Cmp_w _ s) | Omod (Cmp_w _ s)
| Oland s | Olor s | Olxor s | Ovadd _ s | Ovsub _ s | Ovmul _ s
=> let t := sword s in (t, t, t)
| Olsr s | Olsl s | Oasr s
| Ovlsr _ s | Ovlsl _ s | Ovasr _ s
=> let t := sword s in (t, sword8, t)
| Oeq Op_int | Oneq Op_int
| Olt Cmp_int | Ole Cmp_int
| Ogt Cmp_int | Oge Cmp_int
=> (sint, sint, sbool)
| Oeq (Op_w s) | Oneq (Op_w s)
| Olt (Cmp_w _ s) | Ole (Cmp_w _ s)
| Ogt (Cmp_w _ s) | Oge (Cmp_w _ s)
=> let t := sword s in (t, t, sbool)
end.
(* Type of n-ary operators: inputs, output *)
Definition type_of_opN (op: opN) : seq stype * stype :=
match op with
| Opack ws p =>
let n := nat_of_wsize ws %/ nat_of_pelem p in
(nseq n sint, sword ws)
end.
(* ** Expressions
* -------------------------------------------------------------------- *)
(* Used only by the ocaml compiler *)
Definition var_info := positive.
Record var_i := VarI {
v_var :> var;
v_info : var_info
}.
Record var_attr := VarA {
va_pub : bool
}.
Definition var_info_to_attr (vi: var_info) :=
match vi with
| xI _ => VarA true
| _ => VarA false
end.
Inductive pexpr : Type :=
| Pconst :> Z -> pexpr
| Pbool :> bool -> pexpr
| Parr_init : positive → pexpr
| Pvar :> var_i -> pexpr
| Pglobal :> global -> pexpr
| Pget : wsize -> var_i -> pexpr -> pexpr
| Pload : wsize -> var_i -> pexpr -> pexpr
| Papp1 : sop1 -> pexpr -> pexpr
| Papp2 : sop2 -> pexpr -> pexpr -> pexpr
| PappN of opN & seq pexpr
| Pif : stype -> pexpr -> pexpr -> pexpr -> pexpr.
Notation pexprs := (seq pexpr).
Section ALL2.
Variable T:Type.
Variable eqb: T -> T -> bool.
Variable Heq : forall (x y:T), reflect (x = y) (eqb x y).
Lemma reflect_all2 l1 l2 : reflect (l1 = l2) (all2 eqb l1 l2).
Proof.
elim: l1 l2 => [|e1 l1 Hrec1] [|e2 l2] /=;try by constructor.
apply (@equivP (eqb e1 e2 /\ all2 eqb l1 l2));first by apply andP.
split=> [ [] /Heq -> /Hrec1 ->|[] ??] //.
split. by apply /Heq. by apply /Hrec1.
Defined.
End ALL2.
Section ALLT.
Context (A: Type) (P: A → Type).
Fixpoint allT (m: seq A) : Type :=
if m is a :: m' then P a * allT m' else unit.
End ALLT.
Lemma allT_refl A (P: A → A → Prop) m :
allT (λ a, P a a) m → List.Forall2 P m m.
Proof. by elim: m => // a m ih [h] /ih{ih}ih; constructor. Qed.
Section PEXPR_RECT.
Context
(P: pexpr → Type)
(Hconst: ∀ z, P (Pconst z))
(Hbool: ∀ b, P (Pbool b))
(Harr_init: ∀ n, P (Parr_init n))
(Hvar: ∀ x, P (Pvar x))
(Hglobal: ∀ g, P (Pglobal g))
(Hget: ∀ sz x e, P e → P (Pget sz x e))
(Hload: ∀ sz x e, P e → P (Pload sz x e))
(Happ1: ∀ op e, P e → P (Papp1 op e))
(Happ2: ∀ op e1 e2, P e1 → P e2 → P (Papp2 op e1 e2))
(HappN: ∀ op es, allT P es → P (PappN op es))
(Hif: ∀ t e e1 e2, P e → P e1 → P e2 → P (Pif t e e1 e2))
.
Definition pexpr_rect_rec (f: ∀ e, P e) : ∀ es, allT P es :=
fix loop es :=
if es is e :: es
then (f e, loop es)
else tt.
Fixpoint pexpr_rect (e: pexpr) : P e :=
match e with
| Pconst z => Hconst z
| Pbool b => Hbool b
| Parr_init n => Harr_init n
| Pvar x => Hvar x
| Pglobal g => Hglobal g
| Pget sz x e => Hget sz x (pexpr_rect e)
| Pload sz x e => Hload sz x (pexpr_rect e)
| Papp1 op e => Happ1 op (pexpr_rect e)
| Papp2 op e1 e2 => Happ2 op (pexpr_rect e1) (pexpr_rect e2)
| PappN op es => HappN op (pexpr_rect_rec pexpr_rect es)
| Pif t e e1 e2 => Hif t (pexpr_rect e) (pexpr_rect e1) (pexpr_rect e2)
end.
End PEXPR_RECT.
Arguments pexpr_rect: clear implicits.
Definition var_i_beq x1 x2 :=
match x1, x2 with
| VarI x1 i1, VarI x2 i2 => (x1 == x2) && (i1 == i2)
end.
Lemma var_i_eq_axiom : Equality.axiom var_i_beq.
Proof.
move=> [x xi] [y yi] /=.
apply (@equivP ((x == y) /\ (xi == yi)));first by apply: andP.
by split => -[] => [/eqP -> /eqP| -> ] ->.
Qed.
Definition var_i_eqMixin := Equality.Mixin var_i_eq_axiom.
Canonical var_i_eqType := Eval hnf in EqType var_i var_i_eqMixin.
Module Eq_pexpr.
Fixpoint eqb (e1 e2:pexpr) : bool :=
match e1, e2 with
| Pconst n1 , Pconst n2 => n1 == n2
| Pbool b1 , Pbool b2 => b1 == b2
| Parr_init n1, Parr_init n2 => n1 == n2
| Pvar x1 , Pvar x2 => (x1 == x2)
| Pglobal g1, Pglobal g2 => g1 == g2
| Pget sz1 x1 e1, Pget sz2 x2 e2 => (sz1 == sz2) && (x1 == x2) && eqb e1 e2
| Pload sz1 x1 e1, Pload sz2 x2 e2 => (sz1 == sz2) && (x1 == x2) && eqb e1 e2
| Papp1 o1 e1 , Papp1 o2 e2 => (o1 == o2) && eqb e1 e2
| Papp2 o1 e11 e12, Papp2 o2 e21 e22 =>
(o1 == o2) && eqb e11 e21 && eqb e12 e22
| PappN o1 es1, PappN o2 es2 =>
(o1 == o2) && all2 eqb es1 es2
| Pif t1 b1 e11 e12, Pif t2 b2 e21 e22 =>
(t1 == t2) && eqb b1 b2 && eqb e11 e21 && eqb e12 e22
| _, _ => false
end.
Lemma eqb_refl e : eqb e e.
Proof.
elim/pexpr_rect: e => //= *;
repeat match goal with
| H : _ |- _ => rewrite H //=
| |- context[ (?a == ?a) ] => rewrite eqxx //=
end.
apply/all2P; exact: allT_refl.
Qed.
Lemma eq_axiom : Equality.axiom eqb.
Proof.
elim => [n1|b1| n1 |x1|g1|w1 x1 e1 He1|w1 x1 e1 He1
|o1 e1 He1|o1 e11 e12 He11 He12 | o1 es1 Hes1 | st1 t1 e11 e12 Ht1 He11 He12]
[n2|b2| n2 |x2|g2|w2 x2 e2|w2 x2 e2|o2 e2|o2 e21 e22 | o2 es2 |st2 t2 e21 e22] /=;
try by constructor.
+ apply (@equivP (n1 = n2));first by apply: eqP.
by split => [->|[]->].
+ apply (@equivP (b1 = b2));first by apply: eqP.
by split => [->|[]->].
+ apply (@equivP (n1 = n2));first by apply eqP.
by split => [->|[]->].
+ apply (@equivP (x1 = x2));first by apply: eqP.
by split => [->|[]->].
+ apply (@equivP (g1 = g2));first by apply: eqP.
by split => [->|[]->].
+ apply (@equivP (((w1 == w2) && (x1 == x2)) /\ eqb e1 e2));first by apply andP.
split => [ [] /andP [] /eqP -> /eqP -> /He1 -> | [] -> -> <-] //.
by rewrite ! eq_refl; split => //; apply/ He1.
+ apply (@equivP (((w1 == w2) && (x1 == x2)) /\ eqb e1 e2)); first by apply andP.
split => [ [] /andP [] /eqP -> /eqP -> /He1 -> | [] -> -> <-] //.
by rewrite ! eq_refl; split => //; apply/ He1.
+ apply (@equivP ((o1 == o2) /\ eqb e1 e2));first by apply andP.
by split=> [ [] /eqP -> /He1 -> | [] -> <- ] //;split => //;apply /He1.
+ apply (@equivP (((o1 == o2) && eqb e11 e21) /\ eqb e12 e22));first by apply andP.
split=> [ []/andP[]/eqP-> /He11 -> /He12->| [] <- <- <- ] //.
by rewrite eq_refl /=;split;[apply /He11|apply /He12].
+ apply (@equivP ((o1 == o2) ∧ all2 eqb es1 es2)); first by apply: andP.
split.
- case => /eqP <-{o2} h; f_equal.
elim: es1 es2 Hes1 h; first by case.
by move => e1 es1 ih [] // e2 es2 [h1] /ih{ih}ih/=/andP[]/(rwP (h1 _)) <- /ih <-.
move => h.
have : o1 = o2 ∧ es1 = es2 by refine (let: erefl := h in conj erefl erefl).
move => {h} [??]; subst es2 o2; split; first exact: eqxx.
elim: es1 Hes1 => // e es ih [h] /ih{ih}ih /=.
by case: (h e).
apply (@equivP (((st1 == st2) && eqb t1 t2 && eqb e11 e21) /\ eqb e12 e22));first by apply andP.
split => [ [] /andP[]/andP[] /eqP -> /Ht1 -> /He11 -> /He12 ->| [<- <- <- <-]] //.
by split;[apply /andP;split;[apply /andP;split|]|]; [apply /eqP | apply /Ht1 | apply /He11 | apply /He12].
Qed.
Definition pexpr_eqMixin := Equality.Mixin eq_axiom.
Module Exports.
Canonical pexpr_eqType := Eval hnf in EqType pexpr pexpr_eqMixin.
End Exports.
End Eq_pexpr.
Export Eq_pexpr.Exports.
Section PEXPR_IND.
Context
(P: pexpr → Prop)
(Hconst: ∀ z, P (Pconst z))
(Hbool: ∀ b, P (Pbool b))
(Harr_init: ∀ n, P (Parr_init n))
(Hvar: ∀ x, P (Pvar x))
(Hglobal: ∀ g, P (Pglobal g))
(Hget: ∀ sz x e, P e → P (Pget sz x e))
(Hload: ∀ sz x e, P e → P (Pload sz x e))
(Happ1: ∀ op e, P e → P (Papp1 op e))
(Happ2: ∀ op e1, P e1 → ∀ e2, P e2 → P (Papp2 op e1 e2))
(HappN: ∀ op es, (∀ e, e \in es → P e) → P (PappN op es))
(Hif: ∀ t e, P e → ∀ e1, P e1 → ∀ e2, P e2 → P (Pif t e e1 e2))
.
Definition pexpr_ind_rec (f: ∀ e, P e) : ∀ es : pexprs, ∀ e, e \in es → P e.
refine
(fix loop es :=
if es is e :: es'
then λ (e: pexpr), _
else λ e (k: e \in [::]), False_ind _ (Bool.diff_false_true k)
).
rewrite in_cons; case/orP.
+ move => /eqP -> ; exact: f.
apply: loop.
Defined.
Fixpoint pexpr_ind (e: pexpr) : P e :=
match e with
| Pconst z => Hconst z
| Pbool b => Hbool b
| Parr_init n => Harr_init n
| Pvar x => Hvar x
| Pglobal g => Hglobal g
| Pget sz x e => Hget sz x (pexpr_ind e)
| Pload sz x e => Hload sz x (pexpr_ind e)
| Papp1 op e => Happ1 op (pexpr_ind e)
| Papp2 op e1 e2 => Happ2 op (pexpr_ind e1) (pexpr_ind e2)
| PappN op es => HappN op (@pexpr_ind_rec pexpr_ind es)
| Pif t e e1 e2 => Hif t (pexpr_ind e) (pexpr_ind e1) (pexpr_ind e2)
end.
End PEXPR_IND.
(* Mutual induction scheme for pexpr and pexprs *)
Section PEXPRS_IND.
Context
(P: pexpr → Prop)
(Q: pexprs → Prop)
.
Record pexpr_ind_hypotheses : Prop := {
pexprs_nil: Q [::];
pexprs_cons: ∀ pe, P pe → ∀ pes, Q pes → Q (pe :: pes);
pexprs_const: ∀ z, P (Pconst z);
pexprs_bool: ∀ b, P (Pbool b);
pexprs_arr_init: ∀ n, P (Parr_init n);
pexprs_var: ∀ x, P (Pvar x);
pexprs_global: ∀ g, P (Pglobal g);
pexprs_get: ∀ sz x e, P e → P (Pget sz x e);
pexprs_load: ∀ sz x e, P e → P (Pload sz x e);
pexprs_app1: ∀ op e, P e → P (Papp1 op e);
pexprs_app2: ∀ op e1, P e1 → ∀ e2, P e2 → P (Papp2 op e1 e2);
pexprs_appN: ∀ op es, Q es → P (PappN op es);
pexprs_if: ∀ t e, P e → ∀ e1, P e1 → ∀ e2, P e2 → P (Pif t e e1 e2);
}.
Context (h: pexpr_ind_hypotheses).
Definition pexprs_ind pexpr_mut_ind : ∀ pes, Q pes :=
fix pexprs_ind pes :=
if pes is pe :: pes'
then pexprs_cons h (pexpr_mut_ind pe) (pexprs_ind pes')
else pexprs_nil h.
Fixpoint pexpr_mut_ind pe : P pe :=
match pe with
| Pconst z => pexprs_const h z
| Pbool b => pexprs_bool h b
| Parr_init n => pexprs_arr_init h n
| Pvar x => pexprs_var h x
| Pglobal g => pexprs_global h g
| Pget sz x e => pexprs_get h sz x (pexpr_mut_ind e)
| Pload sz x e => pexprs_load h sz x (pexpr_mut_ind e)
| Papp1 op e => pexprs_app1 h op (pexpr_mut_ind e)
| Papp2 op e1 e2 => pexprs_app2 h op (pexpr_mut_ind e1) (pexpr_mut_ind e2)
| PappN op es => pexprs_appN h op (pexprs_ind pexpr_mut_ind es)
| Pif t e e1 e2 => pexprs_if h t (pexpr_mut_ind e) (pexpr_mut_ind e1) (pexpr_mut_ind e2)
end.
Definition pexprs_ind_pair :=
conj pexpr_mut_ind (pexprs_ind pexpr_mut_ind).
End PEXPRS_IND.
(* ** Left values
* -------------------------------------------------------------------- *)
Variant lval : Type :=
| Lnone `(var_info) `(stype)
| Lvar `(var_i)
| Lmem `(wsize) `(var_i) `(pexpr)
| Laset `(wsize) `(var_i) `(pexpr).
Coercion Lvar : var_i >-> lval.
Notation lvals := (seq lval).
Definition lval_beq (x1:lval) (x2:lval) :=
match x1, x2 with
| Lnone i1 t1, Lnone i2 t2 => (i1 == i2) && (t1 == t2)
| Lvar x1 , Lvar x2 => x1 == x2
| Lmem w1 x1 e1, Lmem w2 x2 e2 => (w1 == w2) && (x1 == x2) && (e1 == e2)
| Laset w1 x1 e1, Laset w2 x2 e2 => (w1 == w2) && (x1 == x2) && (e1 == e2)
| _ , _ => false
end.
Lemma lval_eq_axiom : Equality.axiom lval_beq.
Proof.
case=> [i1 t1|x1|w1 x1 e1|w1 x1 e1] [i2 t2|x2|w2 x2 e2|w2 x2 e2] /=;try by constructor.
+ apply (@equivP ((i1 == i2) /\ t1 == t2));first by apply andP.
by split=> [ [] /eqP -> /eqP -> | [] -> <- ] //.
+ apply (@equivP (x1 = x2));first by apply: eqP.
by split => [->|[]->].
+ apply (@equivP (((w1 == w2) && (x1 == x2)) /\ e1 == e2));first by apply andP.
split => [ [] /andP [] /eqP -> /eqP -> /eqP -> // | [] -> -> <- ].
by rewrite !eq_refl.
apply (@equivP (((w1 == w2) && (x1 == x2)) /\ e1 == e2));first by apply andP.
split => [ [] /andP [] /eqP -> /eqP -> /eqP -> // | [] -> -> <- ].
by rewrite !eq_refl.
Qed.
Definition lval_eqMixin := Equality.Mixin lval_eq_axiom.
Canonical lval_eqType := Eval hnf in EqType lval lval_eqMixin.
(* ** Instructions
* -------------------------------------------------------------------- *)
Variant dir := UpTo | DownTo.
Scheme Equality for dir.
Lemma dir_eq_axiom : Equality.axiom dir_beq.
Proof.
move=> x y;apply:(iffP idP).
+ by apply: internal_dir_dec_bl.
by apply: internal_dir_dec_lb.
Qed.
Definition dir_eqMixin := Equality.Mixin dir_eq_axiom.
Canonical dir_eqType := Eval hnf in EqType dir dir_eqMixin.
Definition range := (dir * pexpr * pexpr)%type.
Definition wrange d (n1 n2 : Z) :=
let n := Z.to_nat (n2 - n1) in
match d with
| UpTo => [seq (Z.add n1 (Z.of_nat i)) | i <- iota 0 n]
| DownTo => [seq (Z.sub n2 (Z.of_nat i)) | i <- iota 0 n]
end.
Definition instr_info := positive.
Variant assgn_tag :=
| AT_none (* assignment introduced by the develloper that can be removed *)
| AT_keep (* assignment that should be keep *)
| AT_rename (* equality constraint introduced by inline *)
| AT_inline. (* assignment to be removed later : introduce by unrolling or inlining *)
Scheme Equality for assgn_tag.
Lemma assgn_tag_eq_axiom : Equality.axiom assgn_tag_beq.
Proof.
move=> x y;apply:(iffP idP).
+ by apply: internal_assgn_tag_dec_bl.
by apply: internal_assgn_tag_dec_lb.
Qed.
Definition assgn_tag_eqMixin := Equality.Mixin assgn_tag_eq_axiom.
Canonical assgn_tag_eqType := Eval hnf in EqType assgn_tag assgn_tag_eqMixin.
(* -------------------------------------------------------------------- *)
Variant inline_info :=
| InlineFun
| DoNotInline.
Scheme Equality for inline_info.
Lemma inline_info_eq_axiom : Equality.axiom inline_info_beq.
Proof.
move=> x y;apply:(iffP idP).
+ by apply: internal_inline_info_dec_bl.
by apply: internal_inline_info_dec_lb.
Qed.
Definition inline_info_eqMixin := Equality.Mixin inline_info_eq_axiom.
Canonical inline_info_eqType := Eval hnf in EqType inline_info inline_info_eqMixin.
(* -------------------------------------------------------------------- *)
Variant align :=
| Align
| NoAlign.
Scheme Equality for align.
Lemma align_eq_axiom : Equality.axiom align_beq.
Proof.
move=> x y;apply:(iffP idP).
+ by apply: internal_align_dec_bl.
by apply: internal_align_dec_lb.
Qed.
Definition align_eqMixin := Equality.Mixin align_eq_axiom.
Canonical align_eqType := Eval hnf in EqType align align_eqMixin.
(* -------------------------------------------------------------------- *)
Inductive instr_r :=
| Cassgn : lval -> assgn_tag -> stype -> pexpr -> instr_r
| Copn : lvals -> assgn_tag -> sopn -> pexprs -> instr_r
| Cif : pexpr -> seq instr -> seq instr -> instr_r
| Cfor : var_i -> range -> seq instr -> instr_r
| Cwhile : align -> seq instr -> pexpr -> seq instr -> instr_r
| Ccall : inline_info -> lvals -> funname -> pexprs -> instr_r
with instr := MkI : instr_info -> instr_r -> instr.
Notation cmd := (seq instr).
Record fundef := MkFun {
f_iinfo : instr_info;
f_tyin : seq stype;
f_params : seq var_i;
f_body : cmd;
f_tyout : seq stype;
f_res : seq var_i;
}.
Definition function_signature : Type :=
(seq stype * seq stype).
Definition signature_of_fundef (fd: fundef) : function_signature :=
(f_tyin fd, f_tyout fd).
Definition fun_decl := (funname * fundef)%type.
Notation fun_decls := (seq fun_decl).
Record prog := {
p_globs : glob_decls;
p_funcs : fun_decls;
}.
Definition instr_d (i:instr) :=
match i with
| MkI i _ => i
end.
Fixpoint instr_r_beq i1 i2 :=
match i1, i2 with
| Cassgn x1 tag1 ty1 e1, Cassgn x2 tag2 ty2 e2 =>
(tag1 == tag2) && (ty1 == ty2) && (x1 == x2) && (e1 == e2)
| Copn x1 tag1 o1 e1, Copn x2 tag2 o2 e2 =>
(x1 == x2) && (tag1 == tag2) && (o1 == o2) && (e1 == e2)
| Cif e1 c11 c12, Cif e2 c21 c22 =>
(e1 == e2) && all2 instr_beq c11 c21 && all2 instr_beq c12 c22
| Cfor i1 (dir1,lo1,hi1) c1, Cfor i2 (dir2,lo2,hi2) c2 =>
(i1 == i2) && (dir1 == dir2) && (lo1 == lo2) && (hi1 == hi2) && all2 instr_beq c1 c2
| Cwhile a1 c1 e1 c1' , Cwhile a2 c2 e2 c2' =>
(a1 == a2) && all2 instr_beq c1 c2 && (e1 == e2) && all2 instr_beq c1' c2'
| Ccall ii1 x1 f1 arg1, Ccall ii2 x2 f2 arg2 =>
(ii1 == ii2) && (x1==x2) && (f1 == f2) && (arg1 == arg2)
| _, _ => false
end
with instr_beq i1 i2 :=
match i1, i2 with
| MkI if1 i1, MkI if2 i2 => (if1 == if2) && (instr_r_beq i1 i2)
end.
Section EQI.
Variable Heq : forall (x y:instr_r), reflect (x=y) (instr_r_beq x y).
Lemma instr_eq_axiom_ : Equality.axiom instr_beq.
Proof.
move=> [ii1 ir1] [ii2 ir2].
apply (@equivP (ii1 == ii2 /\ instr_r_beq ir1 ir2));first by apply andP.
by split=> [[] /eqP -> /Heq -> |[]/eqP ?/Heq ]//; split.
Defined.
End EQI.
Lemma instr_r_eq_axiom : Equality.axiom instr_r_beq.
Proof.
rewrite /Equality.axiom.
fix Hrec 1;case =>
[x1 t1 ty1 e1|x1 t1 o1 e1|e1 c11 c12|x1 [[dir1 lo1] hi1] c1|a1 c1 e1 c1'|ii1 x1 f1 arg1]
[x2 t2 ty2 e2|x2 t2 o2 e2|e2 c21 c22|x2 [[dir2 lo2] hi2] c2|a2 c2 e2 c2'|ii2 x2 f2 arg2] /=;
try by constructor.
+ apply (@equivP ((t1 == t2) && (ty1 == ty2) && (x1 == x2) && (e1 == e2)));first by apply idP.
split=> [/andP [] /andP [] /andP [] /eqP -> /eqP-> /eqP-> /eqP-> | [] <- <- <- <- ] //.
by rewrite !eq_refl.
+ apply (@equivP ((x1 == x2) && (t1 == t2)&& (o1 == o2) && (e1 == e2)));first by apply idP.
split=> [/andP [] /andP [] /andP [] /eqP-> /eqP-> /eqP-> /eqP-> | [] <- <- <- <-] //.
by rewrite !eq_refl.
+ apply (@equivP ((e1 == e2) && (all2 instr_beq c11 c21) && (all2 instr_beq c12 c22)));
first by apply idP.
have H := reflect_all2 (instr_eq_axiom_ Hrec).
split=> [/andP[]/andP[]| []] /eqP -> /H -> /H -> //.
+ apply (@equivP ((x1 == x2) && (dir1 == dir2) && (lo1 == lo2) && (hi1 == hi2) &&
all2 instr_beq c1 c2)); first by apply idP.
have H := reflect_all2 (instr_eq_axiom_ Hrec).
split=> [/andP[]/andP[]/andP[]/andP[]| []] /eqP->/eqP->/eqP->/eqP->/H-> //.
+ apply (@equivP ((a1 == a2) && all2 instr_beq c1 c2 && (e1 == e2) && all2 instr_beq c1' c2')); first by apply idP.
have H := reflect_all2 (instr_eq_axiom_ Hrec).
split=> [/andP[]/andP[]/andP[]/eqP->/H->/eqP->/H-> | []/eqP->/H->/eqP->/H->] //.
apply (@equivP ((ii1 == ii2) && (x1 == x2) && (f1 == f2) && (arg1 == arg2)));first by apply idP.
by split=> [/andP[]/andP[]/andP[]| []]/eqP->/eqP->/eqP->/eqP->.
Qed.
Definition instr_r_eqMixin := Equality.Mixin instr_r_eq_axiom.
Canonical instr_r_eqType := Eval hnf in EqType instr_r instr_r_eqMixin.
Lemma instr_eq_axiom : Equality.axiom instr_beq.
Proof.
apply: instr_eq_axiom_ instr_r_eq_axiom .
Qed.
Definition instr_eqMixin := Equality.Mixin instr_eq_axiom.
Canonical instr_eqType := Eval hnf in EqType instr instr_eqMixin.
Definition fundef_beq fd1 fd2 :=
match fd1, fd2 with
| MkFun ii1 tin1 x1 c1 tout1 r1, MkFun ii2 tin2 x2 c2 tout2 r2 =>
(ii1 == ii2) && (tin1 == tin2) && (x1 == x2) && (c1 == c2) && (tout1 == tout2) && (r1 == r2)
end.
Lemma fundef_eq_axiom : Equality.axiom fundef_beq.
Proof.
move=> [i1 tin1 p1 c1 tout1 r1] [i2 tin2 p2 c2 tout2 r2] /=.
apply (@equivP ((i1 == i2) && (tin1 == tin2) && (p1 == p2) &&
(c1 == c2) && (tout1 == tout2) &&(r1 == r2)));first by apply idP.
by split=> [/andP[]/andP[]/andP[]/andP[]/andP[] | []] /eqP->/eqP->/eqP->/eqP->/eqP->/eqP->.
Qed.
Definition fundef_eqMixin := Equality.Mixin fundef_eq_axiom.
Canonical fundef_eqType := Eval hnf in EqType fundef fundef_eqMixin.
Definition prog_beq p1 p2 := (p_globs p1 == p_globs p2) && (p_funcs p1 == p_funcs p2).
Lemma prog_eq_axiom : Equality.axiom prog_beq.
Proof.
move=> [gd1 fs1] [gd2 fs2] /=.
apply (@equivP ((gd1 == gd2) && (fs1 == fs2)));first by apply idP.
by split => [/andP [] | []] /eqP -> /eqP ->.
Qed.
Definition prog_eqMixin := Equality.Mixin prog_eq_axiom.
Canonical prog_eqType := Eval hnf in EqType prog prog_eqMixin.
Definition map_prog (F: fundef -> fundef) (p:prog) :=
{| p_globs := p_globs p;
p_funcs := map (fun f => (f.1, F f.2)) (p_funcs p) |}.
Lemma map_prog_globs F p : p_globs (map_prog F p) = p_globs p.
Proof. done. Qed.
Lemma get_map_prog F p fn :
get_fundef (p_funcs (map_prog F p)) fn = omap F (get_fundef (p_funcs p) fn).
Proof. exact: assoc_map. Qed.
Lemma get_fundef_cons {T} (fnd: funname * T) p fn:
get_fundef (fnd :: p) fn = if fn == fnd.1 then Some fnd.2 else get_fundef p fn.
Proof. by case: fnd. Qed.
Lemma get_fundef_in {T} p f (fd: T) : get_fundef p f = Some fd -> f \in [seq x.1 | x <- p].
Proof. by rewrite/get_fundef; apply: assoc_mem_dom'. Qed.
Lemma get_fundef_in' {T} p fn (fd: T):
get_fundef p fn = Some fd -> List.In (fn, fd) p.
Proof. exact: assoc_mem'. Qed.
Definition all_prog {aT bT cT} (s1: seq (funname * aT)) (s2: seq (funname * bT)) (ll: seq cT) f :=
(size s1 == size s2) && all2 (fun fs a => let '(fd1, fd2) := fs in (fd1.1 == fd2.1) && f a fd1.2 fd2.2) (zip s1 s2) ll.
Lemma all_progP {aT bT cT} (s1: seq (funname * aT)) (s2: seq (funname * bT)) (l: seq cT) f:
all_prog s1 s2 l f ->
forall fn fd, get_fundef s1 fn = Some fd ->
exists fd' l', get_fundef s2 fn = Some fd' /\ f l' fd fd'.
Proof.
elim: s1 s2 l=> // [[fn fd] p IH] [|[fn' fd'] p'] // [|lh la] //.
+ by rewrite /all_prog /= andbF.
+ move=> /andP [/= Hs /andP [/andP [/eqP Hfn Hfd] Hall]].
move=> fn0 fd0.
case: ifP=> /eqP Hfn0.
+ move=> [] <-.
exists fd', lh.
rewrite -Hfn Hfn0 /= eq_refl; split=> //.
+ move=> H.
have [|fd'' [l' [IH1 IH2]]] := (IH p' la _ _ _ H).
apply/andP; split.
by rewrite -eqSS.
exact: Hall.
exists fd'', l'; split=> //.
rewrite /= -Hfn.
by case: ifP=> // /eqP.
Qed.
Section RECT.
Variables (Pr:instr_r -> Type) (Pi:instr -> Type) (Pc : cmd -> Type).
Hypothesis Hmk : forall i ii, Pr i -> Pi (MkI ii i).
Hypothesis Hnil : Pc [::].
Hypothesis Hcons: forall i c, Pi i -> Pc c -> Pc (i::c).
Hypothesis Hasgn: forall x tg ty e, Pr (Cassgn x tg ty e).
Hypothesis Hopn : forall xs t o es, Pr (Copn xs t o es).
Hypothesis Hif : forall e c1 c2, Pc c1 -> Pc c2 -> Pr (Cif e c1 c2).
Hypothesis Hfor : forall v dir lo hi c, Pc c -> Pr (Cfor v (dir,lo,hi) c).
Hypothesis Hwhile : forall a c e c', Pc c -> Pc c' -> Pr (Cwhile a c e c').
Hypothesis Hcall: forall i xs f es, Pr (Ccall i xs f es).
Section C.
Variable instr_rect : forall i, Pi i.
Fixpoint cmd_rect_aux (c:cmd) : Pc c :=
match c return Pc c with
| [::] => Hnil
| i::c => @Hcons i c (instr_rect i) (cmd_rect_aux c)
end.
End C.
Fixpoint instr_Rect (i:instr) : Pi i :=
match i return Pi i with
| MkI ii i => @Hmk i ii (instr_r_Rect i)
end
with instr_r_Rect (i:instr_r) : Pr i :=
match i return Pr i with
| Cassgn x tg ty e => Hasgn x tg ty e
| Copn xs t o es => Hopn xs t o es
| Cif e c1 c2 => @Hif e c1 c2 (cmd_rect_aux instr_Rect c1) (cmd_rect_aux instr_Rect c2)
| Cfor i (dir,lo,hi) c => @Hfor i dir lo hi c (cmd_rect_aux instr_Rect c)
| Cwhile a c e c' => @Hwhile a c e c' (cmd_rect_aux instr_Rect c) (cmd_rect_aux instr_Rect c')
| Ccall ii xs f es => @Hcall ii xs f es
end.
Definition cmd_rect := cmd_rect_aux instr_Rect.
End RECT.
(* ** Compute written variables
* -------------------------------------------------------------------- *)
Definition vrv_rec (s:Sv.t) (rv:lval) :=
match rv with
| Lnone _ _ => s
| Lvar x => Sv.add x s
| Lmem _ _ _ => s
| Laset _ x _ => Sv.add x s
end.
Definition vrvs_rec s (rv:lvals) := foldl vrv_rec s rv.
Definition vrv := (vrv_rec Sv.empty).
Definition vrvs := (vrvs_rec Sv.empty).
Fixpoint write_i_rec s i :=
match i with
| Cassgn x _ _ _ => vrv_rec s x
| Copn xs _ _ _ => vrvs_rec s xs
| Cif _ c1 c2 => foldl write_I_rec (foldl write_I_rec s c2) c1
| Cfor x _ c => foldl write_I_rec (Sv.add x s) c
| Cwhile _ c _ c' => foldl write_I_rec (foldl write_I_rec s c') c
| Ccall _ x _ _ => vrvs_rec s x
end
with write_I_rec s i :=
match i with
| MkI _ i => write_i_rec s i
end.
Definition write_i i := write_i_rec Sv.empty i.
Definition write_I i := write_I_rec Sv.empty i.
Definition write_c_rec s c := foldl write_I_rec s c.
Definition write_c c := write_c_rec Sv.empty c.
Instance vrv_rec_m : Proper (Sv.Equal ==> eq ==> Sv.Equal) vrv_rec.
Proof.
move=> s1 s2 Hs x r ->;case:r => //= [v | _ v _];SvD.fsetdec.
Qed.
Lemma vrv_none i t: vrv (Lnone i t) = Sv.empty.
Proof. by []. Qed.
Lemma vrv_var x: Sv.Equal (vrv (Lvar x)) (Sv.singleton x).
Proof. rewrite /vrv /=;SvD.fsetdec. Qed.
Lemma vrv_mem w x e : vrv (Lmem w x e) = Sv.empty.
Proof. by []. Qed.
Lemma vrv_aset w x e : Sv.Equal (vrv (Laset w x e)) (Sv.singleton x).
Proof. rewrite /vrv /=;SvD.fsetdec. Qed.
Lemma vrv_recE s (r:lval) : Sv.Equal (vrv_rec s r) (Sv.union s (vrv r)).
Proof.
case: r => [i| x| x e| x e];
rewrite ?vrv_none ?vrv_var ?vrv_mem ?vrv_aset /=;
SvD.fsetdec.
Qed.
Lemma vrvs_recE s rs : Sv.Equal (vrvs_rec s rs) (Sv.union s (vrvs rs)).
Proof.
rewrite /vrvs;elim: rs s => [|r rs Hrec] s /=;first by SvD.fsetdec.
rewrite Hrec (Hrec (vrv_rec _ _)) (vrv_recE s);SvD.fsetdec.
Qed.
Lemma vrvs_cons r rs : Sv.Equal (vrvs (r::rs)) (Sv.union (vrv r) (vrvs rs)).
Proof. by rewrite /vrvs /= vrvs_recE. Qed.
Lemma write_c_recE s c : Sv.Equal (write_c_rec s c) (Sv.union s (write_c c)).
Proof.
apply (@cmd_rect
(fun i => forall s, Sv.Equal (write_i_rec s i) (Sv.union s (write_i i)))
(fun i => forall s, Sv.Equal (write_I_rec s i) (Sv.union s (write_I i)))
(fun c => forall s, Sv.Equal (foldl write_I_rec s c) (Sv.union s (write_c c)))) =>
/= {c s}
[ i ii Hi | | i c Hi Hc | x tg ty e | xs t o es | e c1 c2 Hc1 Hc2
| v dir lo hi c Hc | a c e c' Hc Hc' | ii xs f es] s;
rewrite /write_I /write_i /write_c /=
?Hc1 ?Hc2 /write_c_rec ?Hc ?Hc' ?Hi -?vrv_recE -?vrvs_recE //;
by SvD.fsetdec.
Qed.
Lemma write_I_recE s i : Sv.Equal (write_I_rec s i) (Sv.union s (write_I i)).
Proof. by apply (write_c_recE s [:: i]). Qed.
Lemma write_i_recE s i : Sv.Equal (write_i_rec s i) (Sv.union s (write_i i)).
Proof. by apply (write_I_recE s (MkI 1%positive i)). Qed.
Lemma write_c_nil : write_c [::] = Sv.empty.
Proof. done. Qed.
Lemma write_c_cons i c: Sv.Equal (write_c (i::c)) (Sv.union (write_I i) (write_c c)).
Proof. rewrite {1}/write_c /= write_c_recE write_I_recE;SvD.fsetdec. Qed.
Lemma write_c_app c1 c2 :
Sv.Equal (write_c (c1 ++ c2)) (Sv.union (write_c c1) (write_c c2)).
Proof. by elim: c1 => //= i c1 Hrec;rewrite !write_c_cons;SvD.fsetdec. Qed.
Lemma write_i_assgn x tag ty e : write_i (Cassgn x tag ty e) = vrv x.
Proof. done. Qed.
Lemma write_i_opn xs t o es : write_i (Copn xs t o es) = vrvs xs.
Proof. done. Qed.
Lemma write_i_if e c1 c2 :
Sv.Equal (write_i (Cif e c1 c2)) (Sv.union (write_c c1) (write_c c2)).
Proof.
rewrite /write_i /= -/(write_c_rec _ c1) -/(write_c_rec _ c2) !write_c_recE;SvD.fsetdec.
Qed.
Lemma write_i_for x rn c :
Sv.Equal (write_i (Cfor x rn c)) (Sv.union (Sv.singleton x) (write_c c)).
Proof.
rewrite /write_i /= -/(write_c_rec _ c) write_c_recE ;SvD.fsetdec.
Qed.
Lemma write_i_while a c e c' :
Sv.Equal (write_i (Cwhile a c e c')) (Sv.union (write_c c) (write_c c')).
Proof.
rewrite /write_i /= -/(write_c_rec _ c) write_c_recE;SvD.fsetdec.
Qed.
Lemma write_i_call ii xs f es :
write_i (Ccall ii xs f es) = vrvs xs.
Proof. done. Qed.
(* -------------------------------------------------------------------- *)
Hint Rewrite write_c_nil write_c_cons : write_c.
Hint Rewrite write_i_assgn write_i_opn write_i_if : write_i.
Hint Rewrite write_i_while write_i_for write_i_call : write_i.
Hint Rewrite vrv_none vrv_var : vrv.
Ltac writeN := autorewrite with write_c write_i vrv.
(* ** Compute read variables
* -------------------------------------------------------------------- *)
Fixpoint read_e_rec (s:Sv.t) (e:pexpr) : Sv.t :=
match e with
| Pconst _
| Pbool _
| Parr_init _ => s
| Pvar x => Sv.add x s
| Pglobal _ => s
| Pget _ x e => read_e_rec (Sv.add x s) e
| Pload _ x e => read_e_rec (Sv.add x s) e
| Papp1 _ e => read_e_rec s e
| Papp2 _ e1 e2 => read_e_rec (read_e_rec s e2) e1
| PappN _ es => foldl read_e_rec s es
| Pif _ t e1 e2 => read_e_rec (read_e_rec (read_e_rec s e2) e1) t
end.
Definition read_e := read_e_rec Sv.empty.
Definition read_es_rec := foldl read_e_rec.
Definition read_es := read_es_rec Sv.empty.
Definition read_rv_rec (s:Sv.t) (r:lval) :=
match r with
| Lnone _ _ => s
| Lvar _ => s
| Lmem _ x e => read_e_rec (Sv.add x s) e
| Laset _ x e => read_e_rec (Sv.add x s) e
end.
Definition read_rv := read_rv_rec Sv.empty.
Definition read_rvs_rec := foldl read_rv_rec.
Definition read_rvs := read_rvs_rec Sv.empty.
Fixpoint read_i_rec (s:Sv.t) (i:instr_r) : Sv.t :=
match i with
| Cassgn x _ _ e => read_rv_rec (read_e_rec s e) x
| Copn xs _ _ es => read_es_rec (read_rvs_rec s xs) es
| Cif b c1 c2 =>
let s := foldl read_I_rec s c1 in
let s := foldl read_I_rec s c2 in
read_e_rec s b
| Cfor x (dir, e1, e2) c =>
let s := foldl read_I_rec s c in
read_e_rec (read_e_rec s e2) e1
| Cwhile a c e c' =>
let s := foldl read_I_rec s c in
let s := foldl read_I_rec s c' in
read_e_rec s e
| Ccall _ xs _ es => read_es_rec (read_rvs_rec s xs) es
end
with read_I_rec (s:Sv.t) (i:instr) : Sv.t :=
match i with
| MkI _ i => read_i_rec s i
end.
Definition read_c_rec := foldl read_I_rec.
Definition read_i := read_i_rec Sv.empty.
Definition read_I := read_I_rec Sv.empty.
Definition read_c := read_c_rec Sv.empty.
Lemma read_eE e s : Sv.Equal (read_e_rec s e) (Sv.union (read_e e) s).
Proof.
elim: e s => //= [v | w v e He | w v e He | o e1 He1 e2 He2 | o es Hes | t e He e1 He1 e2 He2] s;
rewrite /read_e /= ?He ?He1 ?He2; try SvD.fsetdec.
rewrite -/read_es_rec -/read_es.
elim: es Hes s.
+ by move => _ /= s; SvD.fsetdec.
move => e es ih Hes s /=.
rewrite /read_es /= -/read_e ih.
+ rewrite Hes.
+ rewrite ih.
+ by SvD.fsetdec.
move => e' he' s'; apply: Hes.
by rewrite in_cons he' orbT.
by rewrite in_cons eqxx.
move => e' he' s'; apply: Hes.
by rewrite in_cons he' orbT.
Qed.
Lemma read_e_var (x:var_i) : Sv.Equal (read_e (Pvar x)) (Sv.singleton x).
Proof. rewrite /read_e /=;SvD.fsetdec. Qed.
Lemma read_esE es s : Sv.Equal (read_es_rec s es) (Sv.union (read_es es) s).
Proof.
elim: es s => [ | e es Hes] s;rewrite /read_es /= ?Hes ?read_eE;SvD.fsetdec.
Qed.
Lemma read_es_cons e es :
Sv.Equal (read_es (e :: es)) (Sv.union (read_e e) (read_es es)).
Proof. by rewrite /read_es /= !read_esE read_eE;SvD.fsetdec. Qed.
Lemma read_rvE s x: Sv.Equal (read_rv_rec s x) (Sv.union s (read_rv x)).
Proof.
case: x => //= [_|_|w x e|w x e]; rewrite /read_rv /= ?read_eE; SvD.fsetdec.
Qed.
Lemma read_rvsE s xs: Sv.Equal (read_rvs_rec s xs) (Sv.union s (read_rvs xs)).
Proof.
elim: xs s => [ |x xs Hxs] s;rewrite /read_rvs /= ?Hxs ?read_rvE;SvD.fsetdec.
Qed.
Lemma read_rvs_nil : read_rvs [::] = Sv.empty.
Proof. done. Qed.
Lemma read_rvs_cons x xs : Sv.Equal (read_rvs (x::xs)) (Sv.union (read_rv x) (read_rvs xs)).
Proof.
rewrite {1}/read_rvs /= read_rvsE read_rvE;SvD.fsetdec.
Qed.
Lemma read_cE s c : Sv.Equal (read_c_rec s c) (Sv.union s (read_c c)).
Proof.
apply (@cmd_rect
(fun i => forall s, Sv.Equal (read_i_rec s i) (Sv.union s (read_i i)))
(fun i => forall s, Sv.Equal (read_I_rec s i) (Sv.union s (read_I i)))
(fun c => forall s, Sv.Equal (foldl read_I_rec s c) (Sv.union s (read_c c))))
=> /= {c s}
[ i ii Hi | | i c Hi Hc | x tg ty e | xs t o es | e c1 c2 Hc1 Hc2
| v dir lo hi c Hc | a c e c' Hc Hc' | ii xs f es] s;
rewrite /read_I /read_i /read_c /=
?read_rvE ?read_eE ?read_esE ?read_rvsE ?Hc2 ?Hc1 /read_c_rec ?Hc' ?Hc ?Hi //;
by SvD.fsetdec.
Qed.
Lemma read_IE s i : Sv.Equal (read_I_rec s i) (Sv.union s (read_I i)).
Proof. by apply (read_cE s [:: i]). Qed.
Lemma read_iE s i : Sv.Equal (read_i_rec s i) (Sv.union s (read_i i)).
Proof. by apply (read_IE s (MkI 1%positive i)). Qed.
Lemma read_c_nil : read_c [::] = Sv.empty.
Proof. done. Qed.
Lemma read_c_cons i c: Sv.Equal (read_c (i::c)) (Sv.union (read_I i) (read_c c)).
Proof. by rewrite {1}/read_c /= read_cE //. Qed.
Lemma read_i_assgn x tag ty e :
Sv.Equal (read_i (Cassgn x tag ty e)) (Sv.union (read_rv x) (read_e e)).
Proof. rewrite /read_i /= read_rvE read_eE;SvD.fsetdec. Qed.
Lemma read_i_opn xs t o es:
Sv.Equal (read_i (Copn xs t o es)) (Sv.union (read_rvs xs) (read_es es)).
Proof. by rewrite /read_i /= read_esE read_rvsE;SvD.fsetdec. Qed.
Lemma read_i_if e c1 c2 :
Sv.Equal (read_i (Cif e c1 c2)) (Sv.union (read_e e) (Sv.union (read_c c1) (read_c c2))).
Proof.
rewrite /read_i /= -/read_c_rec read_eE !read_cE;SvD.fsetdec.
Qed.
Lemma read_i_for x dir lo hi c :
Sv.Equal (read_i (Cfor x (dir, lo, hi) c))
(Sv.union (read_e lo) (Sv.union (read_e hi) (read_c c))).
Proof.
rewrite /read_i /= -/read_c_rec !read_eE read_cE;SvD.fsetdec.
Qed.
Lemma read_i_while a c e c' :
Sv.Equal (read_i (Cwhile a c e c'))
(Sv.union (read_c c) (Sv.union (read_e e) (read_c c'))).
Proof.
rewrite /read_i /= -/read_c_rec !read_eE read_cE;SvD.fsetdec.
Qed.
Lemma read_i_call ii xs f es :
Sv.Equal (read_i (Ccall ii xs f es)) (Sv.union (read_rvs xs) (read_es es)).
Proof. rewrite /read_i /= read_esE read_rvsE;SvD.fsetdec. Qed.
Lemma read_Ii ii i: read_I (MkI ii i) = read_i i.
Proof. by done. Qed.
(* ** Some smart constructors
* -------------------------------------------------------------------------- *)
Fixpoint is_const (e:pexpr) :=
match e with
| Pconst n => Some n
| _ => None
end.
Definition is_bool (e:pexpr) :=
match e with
| Pbool b => Some b
| _ => None
end.
Definition wconst (sz: wsize) (n: word sz) : pexpr :=
Papp1 (Oword_of_int sz) (Pconst (wunsigned n)).
Definition is_wconst (sz: wsize) (e: pexpr) : option (word sz) :=
match e with
| Papp1 (Oword_of_int sz') e =>
if (sz <= sz')%CMP then
is_const e >>= λ n, Some (zero_extend sz (wrepr sz' n))
else None
| _ => None
end%O.
Definition is_wconst_of_size sz (e: pexpr) : option Z :=
match e with
| Papp1 (Oword_of_int sz') (Pconst z) =>
if sz' == sz then Some z else None
| _ => None end.
Variant is_reflect (A:Type) (P:A -> pexpr) : pexpr -> option A -> Prop :=
| Is_reflect_some : forall a, is_reflect P (P a) (Some a)
| Is_reflect_none : forall e, is_reflect P e None.
Lemma is_boolP e : is_reflect Pbool e (is_bool e).
Proof. by case e=> *;constructor. Qed.
Lemma is_constP e : is_reflect Pconst e (is_const e).
Proof. by case: e=>*;constructor. Qed.
Lemma is_reflect_some_inv {A P e a} (H: @is_reflect A P e (Some a)) : e = P a.
Proof.
set (d e m := match m with None => True | Some a => e = P a end).
change (d e (Some a)).
case H; simpl; auto.
Qed.
Lemma is_wconst_of_sizeP sz e :
is_reflect (fun z => Papp1 (Oword_of_int sz) (Pconst z)) e (is_wconst_of_size sz e).
Proof.
case: e; try constructor.
case; try constructor.
move => sz' []; try constructor.
move => z /=; case: eqP; try constructor.
move => ->; exact: Is_reflect_some.
Qed.
(* --------------------------------------------------------------------- *)
(* Test the equality of two expressions modulo variable info *)
Fixpoint eq_expr e e' :=
match e, e' with
| Pconst z , Pconst z' => z == z'
| Pbool b , Pbool b' => b == b'
| Parr_init n , Parr_init n' => n == n'
| Pvar x , Pvar x' => v_var x == v_var x'
| Pglobal g, Pglobal g' => g == g'
| Pget w x e , Pget w' x' e' => (w == w') && (v_var x == v_var x') && eq_expr e e'
| Pload w x e, Pload w' x' e' => (w == w') && (v_var x == v_var x') && eq_expr e e'
| Papp1 o e , Papp1 o' e' => (o == o') && eq_expr e e'
| Papp2 o e1 e2, Papp2 o' e1' e2' => (o == o') && eq_expr e1 e1' && eq_expr e2 e2'
| PappN o es, PappN o' es' => (o == o') && (all2 eq_expr es es')
| Pif t e e1 e2, Pif t' e' e1' e2' =>
(t == t') && eq_expr e e' && eq_expr e1 e1' && eq_expr e2 e2'
| _ , _ => false
end.
Lemma eq_expr_refl e : eq_expr e e.
Proof.
elim: e => //= [ ??? -> | ??? -> | ?? -> | ?? -> ? -> | ? es ih | ??-> ? -> ? -> ] //=;
rewrite ?eqxx //=.
elim: es ih => // e es ih h /=; rewrite h.
+ by apply: ih => e' he'; apply: h; rewrite in_cons he' orbT.
by rewrite in_cons eqxx.
Qed.
Definition eq_lval (x x': lval) : bool :=
match x, x' with
| Lnone _ ty, Lnone _ ty' => ty == ty'
| Lvar v, Lvar v' => v_var v == v_var v'
| Lmem w v e, Lmem w' v' e' => (w == w') && (v_var v == v_var v') && (eq_expr e e')
| Laset w v e, Laset w' v' e'
=> (w == w') && (v_var v == v_var v') && (eq_expr e e')
| _, _ => false
end.
Lemma eq_lval_refl x : eq_lval x x.
Proof.
by case: x => // [ i ty | x | w x e | w x e] /=; rewrite !eqxx // eq_expr_refl.
Qed.
Lemma eq_expr_constL z e :
eq_expr (Pconst z) e -> e = z :> pexpr.
Proof. by case: e => // z' /eqP ->. Qed.
Lemma eq_expr_const z1 z2 :
eq_expr (Pconst z1) (Pconst z2) -> z1 = z2.
Proof. by move/eqP. Qed.
Lemma eq_expr_var x1 x2 :
eq_expr (Pvar x1) (Pvar x2) -> x1 = x2 :> var.
Proof. by move/eqP. Qed.
Lemma eq_expr_global g1 g2 :
eq_expr (Pglobal g1) (Pglobal g2) -> g1 = g2.
Proof. by move/eqP. Qed.
Lemma eq_expr_load w1 w2 v1 v2 e1 e2 :
eq_expr (Pload w1 v1 e1) (Pload w2 v2 e2)
-> [/\ w1 = w2, v1 = v2 :> var & eq_expr e1 e2].
Proof. by move=> /= /andP [/andP[]] /eqP-> /eqP-> ->. Qed.
Lemma eq_expr_app1 o1 o2 e1 e2 :
eq_expr (Papp1 o1 e1) (Papp1 o2 e2)
-> [/\ o1 = o2 & eq_expr e1 e2].
Proof. by move=> /= /andP[/eqP-> ->]. Qed.
|
lemma coeff_0_reflect_poly [simp]: "coeff (reflect_poly p) 0 = lead_coeff p" |
lemmas bounded_linear_const_mult = bounded_linear_mult_right [THEN bounded_linear_compose] |
/-
Copyright (c) 2021 OpenAI. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Kunhao Zheng, Stanislas Polu, David Renshaw, OpenAI GPT-f
-/
import mathzoo.imports.miniF2F
open_locale nat rat real big_operators topological_space
theorem mathd_numbertheory_109
(v : ℕ → ℕ)
(h₀ : ∀ n, v n = 2 * n - 1) :
(∑ k in (finset.erase (finset.range 101) 0), v k) % 7 = 4 :=
begin
norm_num,
simp [h₀],
rw finset.sum_erase,
swap,
{ simp, },
norm_num [finset.sum_range_succ, h₀],
end |
namespace Ex1
variable (a : Nat) (i : Fin a) (h : 1 = a)
example : i < a := h ▸ i.2 -- `▸` uses `subst` here
end Ex1
namespace Ex2
def heapifyDown' (a : Array α) (i : Fin a.size) : Array α := sorry
def heapifyDown (a : Array α) (i : Fin a.size) : Array α :=
heapifyDown' a ⟨i.1, a.size_swap i i ▸ i.2⟩ -- Error, failed to compute motive, `subst` is not applicable here
end Ex2
namespace Ex3
def heapifyDown (a : Array α) (i : Fin a.size) : Array α :=
have : i < i := sorry
heapifyDown a ⟨i.1, a.size_swap i i ▸ i.2⟩ -- Error, failed to compute motive, `subst` is not applicable here
termination_by' measure fun i => i.1
decreasing_by assumption
end Ex3
namespace Ex4
def heapifyDown (lt : α → α → Bool) (a : Array α) (i : Fin a.size) : Array α :=
let left := 2 * i.1 + 1
let right := left + 1
have left_le : i ≤ left := sorry
have right_le : i ≤ right := sorry
have i_le : i ≤ i := Nat.le_refl _
have j : {j : Fin a.size // i ≤ j} := if h : left < a.size then
if lt (a.get i) (a.get ⟨left, h⟩) then ⟨⟨left, h⟩, left_le⟩ else ⟨i, i_le⟩ else ⟨i, i_le⟩
have j := if h : right < a.size then
if lt (a.get j) (a.get ⟨right, h⟩) then ⟨⟨right, h⟩, right_le⟩ else j else j
if h : i ≠ j then
let a' := a.swap i j
have : a'.size - j < a.size - i := sorry
heapifyDown lt a' ⟨j.1.1, a.size_swap i j ▸ j.1.2⟩ -- Error, failed to compute motive, `subst` is not applicable here
else
a
termination_by' measure fun ⟨a, i⟩ => a.size - i.1
decreasing_by assumption
end Ex4
|
/ news / Teleskin in ElectroBoutique gallery.
Teleskin offers a televiewer taking control over TV interface in her hands. When pushing a remote control button one does not switch the content (who cares about that?) but the shape: a TV model, interior where it is placed, - another words, the context - both visual and ideological. The process of zapping is not any more a thoughtless way of spending time, but a creative activity that is forming one's living space. When altering TV skin and adjusting it to a current mood, one breaks free form pre-defined behavioral patterns of the totalitarian post-information society. |
Buried in the news that HP is buying Palm is an updated lower guidance for the fourth quarter, otherwise known as a warning.
The Company expects revenues for its fourth fiscal quarter to be in the range of approximately $90 million to $100 million on a GAAP (1) and a non-GAAP basis. Revenues for the fourth fiscal quarter are being impacted by slow sales of the Company’s products, which has resulted in low order volumes from carriers. Palm also expects to close its fourth fiscal quarter with a cash, cash equivalents and short-term investments balance between $350 million and $400 million.
$90 million in revenues for an average ASP of $300 would put unit sales at 300,000 for the quarter. RIM just sold 10.4 million devices, Apple sold 8.75 million. 300k is just an astonishingly small number.
Huawei has largely rejected Palm’s request for a buyout, a tip said this morning. Palm had reportedly proposed that Huawei take over the company in mid-February but hasn’t made any progress since. It’s not clear what objections, if any, Huawei might have.
via Palm rebuffed by Huawei on takeover talks | Electronista.
Dubinsky gets it, Glaser no so much.
[Rob Glaser] said with those “super” abilities, mobile has a great potential, but if Apple gets its way, the wireless industry could end up like the MP3 industry. The other option is for things to go the way of the PC, which he considers more horizontal.
Sorry Rob, you’re still missing the whole point. It’s not incredible, it’s the only way to go. What’s incredible is that anybody tried to do it differently. |
{-# OPTIONS --cubical #-}
module _ where
module _ where
import Agda.Primitive
open import Agda.Primitive.Cubical public
open import Agda.Builtin.Cubical.Path public
refl : ∀ {a} {A : Set a} {x : A} → x ≡ x
refl {x = x} = \ _ → x
testPath : ∀ {A : Set} {b a : A} (let H : b ≡ b; H = _) → ∀ i → H i ≡ b
testPath i = refl
|
lemma no_trailing_coeffs [simp]: "no_trailing (HOL.eq 0) (coeffs p)" |
/-
Copyright (c) 2022 Yury Kudryashov. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Yury Kudryashov
-/
import measure_theory.integral.interval_integral
import measure_theory.integral.average
/-!
# Integral average over an interval
In this file we introduce notation `⨍ x in a..b, f x` for the average `⨍ x in Ι a b, f x` of `f`
over the interval `Ι a b = set.Ioc (min a b) (max a b)` w.r.t. the Lebesgue measure, then prove
formulas for this average:
* `interval_average_eq`: `⨍ x in a..b, f x = (b - a)⁻¹ • ∫ x in a..b, f x`;
* `interval_average_eq_div`: `⨍ x in a..b, f x = (∫ x in a..b, f x) / (b - a)`.
We also prove that `⨍ x in a..b, f x = ⨍ x in b..a, f x`, see `interval_average_symm`.
## Notation
`⨍ x in a..b, f x`: average of `f` over the interval `Ι a b` w.r.t. the Lebesgue measure.
-/
open measure_theory set topological_space
open_locale interval
variables {E : Type*} [normed_add_comm_group E] [normed_space ℝ E] [complete_space E]
notation `⨍` binders ` in ` a `..` b `, `
r:(scoped:60 f, average (measure.restrict volume (Ι a b)) f) := r
lemma interval_average_symm (f : ℝ → E) (a b : ℝ) : ⨍ x in a..b, f x = ⨍ x in b..a, f x :=
by rw [set_average_eq, set_average_eq, uIoc_swap]
lemma interval_average_eq (f : ℝ → E) (a b : ℝ) : ⨍ x in a..b, f x = (b - a)⁻¹ • ∫ x in a..b, f x :=
begin
cases le_or_lt a b with h h,
{ rw [set_average_eq, uIoc_of_le h, real.volume_Ioc, interval_integral.integral_of_le h,
ennreal.to_real_of_real (sub_nonneg.2 h)] },
{ rw [set_average_eq, uIoc_of_lt h, real.volume_Ioc, interval_integral.integral_of_ge h.le,
ennreal.to_real_of_real (sub_nonneg.2 h.le), smul_neg, ← neg_smul, ← inv_neg, neg_sub] }
end
lemma interval_average_eq_div (f : ℝ → ℝ) (a b : ℝ) :
⨍ x in a..b, f x = (∫ x in a..b, f x) / (b - a) :=
by rw [interval_average_eq, smul_eq_mul, div_eq_inv_mul]
|
Formal statement is: lemma frontier_empty [simp]: "frontier {} = {}" Informal statement is: The frontier of the empty set is the empty set. |
{-# LANGUAGE Trustworthy, CPP, MagicHash, UnboxedTuples, BangPatterns #-}
{-# LANGUAGE FlexibleInstances, FlexibleContexts, TypeOperators #-}
{- |
Module : SDP.Unboxed
Copyright : (c) Andrey Mulik 2019-2021
License : BSD-style
Maintainer : [email protected]
Portability : non-portable (GHC extensions)
"SDP.Unboxed" provide service class 'Unboxed', that needed for
"SDP.Prim.SBytes"-based structures.
-}
module SDP.Unboxed
(
-- * Unboxed
Unboxed (..), cloneUnboxed#, cloneUnboxedM#, thawUnboxed#, freezeUnboxed#,
-- ** Kind @(Type -> Type)@ proxies
fromProxy, psizeof#, psizeof, pnewUnboxed, pcopyUnboxed, pcopyUnboxedM,
pcloneUnboxed, pcloneUnboxedM, pthawUnboxed, pfreezeUnboxed,
-- ** Kind @(Type -> Type -> Type)@ proxies
fromProxy1, pnewUnboxed1, pcloneUnboxed1, pcopyUnboxed1, pcopyUnboxedM1,
cloneUnboxed1#, pcloneUnboxedM1,
-- Wrap helper
Wrap (..), lzero#, single#, fromList#, fromFoldable#, fromListN#,
newLinear#, newLinearN#, fromFoldableM#, concat#, pconcat
)
where
import Prelude ()
import SDP.SafePrelude
import SDP.Nullable
import SDP.Finite
import SDP.Shape
import SDP.Ratio
import GHC.Stable
import GHC.Base hiding ( (.), foldr )
import GHC.Word
import GHC.Int
import GHC.Ptr
import GHC.ST
import Data.Complex
import Foreign.C.Types
#include "MachDeps.h"
default ()
--------------------------------------------------------------------------------
{- |
'Unboxed' is a layer between untyped raw data and parameterized unboxed data
structures. Also it prevents direct interaction with primitives.
-}
class (Eq e) => Unboxed e
where
{-# MINIMAL (sizeof#|sizeof), (!#), (!>#), writeByteArray#, newUnboxed #-}
{- |
@sizeof e n@ returns the length (in bytes) of primitive, where @n@ - count
of elements, @e@ - type parameter.
-}
{-# INLINE sizeof #-}
sizeof :: e -> Int -> Int
sizeof e (I# c#) = I# (sizeof# e c#)
-- | 'sizeof#' is unboxed 'sizeof'.
{-# INLINE sizeof# #-}
sizeof# :: e -> Int# -> Int#
sizeof# e c# = case sizeof e (I# c#) of I# n# -> n#
-- | Unsafe 'ByteArray#' reader with overloaded result type.
(!#) :: ByteArray# -> Int# -> e
-- | Unsafe 'MutableByteArray#' reader with overloaded result type.
(!>#) :: MutableByteArray# s -> Int# -> State# s -> (# State# s, e #)
-- | Unsafe 'MutableByteArray#' writer.
writeByteArray# :: MutableByteArray# s -> Int# -> e -> State# s -> State# s
{-# INLINE fillByteArray# #-}
-- | Procedure for filling the array with the default value (like calloc).
fillByteArray# :: MutableByteArray# s -> Int# -> e -> State# s -> State# s
fillByteArray# mbytes# n# e = I# n# > 0 ? go (n# -# 1#) $ \ s1# -> s1#
where
go 0# s2# = writeByteArray# mbytes# 0# e s2#
go c# s2# = go (c# -# 1#) (writeByteArray# mbytes# c# e s2#)
{- |
'newUnboxed' creates new 'MutableByteArray#' of given count of elements.
First argument used as type variable.
-}
newUnboxed :: e -> Int# -> State# s -> (# State# s, MutableByteArray# s #)
{-# INLINE newUnboxed' #-}
{- |
'newUnboxed'' is version of 'newUnboxed', that use first argument as
initial value. May fail when trying to write 'error' or 'undefined'.
-}
newUnboxed' :: e -> Int# -> State# s -> (# State# s, MutableByteArray# s #)
newUnboxed' e n# = \ s1# -> case newByteArray# (sizeof# e n#) s1# of
(# s2#, mbytes# #) -> case fillByteArray# mbytes# n# e s2# of
s3# -> (# s3#, mbytes# #)
{- |
@'copyUnboxed#' e bytes\# o1\# mbytes\# o2\# n\#@ unsafely writes elements
from @bytes\#@ to @mbytes\#@, where o1\# and o2\# - offsets (element
count), @n\#@ - count of elements to copy.
-}
copyUnboxed# :: e -> ByteArray# -> Int# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
copyUnboxed# e bytes# o1# mbytes# o2# n# = copyByteArray# bytes# (sizeof# e o1#) mbytes# (sizeof# e o2#) (sizeof# e n#)
{- |
@'copyUnboxedM#' e msrc\# o1\# mbytes\# o2\# n\#@ unsafely writes elements
from @msrc\#@ to @mbytes\#@, where o1\# and o2\# - offsets (element
count), @n\#@ - count of elements to copy.
-}
copyUnboxedM# :: e -> MutableByteArray# s -> Int# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
copyUnboxedM# e msrc# o1# mbytes# o2# n# = copyMutableByteArray# msrc# (sizeof# e o1#) mbytes# (sizeof# e o2#) (sizeof# e n#)
{- |
@'hashUnboxedWith' e len# off# bytes# salt@ returns @bytes#@ @FNV-1@ hash,
where @off#@ and @len#@ is offset and length (in elements).
Note: the standard definition of this function is written in Haskell using
low-level functions, but this implementation mayn't be as efficient as the
foreign procedure in the @hashable@ package.
-}
hashUnboxedWith :: e -> Int# -> Int# -> ByteArray# -> Int# -> Int#
hashUnboxedWith e len# off# bytes# = go (sizeof# e off#) (sizeof# e len#)
where
go _ 0# salt# = salt#
go o# n# salt# = go (o# +# 1#) (n# -# 1#) (word2Int# hash#)
where
prod# = int2Word# (salt# *# 16777619#)
elem# = indexWord8Array# bytes# o#
hash# = prod# `xor#` elem#
--------------------------------------------------------------------------------
{- Unboxed helpers. -}
{- |
@since 0.2
@cloneUnboxed# e bytes# o# c#@ creates new @c#@-element length immutable slice
of @bytes#@ beginning from @o#@-th element.
-}
cloneUnboxed# :: (Unboxed e) => e -> ByteArray# -> Int# -> Int# -> ByteArray#
cloneUnboxed# e bytes# o# c# = unwrap $ runST $ ST $
\ s1# -> case newUnboxed e c# s1# of
(# s2#, mbytes# #) -> case copyUnboxed# e bytes# o# mbytes# 0# c# s2# of
s3# -> case unsafeFreezeByteArray# mbytes# s3# of
(# s4#, bytes'# #) -> (# s4#, (Wrap bytes'#) #)
{- |
@since 0.2.1
@cloneUnboxedM# e mbytes# o# c#@ creates new @c#@-element length mutable slice
of @bytes#@ beginning from @o#@-th element.
-}
cloneUnboxedM# :: (Unboxed e) => e -> MutableByteArray# s -> Int# -> Int# ->
State# s -> (# State# s, MutableByteArray# s #)
cloneUnboxedM# e mbytes# o# n# = \ s1# -> case newByteArray# (sizeof# e n#) s1# of
(# s2#, copy# #) -> case copyUnboxedM# e mbytes# o# copy# 0# n# s2# of
s3# -> (# s3#, copy# #)
{- |
@since 0.2.1
@'thawUnboxed#' e bytes# c#@ creates new @sizeof# e c#@ bytes length
'MutableByteArray#' and copy @bytes#@ to it.
-}
thawUnboxed# :: (Unboxed e) => e -> ByteArray# -> Int# ->
State# s -> (# State# s, MutableByteArray# s #)
thawUnboxed# e bytes# c# = \ s1# -> case newByteArray# n# s1# of
(# s2#, mbytes# #) -> case copyByteArray# bytes# 0# mbytes# 0# n# s2# of
s3# -> (# s3#, mbytes# #)
where
n# = sizeof# e c#
{- |
@since 0.2.1
@'freezeUnboxed#' e mbytes# c#@ creates new @sizeof# e c#@ bytes length
'ByteArray#' and copy @mbytes#@ to it.
-}
freezeUnboxed# :: (Unboxed e) => e -> MutableByteArray# s -> Int# ->
State# s -> (# State# s, ByteArray# #)
freezeUnboxed# e mbytes# n# = \ s1# -> case cloneUnboxedM# e mbytes# 0# n# s1# of
(# s2#, copy# #) -> unsafeFreezeByteArray# copy# s2#
--------------------------------------------------------------------------------
{- Rank 1 Unboxed proxies. -}
-- | Returns 'undefined' of suitable type.
fromProxy :: proxy e -> e
fromProxy = const undefined
{- |
@since 0.2.1
'psizeof#' is proxy version of 'sizeof#'.
-}
psizeof# :: (Unboxed e) => proxy e -> Int# -> Int#
psizeof# = sizeof# . fromProxy
{- |
@since 0.2
'psizeof' is proxy version of 'sizeof'.
-}
psizeof :: (Unboxed e) => proxy e -> Int -> Int
psizeof = sizeof . fromProxy
{- |
@since 0.2
Kind @(Type -> Type)@ proxy version of 'newUnboxed'.
-}
pnewUnboxed :: (Unboxed e) => proxy e -> Int# ->
State# s -> (# State# s, MutableByteArray# s #)
pnewUnboxed = newUnboxed . fromProxy
{- |
@since 0.2
Kind @(Type -> Type)@ proxy version if 'copyUnboxed#'.
-}
pcopyUnboxed :: (Unboxed e) => proxy e -> ByteArray# -> Int# ->
MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
pcopyUnboxed = copyUnboxed# . fromProxy
{- |
@since 0.2
Kind @(Type -> Type)@ proxy version if 'copyUnboxedM#'.
-}
pcopyUnboxedM :: (Unboxed e) => proxy e -> MutableByteArray# s -> Int# ->
MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
pcopyUnboxedM = copyUnboxedM# . fromProxy
{- |
@since 0.2
Kind @(Type -> Type)@ proxy version of 'cloneUnboxed#'.
-}
cloneUnboxed1# :: (Unboxed e) => proxy e -> ByteArray# -> Int# -> Int# -> ByteArray#
cloneUnboxed1# = cloneUnboxed# . fromProxy
{- |
@since 0.2.1
Same as @sdp-0.2@ 'cloneUnboxed1#'. Use only if you don't need @sdp-0.2@
compatibility.
-}
pcloneUnboxed :: (Unboxed e) => proxy e -> ByteArray# -> Int# -> Int# -> ByteArray#
pcloneUnboxed = cloneUnboxed1#
{- |
@since 0.2.1
Kind @(Type -> Type)@ proxy version of 'cloneUnboxed#'.
-}
pcloneUnboxedM :: (Unboxed e) => proxy e -> MutableByteArray# s -> Int# -> Int# ->
State# s -> (# State# s, MutableByteArray# s #)
pcloneUnboxedM = cloneUnboxedM# . fromProxy
{- |
@since 0.2.1
Kind @(Type -> Type)@ proxy version of 'thawUnboxed#'.
-}
pthawUnboxed :: (Unboxed e) => proxy e -> ByteArray# -> Int# ->
State# s -> (# State# s, MutableByteArray# s #)
pthawUnboxed = thawUnboxed# . fromProxy
{- |
@since 0.2.1
Kind @(Type -> Type)@ proxy version of 'pfreezeUnboxed'.
-}
pfreezeUnboxed :: (Unboxed e) => proxy e -> MutableByteArray# s -> Int# ->
State# s -> (# State# s, ByteArray# #)
pfreezeUnboxed = freezeUnboxed# . fromProxy
--------------------------------------------------------------------------------
{- (Type -> Type -> Type)-kind Unboxed proxies. -}
-- | Returns 'undefined' of suitable type.
fromProxy1 :: m (proxy e) -> e
fromProxy1 = const undefined
{- |
@since 0.2
Kind @(Type -> Type -> Type)@ proxy version of 'newUnboxed'.
-}
pnewUnboxed1 :: (Unboxed e) => p (proxy e) -> Int# ->
State# s -> (# State# s, MutableByteArray# s #)
pnewUnboxed1 = newUnboxed . fromProxy1
{- |
@since 0.2
Kind @(Type -> Type -> Type)@ proxy version of 'copyUnboxed#'.
-}
pcopyUnboxed1 :: (Unboxed e) => p (proxy e) -> ByteArray# -> Int# ->
MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
pcopyUnboxed1 = copyUnboxed# . fromProxy1
{- |
@since 0.2.1
Kind @(Type -> Type -> Type)@ proxy version of 'copyUnboxedM#'.
-}
pcopyUnboxedM1 :: (Unboxed e) => p (proxy e) -> MutableByteArray# s -> Int# ->
MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
pcopyUnboxedM1 = copyUnboxedM# . fromProxy1
{- |
@since 0.2.1
Kind @(Type -> Type -> Type)@ proxy version of 'cloneUnboxed#'.
-}
pcloneUnboxed1 :: (Unboxed e) => p (proxy e) -> ByteArray# -> Int# -> Int# -> ByteArray#
pcloneUnboxed1 = cloneUnboxed# . fromProxy1
{- |
@since 0.2.1
Kind @(Type -> Type -> Type)@ proxy version of 'cloneUnboxed#'.
-}
pcloneUnboxedM1 :: (Unboxed e) => p (proxy e) -> MutableByteArray# s -> Int# -> Int# ->
State# s -> (# State# s, MutableByteArray# s #)
pcloneUnboxedM1 = cloneUnboxedM# . fromProxy1
--------------------------------------------------------------------------------
{- Numeric instances. -}
instance Unboxed Int
where
{-# INLINE sizeof #-}
sizeof _ n = max 0 n * SIZEOF_HSWORD
{-# INLINE (!#) #-}
bytes# !# i# = I# (indexIntArray# bytes# i#)
{-# INLINE (!>#) #-}
mbytes# !># i# = \ s1# -> case readIntArray# mbytes# i# s1# of
(# s2#, e# #) -> (# s2#, I# e# #)
{-# INLINE writeByteArray# #-}
writeByteArray# mbytes# n# (I# e#) = writeIntArray# mbytes# n# e#
{-# INLINE newUnboxed #-}
newUnboxed _ = newUnboxed' (0 :: Int)
instance Unboxed Int8
where
{-# INLINE sizeof #-}
sizeof _ n = max 0 n
{-# INLINE (!#) #-}
bytes# !# i# = I8# (indexInt8Array# bytes# i#)
{-# INLINE (!>#) #-}
mbytes# !># i# = \ s1# -> case readInt8Array# mbytes# i# s1# of
(# s2#, e# #) -> (# s2#, I8# e# #)
{-# INLINE writeByteArray# #-}
writeByteArray# mbytes# n# (I8# e#) = writeInt8Array# mbytes# n# e#
{-# INLINE newUnboxed #-}
newUnboxed _ = newUnboxed' (0 :: Int8)
instance Unboxed Int16
where
{-# INLINE sizeof #-}
sizeof _ n = max 0 n * 2
{-# INLINE (!#) #-}
bytes# !# i# = I16# (indexInt16Array# bytes# i#)
{-# INLINE (!>#) #-}
mbytes# !># i# = \ s1# -> case readInt16Array# mbytes# i# s1# of
(# s2#, e# #) -> (# s2#, I16# e# #)
{-# INLINE writeByteArray# #-}
writeByteArray# mbytes# n# (I16# e#) = writeInt16Array# mbytes# n# e#
{-# INLINE newUnboxed #-}
newUnboxed _ = newUnboxed' (0 :: Int16)
instance Unboxed Int32
where
{-# INLINE sizeof #-}
sizeof _ n = max 0 n * 4
{-# INLINE (!#) #-}
bytes# !# i# = I32# (indexInt32Array# bytes# i#)
{-# INLINE (!>#) #-}
mbytes# !># i# = \ s1# -> case readInt32Array# mbytes# i# s1# of
(# s2#, e# #) -> (# s2#, I32# e# #)
{-# INLINE writeByteArray# #-}
writeByteArray# mbytes# n# (I32# e#) = writeInt32Array# mbytes# n# e#
{-# INLINE newUnboxed #-}
newUnboxed _ = newUnboxed' (0 :: Int32)
instance Unboxed Int64
where
{-# INLINE sizeof #-}
sizeof _ n = max 0 n * 8
{-# INLINE (!#) #-}
bytes# !# i# = I64# (indexInt64Array# bytes# i#)
{-# INLINE (!>#) #-}
mbytes# !># i# = \ s1# -> case readInt64Array# mbytes# i# s1# of
(# s2#, e# #) -> (# s2#, I64# e# #)
{-# INLINE writeByteArray# #-}
writeByteArray# mbytes# n# (I64# e#) = writeInt64Array# mbytes# n# e#
{-# INLINE newUnboxed #-}
newUnboxed _ = newUnboxed' (0 :: Int64)
instance Unboxed Word
where
{-# INLINE sizeof #-}
sizeof _ n = max 0 n * SIZEOF_HSWORD
{-# INLINE (!#) #-}
bytes# !# i# = W# (indexWordArray# bytes# i#)
{-# INLINE (!>#) #-}
mbytes# !># i# = \ s1# -> case readWordArray# mbytes# i# s1# of
(# s2#, e# #) -> (# s2#, W# e# #)
{-# INLINE writeByteArray# #-}
writeByteArray# mbytes# n# (W# e#) = writeWordArray# mbytes# n# e#
{-# INLINE newUnboxed #-}
newUnboxed _ = newUnboxed' (0 :: Word)
instance Unboxed Word8
where
{-# INLINE sizeof #-}
sizeof _ n = max 0 n
{-# INLINE (!#) #-}
bytes# !# i# = W8# (indexWord8Array# bytes# i#)
{-# INLINE (!>#) #-}
mbytes# !># i# = \ s1# -> case readWord8Array# mbytes# i# s1# of
(# s2#, e# #) -> (# s2#, W8# e# #)
{-# INLINE writeByteArray# #-}
writeByteArray# mbytes# n# (W8# e#) = writeWord8Array# mbytes# n# e#
{-# INLINE newUnboxed #-}
newUnboxed _ = newUnboxed' (0 :: Word8)
instance Unboxed Word16
where
{-# INLINE sizeof #-}
sizeof _ n = max 0 n * 2
{-# INLINE (!#) #-}
bytes# !# i# = W16# (indexWord16Array# bytes# i#)
{-# INLINE (!>#) #-}
mbytes# !># i# = \ s1# -> case readWord16Array# mbytes# i# s1# of
(# s2#, e# #) -> (# s2#, W16# e# #)
{-# INLINE writeByteArray# #-}
writeByteArray# mbytes# n# (W16# e#) = writeWord16Array# mbytes# n# e#
{-# INLINE newUnboxed #-}
newUnboxed _ = newUnboxed' (0 :: Word16)
instance Unboxed Word32
where
{-# INLINE sizeof #-}
sizeof _ n = max 0 n * 4
{-# INLINE (!#) #-}
bytes# !# i# = W32# (indexWord32Array# bytes# i#)
{-# INLINE (!>#) #-}
mbytes# !># i# = \ s1# -> case readWord32Array# mbytes# i# s1# of
(# s2#, e# #) -> (# s2#, W32# e# #)
{-# INLINE writeByteArray# #-}
writeByteArray# mbytes# n# (W32# e#) = writeWord32Array# mbytes# n# e#
{-# INLINE newUnboxed #-}
newUnboxed _ = newUnboxed' (0 :: Word32)
instance Unboxed Word64
where
{-# INLINE sizeof #-}
sizeof _ n = max 0 n * 8
{-# INLINE (!#) #-}
bytes# !# i# = W64# (indexWord64Array# bytes# i#)
{-# INLINE (!>#) #-}
mbytes# !># i# = \ s1# -> case readWord64Array# mbytes# i# s1# of
(# s2#, e# #) -> (# s2#, W64# e# #)
{-# INLINE writeByteArray# #-}
writeByteArray# mbytes# n# (W64# e#) = writeWord64Array# mbytes# n# e#
{-# INLINE newUnboxed #-}
newUnboxed _ = newUnboxed' (0 :: Word64)
instance Unboxed Float
where
{-# INLINE sizeof #-}
sizeof _ n = max 0 n * SIZEOF_HSFLOAT
{-# INLINE (!#) #-}
bytes# !# i# = F# (indexFloatArray# bytes# i#)
{-# INLINE (!>#) #-}
mbytes# !># i# = \ s1# -> case readFloatArray# mbytes# i# s1# of
(# s2#, f# #) -> (# s2#, F# f# #)
{-# INLINE writeByteArray# #-}
writeByteArray# mbytes# n# (F# e#) = writeFloatArray# mbytes# n# e#
{-# INLINE newUnboxed #-}
newUnboxed _ = newUnboxed' (0 :: Float)
instance Unboxed Double
where
{-# INLINE sizeof #-}
sizeof _ n = max 0 n * SIZEOF_HSDOUBLE
{-# INLINE (!#) #-}
bytes# !# i# = D# (indexDoubleArray# bytes# i#)
{-# INLINE (!>#) #-}
mbytes# !># i# = \ s1# -> case readDoubleArray# mbytes# i# s1# of
(# s2#, d# #) -> (# s2#, D# d# #)
{-# INLINE writeByteArray# #-}
writeByteArray# mbytes# n# (D# e#) = writeDoubleArray# mbytes# n# e#
{-# INLINE newUnboxed #-}
newUnboxed _ = newUnboxed' (0 :: Double)
instance (Unboxed a, Integral a) => Unboxed (Ratio a)
where
sizeof e n = 2 * psizeof e n
bytes# !# i# = bytes# !# i2# :% (bytes# !# (i2# +# 1#)) where i2# = 2# *# i#
mbytes# !># i# = let i2# = 2# *# i# in \ s1# -> case (!>#) mbytes# i2# s1# of
(# s2#, n #) -> case (!>#) mbytes# (i2# +# 1#) s2# of
(# s3#, d #) -> (# s3#, n :% d #)
{-# INLINE writeByteArray# #-}
writeByteArray# mbytes# i# (n :% d) = let i2# = 2# *# i# in
\ s1# -> case writeByteArray# mbytes# i2# n s1# of
s2# -> writeByteArray# mbytes# (i2# +# 1#) d s2#
{-# INLINE newUnboxed #-}
newUnboxed e n# = pnewUnboxed e (2# *# n#)
instance (Unboxed a, Num a) => Unboxed (Complex a)
where
sizeof e n = 2 * psizeof e n
bytes# !# i# = bytes# !# i2# :+ (bytes# !# (i2# +# 1#)) where i2# = 2# *# i#
mbytes# !># i# = let i2# = 2# *# i# in \ s1# -> case (!>#) mbytes# i2# s1# of
(# s2#, n #) -> case (!>#) mbytes# (i2# +# 1#) s2# of
(# s3#, d #) -> (# s3#, n :+ d #)
{-# INLINE writeByteArray# #-}
writeByteArray# mbytes# i# (n :+ d) = let i2# = 2# *# i# in
\ s1# -> case writeByteArray# mbytes# i2# n s1# of
s2# -> writeByteArray# mbytes# (i2# +# 1#) d s2#
{-# INLINE newUnboxed #-}
newUnboxed e n# = pnewUnboxed e (2# *# n#)
--------------------------------------------------------------------------------
{- Pointer instances. -}
instance Unboxed (Ptr a)
where
{-# INLINE sizeof #-}
sizeof _ n = max 0 n * SIZEOF_HSWORD
{-# INLINE (!#) #-}
bytes# !# i# = Ptr (indexAddrArray# bytes# i#)
{-# INLINE (!>#) #-}
mbytes# !># i# = \ s1# -> case readAddrArray# mbytes# i# s1# of
(# s2#, e# #) -> (# s2#, Ptr e# #)
{-# INLINE writeByteArray# #-}
writeByteArray# mbytes# n# (Ptr e) = writeAddrArray# mbytes# n# e
{-# INLINE newUnboxed #-}
newUnboxed _ = newUnboxed' nullPtr
instance Unboxed (FunPtr a)
where
{-# INLINE sizeof #-}
sizeof _ n = max 0 n * SIZEOF_HSWORD
{-# INLINE (!#) #-}
bytes# !# i# = FunPtr (indexAddrArray# bytes# i#)
{-# INLINE (!>#) #-}
mbytes# !># i# = \ s1# -> case readAddrArray# mbytes# i# s1# of
(# s2#, e# #) -> (# s2#, FunPtr e# #)
{-# INLINE writeByteArray# #-}
writeByteArray# mbytes# n# (FunPtr e) = writeAddrArray# mbytes# n# e
{-# INLINE newUnboxed #-}
newUnboxed e = newUnboxed' (NULL `asTypeOf` e)
instance Unboxed (StablePtr a)
where
{-# INLINE sizeof #-}
sizeof _ n = max 0 n * SIZEOF_HSWORD
{-# INLINE (!#) #-}
bytes# !# i# = StablePtr (indexStablePtrArray# bytes# i#)
{-# INLINE (!>#) #-}
mbytes# !># i# = \ s1# -> case readStablePtrArray# mbytes# i# s1# of
(# s2#, e# #) -> (# s2#, StablePtr e# #)
{-# INLINE writeByteArray# #-}
writeByteArray# mbytes# n# (StablePtr e) = writeStablePtrArray# mbytes# n# e
{-# INLINE newUnboxed #-}
newUnboxed e = newUnboxed' (NULL `asTypeOf` e)
--------------------------------------------------------------------------------
{- Foreign C instances. -}
#define deriving_instance_Unboxed(Type)\
instance Unboxed Type where\
{\
sizeof e = sizeof (consSizeof Type e);\
arr# !# i# = Type ( arr# !# i# );\
marr# !># i# = \ s1# -> case (!>#) marr# i# s1# of {(# s2#, e #) -> (# s2#, Type e #)};\
writeByteArray# marr# i# (Type e) = writeByteArray# marr# i# e;\
fillByteArray# marr# i# (Type e) = fillByteArray# marr# i# e;\
newUnboxed (Type e) = newUnboxed e;\
newUnboxed' (Type e) = newUnboxed' e;\
}
deriving_instance_Unboxed(CChar)
deriving_instance_Unboxed(CSChar)
deriving_instance_Unboxed(CWchar)
deriving_instance_Unboxed(CShort)
deriving_instance_Unboxed(CUShort)
deriving_instance_Unboxed(CInt)
deriving_instance_Unboxed(CUInt)
deriving_instance_Unboxed(CLong)
deriving_instance_Unboxed(CULong)
deriving_instance_Unboxed(CLLong)
deriving_instance_Unboxed(CULLong)
deriving_instance_Unboxed(CIntPtr)
deriving_instance_Unboxed(CUIntPtr)
deriving_instance_Unboxed(CIntMax)
deriving_instance_Unboxed(CUIntMax)
deriving_instance_Unboxed(CPtrdiff)
deriving_instance_Unboxed(CTime)
deriving_instance_Unboxed(CClock)
deriving_instance_Unboxed(CUSeconds)
deriving_instance_Unboxed(CSUSeconds)
deriving_instance_Unboxed(CSize)
#if MIN_VERSION_base(4,10,0)
-- | @since base-4.10.0.0
deriving_instance_Unboxed(CBool)
#endif
deriving_instance_Unboxed(CFloat)
deriving_instance_Unboxed(CDouble)
deriving_instance_Unboxed(CSigAtomic)
#undef deriving_instance_Unboxed
--------------------------------------------------------------------------------
{- Other instances. -}
instance Unboxed Bool
where
{-# INLINE sizeof #-}
sizeof _ c = d == 0 ? n $ n + 1 where (n, d) = max 0 c `divMod` 8
{-# INLINE (!#) #-}
bytes# !# i# = isTrue# ((indexWordArray# bytes# (bool_index i#) `and#` bool_bit i#) `neWord#` int2Word# 0#)
{-# INLINE (!>#) #-}
mbytes# !># i# = \ s1# -> case readWordArray# mbytes# (bool_index i#) s1# of
(# s2#, e# #) -> (# s2#, isTrue# ((e# `and#` bool_bit i#) `neWord#` int2Word# 0#) #)
{-# INLINE writeByteArray# #-}
writeByteArray# mbytes# n# e = \ s1# -> case readWordArray# mbytes# i# s1# of
(# s2#, old_byte# #) -> writeWordArray# mbytes# i# (bitWrite old_byte#) s2#
where
bitWrite old_byte# = if e then old_byte# `or#` bool_bit n# else old_byte# `and#` bool_not_bit n#
i# = bool_index n#
{-# INLINE newUnboxed #-}
newUnboxed _ = newUnboxed' False
fillByteArray# mbytes# n# e =
setByteArray# mbytes# 0# (bool_scale n#) (if e then 0xff# else 0#)
copyUnboxed# e bytes# o1# mbytes# o2# c# = isTrue# (c# <# 1#) ? (\ s1# -> s1#) $
\ s1# -> case writeByteArray# mbytes# o2# ((bytes# !# o1#) `asTypeOf` e) s1# of
s2# -> copyUnboxed# e bytes# (o1# +# 1#) mbytes# (o2# +# 1#) (c# -# 1#) s2#
copyUnboxedM# e src# o1# mbytes# o2# n# = \ s1# -> case (!>#) src# o1# s1# of
(# s2#, x #) -> case writeByteArray# mbytes# o2# (x `asTypeOf` e) s2# of
s3# -> copyUnboxedM# e src# (o1# +# 1#) mbytes# (o2# +# 1#) (n# -# 1#) s3#
hashUnboxedWith e len# off# bytes#
| isTrue# (len# <# 1#) = \ salt# -> salt#
| isTrue# (off# <# 0#) = hashUnboxedWith e len# 0# bytes#
| isTrue# (bit_off# ==# 0#) = go0 byte_cnt# byte_off#
| True = goo byte_cnt# (byte_off# +# 1#) (indexWord8Array# bytes# byte_off#)
where
go0 0# _ salt# = salt#
go0 1# o# salt# = hash# salt# (indexWord8Array# bytes# o# `and#` mask#)
go0 n# o# salt# = go0 (n# -# 1#) (o# +# 1#) (salt# `hash#` indexWord8Array# bytes# o#)
goo 0# _ _ salt# = salt#
goo 1# _ temp# salt# = hash# salt# (shiftRL# temp# bit_off# `and#` mask#)
goo n# o# temp# salt# = goo (n# -# 1#) (o# +# 1#) byte# (hash# salt# curr#)
where
curr# = shiftRL# temp# bit_off# `or#` shiftL# byte# (8# -# bit_off#)
byte# = indexWord8Array# bytes# o#
hash# = \ s# v# -> word2Int# (int2Word# (s# *# 16777619#) `xor#` v#)
mask# = int2Word# 0xff# `shiftRL#` bit_rest#
!(I# byte_off#, I# bit_off#) = I# off# `divMod` 8
!(I# bit_len#) = I# len# `mod` 8
bit_rest# = if isTrue# (bit_len# ==# 0#) then 0# else 8# -# bit_len#
byte_cnt# = sizeof# e len#
instance Unboxed Char
where
{-# INLINE sizeof #-}
sizeof _ n = max 0 n * 4
{-# INLINE (!#) #-}
bytes# !# i# = C# (indexWideCharArray# bytes# i#)
{-# INLINE (!>#) #-}
mbytes# !># i# = \ s1# -> case readWideCharArray# mbytes# i# s1# of
(# s2#, c# #) -> (# s2#, C# c# #)
{-# INLINE writeByteArray# #-}
writeByteArray# mbytes# n# (C# e#) = writeWideCharArray# mbytes# n# e#
{-# INLINE newUnboxed #-}
newUnboxed e n# = \ s1# -> case newByteArray# (sizeof# e n#) s1# of
(# s2#, mbytes# #) -> case fillByteArray# mbytes# n# '\0' s2# of
s3# -> (# s3#, mbytes# #)
instance Unboxed E
where
{-# INLINE sizeof #-}
sizeof _ _ = 0
{-# INLINE (!#) #-}
(!>#) = \ _ _ s# -> (# s#, E #)
(!#) = \ _ _ -> E
newUnboxed _ _ = newByteArray# 0#
newUnboxed' _ _ = newByteArray# 0#
writeByteArray# _ _ = \ _ s# -> s#
fillByteArray# _ _ = \ _ s# -> s#
instance (Unboxed e) => Unboxed (I1 e)
where
sizeof# = psizeof#
sizeof = psizeof
bytes# !# i# = E :& (bytes# !# i#)
bytes# !># i# = \ s1# -> case (!>#) bytes# i# s1# of
(# s2#, e #) -> (# s2#, E :& e #)
writeByteArray# bytes# n# (E :& e) = writeByteArray# bytes# n# e
fillByteArray# bytes# n# (E :& e) = fillByteArray# bytes# n# e
newUnboxed' = \ (E :& i) -> newUnboxed i
newUnboxed = pnewUnboxed
instance (Enum e, Shape e, Bounded e, Unboxed e, Shape (e' :& e), Unboxed (e' :& e)) => Unboxed (e' :& e :& e)
where
sizeof# e n# = psizeof# e (rank# e *# n#)
sizeof e n = psizeof e (rank e * n)
bytes# !# i# = go undefined
where
go t =
let r# = rank# t; o# = i#*#r# +# i#
in ((bytes# !# o#) `asTypeOf` t) :& (bytes# !# (o# +# r#))
bytes# !># i# = go undefined
where
go t = let r# = rank# t; o# = i#*#r# +# i# in
\ s1# -> case (!>#) bytes# o# s1# of
(# s2#, es #) -> case (!>#) bytes# (o# +# r#) s2# of
(# s3#, e #) -> (# s3#, (es `asTypeOf` t) :& e #)
writeByteArray# bytes# i# (es :& e) = let r# = rank# es; o# = i#*#r# +# i# in
\ s1# -> case writeByteArray# bytes# o# es s1# of
s2# -> writeByteArray# bytes# (o# +# r#) e s2#
newUnboxed e n# = pnewUnboxed e (rank# e *# n#)
--------------------------------------------------------------------------------
{- Tuple instances. -}
instance Unboxed ()
where
{-# INLINE sizeof #-}
sizeof _ _ = 0
{-# INLINE (!#) #-}
(!>#) = \ _ _ s# -> (# s#, () #)
(!#) = \ _ _ -> ()
newUnboxed _ _ = newByteArray# 0#
newUnboxed' _ _ = newByteArray# 0#
writeByteArray# _ _ = \ _ s# -> s#
fillByteArray# _ _ = \ _ s# -> s#
instance (Unboxed e) => Unboxed (T2 e)
where
sizeof e2 n = psizeof e2 (2 * n)
sizeof# e2 n# = psizeof# e2 (2# *# n#)
bytes# !# n# = let o# = 2# *# n# in (bytes# !# o#, bytes# !# (o#+#1#))
bytes# !># n# = let o# = 2# *# n# in \ s1# -> case (!>#) bytes# o# s1# of
(# s2#, e1 #) -> case (!>#) bytes# (o# +# 1#) s2# of
(# s3#, e2 #) -> (# s3#, (e1,e2) #)
writeByteArray# mbytes# n# (e1,e2) = let o# = 2# *# n# in
\ s1# -> case writeByteArray# mbytes# o# e1 s1# of
s2# -> writeByteArray# mbytes# (o# +# 1#) e2 s2#
newUnboxed e n# = pnewUnboxed e (2# *# n#)
instance (Unboxed e) => Unboxed (T3 e)
where
sizeof e2 n = psizeof e2 (3 * n)
sizeof# e2 n# = psizeof# e2 (3# *# n#)
bytes# !# n# =
let o# = 3# *# n#
in (bytes# !# o#, bytes# !# (o#+#1#), bytes# !# (o#+#2#))
bytes# !># n# = let o# = 3# *# n# in \ s1# -> case (!>#) bytes# o# s1# of
(# s2#, e1 #) -> case (!>#) bytes# (o# +# 1#) s2# of
(# s3#, e2 #) -> case (!>#) bytes# (o# +# 2#) s3# of
(# s4#, e3 #) -> (# s4#, (e1,e2,e3) #)
writeByteArray# mbytes# n# (e1,e2,e3) = let o# = 3# *# n# in
\ s1# -> case writeByteArray# mbytes# o# e1 s1# of
s2# -> case writeByteArray# mbytes# (o# +# 1#) e2 s2# of
s3# -> writeByteArray# mbytes# (o# +# 2#) e3 s3#
newUnboxed e n# = pnewUnboxed e (3# *# n#)
instance (Unboxed e) => Unboxed (T4 e)
where
sizeof e2 n = psizeof e2 (4 * n)
sizeof# e2 n# = psizeof# e2 (4# *# n#)
bytes# !# n# =
let o# = 4# *# n#
in (bytes# !# o#, bytes# !# (o#+#1#), bytes# !# (o#+#2#), bytes# !# (o#+#3#))
bytes# !># n# = let o# = 4# *# n# in \ s1# -> case (!>#) bytes# o# s1# of
(# s2#, e1 #) -> case (!>#) bytes# (o# +# 1#) s2# of
(# s3#, e2 #) -> case (!>#) bytes# (o# +# 2#) s3# of
(# s4#, e3 #) -> case (!>#) bytes# (o# +# 3#) s4# of
(# s5#, e4 #) -> (# s5#, (e1,e2,e3,e4) #)
writeByteArray# mbytes# n# (e1,e2,e3,e4) = let o# = 4# *# n# in
\ s1# -> case writeByteArray# mbytes# o# e1 s1# of
s2# -> case writeByteArray# mbytes# (o# +# 1#) e2 s2# of
s3# -> case writeByteArray# mbytes# (o# +# 2#) e3 s3# of
s4# -> writeByteArray# mbytes# (o# +# 3#) e4 s4#
newUnboxed e n# = pnewUnboxed e (4# *# n#)
instance (Unboxed e) => Unboxed (T5 e)
where
sizeof e2 n = psizeof e2 (5 * n)
sizeof# e2 n# = psizeof# e2 (5# *# n#)
bytes# !# n# =
let o# = 5# *# n#
in
(
bytes# !# o#, bytes# !# (o#+#1#), bytes# !# (o#+#2#),
bytes# !# (o#+#3#), bytes# !# (o#+#4#)
)
bytes# !># n# = let o# = 5# *# n# in \ s1# -> case (!>#) bytes# o# s1# of
(# s2#, e1 #) -> case (!>#) bytes# (o# +# 1#) s2# of
(# s3#, e2 #) -> case (!>#) bytes# (o# +# 2#) s3# of
(# s4#, e3 #) -> case (!>#) bytes# (o# +# 3#) s4# of
(# s5#, e4 #) -> case (!>#) bytes# (o# +# 4#) s5# of
(# s6#, e5 #) -> (# s6#, (e1,e2,e3,e4,e5) #)
writeByteArray# mbytes# n# (e1,e2,e3,e4,e5) = let o# = 5# *# n# in
\ s1# -> case writeByteArray# mbytes# o# e1 s1# of
s2# -> case writeByteArray# mbytes# (o# +# 1#) e2 s2# of
s3# -> case writeByteArray# mbytes# (o# +# 2#) e3 s3# of
s4# -> case writeByteArray# mbytes# (o# +# 3#) e4 s4# of
s5# -> writeByteArray# mbytes# (o# +# 4#) e5 s5#
newUnboxed e n# = pnewUnboxed e (5# *# n#)
instance (Unboxed e) => Unboxed (T6 e)
where
sizeof e2 n = psizeof e2 (6 * n)
sizeof# e2 n# = psizeof# e2 (6# *# n#)
bytes# !# n# =
let o# = 6# *# n#
in
(
bytes# !# o#, bytes# !# (o#+#1#), bytes# !# (o#+#2#),
bytes# !# (o#+#3#), bytes# !# (o#+#4#), bytes# !# (o#+#5#)
)
bytes# !># n# = let o# = 6# *# n# in \ s1# -> case (!>#) bytes# o# s1# of
(# s2#, e1 #) -> case (!>#) bytes# (o# +# 1#) s2# of
(# s3#, e2 #) -> case (!>#) bytes# (o# +# 2#) s3# of
(# s4#, e3 #) -> case (!>#) bytes# (o# +# 3#) s4# of
(# s5#, e4 #) -> case (!>#) bytes# (o# +# 4#) s5# of
(# s6#, e5 #) -> case (!>#) bytes# (o# +# 5#) s6# of
(# s7#, e6 #) -> (# s7#, (e1,e2,e3,e4,e5,e6) #)
writeByteArray# mbytes# n# (e1,e2,e3,e4,e5,e6) = let o# = 6# *# n# in
\ s1# -> case writeByteArray# mbytes# o# e1 s1# of
s2# -> case writeByteArray# mbytes# (o# +# 1#) e2 s2# of
s3# -> case writeByteArray# mbytes# (o# +# 2#) e3 s3# of
s4# -> case writeByteArray# mbytes# (o# +# 3#) e4 s4# of
s5# -> case writeByteArray# mbytes# (o# +# 4#) e5 s5# of
s6# -> writeByteArray# mbytes# (o# +# 5#) e6 s6#
newUnboxed e n# = pnewUnboxed e (6# *# n#)
instance (Unboxed e) => Unboxed (T7 e)
where
sizeof e2 n = psizeof e2 (7 * n)
sizeof# e2 n# = psizeof# e2 (7# *# n#)
bytes# !# n# =
let o# = 7# *# n#
in
(
bytes# !# o#, bytes# !# (o#+#1#), bytes# !# (o#+#2#),
bytes# !# (o#+#3#), bytes# !# (o#+#4#), bytes# !# (o#+#5#),
bytes# !# (o#+#6#)
)
bytes# !># n# = let o# = 7# *# n# in \ s1# -> case (!>#) bytes# o# s1# of
(# s2#, e1 #) -> case (!>#) bytes# (o# +# 1#) s2# of
(# s3#, e2 #) -> case (!>#) bytes# (o# +# 2#) s3# of
(# s4#, e3 #) -> case (!>#) bytes# (o# +# 3#) s4# of
(# s5#, e4 #) -> case (!>#) bytes# (o# +# 4#) s5# of
(# s6#, e5 #) -> case (!>#) bytes# (o# +# 5#) s6# of
(# s7#, e6 #) -> case (!>#) bytes# (o# +# 6#) s7# of
(# s8#, e7 #) -> (# s8#, (e1,e2,e3,e4,e5,e6,e7) #)
writeByteArray# mbytes# n# (e1,e2,e3,e4,e5,e6,e7) = let o# = 7# *# n# in
\ s1# -> case writeByteArray# mbytes# o# e1 s1# of
s2# -> case writeByteArray# mbytes# (o# +# 1#) e2 s2# of
s3# -> case writeByteArray# mbytes# (o# +# 2#) e3 s3# of
s4# -> case writeByteArray# mbytes# (o# +# 3#) e4 s4# of
s5# -> case writeByteArray# mbytes# (o# +# 4#) e5 s5# of
s6# -> case writeByteArray# mbytes# (o# +# 5#) e6 s6# of
s7# -> writeByteArray# mbytes# (o# +# 6#) e7 s7#
newUnboxed e n# = pnewUnboxed e (7# *# n#)
instance (Unboxed e) => Unboxed (T8 e)
where
sizeof e2 n = psizeof e2 (8 * n)
sizeof# e2 n# = psizeof# e2 (8# *# n#)
bytes# !# n# =
let o# = 8# *# n#
in
(
bytes# !# o#, bytes# !# (o#+#1#), bytes# !# (o#+#2#),
bytes# !# (o#+#3#), bytes# !# (o#+#4#), bytes# !# (o#+#5#),
bytes# !# (o#+#6#), bytes# !# (o#+#7#)
)
bytes# !># n# = let o# = 8# *# n# in \ s1# -> case (!>#) bytes# o# s1# of
(# s2#, e1 #) -> case (!>#) bytes# (o# +# 1#) s2# of
(# s3#, e2 #) -> case (!>#) bytes# (o# +# 2#) s3# of
(# s4#, e3 #) -> case (!>#) bytes# (o# +# 3#) s4# of
(# s5#, e4 #) -> case (!>#) bytes# (o# +# 4#) s5# of
(# s6#, e5 #) -> case (!>#) bytes# (o# +# 5#) s6# of
(# s7#, e6 #) -> case (!>#) bytes# (o# +# 6#) s7# of
(# s8#, e7 #) -> case (!>#) bytes# (o# +# 7#) s8# of
(# s9#, e8 #) -> (# s9#, (e1,e2,e3,e4,e5,e6,e7,e8) #)
writeByteArray# mbytes# n# (e1,e2,e3,e4,e5,e6,e7,e8) = let o# = 8# *# n# in
\ s1# -> case writeByteArray# mbytes# o# e1 s1# of
s2# -> case writeByteArray# mbytes# (o# +# 1#) e2 s2# of
s3# -> case writeByteArray# mbytes# (o# +# 2#) e3 s3# of
s4# -> case writeByteArray# mbytes# (o# +# 3#) e4 s4# of
s5# -> case writeByteArray# mbytes# (o# +# 4#) e5 s5# of
s6# -> case writeByteArray# mbytes# (o# +# 5#) e6 s6# of
s7# -> case writeByteArray# mbytes# (o# +# 6#) e7 s7# of
s8# -> writeByteArray# mbytes# (o# +# 7#) e8 s8#
newUnboxed e n# = pnewUnboxed e (8# *# n#)
instance (Unboxed e) => Unboxed (T9 e)
where
sizeof e2 n = psizeof e2 (9 * n)
sizeof# e2 n# = psizeof# e2 (9# *# n#)
bytes# !# n# =
let o# = 9# *# n#
in
(
bytes# !# o#, bytes# !# (o#+#1#), bytes# !# (o#+#2#),
bytes# !# (o#+#3#), bytes# !# (o#+#4#), bytes# !# (o#+#5#),
bytes# !# (o#+#6#), bytes# !# (o#+#7#), bytes# !# (o#+#8#)
)
bytes# !># n# = let o# = 9# *# n# in \ s1# -> case (!>#) bytes# o# s1# of
(# s2#, e1 #) -> case (!>#) bytes# (o# +# 1#) s2# of
(# s3#, e2 #) -> case (!>#) bytes# (o# +# 2#) s3# of
(# s4#, e3 #) -> case (!>#) bytes# (o# +# 3#) s4# of
(# s5#, e4 #) -> case (!>#) bytes# (o# +# 4#) s5# of
(# s6#, e5 #) -> case (!>#) bytes# (o# +# 5#) s6# of
(# s7#, e6 #) -> case (!>#) bytes# (o# +# 6#) s7# of
(# s8#, e7 #) -> case (!>#) bytes# (o# +# 7#) s8# of
(# s9#, e8 #) -> case (!>#) bytes# (o# +# 8#) s9# of
(# s10#, e9 #) -> (# s10#, (e1,e2,e3,e4,e5,e6,e7,e8,e9) #)
writeByteArray# mbytes# n# (e1,e2,e3,e4,e5,e6,e7,e8,e9) = let o# = 9# *# n# in
\ s1# -> case writeByteArray# mbytes# o# e1 s1# of
s2# -> case writeByteArray# mbytes# (o# +# 1#) e2 s2# of
s3# -> case writeByteArray# mbytes# (o# +# 2#) e3 s3# of
s4# -> case writeByteArray# mbytes# (o# +# 3#) e4 s4# of
s5# -> case writeByteArray# mbytes# (o# +# 4#) e5 s5# of
s6# -> case writeByteArray# mbytes# (o# +# 5#) e6 s6# of
s7# -> case writeByteArray# mbytes# (o# +# 6#) e7 s7# of
s8# -> case writeByteArray# mbytes# (o# +# 7#) e8 s8# of
s9# -> writeByteArray# mbytes# (o# +# 8#) e9 s9#
newUnboxed e n# = pnewUnboxed e (9# *# n#)
instance (Unboxed e) => Unboxed (T10 e)
where
sizeof e2 n = psizeof e2 (10 * n)
sizeof# e2 n# = psizeof# e2 (10# *# n#)
bytes# !# n# =
let o# = 10# *# n#
in
(
bytes# !# o#, bytes# !# (o#+#1#), bytes# !# (o#+#2#),
bytes# !# (o#+#3#), bytes# !# (o#+#4#), bytes# !# (o#+#5#),
bytes# !# (o#+#6#), bytes# !# (o#+#7#), bytes# !# (o#+#8#),
bytes# !# (o#+#9#)
)
bytes# !># n# = let o# = 10# *# n# in \ s1# -> case (!>#) bytes# o# s1# of
(# s2#, e1 #) -> case (!>#) bytes# (o# +# 1#) s2# of
(# s3#, e2 #) -> case (!>#) bytes# (o# +# 2#) s3# of
(# s4#, e3 #) -> case (!>#) bytes# (o# +# 3#) s4# of
(# s5#, e4 #) -> case (!>#) bytes# (o# +# 4#) s5# of
(# s6#, e5 #) -> case (!>#) bytes# (o# +# 5#) s6# of
(# s7#, e6 #) -> case (!>#) bytes# (o# +# 6#) s7# of
(# s8#, e7 #) -> case (!>#) bytes# (o# +# 7#) s8# of
(# s9#, e8 #) -> case (!>#) bytes# (o# +# 8#) s9# of
(# s10#, e9 #) -> case (!>#) bytes# (o# +# 9#) s10# of
(# s11#, e10 #) -> (# s11#, (e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) #)
writeByteArray# mbytes# n# (e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) = let o# = 10# *# n# in
\ s1# -> case writeByteArray# mbytes# o# e1 s1# of
s2# -> case writeByteArray# mbytes# (o# +# 1#) e2 s2# of
s3# -> case writeByteArray# mbytes# (o# +# 2#) e3 s3# of
s4# -> case writeByteArray# mbytes# (o# +# 3#) e4 s4# of
s5# -> case writeByteArray# mbytes# (o# +# 4#) e5 s5# of
s6# -> case writeByteArray# mbytes# (o# +# 5#) e6 s6# of
s7# -> case writeByteArray# mbytes# (o# +# 6#) e7 s7# of
s8# -> case writeByteArray# mbytes# (o# +# 7#) e8 s8# of
s9# -> case writeByteArray# mbytes# (o# +# 8#) e9 s9# of
s10# -> writeByteArray# mbytes# (o# +# 9#) e10 s10#
newUnboxed e n# = pnewUnboxed e (10# *# n#)
instance (Unboxed e) => Unboxed (T11 e)
where
sizeof e2 n = psizeof e2 (11 * n)
sizeof# e2 n# = psizeof# e2 (11# *# n#)
bytes# !# n# =
let o# = 11# *# n#
in
(
bytes# !# o#, bytes# !# (o#+#1#), bytes# !# (o#+#2#),
bytes# !# (o#+#3#), bytes# !# (o#+#4#), bytes# !# (o#+#5#),
bytes# !# (o#+#6#), bytes# !# (o#+#7#), bytes# !# (o#+#8#),
bytes# !# (o#+#9#), bytes# !# (o#+#10#)
)
bytes# !># n# = let o# = 11# *# n# in \ s1# -> case (!>#) bytes# o# s1# of
(# s2#, e1 #) -> case (!>#) bytes# (o# +# 1#) s2# of
(# s3#, e2 #) -> case (!>#) bytes# (o# +# 2#) s3# of
(# s4#, e3 #) -> case (!>#) bytes# (o# +# 3#) s4# of
(# s5#, e4 #) -> case (!>#) bytes# (o# +# 4#) s5# of
(# s6#, e5 #) -> case (!>#) bytes# (o# +# 5#) s6# of
(# s7#, e6 #) -> case (!>#) bytes# (o# +# 6#) s7# of
(# s8#, e7 #) -> case (!>#) bytes# (o# +# 7#) s8# of
(# s9#, e8 #) -> case (!>#) bytes# (o# +# 8#) s9# of
(# s10#, e9 #) -> case (!>#) bytes# (o# +# 9#) s10# of
(# s11#, e10 #) -> case (!>#) bytes# (o# +# 10#) s11# of
(# s12#, e11 #) -> (# s12#, (e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11) #)
writeByteArray# mbytes# n# (e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11) = let o# = 11# *# n# in
\ s1# -> case writeByteArray# mbytes# o# e1 s1# of
s2# -> case writeByteArray# mbytes# (o# +# 1#) e2 s2# of
s3# -> case writeByteArray# mbytes# (o# +# 2#) e3 s3# of
s4# -> case writeByteArray# mbytes# (o# +# 3#) e4 s4# of
s5# -> case writeByteArray# mbytes# (o# +# 4#) e5 s5# of
s6# -> case writeByteArray# mbytes# (o# +# 5#) e6 s6# of
s7# -> case writeByteArray# mbytes# (o# +# 6#) e7 s7# of
s8# -> case writeByteArray# mbytes# (o# +# 7#) e8 s8# of
s9# -> case writeByteArray# mbytes# (o# +# 8#) e9 s9# of
s10# -> case writeByteArray# mbytes# (o# +# 9#) e10 s10# of
s11# -> writeByteArray# mbytes# (o# +# 10#) e11 s11#
newUnboxed e n# = pnewUnboxed e (11# *# n#)
instance (Unboxed e) => Unboxed (T12 e)
where
sizeof e2 n = psizeof e2 (12 * n)
sizeof# e2 n# = psizeof# e2 (12# *# n#)
bytes# !# n# =
let o# = 12# *# n#
in
(
bytes# !# o#, bytes# !# (o#+#1#), bytes# !# (o#+#2#),
bytes# !# (o#+#3#), bytes# !# (o#+#4#), bytes# !# (o#+#5#),
bytes# !# (o#+#6#), bytes# !# (o#+#7#), bytes# !# (o#+#8#),
bytes# !# (o#+#9#), bytes# !# (o#+#10#), bytes# !# (o#+#11#)
)
bytes# !># n# = let o# = 12# *# n# in \ s1# -> case (!>#) bytes# o# s1# of
(# s2#, e1 #) -> case (!>#) bytes# (o# +# 1#) s2# of
(# s3#, e2 #) -> case (!>#) bytes# (o# +# 2#) s3# of
(# s4#, e3 #) -> case (!>#) bytes# (o# +# 3#) s4# of
(# s5#, e4 #) -> case (!>#) bytes# (o# +# 4#) s5# of
(# s6#, e5 #) -> case (!>#) bytes# (o# +# 5#) s6# of
(# s7#, e6 #) -> case (!>#) bytes# (o# +# 6#) s7# of
(# s8#, e7 #) -> case (!>#) bytes# (o# +# 7#) s8# of
(# s9#, e8 #) -> case (!>#) bytes# (o# +# 8#) s9# of
(# s10#, e9 #) -> case (!>#) bytes# (o# +# 9#) s10# of
(# s11#, e10 #) -> case (!>#) bytes# (o# +# 10#) s11# of
(# s12#, e11 #) -> case (!>#) bytes# (o# +# 11#) s12# of
(# s13#, e12 #) -> (# s13#, (e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12) #)
writeByteArray# mbytes# n# (e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12) = let o# = 12# *# n# in
\ s1# -> case writeByteArray# mbytes# o# e1 s1# of
s2# -> case writeByteArray# mbytes# (o# +# 1#) e2 s2# of
s3# -> case writeByteArray# mbytes# (o# +# 2#) e3 s3# of
s4# -> case writeByteArray# mbytes# (o# +# 3#) e4 s4# of
s5# -> case writeByteArray# mbytes# (o# +# 4#) e5 s5# of
s6# -> case writeByteArray# mbytes# (o# +# 5#) e6 s6# of
s7# -> case writeByteArray# mbytes# (o# +# 6#) e7 s7# of
s8# -> case writeByteArray# mbytes# (o# +# 7#) e8 s8# of
s9# -> case writeByteArray# mbytes# (o# +# 8#) e9 s9# of
s10# -> case writeByteArray# mbytes# (o# +# 9#) e10 s10# of
s11# -> case writeByteArray# mbytes# (o# +# 10#) e11 s11# of
s12# -> writeByteArray# mbytes# (o# +# 11#) e12 s12#
newUnboxed e n# = pnewUnboxed e (12# *# n#)
instance (Unboxed e) => Unboxed (T13 e)
where
sizeof e2 n = psizeof e2 (13 * n)
sizeof# e2 n# = psizeof# e2 (13# *# n#)
bytes# !# n# =
let o# = 13# *# n#
in
(
bytes# !# o#, bytes# !# (o#+#1#), bytes# !# (o#+#2#),
bytes# !# (o#+#3#), bytes# !# (o#+#4#), bytes# !# (o#+#5#),
bytes# !# (o#+#6#), bytes# !# (o#+#7#), bytes# !# (o#+#8#),
bytes# !# (o#+#9#), bytes# !# (o#+#10#), bytes# !# (o#+#11#),
bytes# !# (o#+#12#)
)
bytes# !># n# = let o# = 13# *# n# in \ s1# -> case (!>#) bytes# o# s1# of
(# s2#, e1 #) -> case (!>#) bytes# (o# +# 1#) s2# of
(# s3#, e2 #) -> case (!>#) bytes# (o# +# 2#) s3# of
(# s4#, e3 #) -> case (!>#) bytes# (o# +# 3#) s4# of
(# s5#, e4 #) -> case (!>#) bytes# (o# +# 4#) s5# of
(# s6#, e5 #) -> case (!>#) bytes# (o# +# 5#) s6# of
(# s7#, e6 #) -> case (!>#) bytes# (o# +# 6#) s7# of
(# s8#, e7 #) -> case (!>#) bytes# (o# +# 7#) s8# of
(# s9#, e8 #) -> case (!>#) bytes# (o# +# 8#) s9# of
(# s10#, e9 #) -> case (!>#) bytes# (o# +# 9#) s10# of
(# s11#, e10 #) -> case (!>#) bytes# (o# +# 10#) s11# of
(# s12#, e11 #) -> case (!>#) bytes# (o# +# 11#) s12# of
(# s13#, e12 #) -> case (!>#) bytes# (o# +# 12#) s13# of
(# s14#, e13 #) -> (# s14#, (e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13) #)
writeByteArray# mbytes# n# (e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13) = let o# = 13# *# n# in
\ s1# -> case writeByteArray# mbytes# o# e1 s1# of
s2# -> case writeByteArray# mbytes# (o# +# 1#) e2 s2# of
s3# -> case writeByteArray# mbytes# (o# +# 2#) e3 s3# of
s4# -> case writeByteArray# mbytes# (o# +# 3#) e4 s4# of
s5# -> case writeByteArray# mbytes# (o# +# 4#) e5 s5# of
s6# -> case writeByteArray# mbytes# (o# +# 5#) e6 s6# of
s7# -> case writeByteArray# mbytes# (o# +# 6#) e7 s7# of
s8# -> case writeByteArray# mbytes# (o# +# 7#) e8 s8# of
s9# -> case writeByteArray# mbytes# (o# +# 8#) e9 s9# of
s10# -> case writeByteArray# mbytes# (o# +# 9#) e10 s10# of
s11# -> case writeByteArray# mbytes# (o# +# 10#) e11 s11# of
s12# -> case writeByteArray# mbytes# (o# +# 11#) e12 s12# of
s13# -> writeByteArray# mbytes# (o# +# 12#) e13 s13#
newUnboxed e n# = pnewUnboxed e (13# *# n#)
instance (Unboxed e) => Unboxed (T14 e)
where
sizeof e2 n = psizeof e2 (14 * n)
sizeof# e2 n# = psizeof# e2 (14# *# n#)
bytes# !# n# =
let o# = 14# *# n#
in
(
bytes# !# o#, bytes# !# (o#+#1#), bytes# !# (o#+#2#),
bytes# !# (o#+#3#), bytes# !# (o#+#4#), bytes# !# (o#+#5#),
bytes# !# (o#+#6#), bytes# !# (o#+#7#), bytes# !# (o#+#8#),
bytes# !# (o#+#9#), bytes# !# (o#+#10#), bytes# !# (o#+#11#),
bytes# !# (o#+#12#), bytes# !# (o#+#13#)
)
bytes# !># n# = let o# = 14# *# n# in \ s1# -> case (!>#) bytes# o# s1# of
(# s2#, e1 #) -> case (!>#) bytes# (o# +# 1#) s2# of
(# s3#, e2 #) -> case (!>#) bytes# (o# +# 2#) s3# of
(# s4#, e3 #) -> case (!>#) bytes# (o# +# 3#) s4# of
(# s5#, e4 #) -> case (!>#) bytes# (o# +# 4#) s5# of
(# s6#, e5 #) -> case (!>#) bytes# (o# +# 5#) s6# of
(# s7#, e6 #) -> case (!>#) bytes# (o# +# 6#) s7# of
(# s8#, e7 #) -> case (!>#) bytes# (o# +# 7#) s8# of
(# s9#, e8 #) -> case (!>#) bytes# (o# +# 8#) s9# of
(# s10#, e9 #) -> case (!>#) bytes# (o# +# 9#) s10# of
(# s11#, e10 #) -> case (!>#) bytes# (o# +# 10#) s11# of
(# s12#, e11 #) -> case (!>#) bytes# (o# +# 11#) s12# of
(# s13#, e12 #) -> case (!>#) bytes# (o# +# 12#) s13# of
(# s14#, e13 #) -> case (!>#) bytes# (o# +# 13#) s14# of
(# s15#, e14 #) -> (# s15#, (e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14) #)
writeByteArray# mbytes# n# (e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14) =
\ s1# -> let o# = 14# *# n# in case writeByteArray# mbytes# o# e1 s1# of
s2# -> case writeByteArray# mbytes# (o# +# 1#) e2 s2# of
s3# -> case writeByteArray# mbytes# (o# +# 2#) e3 s3# of
s4# -> case writeByteArray# mbytes# (o# +# 3#) e4 s4# of
s5# -> case writeByteArray# mbytes# (o# +# 4#) e5 s5# of
s6# -> case writeByteArray# mbytes# (o# +# 5#) e6 s6# of
s7# -> case writeByteArray# mbytes# (o# +# 6#) e7 s7# of
s8# -> case writeByteArray# mbytes# (o# +# 7#) e8 s8# of
s9# -> case writeByteArray# mbytes# (o# +# 8#) e9 s9# of
s10# -> case writeByteArray# mbytes# (o# +# 9#) e10 s10# of
s11# -> case writeByteArray# mbytes# (o# +# 10#) e11 s11# of
s12# -> case writeByteArray# mbytes# (o# +# 11#) e12 s12# of
s13# -> case writeByteArray# mbytes# (o# +# 12#) e13 s13# of
s14# -> writeByteArray# mbytes# (o# +# 13#) e14 s14#
newUnboxed e n# = pnewUnboxed e (14# *# n#)
instance (Unboxed e) => Unboxed (T15 e)
where
sizeof e2 n = psizeof e2 (15 * n)
sizeof# e2 n# = psizeof# e2 (15# *# n#)
bytes# !# n# =
let o# = 15# *# n#
in
(
bytes# !# o#, bytes# !# (o#+#1#), bytes# !# (o#+#2#),
bytes# !# (o#+#3#), bytes# !# (o#+#4#), bytes# !# (o#+#5#),
bytes# !# (o#+#6#), bytes# !# (o#+#7#), bytes# !# (o#+#8#),
bytes# !# (o#+#9#), bytes# !# (o#+#10#), bytes# !# (o#+#11#),
bytes# !# (o#+#12#), bytes# !# (o#+#13#), bytes# !# (o#+#14#)
)
bytes# !># n# = let o# = 15# *# n# in \ s1# -> case (!>#) bytes# o# s1# of
(# s2#, e1 #) -> case (!>#) bytes# (o# +# 1#) s2# of
(# s3#, e2 #) -> case (!>#) bytes# (o# +# 2#) s3# of
(# s4#, e3 #) -> case (!>#) bytes# (o# +# 3#) s4# of
(# s5#, e4 #) -> case (!>#) bytes# (o# +# 4#) s5# of
(# s6#, e5 #) -> case (!>#) bytes# (o# +# 5#) s6# of
(# s7#, e6 #) -> case (!>#) bytes# (o# +# 6#) s7# of
(# s8#, e7 #) -> case (!>#) bytes# (o# +# 7#) s8# of
(# s9#, e8 #) -> case (!>#) bytes# (o# +# 8#) s9# of
(# s10#, e9 #) -> case (!>#) bytes# (o# +# 9#) s10# of
(# s11#, e10 #) -> case (!>#) bytes# (o# +# 10#) s11# of
(# s12#, e11 #) -> case (!>#) bytes# (o# +# 11#) s12# of
(# s13#, e12 #) -> case (!>#) bytes# (o# +# 12#) s13# of
(# s14#, e13 #) -> case (!>#) bytes# (o# +# 13#) s14# of
(# s15#, e14 #) -> case (!>#) bytes# (o# +# 14#) s15# of
(# s16#, e15 #) -> (# s16#, (e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15) #)
writeByteArray# mbytes# n# (e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15) =
\ s1# -> let o# = 15# *# n# in case writeByteArray# mbytes# o# e1 s1# of
s2# -> case writeByteArray# mbytes# (o# +# 1#) e2 s2# of
s3# -> case writeByteArray# mbytes# (o# +# 2#) e3 s3# of
s4# -> case writeByteArray# mbytes# (o# +# 3#) e4 s4# of
s5# -> case writeByteArray# mbytes# (o# +# 4#) e5 s5# of
s6# -> case writeByteArray# mbytes# (o# +# 5#) e6 s6# of
s7# -> case writeByteArray# mbytes# (o# +# 6#) e7 s7# of
s8# -> case writeByteArray# mbytes# (o# +# 7#) e8 s8# of
s9# -> case writeByteArray# mbytes# (o# +# 8#) e9 s9# of
s10# -> case writeByteArray# mbytes# (o# +# 9#) e10 s10# of
s11# -> case writeByteArray# mbytes# (o# +# 10#) e11 s11# of
s12# -> case writeByteArray# mbytes# (o# +# 11#) e12 s12# of
s13# -> case writeByteArray# mbytes# (o# +# 12#) e13 s13# of
s14# -> case writeByteArray# mbytes# (o# +# 13#) e14 s14# of
s15# -> writeByteArray# mbytes# (o# +# 14#) e15 s15#
newUnboxed e n# = pnewUnboxed e (15# *# n#)
--------------------------------------------------------------------------------
-- | 'ByteArray#' wrapper.
data Wrap = Wrap {unwrap :: ByteArray#}
{- |
@since 0.2.1
Wrapped empty 'ByteArray#'.
-}
lzero# :: Wrap
lzero# = runST $ ST $ \ s1# -> case newByteArray# 0# s1# of
(# s2#, marr# #) -> case unsafeFreezeByteArray# marr# s2# of
(# s3#, arr# #) -> (# s3#, Wrap arr# #)
{- |
@since 0.2.1
'ByteArray#' singleton.
-}
single# :: (Unboxed e) => e -> ByteArray#
single# e = unwrap $ runST $ ST $ \ s1# -> case newUnboxed' e 1# s1# of
(# s2#, marr# #) -> case unsafeFreezeByteArray# marr# s2# of
(# s3#, arr# #) -> (# s3#, Wrap arr# #)
{- |
@since 0.2.1
Create immutable 'Unboxed' array from given list.
-}
fromList# :: (Unboxed e) => [e] -> ByteArray#
fromList# es = let !(I# n#) = length es in fromListN# n# es
{- |
@since 0.2.1
Create immutable 'Unboxed' array from 'Foldable' stream.
-}
fromFoldable# :: (Foldable f, Unboxed e) => f e -> (# Int, ByteArray# #)
fromFoldable# es = unpack' $ runST $ ST $ \ s1# -> case fromFoldableM# es s1# of
(# s2#, n, marr# #) -> case unsafeFreezeByteArray# marr# s2# of
(# s3#, arr# #) -> (# s3#, (n, Wrap arr#) #)
where
unpack' (i, Wrap arr#) = (# i, arr# #)
{- |
@since 0.2.1
Create immutable 'Unboxed' array from known size list.
-}
fromListN# :: (Unboxed e) => Int# -> [e] -> ByteArray#
fromListN# n# es = unwrap $ runST $ ST $ \ s1# -> case newLinearN# n# es s1# of
(# s2#, marr# #) -> case unsafeFreezeByteArray# marr# s2# of
(# s3#, arr# #) -> (# s3#, Wrap arr# #)
{- |
@since 0.2.1
Create mutable 'Unboxed' array from given list.
-}
newLinear# :: (Unboxed e) => [e] -> State# s ->
(# State# s, MutableByteArray# s #)
newLinear# es = let !(I# n#) = length es in newLinearN# n# es
{- |
@since 0.2.1
Create mutable 'Unboxed' array from known size list.
-}
newLinearN# :: (Unboxed e) => Int# -> [e] -> State# s ->
(# State# s, MutableByteArray# s #)
newLinearN# c# es = \ s1# -> case pnewUnboxed es n# s1# of
(# s2#, marr# #) ->
let
go y r = \ i# s4# -> case writeByteArray# marr# i# y s4# of
s5# -> if isTrue# (i# ==# n# -# 1#) then s5# else r (i# +# 1#) s5#
in case if n == 0 then s2# else foldr go (\ _ s# -> s#) es 0# s2# of
s3# -> (# s3#, marr# #)
where
!n@(I# n#) = max 0 (I# c#)
{- |
@since 0.2.1
Create mutable 'Unboxed' array from 'Foldable' stream.
-}
fromFoldableM# :: (Foldable f, Unboxed e) => f e -> State# s ->
(# State# s, Int, MutableByteArray# s #)
fromFoldableM# es = \ s1# -> case pnewUnboxed es n# s1# of
(# s2#, marr# #) ->
let
go y r = \ i# s4# -> case writeByteArray# marr# i# y s4# of
s5# -> if isTrue# (i# ==# n# -# 1#) then s5# else r (i# +# 1#) s5#
in case if n == 0 then s2# else foldr go (\ _ s# -> s#) es 0# s2# of
s3# -> (# s3#, n, marr# #)
where
!n@(I# n#) = length es
{- |
@since 0.2.1
Concatenation of two 'Unboxed' arrays.
-}
concat# :: (Unboxed e) => e ->
ByteArray# -> Int# -> Int# ->
ByteArray# -> Int# -> Int# -> State# s ->
(# State# s, Int#, MutableByteArray# s #)
concat# e arr1# n1# o1# arr2# n2# o2# = \ s1# -> case newUnboxed e n# s1# of
(# s2#, marr# #) -> case copyUnboxed# e arr1# o1# marr# 0# n1# s2# of
s3# -> case copyUnboxed# e arr2# o2# marr# n1# n2# s3# of
s4# -> (# s4#, n#, marr# #)
where
n# = n1# +# n2#
-- | Proxy concatenation of two byte arrays representing 'Unboxed' structures.
pconcat :: (Unboxed e) => proxy e ->
ByteArray# -> Int# -> Int# -> ByteArray# -> Int# -> Int# ->
State# s -> (# State# s, Int#, MutableByteArray# s #)
pconcat = concat# . fromProxy
--------------------------------------------------------------------------------
rank# :: (Shape i) => i -> Int#
rank# i = case rank i of I# r# -> r#
{-# INLINE bool_scale #-}
bool_scale :: Int# -> Int#
bool_scale n# = (n# +# 7#) `uncheckedIShiftRA#` 3#
{-# INLINE bool_bit #-}
bool_bit :: Int# -> Word#
bool_bit n# = case (SIZEOF_HSWORD * 8 - 1) of
W# mask# -> int2Word# 1# `uncheckedShiftL#` word2Int# (int2Word# n# `and#` mask#)
{-# INLINE bool_not_bit #-}
bool_not_bit :: Int# -> Word#
bool_not_bit n# = case maxBound of W# mb# -> bool_bit n# `xor#` mb#
{-# INLINE bool_index #-}
bool_index :: Int# -> Int#
#if SIZEOF_HSWORD == 4
bool_index = (`uncheckedIShiftRA#` 5#)
#elif SIZEOF_HSWORD == 8
bool_index = (`uncheckedIShiftRA#` 6#)
#endif
consSizeof :: (a -> b) -> b -> a
consSizeof = \ _ _ -> undefined
|
[STATEMENT]
lemma prod_mset_multiset_prime_factorization_nat [simp]:
"(x::nat) \<noteq> 0 \<Longrightarrow> prod_mset (prime_factorization x) = x"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. x \<noteq> 0 \<Longrightarrow> \<Prod>\<^sub># (prime_factorization x) = x
[PROOF STEP]
by simp |
-- a^7 = b^7 syss a = b
-- ====================
import tactic
import algebra.order.ring
theorem ex_1_3_5
{α}
[linear_ordered_ring α]
(a b : α)
(h : a^7 = b^7)
: a = b :=
(@strict_mono_pow_bit1 α _ 3).injective h
-- Referencia
-- ==========
-- Mario Carneiro "if a^7=b^7 then a=b" https://bit.ly/3oyBS6M
|
import tactic
/--------------------------------------------------------------------------
Recall that for any ``P : Prop``, you can use ``false.elim : false → P``
to prove ``P`` from a contradiction.
Delete the ``sorry,`` below and replace them with a legitimate proof.
--------------------------------------------------------------------------/
example (P Q R : Prop) : P ∧ false ↔ false :=
begin
sorry,
end
theorem principle_of_explosion (P Q : Prop) : P ∧ ¬ P → Q :=
begin
sorry,
end |
lemmas linear_imp_scaleR = linear_imp_scale |
module ModuleArityMismatch where
module M (A : Set) where
postulate
A : Set
module M′ = M A A
|
classdef(Abstract) AbstractGeometricVectorConstraint < AbstractConstraint
%AbstractGeometricVectorConstraint Summary of this class goes here
% Detailed explanation goes here
properties
normFact = 1;
vector AbstractGeometricVector
event LaunchVehicleEvent
eventNode(1,1) ConstraintStateComparisonNodeEnum = ConstraintStateComparisonNodeEnum.FinalState;
lb(1,1) double = 0;
ub(1,1) double = 0;
type(1,:) char
evalType(1,1) ConstraintEvalTypeEnum = ConstraintEvalTypeEnum.FixedBounds;
stateCompType(1,1) ConstraintStateComparisonTypeEnum = ConstraintStateComparisonTypeEnum.Equals;
stateCompEvent LaunchVehicleEvent
stateCompNode(1,1) ConstraintStateComparisonNodeEnum = ConstraintStateComparisonNodeEnum.FinalState;
end
methods
function [lb, ub] = getBounds(obj)
lb = obj.lb;
ub = obj.ub;
end
function [c, ceq, value, lwrBnd, uprBnd, type, eventNum, valueStateComp] = evalConstraint(obj, stateLog, celBodyData)
type = obj.getConstraintType();
switch obj.eventNode
case ConstraintStateComparisonNodeEnum.FinalState
stateLogEntry = stateLog.getLastStateLogForEvent(obj.event);
case ConstraintStateComparisonNodeEnum.InitialState
stateLogEntry = stateLog.getFirstStateLogForEvent(obj.event);
otherwise
error('Unknown event node.');
end
if(not(isempty(obj.frame)))
frame = obj.frame;
else
frame = stateLogEntry.centralBody.getBodyCenteredInertialFrame();
end
value = lvd_GeometricVectorTasks(stateLogEntry, obj.type, obj.vector, frame);
if(obj.evalType == ConstraintEvalTypeEnum.StateComparison)
switch obj.stateCompNode
case ConstraintStateComparisonNodeEnum.FinalState
stateLogEntryStateComp = stateLog.getLastStateLogForEvent(obj.stateCompEvent);
case ConstraintStateComparisonNodeEnum.InitialState
stateLogEntryStateComp = stateLog.getFirstStateLogForEvent(obj.stateCompEvent);
otherwise
error('Unknown event node.');
end
valueStateComp = lvd_GeometricVectorTasks(stateLogEntryStateComp, obj.type, obj.vector, frame);
else
valueStateComp = NaN;
end
[c, ceq] = obj.computeCAndCeqValues(value, valueStateComp);
lwrBnd = obj.lb;
uprBnd = obj.ub;
eventNum = obj.event.getEventNum();
end
function sF = getScaleFactor(obj)
sF = obj.normFact;
end
function setScaleFactor(obj, sF)
obj.normFact = sF;
end
function tf = usesStage(obj, stage)
tf = false;
end
function tf = usesEngine(obj, engine)
tf = false;
end
function tf = usesTank(obj, tank)
tf = false;
end
function tf = usesEngineToTankConn(obj, engineToTank)
tf = false;
end
function tf = usesEvent(obj, event)
tf = obj.event == event;
if(obj.evalType == ConstraintEvalTypeEnum.StateComparison)
tf = tf || obj.stateCompEvent == event;
end
end
function tf = usesStopwatch(~, ~)
tf = false;
end
function tf = usesExtremum(~, ~)
tf = false;
end
function tf = usesGroundObj(~, ~)
tf = false;
end
function tf = usesGeometricVector(obj, vector)
tf = obj.vector == vector;
end
function tf = canUseSparseOutput(obj)
tf = true;
end
function event = getConstraintEvent(obj)
event = obj.event;
end
function [unit, lbLim, ubLim, usesLbUb, usesCelBody, usesRefSc] = getConstraintStaticDetails(obj)
unit = '';
lbLim = 0;
ubLim = Inf;
usesLbUb = true;
usesCelBody = false;
usesRefSc = false;
end
function addConstraintTf = openEditConstraintUI(obj, lvdData)
if(lvdData.geometry.vectors.getNumVectors() >= 1)
% addConstraintTf = lvd_EditGeometricVectorConstraintGUI(obj, lvdData);
output = AppDesignerGUIOutput({false});
lvd_EditGeometricVectorConstraintGUI_App(obj, lvdData, output);
addConstraintTf = output.output{1};
else
errordlg('There are currently no geometric vectors in this scenario. Add at least one new vector first.');
addConstraintTf = false;
end
end
function vector = selectConstraintObj(obj, lvdData)
[listBoxStr, vectors] = lvdData.geometry.vectors.getListboxStr();
vector = [];
if(isempty(vectors))
warndlg('Cannot create vector value object: no vectors have been created. Create a vector first.','Vector Value Constraint','modal');
else
[Selection,ok] = listdlg('PromptString',{'Select a vector:'},...
'SelectionMode','single',...
'Name','Vectors',...
'ListString',listBoxStr);
if(ok == 0)
vector = [];
else
vector = vectors(Selection);
end
end
end
function useObjFcn = setupForUseAsObjectiveFcn(obj,lvdData)
vectorSel = obj.selectConstraintObj(lvdData);
if(not(isempty(vectorSel)))
obj.vector = vectorSel;
useObjFcn = true;
else
useObjFcn = false;
end
end
end
end |
/-
Copyright (c) 2015 Microsoft Corporation. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Leonardo de Moura, Jeremy Avigad, Mario Carneiro
-/
import Mathlib.Tactic.Alias
import Mathlib.Tactic.IrreducibleDef
import Mathlib.Mathport.Rename
import Mathlib.Init.Logic
/-! ### alignments from lean 3 `init.classical` -/
namespace Classical
#align classical.inhabited_of_nonempty Classical.inhabited_of_nonempty
#align classical.inhabited_of_exists Classical.inhabited_of_exists
attribute [local instance] propDecidable
attribute [local instance] decidableInhabited
alias axiomOfChoice ← axiom_of_choice -- TODO: fix in core
alias propComplete ← prop_complete -- TODO: fix in core
@[elab_as_elim] theorem cases_true_false (p : Prop → Prop)
(h1 : p True) (h2 : p False) (a : Prop) : p a :=
Or.elim (prop_complete a) (fun ht : a = True ↦ ht.symm ▸ h1) fun hf : a = False ↦ hf.symm ▸ h2
theorem cases_on (a : Prop) {p : Prop → Prop} (h1 : p True) (h2 : p False) : p a :=
@cases_true_false p h1 h2 a
theorem cases {p : Prop → Prop} (h1 : p True) (h2 : p False) (a) : p a := cases_on a h1 h2
#align classical.cases Classical.cases
alias byCases ← by_cases
alias byContradiction ← by_contradiction
theorem eq_false_or_eq_true (a : Prop) : a = False ∨ a = True := (prop_complete a).symm
end Classical
|
# Copyright © 2021, UChicago Argonne, LLC
# All Rights Reserved.
# This source code is licensed under the BSD-style license found in the
# LICENSE file in the root directory of this source tree.
using DataFrames, DataStructures, InteractiveUtils, Logging, Printf
import CSV, DelimitedFiles, SCIP, Statistics, Glob
using JuMP, MathOptInterface
const MOI = MathOptInterface |
variables (a b c d e : ℕ)
variable h1 : a = b
variable h2 : b = c + 1
variable h3 : c = d
variable h4 : e = 1 + d
include h1 h2 h3 h4
theorem T : a = e :=
calc
a = b : by rw h1
... = c + 1 : by rw h2
... = d + 1 : by rw h3
... = 1 + d : by rw add_comm
... = e : by rw h4
|
import data.real.irrational
import topology.basic
import algebra.order.floor
--OUTPUT 1
theorem irrational_orbit_dense {α : ℝ} (hα_irrat : irrational α) : closure ((λ m : ℤ, int.fract (α * ↑m)) '' (@set.univ ℤ)) = set.Icc 0 1 :=
begin
-- Let $\alpha$ be an irrational number. Then for distinct $i, j \in \mathbb{Z}$, we must have $\{i \alpha\} \neq\{j \alpha\}$. If this were not true, then
have h1 : ∀ (i j : ℤ), i ≠ j → int.fract (α * ↑i) ≠ int.fract (α * ↑j), from
assume (i j : ℤ) (h : i ≠ j),
have h2 : α ≠ (int.fract (α * ↑i) - int.fract (α * ↑j)) / (i - j), from by {
assume h3 : α = (int.fract (α * ↑i) - int.fract (α * ↑j)) / (i - j),
have h4 : α * ↑i = ↑(int.nat_abs (α * ↑i)) + int.fract (α * ↑i), from by {
rw int.fract_eq_of_nat_abs_lt_one,
have h5 : 0 < α * ↑i, from by {
apply mul_pos,
apply irrational.irrat_pos,
exact hα_irrat,
apply int.coe_nat_pos,
},
exact lt_of_le_of_lt (int.nat_abs_nonneg (α * ↑i)) h5,
},
have h6 : α * ↑j = ↑(int.nat_abs (α * ↑j)) + int.fract (α * ↑j), from by {
rw int.fract_eq_of_nat_abs_lt_one,
have h7 : 0 < α * ↑j, from by {
apply mul_pos,
apply irrational.irrat_pos,
exact hα_irrat,
apply int.coe_nat_pos,
},
exact lt_of_le_of_lt (int.nat_abs_nonneg (α * ↑j)) h7,
},
have h8 : (α * ↑i - α * ↑j) = (int.nat_abs (α * ↑i) - int.nat_abs (α * ↑j)) + (int.fract (α * ↑i) - int.fract (α * ↑j)), from by {
rw [h4,h6],
ring,
},
have h9 : (α * ↑i - α * ↑j) = (i - j) * α, from by {
rw [← mul_sub,mul_comm,mul_comm ↑i α,mul_comm ↑j α],
},
have h10 : (int.nat_abs (α * ↑i) - int.nat_abs (α * ↑j)) = 0, from by {
rw [← int.coe_nat_eq_coe_nat_iff,← int.coe_nat_eq_coe_nat_iff],
rw [← int.nat_abs_of_nonneg,← int.nat_abs_of_nonneg],
have h11 : 0 ≤ α * ↑i, from by {
apply mul_nonneg,
apply irrational.irrat_pos,
exact hα_irrat,
apply int.coe_nat_nonneg,
},
have h12 : 0 ≤ α * ↑j, from by {
apply mul_nonneg,
apply irrational.irrat_pos,
exact hα_irrat,
apply int.coe_nat_nonneg,
},
have h13 : 0 ≤ i, from by {
apply int.coe_nat_nonneg,
},
have h14 : 0 ≤ j, from by {
apply int.coe_nat_nonneg,
},
have h15 : 0 ≤ (i - j), from by {
apply sub_nonneg,
exact h13,
exact h14,
},
have h16 : 0 ≤ (α * ↑i - α * ↑j), from by {
apply sub_nonneg,
exact h11,
exact h12,
},
have h17 : (α * ↑i - α * ↑j) = (i - j) * α, from by {
rw [← mul_sub,mul_comm,mul_comm ↑i α,mul_comm ↑j α],
},
have h18 : (α * ↑i - α * ↑j) = (i - j) * α, from by {
rw [← mul_sub,mul_comm,mul_comm ↑i α,mul_comm ↑j α],
},
have h19 : (i - j) * α = 0, from by {
rw [← h17,← h18],
rw [← int.coe_nat_eq_coe_nat_iff,← int.coe_nat_eq_coe_nat_iff],
rw [← int.nat_abs_of_nonneg,← int.nat_abs_of_nonneg],
exact h16,
exact h15,
},
have h20 : (i - j) = 0, from by {
rw [← mul_eq_zero,mul_comm,mul_comm ↑i α,mul_comm ↑j α],
exact h19,
exact irrational.irrat_pos hα_irrat,
},
have h21 : i = j, from by {
rw [← sub_eq_zero,← h20],
},
exact h21,
},
have h22 : (int.fract (α * ↑i) - int.fract (α * ↑j)) = 0, from by {
rw [← int.coe_nat_eq_coe_nat_iff,← int.coe_nat_eq_coe_nat_iff],
rw [← int.nat_abs_of_nonneg,← int.nat_abs_of_nonneg],
have h23 : 0 ≤ α * ↑i, from by {
apply mul_nonneg,
apply irrational.irrat_pos,
exact hα_irrat,
apply int.coe_nat_nonneg,
},
have h24 : 0 ≤ α * ↑j, from by {
apply mul_nonneg,
apply irrational.irrat_pos,
exact hα_irrat,
apply int.coe_nat_nonneg,
},
have h25 : 0 ≤ (α * ↑i - α * ↑j), from by {
apply sub_nonneg,
exact h23,
exact h24,
},
have h26 : (α * ↑i - α * ↑j) = (i - j) * α, from by {
rw [← mul_sub,mul_comm,mul_comm ↑i α,mul_comm ↑j α],
},
have h27 : (α * ↑i - α * ↑j) = (i - j) * α, from by {
rw [← mul_sub,mul_comm,mul_comm ↑i α,mul_comm ↑j α],
},
have h28 : (i - j) * α = 0, from by {
rw [← h26,← h27],
rw [← int.coe_nat_eq_coe_nat_iff,← int.coe_nat_eq_coe_nat_iff],
rw [← int.nat_abs_of_nonneg,← int.nat_abs_of_nonneg],
exact h25,
exact h10,
},
have h29 : (i - j) = 0, from by {
rw [← mul_eq_zero,mul_comm,mul_comm ↑i α,mul_comm ↑j α],
exact h28,
exact irrational.irrat_pos hα_irrat,
},
have h30 : i = j, from by {
rw [← sub_eq_zero,← h29],
},
exact h30,
},
have h31 :
end --Needs more than 2000 tokens!
--OUTPUT 2
theorem irrational_orbit_dense {α : ℝ} (hα_irrat : irrational α) : closure ((λ m : ℤ, int.fract (α * ↑m)) '' (@set.univ ℤ)) = set.Icc 0 1 :=
begin
--Let $\alpha$ be an irrational number. Then for distinct $i, j \in \mathbb{Z}$, we must have $\{i \alpha\} \neq\{j \alpha\}$.
have h1 : ∀ i j : ℤ, i ≠ j → int.fract (α * ↑i) ≠ int.fract (α * ↑j), from by {
assume i j h,
assume h2 : int.fract (α * ↑i) = int.fract (α * ↑j),
have h3 : α * ↑i - ↑(int.floor (α * ↑i)) = int.fract (α * ↑i), from by {rw ← h2, rw int.fract_eq_of_nonneg (le_of_lt (int.floor_lt_iff.mpr (lt_add_one (α * ↑i)))),},
have h4 : α * ↑j - ↑(int.floor (α * ↑j)) = int.fract (α * ↑j), from by {rw h2, rw int.fract_eq_of_nonneg (le_of_lt (int.floor_lt_iff.mpr (lt_add_one (α * ↑j)))),},
have h5 : α = (int.floor (α * ↑i) - int.floor (α * ↑j)) / (i - j), from by {rw [h3,h4], ring,},
have h6 : (i - j) ≠ 0, from by {intro h7, rw h7 at h, exact h rfl,},
have h7 : (int.floor (α * ↑i) - int.floor (α * ↑j)) / (i - j) ∈ ℚ, from by {rw h5, apply_instance,},
have h8 : α ∈ ℚ, from by {rw h5, apply_instance,},
exact hα_irrat h8,
},
--If this were not true, then
--$$
--i \alpha-\lfloor i \alpha\rfloor=\{i \alpha\}=\{j \alpha\}=j \alpha-\lfloor j \alpha\rfloor,
--$$
--which yields the false statement $\alpha=\frac{\lfloor i \alpha\rfloor-\lfloor j \alpha\rfloor}{i-j} \in \mathbb{Q}$.
--Hence,
--$$
--S:=\{\{i \alpha\} \mid i \in \mathbb{Z}\}
--$$
--is an infinite subset of $\left[0,1\right]$.
have h2 : ∀ i j : ℤ, i ≠ j → int.fract (α * ↑i) ≠ int.fract (α * ↑j), from by {
assume i j h,
assume h2 : int.fract (α * ↑i) = int.fract (α * ↑j),
have h3 : α * ↑i - ↑(int.floor (α * ↑i)) = int.fract (α * ↑i), from by {rw ← h2, rw int.fract_eq_of_nonneg (le_of_lt (int.floor_lt_iff.mpr (lt_add_one (α * ↑i)))),},
have h4 : α * ↑j - ↑(int.floor (α * ↑j)) = int.fract (α * ↑j), from by {rw h2, rw int.fract_eq_of_nonneg (le_of_lt (int.floor_lt_iff.mpr (lt_add_one (α * ↑j)))),},
have h5 : α = (int.floor (α * ↑i) - int.floor (α * ↑j)) / (i - j), from by {rw [h3,h4], ring,},
have h6 : (i - j) ≠ 0, from by {intro h7, rw h7 at h, exact h rfl,},
have h7 : (int.floor (α * ↑i) - int.floor (α * ↑j)) / (i - j) ∈ ℚ, from by {rw h5, apply_instance,},
have h8 : α ∈ ℚ, from by {rw h5, apply_instance,},
exact hα_irrat h8,
},
have h3 : ∀ i j : ℤ, i ≠ j → int.fract (α * ↑i) ≠ int.fract (α * ↑j), from by {
assume i j h,
assume h2 : int.fract (α * ↑i) = int.fract (α * ↑j),
have h3 : α * ↑i - ↑(int.floor (α * ↑i)) = int.fract (α * ↑i), from by {rw ← h2, rw int.fract_eq_of_nonneg (le_of_lt (int.floor_lt_iff.mpr (lt_add_one (α * ↑i)))),},
have h4 : α * ↑j - ↑(int.floor (α * ↑j)) = int.fract (α * ↑j), from by {rw h2, rw int.fract_eq_of_nonneg (le_of_lt (int.floor_lt_iff.mpr (lt_add_one (α * ↑j)))),},
have h5 : α = (int.floor (α * ↑i) - int.floor (α * ↑j)) / (i - j), from by {rw [h3,h4], ring,},
have h6 : (i - j) ≠ 0, from by {intro h7, rw h7 at h, exact h rfl,},
have h7 : (int.floor (α * ↑i) - int.floor (α * ↑j)) / (i - j) ∈ ℚ, from by {rw h5, apply_instance,},
have h8 : α ∈ ℚ, from by {rw h5, apply_instance,},
exact hα_irrat h8,
},
have h4 : ∀ i j : ℤ, i ≠ j → int.fract (α * ↑i) ≠ int.fract (α * ↑j), from by {
assume i j h,
assume h2 : int.fract (α * ↑i) = int.fract (α * ↑j),
have h3 : α * ↑i - ↑(int.floor (α * ↑i)) = int.fract (α * ↑i), from by {rw ← h2, rw int.fract_eq_of_nonneg (le_of_lt (int.floor_lt_iff.mpr (lt_add_one (α * ↑i)))),},
have h4 : α * ↑j - ↑(int.floor (α * ↑j)) = int.fract (α * ↑j), from by {rw h2, rw int.fract_eq_of_nonneg (le_of_lt (int.floor_lt_iff.mpr (lt_add_one (α * ↑j)))),},
have h5 : α = (int.floor (α * ↑i) - int.floor (α * ↑j)) / (i - j), from by {rw [h3,h4], ring,},
have h6 : (i - j) ≠ 0, from by {intro h7, rw h7 at h, exact h rfl,},
have h7 : (int.floor (α * ↑i) - int.floor (α * ↑j)) / (i - j) ∈ ℚ, from by {rw h5, apply_instance,},
have h8 : α ∈ ℚ, from by {rw h5, apply_instance,},
exact hα_irrat h8,
},
have h5 : ∀ i j : ℤ, i ≠ j → int.fract (α * ↑i) ≠ int.fract (α * ↑j), from by {
assume i j h,
assume h2 : int.fract (α * ↑i) = int.fract (α * ↑j),
have h3 : α * ↑
end --Needs more than 2000 tokens!
--OUTPUT 3
theorem irrational_orbit_dense {α : ℝ} (hα_irrat : irrational α) : closure ((λ m : ℤ, int.fract (α * ↑m)) '' (@set.univ ℤ)) = set.Icc 0 1 :=
begin
-- Let $\alpha$ be an irrational number. Then for distinct $i, j \in \mathbb{Z}$, we must have $\{i \alpha\} \neq\{j \alpha\}$. If this were not true, then
-- $$
-- i \alpha-\lfloor i \alpha\rfloor=\{i \alpha\}=\{j \alpha\}=j \alpha-\lfloor j \alpha\rfloor,
-- $$
-- which yields the false statement $\alpha=\frac{\lfloor i \alpha\rfloor-\lfloor j \alpha\rfloor}{i-j} \in \mathbb{Q}$. Hence,
-- $$
-- S:=\{\{i \alpha\} \mid i \in \mathbb{Z}\}
-- $$
-- is an infinite subset of $\left[0,1\right]$.
have h1 : ∀ i j : ℤ, i ≠ j → int.fract (α * ↑i) ≠ int.fract (α * ↑j), from by {
assume i j h,
have h2 : α = (int.fract (α * ↑i) + int.nat_abs (α * ↑i)) / (i - j), from by {
have h3 : α * ↑i = (int.fract (α * ↑i) + int.nat_abs (α * ↑i)) + (int.nat_abs (α * ↑i) * ↑i), from by {
rw int.fract_eq_of_nat_abs_lt_one,
have h4 : (0 : ℝ) < (1 : ℝ), from by {exact zero_lt_one},
have h5 : (0 : ℝ) < (α * ↑i), from by {apply mul_pos h4, exact int.coe_nat_pos.mpr (int.coe_nat_ne_zero_iff_pos.mpr h)},
have h6 : (0 : ℝ) < int.nat_abs (α * ↑i), from by {apply int.nat_abs_pos.mpr h5},
have h7 : (0 : ℝ) < int.nat_abs (α * ↑i) * ↑i, from by {apply mul_pos h6, exact int.coe_nat_pos.mpr (int.coe_nat_ne_zero_iff_pos.mpr h)},
have h8 : (0 : ℝ) < int.nat_abs (α * ↑i) + (int.nat_abs (α * ↑i) * ↑i), from by {apply add_pos h6 h7},
have h9 : (0 : ℝ) < (α * ↑i) - (int.fract (α * ↑i) + int.nat_abs (α * ↑i)), from by {rw ← int.fract_eq_of_nat_abs_lt_one, exact h8},
have h10 : (0 : ℝ) < (α * ↑i) - (int.fract (α * ↑i) + int.nat_abs (α * ↑i)) + (int.fract (α * ↑i) + int.nat_abs (α * ↑i)), from by {apply add_pos h9 h8},
have h11 : (0 : ℝ) < (α * ↑i) - (int.fract (α * ↑i) + int.nat_abs (α * ↑i)) + (int.fract (α * ↑i) + int.nat_abs (α * ↑i)) + (int.nat_abs (α * ↑i) * ↑i), from by {apply add_pos h10 h7},
have h12 : (0 : ℝ) < (α * ↑i) - (int.fract (α * ↑i) + int.nat_abs (α * ↑i)) + (int.fract (α * ↑i) + int.nat_abs (α * ↑i)) + (int.nat_abs (α * ↑i) * ↑i) + (int.fract (α * ↑i) + int.nat_abs (α * ↑i)), from by {apply add_pos h11 h8},
have h13 : (0 : ℝ) < (α * ↑i) - (int.fract (α * ↑i) + int.nat_abs (α * ↑i)) + (int.fract (α * ↑i) + int.nat_abs (α * ↑i)) + (int.nat_abs (α * ↑i) * ↑i) + (int.fract (α * ↑i) + int.nat_abs (α * ↑i)) + (int.fract (α * ↑i) + int.nat_abs (α * ↑i)), from by {apply add_pos h12 h8},
have h14 : (0 : ℝ) < (α * ↑i) - (int.fract (α * ↑i) + int.nat_abs (α * ↑i)) + (int.fract (α * ↑i) + int.nat_abs (α * ↑i)) + (int.nat_abs (α * ↑i) * ↑i) + (int.fract (α * ↑i) + int.nat_abs (α * ↑i)) + (int.fract (α * ↑i) + int.nat_abs (α * ↑i)) + (int.fract (α * ↑i) + int.nat_abs (α * ↑i)), from by {apply add_pos h13 h8},
have h15 : (0 : ℝ) < (α * ↑i) - (int.fract (α * ↑i) + int.nat_abs (α * ↑i)) + (int.fract (α * ↑i) + int.nat_abs (α * ↑i)) + (int.nat_abs (α * ↑i) * ↑i) + (int.fract (α * ↑i) + int.nat_abs (α * ↑i)) + (int.fract (α * ↑i) + int.nat_abs (α * ↑i)) + (int.fract (α * ↑i) + int.nat_abs (α * ↑i)) + (int.fract (α * ↑i) + int.nat_abs (α * ↑i)), from by {apply add_pos h14 h8},
have h16 : (0 : ℝ) < (α * ↑i) - (int.fract (α * ↑i) + int.nat_abs (α * ↑i)) + (int.fract (α * ↑i) + int.nat_abs (α * ↑i)) + (int.nat_abs (α * ↑i) * ↑i) + (int.fract (α * ↑i) + int.nat_abs (α * ↑i)) + (int.fract (α * ↑i) + int.nat_abs (α * ↑i)) + (int.fract (α * ↑i) + int.nat_abs (α * ↑i)) + (int.fract (α * ↑i) + int.nat_abs (α * ↑i)) + (int.fract (α * ↑i) + int.nat_abs (α * ↑i)), from by {apply add_pos h15 h8},
have h17 : (0 : ℝ) < (α * ↑i) - (int.fract (α * ↑i) + int.nat_abs (α * ↑i)) + (int.fract (α * ↑i) + int.nat_abs (α * ↑i)) + (int.nat_abs (α * ↑i) * ↑i) + (int.fract (α * ↑i) + int.nat_abs (α * ↑i)) + (int.fract (α * ↑i) + int.nat_abs (α * ↑i)) + (int.fract (α * ↑i) + int.nat_abs (α * ↑i)) + (int.fract (α * ↑i) + int.nat_abs (α * ↑i)) + (int.fract (α * ↑i) + int.nat_abs (α * ↑i)) + (int.fract (α * ↑i) + int.nat_abs (α * ↑i)), from by {apply add_pos h16 h8},
have h18 : (0 : ℝ) < (α * ↑i) - (int
end --Needs more than 2000 tokens!
/- FEW SHOT PROMPTS TO CODEX(START)
/--`theorem`
Power Set is Closed under Intersection
Let $S$ be a set.
Let $\powerset S$ be the power set of $S$.
Then:
:$\forall A, B \in \powerset S: A \cap B \in \powerset S$
`proof`
Let $A, B \in \powerset S$.
Then by the definition of power set, $A \subseteq S$ and $B \subseteq S$.
From Intersection is Subset we have that $A \cap B \subseteq A$.
It follows from Subset Relation is Transitive that $A \cap B \subseteq S$.
Thus $A \cap B \in \powerset S$ and closure is proved.
{{qed}}
-/
theorem power_set_intersection_closed {α : Type*} (S : set α) : ∀ A B ∈ 𝒫 S, (A ∩ B) ∈ 𝒫 S :=
begin
-- $A$ and $B$ are sets. $A$ and $B$ belong to power set of $S$
assume (A : set α) (hA : A ∈ 𝒫 S) (B : set α) (hB : B ∈ 𝒫 S),
-- Then $A ⊆ S$ and $B ⊆ S$, by power set definition
have h1 : (A ⊆ S) ∧ (B ⊆ S), from by {split,apply set.subset_of_mem_powerset,exact hA,apply set.subset_of_mem_powerset,exact hB},
-- Then $(A ∩ B) ⊆ A$, by intersection of set is a subset
have h2 : (A ∩ B) ⊆ A, from by apply set.inter_subset_left,
-- Then $(A ∩ B) ⊆ S$, by subset relation is transitive
have h3 : (A ∩ B) ⊆ S, from by {apply set.subset.trans h2 h1.left},
-- Hence $(A ∩ B) ∈ 𝒫 S$, by power set definition
show (A ∩ B) ∈ 𝒫 S, from by {apply set.mem_powerset h3},
end
/--`theorem`
Square of Sum
:$\forall x, y \in \R: \paren {x + y}^2 = x^2 + 2 x y + y^2$
`proof`
Follows from the distribution of multiplication over addition:
{{begin-eqn}}
{{eqn | l = \left({x + y}\right)^2
| r = \left({x + y}\right) \cdot \left({x + y}\right)
}}
{{eqn | r = x \cdot \left({x + y}\right) + y \cdot \left({x + y}\right)
| c = Real Multiplication Distributes over Addition
}}
{{eqn | r = x \cdot x + x \cdot y + y \cdot x + y \cdot y
| c = Real Multiplication Distributes over Addition
}}
{{eqn | r = x^2 + 2xy + y^2
| c =
}}
{{end-eqn}}
{{qed}}
-/
theorem square_of_sum (x y : ℝ) : (x + y)^2 = (x^2 + 2*x*y + y^2) :=
begin
-- expand the power
calc (x + y)^2 = (x+y)*(x+y) : by rw sq
-- distributive property of multiplication over addition gives:
... = x*(x+y) + y*(x+y) : by rw add_mul
-- applying the above property further gives:
... = x*x + x*y + y*x + y*y : by {rw [mul_comm x (x+y),mul_comm y (x+y)], rw [add_mul,add_mul], ring}
-- rearranging the terms using commutativity and adding gives:
... = x^2 + 2*x*y + y^2 : by {repeat {rw ← sq}, rw mul_comm y x, ring}
end
/--`theorem`
Identity of Group is Unique
Let $\struct {G, \circ}$ be a group. Then there is a unique identity element $e \in G$.
`proof`
From Group has Latin Square Property, there exists a unique $x \in G$ such that:
:$a x = b$
and there exists a unique $y \in G$ such that:
:$y a = b$
Setting $b = a$, this becomes:
There exists a unique $x \in G$ such that:
:$a x = a$
and there exists a unique $y \in G$ such that:
:$y a = a$
These $x$ and $y$ are both $e$, by definition of identity element.
{{qed}}
-/
theorem group_identity_unique {G : Type*} [group G] : ∃! e : G, ∀ a : G, e * a = a ∧ a * e = a :=
begin
-- Group has Latin Square Property
have h1 : ∀ a b : G, ∃! x : G, a * x = b, from by {
assume a b : G, use a⁻¹ * b, obviously, },
have h2 : ∀ a b : G, ∃! y : G, y * a = b, from by {
assume a b : G, use b * a⁻¹, obviously, },
-- Setting $b = a$, this becomes:
have h3 : ∀ a : G, ∃! x : G, a * x = a, from
assume a : G, h1 a a,
have h4 : ∀ a : G, ∃! y : G, y * a = a, from
assume a : G, h2 a a,
-- These $x$ and $y$ are both $(1 : G)$, by definition of identity element
have h5 : ∀ a : G, classical.some (h3 a).exists = (1 : G), from assume a :G,
exists_unique.unique (h3 a) (classical.some_spec (exists_unique.exists (h3 a)))
(mul_one a),
have h6 : ∀ a : G, classical.some (h4 a).exists = (1 : G), from assume a : G,
exists_unique.unique (h4 a) (classical.some_spec (exists_unique.exists (h4 a))) (one_mul a),
show ∃! e : G, ∀ a : G, e * a = a ∧ a * e = a, from by {
use (1 : G),
have h7 : ∀ e : G, (∀ a : G, e * a = a ∧ a * e = a) → e = 1, from by {
assume (e : G) (hident : ∀ a : G, e * a = a ∧ a * e = a),
have h8 : ∀ a : G, e = classical.some (h3 a).exists, from assume (a : G),
exists_unique.unique (h3 a) (hident a).right
(classical.some_spec (exists_unique.exists (h3 a))),
have h9 : ∀ a : G, e = classical.some (h4 a).exists, from assume (a : G),
exists_unique.unique (h4 a) (hident a).left
(classical.some_spec (exists_unique.exists (h4 a))),
show e = (1 : G), from eq.trans (h9 e) (h6 _),
},
exact ⟨by obviously, h7⟩,
}
end
/--`theorem`
Squeeze Theorem for Real Numbers
Let $\sequence {x_n}$, $\sequence {y_n}$ and $\sequence {z_n}$ be sequences in $\R$.
Let $\sequence {y_n}$ and $\sequence {z_n}$ both be convergent to the following limit:
:$\ds \lim_{n \mathop \to \infty} y_n = l, \lim_{n \mathop \to \infty} z_n = l$
Suppose that:
:$\forall n \in \N: y_n \le x_n \le z_n$
Then:
:$x_n \to l$ as $n \to \infty$
that is:
:$\ds \lim_{n \mathop \to \infty} x_n = l$
`proof`
From Negative of Absolute Value:
:$\size {x - l} < \epsilon \iff l - \epsilon < x < l + \epsilon$
Let $\epsilon > 0$.
We need to prove that:
:$\exists N: \forall n > N: \size {x_n - l} < \epsilon$
As $\ds \lim_{n \mathop \to \infty} y_n = l$ we know that:
:$\exists N_1: \forall n > N_1: \size {y_n - l} < \epsilon$
As $\ds \lim_{n \mathop \to \infty} z_n = l$ we know that:
:$\exists N_2: \forall n > N_2: \size {z_n - l} < \epsilon$
Let $N = \max \set {N_1, N_2}$.
Then if $n > N$, it follows that $n > N_1$ and $n > N_2$.
So:
:$\forall n > N: l - \epsilon < y_n < l + \epsilon$
:$\forall n > N: l - \epsilon < z_n < l + \epsilon$
But:
:$\forall n \in \N: y_n \le x_n \le z_n$
So:
:$\forall n > N: l - \epsilon < y_n \le x_n \le z_n < l + \epsilon$
and so:
:$\forall n > N: l - \epsilon < x_n < l + \epsilon$
So:
:$\forall n > N: \size {x_n - l} < \epsilon$
Hence the result.
{{qed}}
-/
theorem squeeze_theorem_real_numbers (x y z : ℕ → ℝ) (l : ℝ) :
let seq_limit : (ℕ → ℝ) → ℝ → Prop := λ (u : ℕ → ℝ) (l : ℝ), ∀ ε > 0, ∃ N, ∀ n > N, |u n - l| < ε in
seq_limit y l → seq_limit z l → (∀ n : ℕ, (y n) ≤ (x n) ∧ (x n) ≤ (z n)) → seq_limit x l :=
begin
assume seq_limit (h2 : seq_limit y l) (h3 : seq_limit z l) (h4 : ∀ (n : ℕ), y n ≤ x n ∧ x n ≤ z n) (ε),
--From Negative of Absolute Value: $\size {x - l} < \epsilon \iff l - \epsilon < x < l + \epsilon$
have h5 : ∀ x, |x - l| < ε ↔ (((l - ε) < x) ∧ (x < (l + ε))),
from by
{
intro x0,
have h6 : |x0 - l| < ε ↔ ((x0 - l) < ε) ∧ ((l - x0) < ε),
from abs_sub_lt_iff, rw h6,
split,
rintro ⟨ S_1, S_2 ⟩,
split; linarith,
rintro ⟨ S_3, S_4 ⟩,
split; linarith,
},
--Let $\epsilon > 0$.
assume (h7 : ε > 0),
--As $\ds \lim_{n \mathop \to \infty} y_n = l$ we know that $\exists N_1: \forall n > N_1: \size {y_n - l} < \epsilon$
cases h2 ε h7 with N1 h8,
--As $\ds \lim_{n \mathop \to \infty} z_n = l$ we know that $\exists N_2: \forall n > N_2: \size {z_n - l} < \epsilon$
cases h3 ε h7 with N2 h9,
--Let $N = \max \set {N_1, N_2}$.
let N := max N1 N2,
use N,
--Then if $n > N$, it follows that $n > N_1$ and $n > N_2$.
have h10 : ∀ n > N, n > N1 ∧ n > N2 := by {
assume n h,
split,
exact lt_of_le_of_lt (le_max_left N1 N2) h,
exact lt_of_le_of_lt (le_max_right N1 N2) h,
},
--$\forall n > N: l - \epsilon < y_n < l + \epsilon$
--$\forall n > N: l - \epsilon < z_n < l + \epsilon$
--$\forall n \in \N: y_n \le x_n \le z_n$
--So $\forall n > N: l - \epsilon < y_n \le x_n \le z_n < l + \epsilon$
have h11 : ∀ n > N, (((l - ε) < (y n)) ∧ ((y n) ≤ (x n))) ∧ (((x n) ≤ (z n)) ∧ ((z n) < l+ε)),
from by {
intros n h12,
split,
{
have h13 := (h8 n (h10 n h12).left), rw h5 (y n) at h13,
split,
exact h13.left,
exact (h4 n).left,
},
{
have h14 := (h9 n (h10 n h12).right),rw h5 (z n) at h14,
split,
exact (h4 n).right,
exact h14.right,
},
},
--$\forall n > N: l - \epsilon < x_n < l + \epsilon$
have h15 : ∀ n > N, ((l - ε) < (x n)) ∧ ((x n) < (l+ε)),
from by {
intros n1 h16, cases (h11 n1 h16);
split; linarith,
},
--So $\forall n > N: \size {x_n - l} < \epsilon$
--Hence the result
show ∀ (n : ℕ), n > N → |x n - l| < ε,
from by {
intros n h17,
cases h5 (x n) with h18 h19,
apply h19, exact h15 n h17,
},
end
/--`theorem`
Density of irrational orbit
The fractional parts of the integer multiples of an irrational number form a dense subset of the unit interval
`proof`
Let $\alpha$ be an irrational number. Then for distinct $i, j \in \mathbb{Z}$, we must have $\{i \alpha\} \neq\{j \alpha\}$. If this were not true, then
$$
i \alpha-\lfloor i \alpha\rfloor=\{i \alpha\}=\{j \alpha\}=j \alpha-\lfloor j \alpha\rfloor,
$$
which yields the false statement $\alpha=\frac{\lfloor i \alpha\rfloor-\lfloor j \alpha\rfloor}{i-j} \in \mathbb{Q}$. Hence,
$$
S:=\{\{i \alpha\} \mid i \in \mathbb{Z}\}
$$
is an infinite subset of $\left[0,1\right]$.
By the Bolzano-Weierstrass theorem, $S$ has a limit point in $[0, 1]$. One can thus find pairs of elements of $S$ that are arbitrarily close. Since (the absolute value of) the difference of any two elements of $S$ is also an element of $S$, it follows that $0$ is a limit point of $S$.
To show that $S$ is dense in $[0, 1]$, consider $y \in[0,1]$, and $\epsilon>0$. Then by selecting $x \in S$ such that $\{x\}<\epsilon$ (which exists as $0$ is a limit point), and $N$ such that $N \cdot\{x\} \leq y<(N+1) \cdot\{x\}$, we get: $|y-\{N x\}|<\epsilon$.
QED
-/
theorem irrational_orbit_dense {α : ℝ} (hα_irrat : irrational α) : closure ((λ m : ℤ, int.fract (α * ↑m)) '' (@set.univ ℤ)) = set.Icc 0 1 :=
FEW SHOT PROMPTS TO CODEX(END)-/
|
/-
Copyright (c) 2022 Andrew Yang. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Andrew Yang
-/
import morphisms.open_immersion
/-!
# Open immersions
A morphism is an open immersions if the underlying map of spaces is an open embedding
`f : X ⟶ U ⊆ Y`, and the sheaf map `Y(V) ⟶ f _* X(V)` is an iso for each `V ⊆ U`.
Most of the theories are developed in `algebraic_geometry/open_immersion`, and we provide the
remaining theorems analogous to other lemmas in `algebraic_geometry/morphisms/*`.
-/
noncomputable theory
open category_theory category_theory.limits opposite topological_space
universe u
namespace algebraic_geometry
variables {X Y Z : Scheme.{u}} (f : X ⟶ Y) (g : Y ⟶ Z)
lemma is_iso_iff_stalk {f : X ⟶ Y} :
is_iso f ↔
is_iso f.1.base ∧ ∀ x, is_iso (PresheafedSpace.stalk_map f.1 x) :=
begin
split,
{ intro h, exactI ⟨infer_instance, infer_instance⟩ },
{ rintro ⟨h₁, h₂⟩, resetI,
haveI := is_open_immersion.of_stalk_iso f (Top.homeo_of_iso $ as_iso f.1.base).open_embedding,
exact is_open_immersion.to_iso f }
end
lemma is_iso_respects_iso : morphism_property.respects_iso (@is_iso Scheme _) :=
by split; { introv H, resetI, apply_instance }
lemma is_iso_is_local_at_target : property_is_local_at_target (@is_iso Scheme _) :=
begin
constructor,
{ exact is_iso_respects_iso },
{ introsI, apply_instance },
{ introsI X Y f 𝒰 H,
haveI := is_open_immersion_is_local_at_target.3 f 𝒰 infer_instance,
suffices : function.surjective f.1.base,
{ rw ← Top.epi_iff_surjective f.1.base at this, exactI is_open_immersion.to_iso f },
have := congr_arg (coe : opens Y.carrier → set Y.carrier) 𝒰.supr_opens_range,
rw opens.coe_supr at this,
rw set.surjective_iff_surjective_of_Union_eq_univ this,
intro i,
haveI := (is_iso_respects_iso.arrow_iso_iff
(morphism_restrict_opens_range f (𝒰.map i))).mpr (H i),
have : epi (arrow.mk (f ∣_ Scheme.hom.opens_range (𝒰.map i))).hom.1.base := infer_instance,
rw [Top.epi_iff_surjective, arrow.mk_hom, morphism_restrict_val_base] at this,
exact this }
end
lemma is_iso.open_cover_tfae {X Y : Scheme.{u}} (f : X ⟶ Y) :
tfae [is_iso f,
∃ (𝒰 : Scheme.open_cover.{u} Y), ∀ (i : 𝒰.J),
is_iso (pullback.snd : (𝒰.pullback_cover f).obj i ⟶ 𝒰.obj i),
∀ (𝒰 : Scheme.open_cover.{u} Y) (i : 𝒰.J),
is_iso (pullback.snd : (𝒰.pullback_cover f).obj i ⟶ 𝒰.obj i),
∀ (U : opens Y.carrier), is_iso (f ∣_ U),
∀ {U : Scheme} (g : U ⟶ Y) [is_open_immersion g],
is_iso (pullback.snd : pullback f g ⟶ U),
∃ {ι : Type u} (U : ι → opens Y.carrier) (hU : supr U = ⊤),
∀ i, is_iso (f ∣_ (U i))] :=
is_iso_is_local_at_target.open_cover_tfae f
lemma is_iso_of_is_affine_is_iso {X Y : Scheme} [hX : is_affine X] [hY : is_affine Y] (f : X ⟶ Y)
[hf : is_iso (f.1.c.app (op ⊤))] : is_iso f :=
begin
rw ← mem_Spec_ess_image at hX hY,
have : is_iso (AffineScheme.Γ.map (@quiver.hom.op AffineScheme _ ⟨X, hX⟩ ⟨Y, hY⟩ f)) := hf,
have := @@is_iso_of_reflects_iso _ _ _ _ this _,
exact @@functor.map_is_iso _ _ AffineScheme.forget_to_Scheme _ (@@is_iso_of_op _ _ this)
end
lemma target_affine_locally_affine_and_is_iso :
target_affine_locally (λ X Y f hY, is_affine X ∧ is_iso (Scheme.Γ.map f.op)) = @is_iso Scheme _ :=
begin
rw ← is_iso_is_local_at_target.target_affine_locally_eq,
congr,
ext X Y f hY,
split,
{ rintros ⟨hX, hf⟩, exactI @@is_iso_of_is_affine_is_iso _ _ f hf },
{ intro hf, exactI ⟨is_affine_of_iso f, infer_instance⟩ }
end
end algebraic_geometry |
[STATEMENT]
lemma size_Iff [simp]: "size (A IFF B) = 2*(size A + size B) + 8"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. size (A IFF B) = 2 * (size A + size B) + 8
[PROOF STEP]
by (simp add: Iff_def) |
{-# OPTIONS --safe --warning=error --without-K #-}
open import LogicalFormulae
open import Setoids.Setoids
open import Rings.Definition
open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
module Rings.Units.Definition {a b : _} {A : Set a} {S : Setoid {a} {b} A} {_+_ _*_ : A → A → A} (R : Ring S _+_ _*_) where
open Setoid S
open Ring R
Unit : A → Set (a ⊔ b)
Unit r = Sg A (λ s → (r * s) ∼ 1R)
|
lemma Cauchy_uniform_iff: "Cauchy X \<longleftrightarrow> (\<forall>P. eventually P uniformity \<longrightarrow> (\<exists>N. \<forall>n\<ge>N. \<forall>m\<ge>N. P (X n, X m)))" |
import fibonacci_world.divides_mul -- hide
/-
## Divisibility of a sum
In the quest for proving an interesting result about Fibonacci numbers
it will be useful to have the following lemma, that allows to deduce
the divibility of a sum from the divisibility of the summands.
-/
/- Lemma :
If $k$ divides $n$ and $m$, then $k$ divides $m + n$.
-/
lemma divides_add {k n m : ℕ} (hn : k ∣ n) (hm : k ∣ m) : k ∣ m + n :=
begin
cases hn with n1 hn1,
cases hm with m1 hm1,
use n1 + m1,
rw hn1,
rw hm1,
ring,
end
|
import analysis.normed.normed_field
import data.polynomial.taylor
import topology.metric_space.cau_seq_filter
import topology.algebra.polynomial
section nonarchimedean
variables (𝕜 : Type) [normed_group 𝕜]
/-- A type with a normed group structure is nonarchimedean if it satisfies `∥x + y∥ ≤ max ∥x∥ ∥y∥`. -/
class nonarchimedean :=
(nonarch : ∀ x y : 𝕜, ∥x + y∥ ≤ max (∥x∥) (∥y∥))
variables {𝕜} [nonarchimedean 𝕜]
/-- The nonarchimedean inequality with addition replaced with subtraction. -/
theorem nonarchimedean.nonarch_sub (x y : 𝕜) : ∥x - y∥ ≤ max (∥x∥) (∥y∥) :=
(sub_eq_add_neg x y).symm ▸ norm_neg y ▸ nonarchimedean.nonarch x (-y)
/-- The nonarchimedean inequality is equal if the elements being added have different norms. -/
theorem nonarchimedean.eq_max_of_ne_norm {x y : 𝕜} (h : ∥x∥ ≠ ∥y∥) :
∥x + y∥ = max (∥x∥) (∥y∥) :=
begin
have : ∀ {x y : 𝕜}, ∥x∥ > ∥y∥ → ∥x + y∥ = max (∥x∥) (∥y∥),
{ intros x y h,
rw [max_eq_left_of_lt h],
have := nonarchimedean.nonarch_sub (x + y) y,
rw [←(eq_sub_of_add_eq rfl : x = x + y - y)] at this,
apply le_antisymm (max_eq_left_of_lt h ▸ nonarchimedean.nonarch x y : ∥x + y∥ ≤ ∥x∥),
cases le_max_iff.mp this with h' h',
{ exact h' },
{ exact absurd h' (not_le.mpr h) } },
cases h.lt_or_lt with h h,
{ rw [add_comm, max_comm], exact this h },
{ exact this h }
end
/-- If the nonarchimedean inequality is not equal, the elements being added have the same norm. -/
theorem nonarchimedean.eq_norm_of_ne_max {x y : 𝕜} (h : ∥x + y∥ ≠ max (∥x∥) (∥y∥)) :
∥x∥ = ∥y∥ := of_not_not (mt nonarchimedean.eq_max_of_ne_norm h)
/-- A `ℕ`-indexed sequence in a nonarchimedean normed ring is Cauchy iff the difference
of its consecutive terms tends to `0`. -/
theorem nonarchimedean.cau {𝕜} [normed_ring 𝕜] [nonarchimedean 𝕜] {s : ℕ → 𝕜} :
is_cau_seq norm s ↔ ∀ ε > 0, ∃ i, ∀ j ≥ i, ∥s (j + 1) - s j∥ < ε :=
begin
apply forall₂_congr, intros ε hε,
split,
{ rintro ⟨i, hi⟩, use i, intros j hj,
exact sub_add_sub_cancel (s (j + 1)) (s i) (s j) ▸ neg_sub (s j) (s i) ▸
lt_of_le_of_lt (nonarchimedean.nonarch (s (j + 1) - s i) (-(s j - s i)))
(max_lt (hi (j + 1) (le_add_right hj)) ((norm_neg (s j - s i)).symm ▸ hi j hj)) },
{ rintro ⟨i, hi⟩, use i, intros j hj,
cases le_iff_exists_add.mp hj with k hk,
induction k with k ih generalizing j,
{ rw [(add_zero i ▸ hk : j = i), sub_self, norm_zero], exact hε },
{ exact hk.symm ▸ (sub_add_sub_cancel (s (i + k + 1)) (s (i + k)) (s i)) ▸
lt_of_le_of_lt (nonarchimedean.nonarch (s (i + k + 1) - s (i + k)) (s (i + k) - s i))
(max_lt (hi (i + k) le_self_add) (ih (i + k) le_self_add rfl)) } }
end
end nonarchimedean
section
variables (𝕜 : Type) [normed_field 𝕜] [nonarchimedean 𝕜]
/-- The closed unit ball in the nonarchimedean normed field `𝕜`. -/
def disc : subring 𝕜 := {
carrier := {x | ∥x∥ ≤ 1},
mul_mem' := λ x y hx hy, (norm_mul_le x y).trans (one_mul (1 : ℝ) ▸
mul_le_mul hx hy (norm_nonneg y) zero_le_one),
one_mem' := norm_one.le,
add_mem' := λ x y hx hy, (nonarchimedean.nonarch x y).trans (max_le hx hy),
zero_mem' := norm_zero.le.trans zero_le_one,
neg_mem' := λ x hx, ((norm_neg x).symm ▸ hx : ∥-x∥ ≤ 1)
}
namespace disc
/-- `disc 𝕜` inherits the norm of `𝕜`. -/
instance disc_normed_ring : normed_ring (disc 𝕜) := {
norm := norm ∘ subtype.val,
dist_eq := λ x y, normed_field.dist_eq x.1 y.1 ▸ rfl,
norm_mul := λ x y, le_of_eq (norm_mul x.1 y.1)
}
section
variable {𝕜}
/-- The norm of `disc 𝕜` equals the norm of the inclusion into `𝕜`. -/
theorem norm_def (x : disc 𝕜) : ∥x∥ = ∥x.1∥ := rfl
/-- All elements in `disc 𝕜` have norm less than or equal to `1`. -/
theorem norm_le_one (x : disc 𝕜) : ∥x∥ ≤ 1 := x.2
/-- The norm in `disc 𝕜` preserves multiplication. -/
protected theorem norm_mul (x y : disc 𝕜) : ∥x * y∥ = ∥x∥ * ∥y∥ :=
norm_mul x.1 y.1
/-- The norm in `disc 𝕜` preserves exponentiation. -/
protected theorem norm_pow (x : disc 𝕜) (n : ℕ) : ∥x ^ n∥ = ∥x∥ ^ n :=
norm_pow x.1 n
/-- Sequences with all elements having norm `≤ 1` are Cauchy in `𝕜` if and only if they are Cauchy in `disc 𝕜`. -/
theorem disc_is_cau_seq_iff (s : ℕ → 𝕜) (hs : ∀ n, ∥s n∥ ≤ 1) :
is_cau_seq norm s ↔ is_cau_seq norm (λ n, ⟨s n, hs n⟩ : ℕ → disc 𝕜) := iff.rfl
/-- The injection of any Cauchy sequence in `disc 𝕜` into `𝕜` is also a Cauchy sequence. -/
theorem disc_is_cau_seq {s : ℕ → disc 𝕜} (h : is_cau_seq norm s) : is_cau_seq norm (λ n, (s n).1) :=
(disc_is_cau_seq_iff (λ n, (s n).1) (λ n, (s n).2)).mpr h
variables {x y : disc 𝕜} (h : ∥x∥ ≤ ∥y∥)
include h
/-- `disc 𝕜` inherits division from `𝕜`, so long as the denominator has at least the numerator's norm. -/
def divide : disc 𝕜 := ⟨x.1 / y.1,
begin
change ∥_∥ ≤ 1,
rw [norm_div, ←norm_def x, ←norm_def y],
by_cases hy : ∥y∥ = 0,
{ rw [hy, div_zero], exact zero_le_one },
{ exact (div_le_one (lt_of_le_of_ne (norm_nonneg y) (ne.symm hy))).mpr h }
end⟩
/-- The norm in `disc 𝕜` preserves division. -/
theorem divide.norm : ∥divide h∥ = ∥x∥ / ∥y∥ :=
norm_div x.1 y.1
/-- If the denominator `y` is non-zero, multiplying `divide h` by `y` cancels the division, leaving the numerator `x`. -/
theorem divide.mul_cancel (hy : y ≠ 0) : divide h * y = x :=
subtype.val_inj.mp (div_mul_cancel x.1 (mt subtype.val_inj.mp hy : y.1 ≠ (0 : disc 𝕜).val))
end
/-- `disc 𝕜` inherits the nonarchimedean inequality from `𝕜`. -/
instance disc_nonarchimedean : nonarchimedean (disc 𝕜) :=
⟨λ x y, (norm_def (x + y)).symm ▸ nonarchimedean.nonarch x.1 y.1⟩
/-- The norm in `disc 𝕜` is an absolute value, thanks to properties inherited from the normed field `𝕜`. -/
instance disc_norm_is_absolute_value : is_absolute_value (norm : disc 𝕜 → ℝ) := {
abv_nonneg := norm_nonneg,
abv_eq_zero := λ _, norm_eq_zero,
abv_add := λ x y, (normed_field.is_absolute_value.abv_add : ∀ x y : 𝕜, ∥x + y∥ ≤ ∥x∥ + ∥y∥) x y,
abv_mul := disc.norm_mul,
}
/-- `disc 𝕜` inherits the completeness of `𝕜`, i.e. if all Cauchy sequences in `𝕜` are convergent,
then so are all Cauchy sequences in `disc 𝕜`. -/
instance disc_is_complete [cau_seq.is_complete 𝕜 norm] : cau_seq.is_complete (disc 𝕜) norm := ⟨λ s,
begin
let s' : cau_seq 𝕜 norm := ⟨λ n, (s n).1, s.2⟩,
use s'.lim,
{ cases s'.equiv_lim 1 zero_lt_one with n hn,
rw [←sub_add_cancel s'.lim (s' n)],
apply le_trans (nonarchimedean.nonarch (s'.lim - s' n) (s' n)),
have : ∥s' n - cau_seq.const norm s'.lim n∥ = ∥s'.lim - s' n∥,
{ rw [←norm_neg, neg_sub, cau_seq.const_apply] },
exact max_le (this ▸ le_of_lt (hn n (le_refl n))) (s n).2 },
{ exact s'.equiv_lim }
end⟩
end disc
end
section taylor
open polynomial
variables {R : Type} [comm_ring R]
/-- Any term of a polynomial sum can be removed and added separately so long as zero terms
do not contribute to the sum. -/
theorem polynomial.sum_term (n : ℕ) (f : polynomial R) (fn : ℕ → R → polynomial R) (h : ∀ k, fn k 0 = 0) :
f.sum fn = fn n (f.coeff n) + (f.erase n).sum fn :=
begin
rw [sum_def, sum_def, support_erase],
by_cases hn : n ∈ f.support,
{ rw [←finset.add_sum_erase f.support (λ n, fn n (f.coeff n)) hn],
apply congr_arg, apply finset.sum_congr rfl, intros x hx,
rw [erase_ne f n x (finset.ne_of_mem_erase hx)] },
{ rw [not_mem_support_iff.mp hn, h n, zero_add],
exact eq.symm (finset.sum_congr (finset.erase_eq_of_not_mem hn)
(λ x hx, congr_arg _ (erase_ne f n x (λ h, absurd (h ▸ hx : n ∈ f.support) hn)))) }
end
/-- Any polynomial `f` can be approximated as a quadratic polynomial centred on a chosen point `t₀`. -/
theorem taylor₂ (f : polynomial R) (t₀ : R) : ∃ err : polynomial R, ∀ t,
f.eval t = f.eval t₀ + (t - t₀) * f.derivative.eval t₀ + (t - t₀)^2 * err.eval t :=
begin
use (((taylor t₀ f).erase 0).erase 1).sum (λ i a, C a * (X - C t₀) ^ (i - 2)), intro t,
have : ∀ n, C 0 * (X - C t₀) ^ n = 0, { intro n, rw [C_0, zero_mul] },
conv_lhs { rw [←f.sum_taylor_eq t₀, (taylor t₀ f).sum_term 0 (λ i a, C a * (X - C t₀) ^ i) this,
((taylor t₀ f).erase 0).sum_term 1 (λ i a, C a * (X - C t₀) ^ i) this, taylor_coeff_zero,
erase_ne (taylor t₀ f) 0 1 nat.one_ne_zero, taylor_coeff_one], simp only,
rw [pow_zero, mul_one, pow_one, ←add_assoc, mul_comm, eval_add, eval_add,
eval_C, eval_mul, eval_sub, eval_X, eval_C, eval_C] },
apply congr_arg,
have : (t - t₀)^2 = ((X - C t₀) ^ 2).eval t := by rw [eval_pow, eval_sub, eval_X, eval_C],
rw [this, ←eval_mul], apply congr_arg,
rw [sum_def, sum_def, finset.mul_sum, finset.sum_congr rfl],
intros n hn,
conv_rhs { rw [mul_comm, mul_assoc, ←pow_add], },
have : 2 ≤ n,
{ cases n with n,
{ exfalso, rw [support_erase, support_erase, finset.erase_right_comm] at hn,
exact absurd rfl (finset.ne_of_mem_erase hn) },
{ cases n with n, { rw [support_erase] at hn, exact absurd rfl (finset.ne_of_mem_erase hn) },
{ simp only [succ_order.succ_le_succ_iff, zero_le'] } } },
rw [nat.sub_add_cancel this]
end
/-- Any polynomial `f` can be approximated as a linear polynomial centred on a chosen point `t₀`. -/
theorem taylor₁ (f : polynomial R) (t₀ : R) : ∃ err : polynomial R, ∀ t,
f.eval t = f.eval t₀ + (t - t₀) * err.eval t :=
begin
cases taylor₂ f t₀ with err h,
use C (f.derivative.eval t₀) + (X - C t₀) * err, intro t,
rw [h t, eval_add, eval_C, mul_add, ←add_assoc, eval_mul,
eval_sub, eval_X, eval_C, ←mul_assoc, sq]
end
end taylor
section
variables {R : Type} [normed_ring R] [is_absolute_value (norm : R → ℝ)]
/-- A filter-wise Cauchy sequence is an absolute-value-wise Cauchy sequence.
(This already exists in `topology.metric_space.cau_seq_filter`, but only for normed fields,
here it is restated for normed rings whose norm is an absolute value). -/
theorem cauchy_seq.is_cau_seq' {f : ℕ → R} (hf : cauchy_seq f) :
is_cau_seq norm f :=
begin
cases cauchy_iff.1 hf with hf1 hf2,
intros ε hε,
rcases hf2 {x | dist x.1 x.2 < ε} (metric.dist_mem_uniformity hε) with ⟨t, ⟨ht, htsub⟩⟩,
simp at ht, cases ht with N hN,
existsi N,
intros j hj,
rw ←dist_eq_norm,
apply @htsub (f j, f N),
apply set.mk_mem_prod; solve_by_elim [le_refl]
end
variable [cau_seq.is_complete R norm]
/-- A Cauchy sequence formed by composing a Cauchy sequence with a polynomial. -/
noncomputable def polynomial_comp (f : polynomial R) (s : cau_seq R norm) : cau_seq R norm :=
⟨λ n, f.eval (s n), ((f.continuous.tendsto s.lim).comp s.tendsto_limit).cauchy_seq.is_cau_seq'⟩
/-- The composition of a polynomial with a Cauchy sequence's limit equals the limit of the
composition of the polynomial with the Cauchy sequence. -/
theorem polynomial_comp_lim (f : polynomial R) (s : cau_seq R norm) : f.eval s.lim = (polynomial_comp f s).lim :=
tendsto_nhds_unique ((f.continuous.tendsto s.lim).comp s.tendsto_limit) (polynomial_comp f s).tendsto_limit
/-- A Cauchy sequence formed by composing a Cauchy sequence with the norm. -/
noncomputable def norm_comp (s : cau_seq R norm) : cau_seq ℝ norm :=
⟨λ n, ∥s n∥, ((continuous_norm.tendsto s.lim).comp s.tendsto_limit).cauchy_seq.is_cau_seq'⟩
/-- The composition of the norm with a Cauchy sequence's limit equals the limit of the
composition of the norm with the Cauchy sequence. -/
theorem norm_comp_lim (s : cau_seq R norm) : ∥s.lim∥ = (norm_comp s).lim :=
tendsto_nhds_unique ((continuous_norm.tendsto s.lim).comp s.tendsto_limit) (norm_comp s).tendsto_limit
end
|
parameters (n:Nat)
namespace X
export
foo : Bool
foo = True
U : Bool
U = foo
|
integer function fun(num)
write(6, *) num
fun = 10 + num
return
end
subroutine sub1(func)
implicit none
external func
integer func
integer i
save
i = func(i)
write(6, *) i
return
end
subroutine sub2(func)
external func
integer func
i = func(3)
write(6, *) i
return
end
program prog
implicit none
external fun
integer fun
integer i
i = fun(1)
write(6, *) i
call sub1(fun)
call sub1(fun)
call sub2(fun)
end
|
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE FunctionalDependencies #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE ViewPatterns #-}
{-# OPTIONS_HADDOCK show-extensions #-}
module NQS.CG
( Operator
, NQS.CG.cg
, test
) where
import Data.Complex
import Control.Monad.Primitive
import qualified Data.Vector.Storable as V
import qualified Data.Vector.Storable.Mutable as MV
import Foreign.Storable
import Lens.Micro
import NQS.Internal.Types
import NQS.Internal.BLAS
type Operator m el = -- forall m. PrimMonad m
MDenseVector 'Direct (PrimState m) el -- ^ Input
-> MDenseVector 'Direct (PrimState m) el -- ^ Output
-> m ()
class ToComplex a where
promoteToComplex :: RealOf a -> a
instance {-# OVERLAPPABLE #-} (a ~ RealOf a) => ToComplex a where
promoteToComplex = id
instance {-# OVERLAPS #-} (Num a, a ~ RealOf (Complex a)) => ToComplex (Complex a) where
promoteToComplex = (:+ 0)
cg :: forall v el m.
( PrimMonad m, v ~ MDenseVector 'Direct
, DOTC v el el, AXPY v el, COPY v el
, NRM2 v el (RealOf el), SCAL (RealOf el) v el
, Storable el, Fractional el, ToComplex el, RealFloat (RealOf el)
)
=> Int -- ^ Max number of iterations
-> RealOf el -- ^ Tolerance
-> Operator m el -- ^ A
-> MDenseVector 'Direct (PrimState m) el -- ^ b
-> MDenseVector 'Direct (PrimState m) el -- ^ Initial guess x
-> m (Int, RealOf el)
cg !maxIter !tol operator !b !x0 = do
r <- newTempVector n
p <- newTempVector n
q <- newTempVector n
bNorm <- norm b
-- This will probably never ever happen, but we should check anyway
if bNorm == 0
then fill x0 0 >> return (0, 0)
else do
-- r := b - max * x0
copy b r
operator x0 q
axpy (-1) q r
-- Are we done already?
norm r >>= \rNorm -> if rNorm < tol * tol * bNorm
then return $! (0, sqrt (rNorm / bNorm))
else do
-- Start the loop
copy r p
go bNorm x0 r p q rNorm 0
where
n = b ^. dim
newTempVector size = MDenseVector size 1 <$> newVectorAligned size 64
norm x = (\y -> y * y) <$> nrm2 x
go !bNorm !x !r !p !q !ρ !i
| i >= maxIter = nrm2 r >>= \rNorm -> return (i, rNorm / bNorm)
| otherwise = do
operator p q
α <- (promoteToComplex ρ /) <$> dotc p q
axpy α p x
axpy (-α) q r
norm r >>= \rNorm -> if rNorm < threshold
then return (i, sqrt (rNorm / bNorm))
else do copy r q
let ρ' = rNorm
β = ρ' / ρ
scal β p
axpy 1 q p
go bNorm x r p q ρ' (i + 1)
where threshold :: RealOf el
threshold = tol * tol * bNorm
test :: IO ()
test = do
let -- operator :: Operator Float
operator x y = do
aBuff <- newVectorAligned 9 64 :: IO (MV.MVector (PrimState IO) Float)
V.copy aBuff $ V.fromList [1, 2, 3, 4, 5, 6, 7, 8, 9]
let a = MDenseMatrix 3 3 3 aBuff :: MDenseMatrix 'Row (PrimState IO) Float
gemv NoTranspose 1.0 a x 0.0 y
bBuff <- V.unsafeThaw $ V.fromList [2, 2, 2 :: Float]
xBuff <- V.unsafeThaw $ V.fromList [0, 0, 0 :: Float]
let x = MDenseVector 3 1 xBuff :: MDenseVector 'Direct (PrimState IO) Float
let b = MDenseVector 3 1 bBuff :: MDenseVector 'Direct (PrimState IO) Float
print =<< (NQS.CG.cg 30 (1.0E-8 :: Float) operator b x)
|
/-
Copyright (c) 2022 Jannis Limperg. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: David Renshaw, Jannis Limperg
-/
import Aesop
-- This is an example which is currently challenging for Lean 4 `tauto`.
example {α : Type} [LE α] (a b c : α) (x₀ x₁ x₂ : Prop)
(this1 : x₀ → x₁ → a ≤ c)
(this2 : x₁ → x₂ → b ≤ a)
(this3 : x₂ → x₀ → c ≤ b) :
((x₀ ∧ ¬b ≤ a) ∧ x₁ ∧ ¬c ≤ b ∨
(x₁ ∧ ¬c ≤ b) ∧ x₂ ∧ ¬a ≤ c ∨ (x₂ ∧ ¬a ≤ c) ∧ x₀ ∧ ¬b ≤ a ↔
(x₀ ∧ x₁ ∨ x₁ ∧ x₂ ∨ x₂ ∧ x₀) ∧
¬(c ≤ b ∧ b ≤ a ∨ b ≤ a ∧ a ≤ c ∨ a ≤ c ∧ c ≤ b)) :=
by aesop
|
/-
Copyright (c) 2021 Mario Carneiro. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Mario Carneiro
-/
import Lean
section
open Lean Elab Command
syntax (name := timeCmd) "#time " command : command
/--
Time the elaboration of a command, and print the result (in milliseconds).
Example usage:
```
set_option maxRecDepth 100000 in
#time example : (List.range 500).length = 500 := rfl
```
-/
@[commandElab timeCmd] def timeCmdElab : CommandElab
| `(#time%$tk $stx:command) => do
let start ← IO.monoMsNow
elabCommand stx
logInfoAt tk m!"time: {(← IO.monoMsNow) - start}ms"
| _ => throwUnsupportedSyntax
end
|
Formal statement is: lemma contractible_empty [simp]: "contractible {}" Informal statement is: The empty space is contractible. |
Reserved Notation "A 'wimp' B" (at level 99).
Inductive WImp (A B : Prop) : Prop :=
| wl : ~A -> A wimp B
| wr : ~~B -> A wimp B
where "A 'wimp' B" := (WImp A B) : type_scope.
Print WImp_ind.
Theorem problem_1 : forall A B : Prop, A wimp B -> A -> ~~B.
Proof.
intro.
intro.
intro.
induction H. contradiction.
auto.
Qed.
Theorem problem_2 : forall A B C: Prop,
A -> A wimp (B wimp C) -> (~~(B wimp C)) wimp C -> ~~C.
Proof.
intro.
intro.
intro.
intros.
destruct H0.
contradiction.
destruct H1.
contradiction.
auto.
Qed.
Axiom wmp : forall A B : Prop, A wimp B -> A -> ~~B.
Theorem wimp_ind : forall A B P : Prop, (A \/ ~A) -> (~ A -> P) -> (~ ~ B -> P) -> (A wimp B) -> P.
Proof.
intro.
intro.
intro.
intro.
intro.
intro.
intro.
Print wmp.
destruct H2.
auto.
auto.
Qed.
|
def twice : Nat → Nat := λ n => 2*n
def foo1 : (λ x : Nat => id (twice (id x))) = twice := by
conv in (id _) =>
trace_state
conv =>
enter [1,1]
trace_state
simp
trace_state
trace_state -- `id (twice x)`
theorem foo2 (y : Nat) : (fun x => x + y = 0) = (fun x => False) := by
conv =>
trace_state
conv =>
lhs
trace_state
intro x
rw [Nat.add_comm]
trace_state
trace_state
trace_state
sorry
|
[STATEMENT]
lemma take_bit_int_eq_self:
\<open>take_bit n k = k\<close> if \<open>0 \<le> k\<close> \<open>k < 2 ^ n\<close> for k :: int
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. take_bit n k = k
[PROOF STEP]
using that
[PROOF STATE]
proof (prove)
using this:
0 \<le> k
k < 2 ^ n
goal (1 subgoal):
1. take_bit n k = k
[PROOF STEP]
by (simp add: take_bit_int_eq_self_iff) |
universe u
def f1 (n m : Nat) (x : Fin n) (h : n = m) : Fin m :=
h ▸ x
def f2 (n m : Nat) (x : Fin n) (h : m = n) : Fin m :=
h ▸ x
theorem ex1 {α : Sort u} {a b c : α} (h₁ : a = b) (h₂ : b = c) : a = c :=
h₂ ▸ h₁
theorem ex2 {α : Sort u} {a b : α} (h : a = b) : b = a :=
h ▸ rfl
theorem ex3 {α : Sort u} {a b c : α} (r : α → α → Prop) (h₁ : r a b) (h₂ : b = c) : r a c :=
h₂ ▸ h₁
theorem ex3b {α : Sort u} {a b c : α} (r : α → α → Prop) (h₁ : r a b) (h₂ : b = c) : r a c :=
h₂.symm ▸ h₁
theorem ex3c {α : Sort u} {a b c : α} (r : α → α → Prop) (h₁ : r a b) (h₂ : b = c) : r a c :=
h₂.symm.symm ▸ h₁
theorem ex4 {α : Sort u} {a b c : α} (r : α → α → Prop) (h₁ : a = b) (h₂ : r b c) : r a c :=
h₁ ▸ h₂
theorem ex5 {p : Prop} (h : p = True) : p :=
h ▸ trivial
theorem ex6 {p : Prop} (h : p = False) : ¬p :=
fun hp => h ▸ hp
theorem ex7 {α} {a b c d : α} (h₁ : a = c) (h₂ : b = d) (h₃ : c ≠ d) : a ≠ b :=
h₁ ▸ h₂ ▸ h₃
theorem ex8 (n m k : Nat) (h : Nat.succ n + m = Nat.succ n + k) : Nat.succ (n + m) = Nat.succ (n + k) :=
Nat.succ_add .. ▸ Nat.succ_add .. ▸ h
theorem ex9 (a b : Nat) (h₁ : a = a + b) (h₂ : a = b) : a = b + a :=
h₂ ▸ h₁
theorem ex10 (a b : Nat) (h : a = b) : b = a :=
h ▸ rfl
def ex11 {α : Type u} {n : Nat} (a : Array α) (i : Nat) (h₁ : a.size = n) (h₂ : i < n) : α :=
a.get ⟨i, h₁ ▸ h₂⟩
theorem ex12 {α : Type u} {n : Nat}
(a b : Array α)
(hsz₁ : a.size = n) (hsz₂ : b.size = n)
(h : ∀ (i : Nat) (hi : i < n), a.getLit i hsz₁ hi = b.getLit i hsz₂ hi) : a = b :=
Array.ext a b (hsz₁.trans hsz₂.symm) fun i hi₁ hi₂ => h i (hsz₁ ▸ hi₁)
def toArrayLit {α : Type u} (a : Array α) (n : Nat) (hsz : a.size = n) : Array α :=
List.toArray $ Array.toListLitAux a n hsz n (hsz ▸ Nat.leRefl _) []
partial def isEqvAux {α} (a b : Array α) (hsz : a.size = b.size) (p : α → α → Bool) (i : Nat) : Bool :=
if h : i < a.size then
let aidx : Fin a.size := ⟨i, h⟩
let bidx : Fin b.size := ⟨i, hsz ▸ h⟩
match p (a.get aidx) (b.get bidx) with
| true => isEqvAux a b hsz p (i+1)
| false => false
else
true
|
Formal statement is: lemma map_poly_0 [simp]: "map_poly f 0 = 0" Informal statement is: The polynomial $f(0)$ is the zero polynomial. |
import data.real.irrational
import topology.basic
import algebra.order.floor
--OUTPUT 1
theorem irrational_orbit_dense {α : ℝ} (hα_irrat : irrational α) : closure ((λ m : ℤ, int.fract (α * ↑m)) '' (@set.univ ℤ)) = set.Icc 0 1 :=
begin
--Let $\alpha$ be an irrational number. Then for distinct $i, j \in \mathbb{Z}$, we must have $\{i \alpha\} \neq\{j \alpha\}$. If this were not true, then
have h1 : ∀ i j : ℤ, i ≠ j → int.fract (α * ↑i) ≠ int.fract (α * ↑j), from by {
assume i j : ℤ,
assume h2 : i ≠ j,
assume h3 : int.fract (α * ↑i) = int.fract (α * ↑j),
have h4 : α * ↑i - ↑(int.floor (α * ↑i)) = int.fract (α * ↑i), from by {rw int.fract_eq_of_nonneg (le_of_lt (int.floor_lt_iff.mpr (lt_of_le_of_lt (int.coe_nat_le_coe_nat_of_le (int.floor_nonneg (α * ↑i))) (int.floor_lt_iff.mpr (lt_of_le_of_lt (int.coe_nat_le_coe_nat_of_le (int.floor_nonneg (α * ↑i))) (int.floor_lt_iff.mpr (lt_of_le_of_lt (int.coe_nat_le_coe_nat_of_le (int.floor_nonneg (α * ↑i))) (int.floor_lt_iff.mpr (lt_of_le_of_lt (int.coe_nat_le_coe_nat_of_le (int.floor_nonneg (α * ↑i))) (int.floor_lt_iff.mpr (lt_of_le_of_lt (int.coe_nat_le_coe_nat_of_le (int.floor_nonneg (α * ↑i))) (int.floor_lt_iff.mpr (lt_of_le_of_lt (int.coe_nat_le_coe_nat_of_le (int.floor_nonneg (α * ↑i))) (int.floor_lt_iff.mpr (lt_of_le_of_lt (int.coe_nat_le_coe_nat_of_le (int.floor_nonneg (α * ↑i))) (int.floor_lt_iff.mpr (lt_of_le_of_lt (int.coe_nat_le_coe_nat_of_le (int.floor_nonneg (α * ↑i))) (int.floor_lt_iff.mpr (lt_of_le_of_lt (int.coe_nat_le_coe_nat_of_le (int.floor_nonneg (α * ↑i))) (int.floor_lt_iff.mpr (lt_of_le_of_lt (int.coe_nat_le_coe_nat_of_le (int.floor_nonneg (α * ↑i))) (int.floor_lt_iff.mpr (lt_of_le_of_lt (int.coe_nat_le_coe_nat_of_le (int.floor_nonneg (α * ↑i))) (int.floor_lt_iff.mpr (lt_of_le_of_lt (int.coe_nat_le_coe_nat_of_le (int.floor_nonneg (α * ↑i))) (int.floor_lt_iff.mpr (lt_of_le_of_lt (int.coe_nat_le_coe_nat_of_le (int.floor_nonneg (α * ↑i))) (int.floor_lt_iff.mpr (lt_of_le_of_lt (int.coe_nat_le_coe_nat_of_le (int.floor_nonneg (α * ↑i))) (int.floor_lt_iff.mpr (lt_of_le_of_lt (int.coe_nat_le_coe_nat_of_le (int.floor_nonneg (α * ↑i))) (int.floor_lt_iff.mpr (lt_of_le_of_lt (int.coe_nat_le_coe_nat_of_le (int.floor_nonneg (α * ↑i))) (int.floor_lt_iff.mpr (lt_of_le_of_lt (int.coe_nat_le_coe_nat_of_le (int.floor_nonneg (α * ↑i))) (int.floor_lt_iff.mpr (lt_of_le_of_lt (int.coe_nat_le_coe_nat_of_le (int.floor_nonneg (α * ↑i))) (int.floor_lt_iff.mpr (lt_of_le_of_lt (int.coe_nat_le_coe_nat_of_le (int.floor_nonneg (α * ↑i))) (int.floor_lt_iff.mpr (lt_of_le_of_lt (int.coe_nat_le_coe_nat_of_le (int.floor_nonneg (α * ↑i))) (int.floor_lt_iff.mpr (lt_of_le_of_lt (int.coe_nat_le_coe_nat_of_le (int.floor_nonneg (α * ↑i))) (int.floor_lt_iff.mpr (lt_of_le_of_lt (int.coe_nat_le_coe_nat_of_le (int.floor_nonneg (α * ↑i))) (int.floor_lt_iff.mpr (lt_of_le_of_lt (int.coe_nat_le_coe_nat_of_le (int.floor_nonneg (α * ↑i))) (int.floor_lt_iff.mpr (lt_of_le_of_lt (int.coe_nat_le_coe_nat_of_le (int.floor_nonneg (α * ↑i))) (int.floor_lt_iff.mpr (lt_of_le_of_lt (int.coe_nat_le_coe_nat_of_le (int.floor_nonneg (α * ↑i))) (int.floor_lt_iff.mpr (lt_of_le_of_lt (int.coe_nat_le_coe_nat_of_le (int.floor_nonneg (α * ↑i))) (int.floor_lt_iff.mpr (lt_of_le_of_lt (int.coe_nat_le_coe_nat_of_le (int.floor_nonneg (α * ↑i))) (int.floor_lt_iff.mpr (lt_of_le_of_lt (int.coe_nat_le_coe_nat_of_le (int.floor_nonneg (α * ↑i))) (int.floor_lt_iff.mpr (lt_of_le_of_lt (int.coe_nat_le_coe_nat_of_le (int.floor_nonneg (α * ↑i))) (int.floor_lt_iff.mpr (lt_of_le_of_lt (int.coe_nat_le_coe_nat_of_le (int.floor_nonneg (α * ↑i))) (int.floor_lt_iff.mpr (lt_of_le_of_lt (int.coe_nat_le_coe_nat_of_le (int.floor_nonneg (α * ↑i))) (int.floor_lt_iff.mpr (lt_of_le_of_lt (int.coe_nat_le_coe_nat_of_le (int.floor_nonneg (α * ↑i))) (int.floor_lt_iff.mpr (lt_of_le_of_lt (int.coe_nat_le_coe_nat_of_le (int.floor_nonneg (α * ↑i))) (int.floor_lt_iff.mpr (lt_of_le_of_lt (int.coe_nat_le_coe_nat_of_le (int.floor_nonneg (α * ↑i))) (int.floor_lt_iff.mpr (lt_of_le_of_lt (int.coe_nat_le_coe_nat_of_le (int.floor_nonneg (α * ↑i))) (int.floor_lt_iff.mpr (lt_of_le_of_lt (int.coe_nat_le_coe_nat_of_le (int.floor_nonneg (
end --Needs more than 2000 tokens!
/- FEW SHOT PROMPTS TO CODEX(START)
/--`theorem`
Power Set is Closed under Intersection
Let $S$ be a set.
Let $\powerset S$ be the power set of $S$.
Then:
:$\forall A, B \in \powerset S: A \cap B \in \powerset S$
`proof`
Let $A, B \in \powerset S$.
Then by the definition of power set, $A \subseteq S$ and $B \subseteq S$.
From Intersection is Subset we have that $A \cap B \subseteq A$.
It follows from Subset Relation is Transitive that $A \cap B \subseteq S$.
Thus $A \cap B \in \powerset S$ and closure is proved.
{{qed}}
-/
theorem power_set_intersection_closed {α : Type*} (S : set α) : ∀ A B ∈ 𝒫 S, (A ∩ B) ∈ 𝒫 S :=
begin
-- $A$ and $B$ are sets. $A$ and $B$ belong to power set of $S$
assume (A : set α) (hA : A ∈ 𝒫 S) (B : set α) (hB : B ∈ 𝒫 S),
-- Then $A ⊆ S$ and $B ⊆ S$, by power set definition
have h1 : (A ⊆ S) ∧ (B ⊆ S), from by {split,apply set.subset_of_mem_powerset,exact hA,apply set.subset_of_mem_powerset,exact hB},
-- Then $(A ∩ B) ⊆ A$, by intersection of set is a subset
have h2 : (A ∩ B) ⊆ A, from by apply set.inter_subset_left,
-- Then $(A ∩ B) ⊆ S$, by subset relation is transitive
have h3 : (A ∩ B) ⊆ S, from by {apply set.subset.trans h2 h1.left},
-- Hence $(A ∩ B) ∈ 𝒫 S$, by power set definition
show (A ∩ B) ∈ 𝒫 S, from by {apply set.mem_powerset h3},
end
/--`theorem`
Square of Sum
:$\forall x, y \in \R: \paren {x + y}^2 = x^2 + 2 x y + y^2$
`proof`
Follows from the distribution of multiplication over addition:
{{begin-eqn}}
{{eqn | l = \left({x + y}\right)^2
| r = \left({x + y}\right) \cdot \left({x + y}\right)
}}
{{eqn | r = x \cdot \left({x + y}\right) + y \cdot \left({x + y}\right)
| c = Real Multiplication Distributes over Addition
}}
{{eqn | r = x \cdot x + x \cdot y + y \cdot x + y \cdot y
| c = Real Multiplication Distributes over Addition
}}
{{eqn | r = x^2 + 2xy + y^2
| c =
}}
{{end-eqn}}
{{qed}}
-/
theorem square_of_sum (x y : ℝ) : (x + y)^2 = (x^2 + 2*x*y + y^2) :=
begin
-- expand the power
calc (x + y)^2 = (x+y)*(x+y) : by rw sq
-- distributive property of multiplication over addition gives:
... = x*(x+y) + y*(x+y) : by rw add_mul
-- applying the above property further gives:
... = x*x + x*y + y*x + y*y : by {rw [mul_comm x (x+y),mul_comm y (x+y)], rw [add_mul,add_mul], ring}
-- rearranging the terms using commutativity and adding gives:
... = x^2 + 2*x*y + y^2 : by {repeat {rw ← sq}, rw mul_comm y x, ring}
end
/--`theorem`
Identity of Group is Unique
Let $\struct {G, \circ}$ be a group. Then there is a unique identity element $e \in G$.
`proof`
From Group has Latin Square Property, there exists a unique $x \in G$ such that:
:$a x = b$
and there exists a unique $y \in G$ such that:
:$y a = b$
Setting $b = a$, this becomes:
There exists a unique $x \in G$ such that:
:$a x = a$
and there exists a unique $y \in G$ such that:
:$y a = a$
These $x$ and $y$ are both $e$, by definition of identity element.
{{qed}}
-/
theorem group_identity_unique {G : Type*} [group G] : ∃! e : G, ∀ a : G, e * a = a ∧ a * e = a :=
begin
-- Group has Latin Square Property
have h1 : ∀ a b : G, ∃! x : G, a * x = b, from by {
assume a b : G, use a⁻¹ * b, obviously, },
have h2 : ∀ a b : G, ∃! y : G, y * a = b, from by {
assume a b : G, use b * a⁻¹, obviously, },
-- Setting $b = a$, this becomes:
have h3 : ∀ a : G, ∃! x : G, a * x = a, from
assume a : G, h1 a a,
have h4 : ∀ a : G, ∃! y : G, y * a = a, from
assume a : G, h2 a a,
-- These $x$ and $y$ are both $(1 : G)$, by definition of identity element
have h5 : ∀ a : G, classical.some (h3 a).exists = (1 : G), from assume a :G,
exists_unique.unique (h3 a) (classical.some_spec (exists_unique.exists (h3 a)))
(mul_one a),
have h6 : ∀ a : G, classical.some (h4 a).exists = (1 : G), from assume a : G,
exists_unique.unique (h4 a) (classical.some_spec (exists_unique.exists (h4 a))) (one_mul a),
show ∃! e : G, ∀ a : G, e * a = a ∧ a * e = a, from by {
use (1 : G),
have h7 : ∀ e : G, (∀ a : G, e * a = a ∧ a * e = a) → e = 1, from by {
assume (e : G) (hident : ∀ a : G, e * a = a ∧ a * e = a),
have h8 : ∀ a : G, e = classical.some (h3 a).exists, from assume (a : G),
exists_unique.unique (h3 a) (hident a).right
(classical.some_spec (exists_unique.exists (h3 a))),
have h9 : ∀ a : G, e = classical.some (h4 a).exists, from assume (a : G),
exists_unique.unique (h4 a) (hident a).left
(classical.some_spec (exists_unique.exists (h4 a))),
show e = (1 : G), from eq.trans (h9 e) (h6 _),
},
exact ⟨by obviously, h7⟩,
}
end
/--`theorem`
Squeeze Theorem for Real Numbers
Let $\sequence {x_n}$, $\sequence {y_n}$ and $\sequence {z_n}$ be sequences in $\R$.
Let $\sequence {y_n}$ and $\sequence {z_n}$ both be convergent to the following limit:
:$\ds \lim_{n \mathop \to \infty} y_n = l, \lim_{n \mathop \to \infty} z_n = l$
Suppose that:
:$\forall n \in \N: y_n \le x_n \le z_n$
Then:
:$x_n \to l$ as $n \to \infty$
that is:
:$\ds \lim_{n \mathop \to \infty} x_n = l$
`proof`
From Negative of Absolute Value:
:$\size {x - l} < \epsilon \iff l - \epsilon < x < l + \epsilon$
Let $\epsilon > 0$.
We need to prove that:
:$\exists N: \forall n > N: \size {x_n - l} < \epsilon$
As $\ds \lim_{n \mathop \to \infty} y_n = l$ we know that:
:$\exists N_1: \forall n > N_1: \size {y_n - l} < \epsilon$
As $\ds \lim_{n \mathop \to \infty} z_n = l$ we know that:
:$\exists N_2: \forall n > N_2: \size {z_n - l} < \epsilon$
Let $N = \max \set {N_1, N_2}$.
Then if $n > N$, it follows that $n > N_1$ and $n > N_2$.
So:
:$\forall n > N: l - \epsilon < y_n < l + \epsilon$
:$\forall n > N: l - \epsilon < z_n < l + \epsilon$
But:
:$\forall n \in \N: y_n \le x_n \le z_n$
So:
:$\forall n > N: l - \epsilon < y_n \le x_n \le z_n < l + \epsilon$
and so:
:$\forall n > N: l - \epsilon < x_n < l + \epsilon$
So:
:$\forall n > N: \size {x_n - l} < \epsilon$
Hence the result.
{{qed}}
-/
theorem squeeze_theorem_real_numbers (x y z : ℕ → ℝ) (l : ℝ) :
let seq_limit : (ℕ → ℝ) → ℝ → Prop := λ (u : ℕ → ℝ) (l : ℝ), ∀ ε > 0, ∃ N, ∀ n > N, |u n - l| < ε in
seq_limit y l → seq_limit z l → (∀ n : ℕ, (y n) ≤ (x n) ∧ (x n) ≤ (z n)) → seq_limit x l :=
begin
assume seq_limit (h2 : seq_limit y l) (h3 : seq_limit z l) (h4 : ∀ (n : ℕ), y n ≤ x n ∧ x n ≤ z n) (ε),
--From Negative of Absolute Value: $\size {x - l} < \epsilon \iff l - \epsilon < x < l + \epsilon$
have h5 : ∀ x, |x - l| < ε ↔ (((l - ε) < x) ∧ (x < (l + ε))),
from by
{
intro x0,
have h6 : |x0 - l| < ε ↔ ((x0 - l) < ε) ∧ ((l - x0) < ε),
from abs_sub_lt_iff, rw h6,
split,
rintro ⟨ S_1, S_2 ⟩,
split; linarith,
rintro ⟨ S_3, S_4 ⟩,
split; linarith,
},
--Let $\epsilon > 0$.
assume (h7 : ε > 0),
--As $\ds \lim_{n \mathop \to \infty} y_n = l$ we know that $\exists N_1: \forall n > N_1: \size {y_n - l} < \epsilon$
cases h2 ε h7 with N1 h8,
--As $\ds \lim_{n \mathop \to \infty} z_n = l$ we know that $\exists N_2: \forall n > N_2: \size {z_n - l} < \epsilon$
cases h3 ε h7 with N2 h9,
--Let $N = \max \set {N_1, N_2}$.
let N := max N1 N2,
use N,
--Then if $n > N$, it follows that $n > N_1$ and $n > N_2$.
have h10 : ∀ n > N, n > N1 ∧ n > N2 := by {
assume n h,
split,
exact lt_of_le_of_lt (le_max_left N1 N2) h,
exact lt_of_le_of_lt (le_max_right N1 N2) h,
},
--$\forall n > N: l - \epsilon < y_n < l + \epsilon$
--$\forall n > N: l - \epsilon < z_n < l + \epsilon$
--$\forall n \in \N: y_n \le x_n \le z_n$
--So $\forall n > N: l - \epsilon < y_n \le x_n \le z_n < l + \epsilon$
have h11 : ∀ n > N, (((l - ε) < (y n)) ∧ ((y n) ≤ (x n))) ∧ (((x n) ≤ (z n)) ∧ ((z n) < l+ε)),
from by {
intros n h12,
split,
{
have h13 := (h8 n (h10 n h12).left), rw h5 (y n) at h13,
split,
exact h13.left,
exact (h4 n).left,
},
{
have h14 := (h9 n (h10 n h12).right),rw h5 (z n) at h14,
split,
exact (h4 n).right,
exact h14.right,
},
},
--$\forall n > N: l - \epsilon < x_n < l + \epsilon$
have h15 : ∀ n > N, ((l - ε) < (x n)) ∧ ((x n) < (l+ε)),
from by {
intros n1 h16, cases (h11 n1 h16);
split; linarith,
},
--So $\forall n > N: \size {x_n - l} < \epsilon$
--Hence the result
show ∀ (n : ℕ), n > N → |x n - l| < ε,
from by {
intros n h17,
cases h5 (x n) with h18 h19,
apply h19, exact h15 n h17,
},
end
/--`theorem`
Density of irrational orbit
The fractional parts of the integer multiples of an irrational number form a dense subset of the unit interval
`proof`
Let $\alpha$ be an irrational number. Then for distinct $i, j \in \mathbb{Z}$, we must have $\{i \alpha\} \neq\{j \alpha\}$. If this were not true, then
$$
i \alpha-\lfloor i \alpha\rfloor=\{i \alpha\}=\{j \alpha\}=j \alpha-\lfloor j \alpha\rfloor,
$$
which yields the false statement $\alpha=\frac{\lfloor i \alpha\rfloor-\lfloor j \alpha\rfloor}{i-j} \in \mathbb{Q}$. Hence,
$$
S:=\{\{i \alpha\} \mid i \in \mathbb{Z}\}
$$
is an infinite subset of $\left[0,1\right]$.
By the Bolzano-Weierstrass theorem, $S$ has a limit point in $[0, 1]$. One can thus find pairs of elements of $S$ that are arbitrarily close. Since (the absolute value of) the difference of any two elements of $S$ is also an element of $S$, it follows that $0$ is a limit point of $S$.
To show that $S$ is dense in $[0, 1]$, consider $y \in[0,1]$, and $\epsilon>0$. Then by selecting $x \in S$ such that $\{x\}<\epsilon$ (which exists as $0$ is a limit point), and $N$ such that $N \cdot\{x\} \leq y<(N+1) \cdot\{x\}$, we get: $|y-\{N x\}|<\epsilon$.
QED
-/
theorem irrational_orbit_dense {α : ℝ} (hα_irrat : irrational α) : closure ((λ m : ℤ, int.fract (α * ↑m)) '' (@set.univ ℤ)) = set.Icc 0 1 :=
FEW SHOT PROMPTS TO CODEX(END)-/
|
import data.complex.basic
import data.complex.module
import data.fintype.basic
import data.real.basic
import data.matrix.basic
import linear_algebra.matrix
open_locale matrix big_operators
open_locale complex_conjugate
open fintype finset matrix complex
universes u
-- variables {α : Type u}
-- variables {m n : Type*} [fintype m] [fintype n] [decidable_eq m] [decidable_eq n] [has_one n]
variable (n : ℕ)
-- namespace matrix
variables (M : matrix (fin n) (fin n) ℂ)
-- end matrix
-- def make_mat (M : matrix n n ℂ) : matrix n n ℂ := λ i: n, (λ j : n, (M i j))
-- lemma trace_form (A : matrix n n ℂ) (B : matrix n n ℂ) : ∑ (i : n), ∑ (j : n), (A i j)*(B i j) = ( (A.transpose).mul B).trce :=
-- begin
-- simp only [matrix.trce, matrix.mul],
-- -- ∑ (i j : n), A i j * B i j = ∑ (x : n), Aᵀ x ⬝ᵥ λ (j : n), B j x
-- simp [matrix.transpose, dot_product],
-- exact sum_comm,
-- -- ∑ (i j : n), A i j * B i j = ∑ (x : n), Aᵀ x ⬝ᵥ λ (j : n), B j x
-- end
lemma trace_form (A : matrix (fin n) (fin n) ℂ) (B : matrix (fin n) (fin n) ℂ) : ∑ (i : (fin n)), ∑ (j : (fin n)), (A i j)*(B i j) = matrix.trace (fin n) ℂ ℂ ( (A.transpose).mul B) :=
begin
simp only [matrix.trace, matrix.mul],
-- ∑ (i j : n), A i j * B i j = ∑ (x : n), Aᵀ x ⬝ᵥ λ (j : n), B j x
simp [matrix.transpose, dot_product],
exact sum_comm,
-- ∑ (i j : n), A i j * B i j = ∑ (x : n), Aᵀ x ⬝ᵥ λ (j : n), B j x
end
lemma Laplace (A : matrix (fin n.succ) (fin n.succ) ℂ) : ∀ i : (fin n.succ), det A = ∑ (j : (fin n.succ)), (A i j)*(-1)^(i+j : ℕ)*det (A.minor i.succ_above j.succ_above) :=
begin
intro i,
have hyp := det_succ_row A i,
rw hyp,
simp [add_comm, mul_comm],
end
|
/-
Copyright (c) 2021 OpenAI. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Kunhao Zheng, Stanislas Polu, David Renshaw, OpenAI GPT-f
-/
import mathzoo.imports.miniF2F
open_locale nat rat real big_operators topological_space
theorem mathd_algebra_419
(a b : ℝ)
(h₀ : a = -1)
(h₁ : b = 5) :
-a - b^2 + 3 * (a * b) = -39 :=
begin
rw [h₀, h₁],
norm_num,
end |
{-# OPTIONS --type-in-type --guardedness #-}
module IO.Exts where
import IO.Primitive as Prim
open import Class.Monad
open import Class.Functor
open import Data.List
open import Data.Nat using (ℕ)
open import Data.String
open import Data.Sum
open import Data.Unit
open import Function
open import IO using (IO; run; readFiniteFile; lift)
open import IO.Instance
open import Level
private
variable
A : Set
{-#
FOREIGN GHC
import Data.Text
import System.CPUTime
import System.Environment
import System.Exit
import System.IO
import System.IO.Error
import System.Process
#-}
postulate
flushStdoutPrim : Prim.IO ⊤
getCPUTimePrim : Prim.IO ℕ
putStrErrPrim : String → Prim.IO ⊤
runShellCmdPrim : String → List String → Prim.IO String
catchIOErrorPrim : Prim.IO A → (String → Prim.IO A) → Prim.IO A
{-# COMPILE GHC flushStdoutPrim = hFlush stdout #-}
{-# COMPILE GHC getCPUTimePrim = getCPUTime #-}
{-# COMPILE GHC putStrErrPrim = hPutStr stderr . unpack #-}
{-# COMPILE GHC runShellCmdPrim = \ s t -> pack <$> (readProcess (unpack s) (fmap unpack t) "") #-} -- use haskell proc
{-# COMPILE GHC catchIOErrorPrim = \ _ a f -> catchIOError a (f . pack . show) #-}
flushStdout : IO ⊤
flushStdout = lift flushStdoutPrim
getCPUTime : IO ℕ
getCPUTime = lift getCPUTimePrim
putStrErr : String → IO ⊤
putStrErr s = lift (putStrErrPrim s)
runShellCmd : String → List String → IO String
runShellCmd s args = lift (runShellCmdPrim s args)
catchIOError : IO A → (String → IO A) → IO A
catchIOError a f = lift $ catchIOErrorPrim (run a) (run ∘ f)
readFiniteFileError : String → IO (String ⊎ String)
readFiniteFileError name =
catchIOError (inj₂ <$> readFiniteFile name) (return ∘ inj₁)
|
lemma convex_onD_Icc: assumes "convex_on {x..y} f" "x \<le> (y :: _ :: {real_vector,preorder})" shows "\<And>t. t \<ge> 0 \<Longrightarrow> t \<le> 1 \<Longrightarrow> f ((1 - t) *\<^sub>R x + t *\<^sub>R y) \<le> (1 - t) * f x + t * f y" |
import data.real.basic
theorem exo (f: real -> real):
(forall x y, f(x^2)-f(y^2)=(x+y)*(f(x)-f(y)))
-> (exists m l, forall x, f(x) = m * x + l)
:=
sorry
|
-- Int
theorem Int.n_sub_0 (n: Int): n - 0 = n := by
cases n <;> rfl
theorem Int.ge_0_NonNeg (n: Int): n ≥ 0 ↔ Int.NonNeg n := by
simp [GE.ge, LE.le, Int.le]
simp [Int.n_sub_0]
theorem Int.mul_ge_0 (n m: Int): n ≥ 0 → m ≥ 0 → n * m ≥ 0 := by
rw [Int.ge_0_NonNeg, Int.ge_0_NonNeg, Int.ge_0_NonNeg]
intros hn hm;
cases hn; cases hm; constructor
theorem Int.mul_comm (n m: Int): n * m = m * n := by
sorry
-- Nat
theorem Nat.lt_of_add_lt_add_right {a b c: Nat} (h: a + c < b + c):
a < b := by
sorry
theorem Nat.minus_plus_one {a: Nat} (h: a > 0):
a - 1 + 1 = a := by
sorry
|
(*************************************************************)
(* Copyright Dominique Larchey-Wendling [*] *)
(* Yannick Forster [+] *)
(* *)
(* [*] Affiliation LORIA -- CNRS *)
(* [+] Affiliation Saarland Univ. *)
(*************************************************************)
(* This file is distributed under the terms of the *)
(* CeCILL v2 FREE SOFTWARE LICENSE AGREEMENT *)
(*************************************************************)
From Undecidability.Shared.Libs.DLW
Require Import utils_tac.
Require Import Undecidability.Synthetic.Undecidability.
Require Import Undecidability.Synthetic.ReducibilityFacts.
From Undecidability.PCP Require Import PCP PCP_undec.
From Undecidability.StackMachines Require Import BSM.
From Undecidability.MinskyMachines Require Import MM.
From Undecidability.ILL
Require Import EILL ILL iBPCP_MM MM_EILL EILL_ILL.
Require Import Undecidability.PCP.Reductions.HaltTM_1_to_PCPb.
Import ReductionChainNotations UndecidabilityNotations.
(* The reduction chain from the CPP 2019, Y. Forster & D. Larchey-Wendling *)
Theorem PCP_chain_ILL :
⎩ PCP ⪯ₘ PCPb ⪯ₘ iPCPb ⪯ₘ BSM_HALTING ⪯ₘ MM_HALTS_ON_ZERO ⪯ₘ EILL_PROVABILITY ⪯ₘ ILL_PROVABILITY ⎭.
Proof.
msplit 5; ( apply PCP_chain_iPCPb || apply iBPCP_chain_MM || idtac).
+ apply MM_HALTS_ON_ZERO_EILL_PROVABILITY.
+ apply EILL_ILL_PROVABILITY.
Qed.
Check PCP_chain_ILL.
(* Undecidability results *)
Local Hint Resolve EILL_rILL_cf_PROVABILITY
EILL_rILL_PROVABILITY
EILL_ILL_cf_PROVABILITY
: core.
(* EILL provability using G_eill *)
Theorem EILL_undec : undecidable EILL_PROVABILITY.
Proof. undec from PCP_undec using chain PCP_chain_ILL. Qed.
(* whole ILL with cut *)
Theorem ILL_undec : undecidable ILL_PROVABILITY.
Proof. undec from PCP_undec using chain PCP_chain_ILL. Qed.
(* whole ILL without cut *)
Theorem ILL_cf_undec : undecidable ILL_cf_PROVABILITY.
Proof. undec from EILL_undec; auto. Qed.
(* (!,&,-o) fragment of ILL without cut *)
Theorem rILL_cf_undec : undecidable rILL_cf_PROVABILITY.
Proof. undec from EILL_undec; auto. Qed.
(* (!,&,-o) fragment of ILL with cut *)
Theorem rILL_undec : undecidable rILL_PROVABILITY.
Proof. undec from EILL_undec; auto. Qed.
|
Require Import Coq.ZArith.ZArith.
Require Import Crypto.LegacyArithmetic.Interface.
Require Import Crypto.LegacyArithmetic.Double.Core.
Require Import Crypto.LegacyArithmetic.Double.Proofs.Decode.
Require Import Crypto.LegacyArithmetic.Double.Proofs.ShiftLeftRightTactic.
Require Import Crypto.Util.ZUtil.
(*Require Import Crypto.Util.Tactics.*)
Local Open Scope Z_scope.
Local Opaque tuple_decoder.
Local Arguments Z.pow !_ !_.
Local Arguments Z.mul !_ !_.
Section shr.
Context (n : Z) {W}
{ldi : load_immediate W}
{shl : shift_left_immediate W}
{shr : shift_right_immediate W}
{or : bitwise_or W}
{decode : decoder n W}
{isdecode : is_decode decode}
{isldi : is_load_immediate ldi}
{isshl : is_shift_left_immediate shl}
{isshr : is_shift_right_immediate shr}
{isor : is_bitwise_or or}.
Global Instance is_shift_right_immediate_double : is_shift_right_immediate (shr_double n).
Proof using Type*.
intros r count H; hnf in H.
assert (0 < 2^count) by auto with zarith.
assert (0 < 2^(n+count)) by auto with zarith.
assert (forall n', ~n' + count < n -> 2^n <= 2^(n'+count)) by auto with zarith omega.
assert (forall n', ~n' + count < n -> 2^n <= 2^(n'+count)) by auto with zarith omega.
unfold shr_double; simpl.
generalize (decode_range r).
pose proof (decode_range (fst r)).
pose proof (decode_range (snd r)).
assert (forall n', 2^n <= 2^n' -> 0 <= decode (fst r) < 2^n') by (simpl in *; auto with zarith).
assert (forall n', n <= n' -> 0 <= decode (fst r) < 2^n') by auto with zarith omega.
autorewrite with simpl_tuple_decoder; push_decode.
shift_left_right_t.
Qed.
End shr.
|
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
module homotopy.PathSetIsInitalCover {i} (X : Ptd i)
-- and an arbitrary covering
{k} (⊙cov : ⊙Cover X k) where
open Cover
private
univ-cover = path-set-cover X
module ⊙cov = ⊙Cover ⊙cov
-- Weak initiality by transport.
quotient-cover : CoverHom univ-cover ⊙cov.cov
quotient-cover _ p = cover-trace ⊙cov.cov ⊙cov.pt p
-- Strong initiality by path induction.
module Uniqueness
(cover-hom : CoverHom univ-cover ⊙cov.cov)
(pres-pt : cover-hom (pt X) idp₀ == ⊙cov.pt)
where
private
lemma₁ : ∀ a p → cover-hom a [ p ] == quotient-cover a [ p ]
lemma₁ ._ idp = pres-pt
lemma₂ : ∀ a p → cover-hom a p == quotient-cover a p
lemma₂ a = Trunc-elim
(λ p → =-preserves-set (⊙cov.Fiber-level a))
(lemma₁ a)
theorem : cover-hom == quotient-cover
theorem = λ= λ a → λ= $ lemma₂ a
|
theorem Ex006(a b c : Prop): a ∨ b → a ∨ c → a ∨ (b ∧ c) :=
assume H1:a ∨ b,
assume H2:a ∨ c,
show a ∨ (b ∧ c), from or.elim H1
(
assume H :a,
show a ∨ (b ∧ c), from or.inl H
)
(
assume H: b,
show a ∨ (b ∧ c), from or.elim H2
(
assume HH:a,
show a ∨ (b ∧ c), from or.inl HH
)
(
assume HH:c,
have H3:b ∧ c, from and.intro H HH,
show a ∨ (b ∧ c), from or.inr H3
)
)
|
import data.real.basic
import game.Completeness.level04
import game.Completeness.level02
noncomputable theory
open_locale classical
definition has_lub (S : set ℝ) := ∃ x, is_lub S x
--sup(S) - ε < s < sup(S)
--lemma thinklater (S : set ℝ) (x y ε : ℝ) (H : has_lub S) (S ≠ ∅) (hy : is_sup S y) :
--∀ ε > 0, ∃ x ∈ S, is_sup S y - ε < x ∧ x ≤ is_sup S y :=
lemma do_now {x : ℝ} {S : set ℝ} (h : S ≠ ∅) (Hsup : is_sup S x) : (∀ ε > 0, ∃ s ∈ S, x-ε<s ∧ s ≤ x) :=
begin
rw is_sup at Hsup,
cases Hsup with a ha,
rw upper_bound at a,
intro ε, intro h,
use x, split, swap,
split,
linarith, linarith,
-- rewrite this level cause I am pretty sure it is written incorrectly
end
|
theorem ex1 (p : Prop) (h1 : p) (h2 : p → False) : α := by
contradiction
theorem ex2 (p : Prop) (h1 : p) (h2 : ¬ p) : α := by
contradiction
theorem ex3 (p : Prop) (h1 : id p) (h2 : ¬ p) : α := by
contradiction
theorem ex4 (p : Prop) (h1 : id p) (h2 : id (Not p)) : α := by
contradiction
theorem ex5 (h : x+1 = 0) : α := by
contradiction
theorem ex6 (h : 0+0 ≠ 0) : α := by
contradiction
theorem ex7 (x : α) (h : Not (x = x)) : α := by
contradiction
theorem ex8 (h : 0+0 = 0 → False) : α := by
contradiction
theorem ex9 (h : 10 = 20) : α := by
contradiction
theorem ex10 (h : [] = [1, 2, 3]) : α := by
contradiction
theorem ex11 (h : id [] = [1, 2, 3]) : α := by
contradiction
theorem ex12 (h : False) : α := by
contradiction
theorem ex13 (h : id False) : α := by
contradiction
theorem ex14 (h : 100000000 ≤ 20) : α := by
contradiction
theorem ex15 (x : α) (h : x = x → False) : α := by
contradiction
theorem ex16 (xs : List α) (h : xs = [] → False) : Nonempty α := by
cases xs using List.rec with
| nil => contradiction
| cons x _ => apply Nonempty.intro; assumption
|
/-
Copyright (c) 2021 OpenAI. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Kunhao Zheng, Stanislas Polu, David Renshaw, OpenAI GPT-f
-/
import mathzoo.imports.miniF2F
open_locale nat rat real big_operators topological_space
theorem mathd_algebra_109
(a b : ℝ)
(h₀ : 3 * a + 2 * b = 12)
(h₁ : a = 4) :
b = 0 :=
begin
linarith,
end |
corollary fps_coeff_residues_bigo: fixes f :: "complex \<Rightarrow> complex" and r :: real assumes "open A" "connected A" "cball 0 r \<subseteq> A" "r > 0" assumes "f holomorphic_on A - S" "S \<subseteq> ball 0 r" "finite S" "0 \<notin> S" assumes g: "eventually (\<lambda>n. g n = -(\<Sum>z\<in>S. residue (\<lambda>z. f z / z ^ Suc n) z)) sequentially" (is "eventually (\<lambda>n. _ = -?g' n) _") shows "(\<lambda>n. (deriv ^^ n) f 0 / fact n - g n) \<in> O(\<lambda>n. 1 / r ^ n)" (is "(\<lambda>n. ?c n - _) \<in> O(_)") |
lemma of_real_add [simp]: "of_real (x + y) = of_real x + of_real y" |
[STATEMENT]
lemma of_hypnat_0 [simp]: "of_hypnat 0 = 0"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. of_hypnat 0 = 0
[PROOF STEP]
by transfer (rule of_nat_0) |
import data.nat.modeq
/-
(a) Find r with 0 ≤ r ≤ 10 such that 7^137 ≡ r mod 11.
(b) Find r with 0 ≤ r < 645 such that 2^81 ≡ r mod 645.
(c) Find the last two digits of 3^124 (when expressed in decimal notation).
(d) Show that there is a multiple of 21 which has 241 as its last three digits.
-/
lemma part_a : ∃r : ℕ, 0 ≤ r ∧ r ≤ 10 ∧ 7^137 ≡ r [MOD 11] :=
begin
use 6,
unfold nat.modeq,
norm_num,
end
lemma part_b : ∃r : ℕ, 0 ≤ r ∧ r < 645 ∧ 2^81 ≡ r [MOD 645] :=
begin
use 242,
unfold nat.modeq,
norm_num,
end
-- Once you compute the last two digits, change 37 below to them.
lemma part_c : 3^124 ≡ 81 [MOD 100] :=
begin
unfold nat.modeq,
norm_num,
end
lemma part_d : ∃k : ℕ, 21 ∣ k ∧ k ≡ 241 [MOD 1000] :=
begin
unfold nat.modeq,
use 17241,
split,
{norm_num, },
{norm_num, },
end |
import MyNat.Definition
import MultiplicationWorld.Level6 -- succ_mul
import MyNat.Multiplication -- mul_succ, mul_zero
import AdvancedMultiplicationWorld.Level2 -- eq_zero_or_eq_zero_of_mul_eq_zero
namespace MyNat
open MyNat
/-!
# Advanced Multiplication World
## Level 4: `mul_left_cancel`
This is the last of the bonus multiplication levels. `mul_left_cancel` will be useful in inequality
world.
People find this level hard. I have probably had more questions about this level than all the other
levels put together, in fact. Many levels in this game can just be solved by "running at it" -- do
induction on one of the variables, keep your head, and you're done. In fact, if you like a
challenge, it might be instructive if you stop reading after the end of this paragraph and try
solving this level now by induction, seeing the trouble you run into, and reading the rest of these
comments afterwards. This level has a sting in the tail. If you are a competent mathematician, try
and figure out what is going on. Write down a maths proof of the theorem in this level. Exactly what
statement do you want to prove by induction? It is subtle.
Ok so here are some spoilers. The problem with naively running at it, is that if you try induction
on, say, `c`, then you are imagining `a` and `b` as fixed, and your inductive hypothesis `P(c)` is
`ab=ac ⟹ b=c`. So for your inductive step you will be able to assume `ab=ad ⟹ b=d` and your goal
will be to show `ab=a(d+1) ⟹ b=d+1`. When you also assume `ab=a(d+1)` you will realize that your
inductive hypothesis is *useless*, because `ab=ad` is not true! The statement `P(c)` (with `a` and
`b` regarded as constants) is not provable by induction.
What you *can* prove by induction is the following *stronger* statement. Imagine `a ≠ 0` as fixed,
and then prove "for all `b`, if `ab=ac` then `b=c`" by induction on `c`. This gives us the extra
flexibility we require. Note that we are quantifying over all `b` in the inductive hypothesis -- it
is essential that `b` is not fixed.
You can do this in two ways in Lean -- before you start the induction you can write `revert b`. The
`revert` tactic is the opposite of the `intro` tactic; it replaces the `b` in the hypotheses with
"for all `b`" in the goal.
Alternatively, you can write `induction c generalizing b with` as the first line of the proof.
If you do not modify your technique in this way, then this level seems
to be impossible (judging by the comments I've had about it!)
## Theorem
If `a ≠ 0`, `b` and `c` are natural numbers such that ` ab = ac, ` then `b = c`.
-/
set_option trace.Meta.Tactic.simp true
theorem mul_left_cancel (a b c : MyNat) (ha : a ≠ 0) : a * b = a * c → b = c := by
induction c generalizing b with
| zero =>
rw [zero_is_0]
rw [mul_zero]
intro h
cases (eq_zero_or_eq_zero_of_mul_eq_zero _ _ h) with
| inl h1 =>
exfalso
apply ha
assumption
| inr h2 =>
assumption
| succ d hd =>
intro hb
cases b with
| zero =>
rw [zero_is_0] at hb
rw [mul_zero] at hb
rw [zero_is_0]
exfalso
apply ha
have hb := hb.symm
cases (eq_zero_or_eq_zero_of_mul_eq_zero _ _ hb) with
| inl h =>
exact h
| inr h =>
exfalso
exact succ_ne_zero _ h
| succ c =>
have h := c = d
apply hd
rw [mul_succ] at hb
rw [mul_succ] at hb
apply add_right_cancel _ _ _ hb
rw [h]
/-!
You should now be ready for [Inequality World](../InequalityWorld.lean.md).
-/
|
/-
Copyright (c) 2021 Heather Macbeth. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Heather Macbeth
-/
import measure_theory.measure.regular
import measure_theory.function.simple_func_dense
import topology.urysohns_lemma
/-!
# Approximation in Lᵖ by continuous functions
This file proves that bounded continuous functions are dense in `Lp E p μ`, for `1 ≤ p < ∞`, if the
domain `α` of the functions is a normal topological space and the measure `μ` is weakly regular.
The result is presented in several versions:
* `measure_theory.Lp.bounded_continuous_function_dense`: The subgroup
`measure_theory.Lp.bounded_continuous_function` of `Lp E p μ`, the additive subgroup of
`Lp E p μ` consisting of equivalence classes containing a continuous representative, is dense in
`Lp E p μ`.
* `bounded_continuous_function.to_Lp_dense_range`: For finite-measure `μ`, the continuous linear
map `bounded_continuous_function.to_Lp p μ 𝕜` from `α →ᵇ E` to `Lp E p μ` has dense range.
* `continuous_map.to_Lp_dense_range`: For compact `α` and finite-measure `μ`, the continuous linear
map `continuous_map.to_Lp p μ 𝕜` from `C(α, E)` to `Lp E p μ` has dense range.
Note that for `p = ∞` this result is not true: the characteristic function of the set `[0, ∞)` in
`ℝ` cannot be continuously approximated in `L∞`.
The proof is in three steps. First, since simple functions are dense in `Lp`, it suffices to prove
the result for a scalar multiple of a characteristic function of a measurable set `s`. Secondly,
since the measure `μ` is weakly regular, the set `s` can be approximated above by an open set and
below by a closed set. Finally, since the domain `α` is normal, we use Urysohn's lemma to find a
continuous function interpolating between these two sets.
## Related results
Are you looking for a result on "directional" approximation (above or below with respect to an
order) of functions whose codomain is `ℝ≥0∞` or `ℝ`, by semicontinuous functions? See the
Vitali-Carathéodory theorem, in the file `measure_theory.vitali_caratheodory`.
-/
open_locale ennreal nnreal topological_space bounded_continuous_function
open measure_theory topological_space continuous_map
variables {α : Type*} [measurable_space α] [topological_space α] [normal_space α] [borel_space α]
variables (E : Type*) [measurable_space E] [normed_group E] [borel_space E]
[second_countable_topology E]
variables {p : ℝ≥0∞} [_i : fact (1 ≤ p)] (hp : p ≠ ∞) (μ : measure α)
include _i hp
namespace measure_theory.Lp
variables [normed_space ℝ E]
/-- A function in `Lp` can be approximated in `Lp` by continuous functions. -/
lemma bounded_continuous_function_dense [μ.weakly_regular] :
(bounded_continuous_function E p μ).topological_closure = ⊤ :=
begin
have hp₀ : 0 < p := lt_of_lt_of_le ennreal.zero_lt_one _i.elim,
have hp₀' : 0 ≤ 1 / p.to_real := div_nonneg zero_le_one ennreal.to_real_nonneg,
have hp₀'' : 0 < p.to_real,
{ simpa [← ennreal.to_real_lt_to_real ennreal.zero_ne_top hp] using hp₀ },
-- It suffices to prove that scalar multiples of the indicator function of a finite-measure
-- measurable set can be approximated by continuous functions
suffices : ∀ (c : E) {s : set α} (hs : measurable_set s) (hμs : μ s < ⊤),
(Lp.simple_func.indicator_const p hs hμs.ne c : Lp E p μ)
∈ (bounded_continuous_function E p μ).topological_closure,
{ rw add_subgroup.eq_top_iff',
refine Lp.induction hp _ _ _ _,
{ exact this },
{ exact λ f g hf hg hfg', add_subgroup.add_mem _ },
{ exact add_subgroup.is_closed_topological_closure _ } },
-- Let `s` be a finite-measure measurable set, let's approximate `c` times its indicator function
intros c s hs hsμ,
refine mem_closure_iff_frequently.mpr _,
rw metric.nhds_basis_closed_ball.frequently_iff,
intros ε hε,
-- A little bit of pre-emptive work, to find `η : ℝ≥0` which will be a margin small enough for
-- our purposes
obtain ⟨η, hη_pos, hη_le⟩ : ∃ η, 0 < η ∧ (↑(∥bit0 (∥c∥)∥₊ * (2 * η) ^ (1 / p.to_real)) : ℝ) ≤ ε,
{ have : filter.tendsto (λ x : ℝ≥0, ∥bit0 (∥c∥)∥₊ * (2 * x) ^ (1 / p.to_real)) (𝓝 0) (𝓝 0),
{ have : filter.tendsto (λ x : ℝ≥0, 2 * x) (𝓝 0) (𝓝 (2 * 0)) := filter.tendsto_id.const_mul 2,
convert ((nnreal.continuous_at_rpow_const (or.inr hp₀')).tendsto.comp this).const_mul _,
simp [hp₀''.ne'] },
let ε' : ℝ≥0 := ⟨ε, hε.le⟩,
have hε' : 0 < ε' := by exact_mod_cast hε,
obtain ⟨δ, hδ, hδε'⟩ :=
nnreal.nhds_zero_basis.eventually_iff.mp (eventually_le_of_tendsto_lt hε' this),
obtain ⟨η, hη, hηδ⟩ := exists_between hδ,
refine ⟨η, hη, _⟩,
exact_mod_cast hδε' hηδ },
have hη_pos' : (0 : ℝ≥0∞) < η := ennreal.coe_pos.2 hη_pos,
-- Use the regularity of the measure to `η`-approximate `s` by an open superset and a closed
-- subset
obtain ⟨u, su, u_open, μu⟩ : ∃ u ⊇ s, is_open u ∧ μ u < μ s + ↑η,
{ refine s.exists_is_open_lt_of_lt _ _,
simpa using ennreal.add_lt_add_left hsμ.ne hη_pos' },
obtain ⟨F, Fs, F_closed, μF⟩ : ∃ F ⊆ s, is_closed F ∧ μ s < μ F + ↑η :=
hs.exists_is_closed_lt_add hsμ.ne hη_pos'.ne',
have : disjoint uᶜ F,
{ rw [set.disjoint_iff_inter_eq_empty, set.inter_comm, ← set.subset_compl_iff_disjoint],
simpa using Fs.trans su },
have h_μ_sdiff : μ (u \ F) ≤ 2 * η,
{ have hFμ : μ F < ⊤ := (measure_mono Fs).trans_lt hsμ,
refine ennreal.le_of_add_le_add_left hFμ.ne _,
have : μ u < μ F + ↑η + ↑η,
from μu.trans (ennreal.add_lt_add_right ennreal.coe_ne_top μF),
convert this.le using 1,
{ rw [add_comm, ← measure_union, set.diff_union_of_subset (Fs.trans su)],
{ exact disjoint_sdiff_self_left },
{ exact (u_open.sdiff F_closed).measurable_set },
{ exact F_closed.measurable_set } },
have : (2:ℝ≥0∞) * η = η + η := by simpa using add_mul (1:ℝ≥0∞) 1 η,
rw this,
abel },
-- Apply Urysohn's lemma to get a continuous approximation to the characteristic function of
-- the set `s`
obtain ⟨g, hgu, hgF, hg_range⟩ :=
exists_continuous_zero_one_of_closed u_open.is_closed_compl F_closed this,
-- Multiply this by `c` to get a continuous approximation to the function `f`; the key point is
-- that this is pointwise bounded by the indicator of the set `u \ F`
have g_norm : ∀ x, ∥g x∥ = g x := λ x, by rw [real.norm_eq_abs, abs_of_nonneg (hg_range x).1],
have gc_bd : ∀ x, ∥g x • c - s.indicator (λ x, c) x∥ ≤ ∥(u \ F).indicator (λ x, bit0 ∥c∥) x∥,
{ intros x,
by_cases hu : x ∈ u,
{ rw ← set.diff_union_of_subset (Fs.trans su) at hu,
cases hu with hFu hF,
{ refine (norm_sub_le _ _).trans _,
refine (add_le_add_left (norm_indicator_le_norm_self (λ x, c) x) _).trans _,
have h₀ : g x * ∥c∥ + ∥c∥ ≤ 2 * ∥c∥,
{ nlinarith [(hg_range x).1, (hg_range x).2, norm_nonneg c] },
have h₁ : (2:ℝ) * ∥c∥ = bit0 (∥c∥) := by simpa using add_mul (1:ℝ) 1 (∥c∥),
simp [hFu, norm_smul, h₀, ← h₁, g_norm x] },
{ simp [hgF hF, Fs hF] } },
{ have : x ∉ s := λ h, hu (su h),
simp [hgu hu, this] } },
-- The rest is basically just `ennreal`-arithmetic
have gc_snorm : snorm ((λ x, g x • c) - s.indicator (λ x, c)) p μ
≤ (↑(∥bit0 (∥c∥)∥₊ * (2 * η) ^ (1 / p.to_real)) : ℝ≥0∞),
{ refine (snorm_mono_ae (filter.eventually_of_forall gc_bd)).trans _,
rw snorm_indicator_const (u_open.sdiff F_closed).measurable_set hp₀.ne' hp,
push_cast [← ennreal.coe_rpow_of_nonneg _ hp₀'],
exact ennreal.mul_left_mono (ennreal.rpow_left_monotone_of_nonneg hp₀' h_μ_sdiff) },
have gc_cont : continuous (λ x, g x • c) := g.continuous.smul continuous_const,
have gc_mem_ℒp : mem_ℒp (λ x, g x • c) p μ,
{ have : mem_ℒp ((λ x, g x • c) - s.indicator (λ x, c)) p μ :=
⟨(gc_cont.ae_measurable μ).sub (measurable_const.indicator hs).ae_measurable,
gc_snorm.trans_lt ennreal.coe_lt_top⟩,
simpa using this.add (mem_ℒp_indicator_const p hs c (or.inr hsμ.ne)) },
refine ⟨gc_mem_ℒp.to_Lp _, _, _⟩,
{ rw mem_closed_ball_iff_norm,
refine le_trans _ hη_le,
rw [simple_func.coe_indicator_const, indicator_const_Lp, ← mem_ℒp.to_Lp_sub, Lp.norm_to_Lp],
exact ennreal.to_real_le_coe_of_le_coe gc_snorm },
{ rw [set_like.mem_coe, mem_bounded_continuous_function_iff],
refine ⟨bounded_continuous_function.of_normed_group _ gc_cont (∥c∥) _, rfl⟩,
intros x,
have h₀ : g x * ∥c∥ ≤ ∥c∥,
{ nlinarith [(hg_range x).1, (hg_range x).2, norm_nonneg c] },
simp [norm_smul, g_norm x, h₀] },
end
end measure_theory.Lp
variables (𝕜 : Type*) [measurable_space 𝕜] [normed_field 𝕜] [opens_measurable_space 𝕜]
[normed_algebra ℝ 𝕜] [normed_space 𝕜 E]
namespace bounded_continuous_function
lemma to_Lp_dense_range [μ.weakly_regular] [is_finite_measure μ] :
dense_range ⇑(to_Lp p μ 𝕜 : (α →ᵇ E) →L[𝕜] Lp E p μ) :=
begin
haveI : normed_space ℝ E := restrict_scalars.normed_space ℝ 𝕜 E,
rw dense_range_iff_closure_range,
suffices : (to_Lp p μ 𝕜 : _ →L[𝕜] Lp E p μ).range.to_add_subgroup.topological_closure = ⊤,
{ exact congr_arg coe this },
simp [range_to_Lp p μ, measure_theory.Lp.bounded_continuous_function_dense E hp],
end
end bounded_continuous_function
namespace continuous_map
lemma to_Lp_dense_range [compact_space α] [μ.weakly_regular] [is_finite_measure μ] :
dense_range ⇑(to_Lp p μ 𝕜 : C(α, E) →L[𝕜] Lp E p μ) :=
begin
haveI : normed_space ℝ E := restrict_scalars.normed_space ℝ 𝕜 E,
rw dense_range_iff_closure_range,
suffices : (to_Lp p μ 𝕜 : _ →L[𝕜] Lp E p μ).range.to_add_subgroup.topological_closure = ⊤,
{ exact congr_arg coe this },
simp [range_to_Lp p μ, measure_theory.Lp.bounded_continuous_function_dense E hp]
end
end continuous_map
|
import topology.basic
import data.real.nnreal
import data.real.basic
open set
theorem open_set_for_each
(X : Type*)
[topological_space X]
(A : set X)
(h₀ : ∀ x ∈ A, ∃ (U : set X), is_open U ∧ x ∈ U ∧ U ⊆ A) :
is_open A :=
begin
choose! f hf using h₀,
have : A = ⋃ x ∈ A, f x,
{
ext p,
split,
{
intro hp,
have hfp := hf p hp,
rw mem_Union₂,
use p,
exact ⟨ hp, hfp.2.1 ⟩,
},
{
intro hp,
rw mem_Union₂ at hp,
cases hp with i hi,
cases hi with hia hpfi,
have x := hf i hia,
exact x.2.2 hpfi,
}
},
rw this,
apply is_open_bUnion,
intros i hi,
exact (hf i hi).1,
end
def intersection_of_topologies {X : Type*} {ι : Sort*}
(f : ι → topological_space X) : topological_space X :=
{ is_open := λ s, ∀ i, (f i).is_open s,
is_open_univ :=
begin
sorry
end,
is_open_inter :=
begin
intros s t hos hot i,
specialize hos i,
specialize hot i,
exact (f i).is_open_inter s t hos hot,
end,
is_open_sUnion := sorry } |
/-
Copyright 2020 Google LLC
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-/
import measure_theory.measurable_space
import measure_theory.measure_space
import measure_theory.outer_measure
import measure_theory.lebesgue_measure
import measure_theory.integration
import measure_theory.set_integral
import measure_theory.borel_space
import data.set.countable
import formal_ml.nnreal
import formal_ml.sum
import formal_ml.core
import formal_ml.measurable_space
import formal_ml.semiring
import formal_ml.real_measurable_space
import formal_ml.set
import formal_ml.filter_util
import topology.instances.ennreal
import formal_ml.int
import formal_ml.with_density_compose_eq_multiply
import formal_ml.classical
lemma with_density_le_with_density {Ω:Type*} {M:measurable_space Ω}
{μ:measure_theory.measure Ω} {x y:Ω → ennreal}
{S:set Ω}:
measurable_set S →
(∀ ω ∈ S, x ω ≤ y ω) →
μ.with_density x S ≤ μ.with_density y S :=
begin
intros A3 A4,
rw measure_theory.with_density_apply2' μ x S A3,
rw measure_theory.with_density_apply2' μ y S A3,
apply measure_theory.lintegral_mono,
rw le_func_def2,
intros ω,
cases (classical.em (ω ∈ S)) with A5 A5,
{
rw set.indicator_of_mem A5,
rw set.indicator_of_mem A5,
apply A4 _ A5,
},
{
rw set.indicator_of_not_mem A5,
rw set.indicator_of_not_mem A5,
apply le_refl _,
},
end
--TODO: Remove measurability?
lemma with_density_sup_of_le {Ω:Type*} {M:measurable_space Ω}
{μ:measure_theory.measure Ω} {x y:Ω → ennreal}
{S:set Ω}:measurable x → measurable y →
measurable_set S →
(∀ ω ∈ S, x ω ≤ y ω) →
μ.with_density (x⊔y) S = μ.with_density y S :=
begin
intros A1 A2 A3 A4,
rw measure_theory.with_density_apply2' μ (x ⊔ y) S A3,
rw measure_theory.with_density_apply2' μ y S A3,
have A5:set.indicator S (x ⊔ y) = set.indicator S y,
{
apply funext,
intro ω,
cases (classical.em (ω∈ S)) with A5A A5A,
{
rw set.indicator_of_mem A5A,
rw set.indicator_of_mem A5A,
rw sup_apply,
simp [A4 _ A5A],
},
{
rw set.indicator_of_not_mem A5A,
rw set.indicator_of_not_mem A5A,
},
},
rw A5,
end
lemma measure_theory.measure.sup_le_apply {Ω:Type*}
{M:measurable_space Ω}
{μ ν m:measure_theory.measure Ω}
{S:set Ω}:measurable_set S →
(μ ≤ m) →
(ν ≤ m) →
(μ ⊔ ν) S ≤ m S :=
begin
intros A1 A2 A3,
have A4:μ ⊔ ν ≤ m :=
@sup_le (measure_theory.measure Ω) _ μ ν m A2 A3,
apply A4,
apply A1,
end
|
[STATEMENT]
lemma dbproj_Cons:
"dbproj i ((i,d)#D) = (i,d)#dbproj i D"
"i \<noteq> j \<Longrightarrow> dbproj j ((i,d)#D) = dbproj j D"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. dbproj i ((i, d) # D) = (i, d) # dbproj i D &&& (i \<noteq> j \<Longrightarrow> dbproj j ((i, d) # D) = dbproj j D)
[PROOF STEP]
unfolding dbproj_def
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. filter (\<lambda>d. fst d = i) ((i, d) # D) = (i, d) # filter (\<lambda>d. fst d = i) D &&& (i \<noteq> j \<Longrightarrow> filter (\<lambda>d. fst d = j) ((i, d) # D) = filter (\<lambda>d. fst d = j) D)
[PROOF STEP]
by auto |
/-
Copyright (c) 2015 Jeremy Avigad. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Jeremy Avigad, Robert Y. Lewis
-/
import algebra.group_power.basic
import algebra.invertible
import algebra.opposites
import data.list.basic
import data.int.cast
import data.equiv.basic
import data.equiv.mul_add
import deprecated.group
/-!
# Lemmas about power operations on monoids and groups
This file contains lemmas about `monoid.pow`, `group.pow`, `nsmul`, `gsmul`
which require additional imports besides those available in `.basic`.
-/
universes u v w x y z u₁ u₂
variables {M : Type u} {N : Type v} {G : Type w} {H : Type x} {A : Type y} {B : Type z}
{R : Type u₁} {S : Type u₂}
/-!
### (Additive) monoid
-/
section monoid
variables [monoid M] [monoid N] [add_monoid A] [add_monoid B]
@[simp] theorem nsmul_one [has_one A] : ∀ n : ℕ, n • (1 : A) = n :=
add_monoid_hom.eq_nat_cast
⟨λ n, n • (1 : A), zero_nsmul _, λ _ _, add_nsmul _ _ _⟩
(one_nsmul _)
@[simp, priority 500]
theorem list.prod_repeat (a : M) (n : ℕ) : (list.repeat a n).prod = a ^ n :=
begin
induction n with n ih,
{ rw pow_zero, refl },
{ rw [list.repeat_succ, list.prod_cons, ih, pow_succ] }
end
@[simp, priority 500]
theorem list.sum_repeat : ∀ (a : A) (n : ℕ), (list.repeat a n).sum = n • a :=
@list.prod_repeat (multiplicative A) _
@[simp, norm_cast] lemma units.coe_pow (u : units M) (n : ℕ) : ((u ^ n : units M) : M) = u ^ n :=
(units.coe_hom M).map_pow u n
instance invertible_pow (m : M) [invertible m] (n : ℕ) : invertible (m ^ n) :=
{ inv_of := ⅟ m ^ n,
inv_of_mul_self := by rw [← (commute_inv_of m).symm.mul_pow, inv_of_mul_self, one_pow],
mul_inv_of_self := by rw [← (commute_inv_of m).mul_pow, mul_inv_of_self, one_pow] }
lemma inv_of_pow (m : M) [invertible m] (n : ℕ) [invertible (m ^ n)] :
⅟(m ^ n) = ⅟m ^ n :=
@invertible_unique M _ (m ^ n) (m ^ n) rfl ‹_› (invertible_pow m n)
lemma is_unit.pow {m : M} (n : ℕ) : is_unit m → is_unit (m ^ n) :=
λ ⟨u, hu⟩, ⟨u ^ n, by simp *⟩
/-- If `x ^ n.succ = 1` then `x` has an inverse, `x^n`. -/
def invertible_of_pow_succ_eq_one (x : M) (n : ℕ) (hx : x ^ n.succ = 1) :
invertible x :=
⟨x ^ n, (pow_succ' x n).symm.trans hx, (pow_succ x n).symm.trans hx⟩
/-- If `x ^ n = 1` then `x` has an inverse, `x^(n - 1)`. -/
def invertible_of_pow_eq_one (x : M) (n : ℕ) (hx : x ^ n = 1) (hn : 0 < n) :
invertible x :=
begin
apply invertible_of_pow_succ_eq_one x (n - 1),
convert hx,
exact nat.sub_add_cancel (nat.succ_le_of_lt hn),
end
lemma is_unit_of_pow_eq_one (x : M) (n : ℕ) (hx : x ^ n = 1) (hn : 0 < n) :
is_unit x :=
begin
haveI := invertible_of_pow_eq_one x n hx hn,
exact is_unit_of_invertible x
end
end monoid
theorem nat.nsmul_eq_mul (m n : ℕ) : m • n = m * n :=
by induction m with m ih; [rw [zero_nsmul, zero_mul],
rw [succ_nsmul', ih, nat.succ_mul]]
section group
variables [group G] [group H] [add_group A] [add_group B]
open int
local attribute [ematch] le_of_lt
open nat
theorem gsmul_one [has_one A] (n : ℤ) : n • (1 : A) = n :=
by cases n; simp
lemma gpow_add_one (a : G) : ∀ n : ℤ, a ^ (n + 1) = a ^ n * a
| (of_nat n) := by simp [← int.coe_nat_succ, pow_succ']
| -[1+0] := by simp [int.neg_succ_of_nat_eq]
| -[1+(n+1)] := by rw [int.neg_succ_of_nat_eq, gpow_neg, neg_add, neg_add_cancel_right, gpow_neg,
← int.coe_nat_succ, gpow_coe_nat, gpow_coe_nat, pow_succ _ (n + 1), mul_inv_rev,
inv_mul_cancel_right]
theorem add_one_gsmul : ∀ (a : A) (i : ℤ), (i + 1) • a = i • a + a :=
@gpow_add_one (multiplicative A) _
lemma gpow_sub_one (a : G) (n : ℤ) : a ^ (n - 1) = a ^ n * a⁻¹ :=
calc a ^ (n - 1) = a ^ (n - 1) * a * a⁻¹ : (mul_inv_cancel_right _ _).symm
... = a^n * a⁻¹ : by rw [← gpow_add_one, sub_add_cancel]
lemma gpow_add (a : G) (m n : ℤ) : a ^ (m + n) = a ^ m * a ^ n :=
begin
induction n using int.induction_on with n ihn n ihn,
case hz : { simp },
{ simp only [← add_assoc, gpow_add_one, ihn, mul_assoc] },
{ rw [gpow_sub_one, ← mul_assoc, ← ihn, ← gpow_sub_one, add_sub_assoc] }
end
lemma mul_self_gpow (b : G) (m : ℤ) : b*b^m = b^(m+1) :=
by { conv_lhs {congr, rw ← gpow_one b }, rw [← gpow_add, add_comm] }
lemma mul_gpow_self (b : G) (m : ℤ) : b^m*b = b^(m+1) :=
by { conv_lhs {congr, skip, rw ← gpow_one b }, rw [← gpow_add, add_comm] }
theorem add_gsmul : ∀ (a : A) (i j : ℤ), (i + j) • a = i • a + j • a :=
@gpow_add (multiplicative A) _
lemma gpow_sub (a : G) (m n : ℤ) : a ^ (m - n) = a ^ m * (a ^ n)⁻¹ :=
by rw [sub_eq_add_neg, gpow_add, gpow_neg]
lemma sub_gsmul (m n : ℤ) (a : A) : (m - n) • a = m • a - n • a :=
by simpa only [sub_eq_add_neg] using @gpow_sub (multiplicative A) _ _ _ _
theorem gpow_one_add (a : G) (i : ℤ) : a ^ (1 + i) = a * a ^ i :=
by rw [gpow_add, gpow_one]
theorem one_add_gsmul : ∀ (a : A) (i : ℤ), (1 + i) • a = a + i • a :=
@gpow_one_add (multiplicative A) _
theorem gpow_mul_comm (a : G) (i j : ℤ) : a ^ i * a ^ j = a ^ j * a ^ i :=
by rw [← gpow_add, ← gpow_add, add_comm]
theorem gsmul_add_comm : ∀ (a : A) (i j : ℤ), i • a + j • a = j • a + i • a :=
@gpow_mul_comm (multiplicative A) _
theorem gpow_mul (a : G) (m n : ℤ) : a ^ (m * n) = (a ^ m) ^ n :=
int.induction_on n (by simp) (λ n ihn, by simp [mul_add, gpow_add, ihn])
(λ n ihn, by simp only [mul_sub, gpow_sub, ihn, mul_one, gpow_one])
theorem gsmul_mul' : ∀ (a : A) (m n : ℤ), (m * n) • a = n • (m • a) :=
@gpow_mul (multiplicative A) _
theorem gpow_mul' (a : G) (m n : ℤ) : a ^ (m * n) = (a ^ n) ^ m :=
by rw [mul_comm, gpow_mul]
theorem mul_gsmul (a : A) (m n : ℤ) : (m * n) • a = m • (n • a) :=
by rw [mul_comm, gsmul_mul']
theorem gpow_bit0 (a : G) (n : ℤ) : a ^ bit0 n = a ^ n * a ^ n := gpow_add _ _ _
theorem bit0_gsmul (a : A) (n : ℤ) : bit0 n • a = n • a + n • a :=
@gpow_bit0 (multiplicative A) _ _ _
theorem gpow_bit1 (a : G) (n : ℤ) : a ^ bit1 n = a ^ n * a ^ n * a :=
by rw [bit1, gpow_add, gpow_bit0, gpow_one]
theorem bit1_gsmul : ∀ (a : A) (n : ℤ), bit1 n • a = n • a + n • a + a :=
@gpow_bit1 (multiplicative A) _
@[simp] theorem monoid_hom.map_gpow (f : G →* H) (a : G) (n : ℤ) : f (a ^ n) = f a ^ n :=
by cases n; simp
@[simp] theorem add_monoid_hom.map_gsmul (f : A →+ B) (a : A) (n : ℤ) : f (n • a) = n • f a :=
f.to_multiplicative.map_gpow a n
@[simp, norm_cast] lemma units.coe_gpow (u : units G) (n : ℤ) : ((u ^ n : units G) : G) = u ^ n :=
(units.coe_hom G).map_gpow u n
end group
section ordered_add_comm_group
variables [ordered_add_comm_group A]
/-! Lemmas about `gsmul` under ordering, placed here (rather than in `algebra.group_power.order`
with their friends) because they require facts from `data.int.basic`-/
open int
lemma gsmul_pos {a : A} (ha : 0 < a) {k : ℤ} (hk : (0:ℤ) < k) : 0 < k • a :=
begin
lift k to ℕ using int.le_of_lt hk,
rw gsmul_coe_nat,
apply nsmul_pos ha,
exact coe_nat_pos.mp hk,
end
theorem gsmul_le_gsmul {a : A} {n m : ℤ} (ha : 0 ≤ a) (h : n ≤ m) : n • a ≤ m • a :=
calc n • a = n • a + 0 : (add_zero _).symm
... ≤ n • a + (m - n) • a : add_le_add_left (gsmul_nonneg ha (sub_nonneg.mpr h)) _
... = m • a : by { rw [← add_gsmul], simp }
theorem gsmul_lt_gsmul {a : A} {n m : ℤ} (ha : 0 < a) (h : n < m) : n • a < m • a :=
calc n • a = n • a + 0 : (add_zero _).symm
... < n • a + (m - n) • a : add_lt_add_left (gsmul_pos ha (sub_pos.mpr h)) _
... = m • a : by { rw [← add_gsmul], simp }
lemma abs_nsmul {α : Type*} [linear_ordered_add_comm_group α] (n : ℕ) (a : α) :
abs (n • a) = n • abs a :=
begin
cases le_total a 0 with hneg hpos,
{ rw [abs_of_nonpos hneg, ← abs_neg, ← neg_nsmul, abs_of_nonneg],
exact nsmul_nonneg (neg_nonneg.mpr hneg) n },
{ rw [abs_of_nonneg hpos, abs_of_nonneg],
exact nsmul_nonneg hpos n }
end
lemma abs_gsmul {α : Type*} [linear_ordered_add_comm_group α] (n : ℤ) (a : α) :
abs (n • a) = (abs n) • abs a :=
begin
by_cases n0 : 0 ≤ n,
{ lift n to ℕ using n0,
simp only [abs_nsmul, coe_nat_abs, gsmul_coe_nat] },
{ lift (- n) to ℕ using int.le_of_lt (neg_pos.mpr (not_le.mp n0)) with m h,
rw [← abs_neg (n • a), ← neg_gsmul, ← abs_neg n, ← h, gsmul_coe_nat, coe_nat_abs,
gsmul_coe_nat],
exact abs_nsmul m _ },
end
lemma abs_add_eq_add_abs_le {α : Type*} [linear_ordered_add_comm_group α] {a b : α} (hle : a ≤ b) :
abs (a + b) = abs a + abs b ↔ (0 ≤ a ∧ 0 ≤ b ∨ a ≤ 0 ∧ b ≤ 0) :=
begin
by_cases a0 : 0 ≤ a; by_cases b0 : 0 ≤ b,
{ simp [a0, b0, abs_of_nonneg, add_nonneg a0 b0] },
{ exact (lt_irrefl (0 : α) (a0.trans_lt (hle.trans_lt (not_le.mp b0)))).elim },
any_goals { simp [(not_le.mp a0).le, (not_le.mp b0).le, abs_of_nonpos, add_nonpos, add_comm] },
obtain F := (not_le.mp a0),
have : (abs (a + b) = -a + b ↔ b ≤ 0) ↔ (abs (a + b) =
abs a + abs b ↔ 0 ≤ a ∧ 0 ≤ b ∨ a ≤ 0 ∧ b ≤ 0),
{ simp [a0, b0, abs_of_neg, abs_of_nonneg, F, F.le] },
refine this.mp ⟨λ h, _, λ h, by simp only [le_antisymm h b0, abs_of_neg F, add_zero]⟩,
by_cases ba : a + b ≤ 0,
{ refine le_of_eq (eq_zero_of_neg_eq _),
rwa [abs_of_nonpos ba, neg_add_rev, add_comm, add_right_inj] at h },
{ refine (lt_irrefl (0 : α) _).elim,
rw [abs_of_pos (not_le.mp ba), add_left_inj] at h,
rwa eq_zero_of_neg_eq h.symm at F }
end
lemma abs_add_eq_add_abs_iff {α : Type*} [linear_ordered_add_comm_group α] (a b : α) :
abs (a + b) = abs a + abs b ↔ (0 ≤ a ∧ 0 ≤ b ∨ a ≤ 0 ∧ b ≤ 0) :=
begin
by_cases ab : a ≤ b,
{ exact abs_add_eq_add_abs_le ab },
{ rw [add_comm a, add_comm (abs _), abs_add_eq_add_abs_le ((not_le.mp ab).le), and.comm,
@and.comm (b ≤ 0 ) _] }
end
end ordered_add_comm_group
section linear_ordered_add_comm_group
variable [linear_ordered_add_comm_group A]
theorem gsmul_le_gsmul_iff {a : A} {n m : ℤ} (ha : 0 < a) : n • a ≤ m • a ↔ n ≤ m :=
begin
refine ⟨λ h, _, gsmul_le_gsmul $ le_of_lt ha⟩,
by_contra H,
exact lt_irrefl _ (lt_of_lt_of_le (gsmul_lt_gsmul ha (not_le.mp H)) h)
end
theorem gsmul_lt_gsmul_iff {a : A} {n m : ℤ} (ha : 0 < a) : n • a < m • a ↔ n < m :=
begin
refine ⟨λ h, _, gsmul_lt_gsmul ha⟩,
by_contra H,
exact lt_irrefl _ (lt_of_le_of_lt (gsmul_le_gsmul (le_of_lt ha) $ not_lt.mp H) h)
end
theorem nsmul_le_nsmul_iff {a : A} {n m : ℕ} (ha : 0 < a) : n • a ≤ m • a ↔ n ≤ m :=
begin
refine ⟨λ h, _, nsmul_le_nsmul $ le_of_lt ha⟩,
by_contra H,
exact lt_irrefl _ (lt_of_lt_of_le (nsmul_lt_nsmul ha (not_le.mp H)) h)
end
theorem nsmul_lt_nsmul_iff {a : A} {n m : ℕ} (ha : 0 < a) : n • a < m • a ↔ n < m :=
begin
refine ⟨λ h, _, nsmul_lt_nsmul ha⟩,
by_contra H,
exact lt_irrefl _ (lt_of_le_of_lt (nsmul_le_nsmul (le_of_lt ha) $ not_lt.mp H) h)
end
end linear_ordered_add_comm_group
@[simp] lemma with_bot.coe_nsmul [add_monoid A] (a : A) (n : ℕ) :
((n • a : A) : with_bot A) = n • a :=
add_monoid_hom.map_nsmul ⟨(coe : A → with_bot A), with_bot.coe_zero, with_bot.coe_add⟩ a n
theorem nsmul_eq_mul' [semiring R] (a : R) (n : ℕ) : n • a = a * n :=
by induction n with n ih; [rw [zero_nsmul, nat.cast_zero, mul_zero],
rw [succ_nsmul', ih, nat.cast_succ, mul_add, mul_one]]
@[simp] theorem nsmul_eq_mul [semiring R] (n : ℕ) (a : R) : n • a = n * a :=
by rw [nsmul_eq_mul', (n.cast_commute a).eq]
theorem mul_nsmul_left [semiring R] (a b : R) (n : ℕ) : n • (a * b) = a * (n • b) :=
by rw [nsmul_eq_mul', nsmul_eq_mul', mul_assoc]
theorem mul_nsmul_assoc [semiring R] (a b : R) (n : ℕ) : n • (a * b) = n • a * b :=
by rw [nsmul_eq_mul, nsmul_eq_mul, mul_assoc]
@[simp, norm_cast] theorem nat.cast_pow [semiring R] (n m : ℕ) : (↑(n ^ m) : R) = ↑n ^ m :=
begin
induction m with m ih,
{ rw [pow_zero, pow_zero], exact nat.cast_one },
{ rw [pow_succ', pow_succ', nat.cast_mul, ih] }
end
@[simp, norm_cast] theorem int.coe_nat_pow (n m : ℕ) : ((n ^ m : ℕ) : ℤ) = n ^ m :=
by induction m with m ih; [exact int.coe_nat_one, rw [pow_succ', pow_succ', int.coe_nat_mul, ih]]
theorem int.nat_abs_pow (n : ℤ) (k : ℕ) : int.nat_abs (n ^ k) = (int.nat_abs n) ^ k :=
by induction k with k ih; [refl, rw [pow_succ', int.nat_abs_mul, pow_succ', ih]]
-- The next four lemmas allow us to replace multiplication by a numeral with a `gsmul` expression.
-- They are used by the `noncomm_ring` tactic, to normalise expressions before passing to `abel`.
lemma bit0_mul [ring R] {n r : R} : bit0 n * r = (2 : ℤ) • (n * r) :=
by { dsimp [bit0], rw [add_mul, add_gsmul, one_gsmul], }
lemma mul_bit0 [ring R] {n r : R} : r * bit0 n = (2 : ℤ) • (r * n) :=
by { dsimp [bit0], rw [mul_add, add_gsmul, one_gsmul], }
lemma bit1_mul [ring R] {n r : R} : bit1 n * r = (2 : ℤ) • (n * r) + r :=
by { dsimp [bit1], rw [add_mul, bit0_mul, one_mul], }
lemma mul_bit1 [ring R] {n r : R} : r * bit1 n = (2 : ℤ) • (r * n) + r :=
by { dsimp [bit1], rw [mul_add, mul_bit0, mul_one], }
@[simp] theorem gsmul_eq_mul [ring R] (a : R) : ∀ (n : ℤ), n • a = n * a
| (n : ℕ) := by { rw [gsmul_coe_nat, nsmul_eq_mul], refl }
| -[1+ n] := by simp [nat.cast_succ, neg_add_rev, int.cast_neg_succ_of_nat, add_mul]
theorem gsmul_eq_mul' [ring R] (a : R) (n : ℤ) : n • a = a * n :=
by rw [gsmul_eq_mul, (n.cast_commute a).eq]
theorem mul_gsmul_left [ring R] (a b : R) (n : ℤ) : n • (a * b) = a * (n • b) :=
by rw [gsmul_eq_mul', gsmul_eq_mul', mul_assoc]
theorem mul_gsmul_assoc [ring R] (a b : R) (n : ℤ) : n • (a * b) = n • a * b :=
by rw [gsmul_eq_mul, gsmul_eq_mul, mul_assoc]
lemma gsmul_int_int (a b : ℤ) : a • b = a * b := by simp
lemma gsmul_int_one (n : ℤ) : n • 1 = n := by simp
@[simp, norm_cast] theorem int.cast_pow [ring R] (n : ℤ) (m : ℕ) : (↑(n ^ m) : R) = ↑n ^ m :=
begin
induction m with m ih,
{ rw [pow_zero, pow_zero, int.cast_one] },
{ rw [pow_succ, pow_succ, int.cast_mul, ih] }
end
lemma neg_one_pow_eq_pow_mod_two [ring R] {n : ℕ} : (-1 : R) ^ n = (-1) ^ (n % 2) :=
by rw [← nat.mod_add_div n 2, pow_add, pow_mul]; simp [sq]
section ordered_semiring
variable [ordered_semiring R]
/-- Bernoulli's inequality. This version works for semirings but requires
additional hypotheses `0 ≤ a * a` and `0 ≤ (1 + a) * (1 + a)`. -/
theorem one_add_mul_le_pow' {a : R} (Hsq : 0 ≤ a * a) (Hsq' : 0 ≤ (1 + a) * (1 + a))
(H : 0 ≤ 2 + a) :
∀ (n : ℕ), 1 + (n : R) * a ≤ (1 + a) ^ n
| 0 := by simp
| 1 := by simp
| (n+2) :=
have 0 ≤ (n : R) * (a * a * (2 + a)) + a * a,
from add_nonneg (mul_nonneg n.cast_nonneg (mul_nonneg Hsq H)) Hsq,
calc 1 + (↑(n + 2) : R) * a ≤ 1 + ↑(n + 2) * a + (n * (a * a * (2 + a)) + a * a) :
(le_add_iff_nonneg_right _).2 this
... = (1 + a) * (1 + a) * (1 + n * a) :
by { simp [add_mul, mul_add, bit0, mul_assoc, (n.cast_commute (_ : R)).left_comm],
ac_refl }
... ≤ (1 + a) * (1 + a) * (1 + a)^n :
mul_le_mul_of_nonneg_left (one_add_mul_le_pow' n) Hsq'
... = (1 + a)^(n + 2) : by simp only [pow_succ, mul_assoc]
private lemma pow_lt_pow_of_lt_one_aux {a : R} (h : 0 < a) (ha : a < 1) (i : ℕ) :
∀ k : ℕ, a ^ (i + k + 1) < a ^ i
| 0 :=
begin
rw [←one_mul (a^i), add_zero, pow_succ],
exact mul_lt_mul ha (le_refl _) (pow_pos h _) zero_le_one
end
| (k+1) :=
begin
rw [←one_mul (a^i), pow_succ],
apply mul_lt_mul ha _ _ zero_le_one,
{ apply le_of_lt, apply pow_lt_pow_of_lt_one_aux },
{ show 0 < a ^ (i + (k + 1) + 0), apply pow_pos h }
end
private lemma pow_le_pow_of_le_one_aux {a : R} (h : 0 ≤ a) (ha : a ≤ 1) (i : ℕ) :
∀ k : ℕ, a ^ (i + k) ≤ a ^ i
| 0 := by simp
| (k+1) := by { rw [←add_assoc, ←one_mul (a^i), pow_succ],
exact mul_le_mul ha (pow_le_pow_of_le_one_aux _) (pow_nonneg h _) zero_le_one }
lemma pow_lt_pow_of_lt_one {a : R} (h : 0 < a) (ha : a < 1)
{i j : ℕ} (hij : i < j) : a ^ j < a ^ i :=
let ⟨k, hk⟩ := nat.exists_eq_add_of_lt hij in
by rw hk; exact pow_lt_pow_of_lt_one_aux h ha _ _
lemma pow_lt_pow_iff_of_lt_one {a : R} {n m : ℕ} (hpos : 0 < a) (h : a < 1) :
a ^ m < a ^ n ↔ n < m :=
begin
have : strict_mono (λ (n : order_dual ℕ), a ^ (id n : ℕ)) := λ m n, pow_lt_pow_of_lt_one hpos h,
exact this.lt_iff_lt
end
lemma pow_le_pow_of_le_one {a : R} (h : 0 ≤ a) (ha : a ≤ 1)
{i j : ℕ} (hij : i ≤ j) : a ^ j ≤ a ^ i :=
let ⟨k, hk⟩ := nat.exists_eq_add_of_le hij in
by rw hk; exact pow_le_pow_of_le_one_aux h ha _ _
lemma pow_le_one {x : R} : ∀ (n : ℕ) (h0 : 0 ≤ x) (h1 : x ≤ 1), x ^ n ≤ 1
| 0 h0 h1 := by rw [pow_zero]
| (n+1) h0 h1 := by { rw [pow_succ], exact mul_le_one h1 (pow_nonneg h0 _) (pow_le_one n h0 h1) }
end ordered_semiring
section linear_ordered_semiring
variables [linear_ordered_semiring R]
lemma sign_cases_of_C_mul_pow_nonneg {C r : R} (h : ∀ n : ℕ, 0 ≤ C * r ^ n) :
C = 0 ∨ (0 < C ∧ 0 ≤ r) :=
begin
have : 0 ≤ C, by simpa only [pow_zero, mul_one] using h 0,
refine this.eq_or_lt.elim (λ h, or.inl h.symm) (λ hC, or.inr ⟨hC, _⟩),
refine nonneg_of_mul_nonneg_left _ hC,
simpa only [pow_one] using h 1
end
end linear_ordered_semiring
section linear_ordered_ring
variables [linear_ordered_ring R] {a : R} {n : ℕ}
@[simp] lemma abs_pow (a : R) (n : ℕ) : abs (a ^ n) = abs a ^ n :=
(pow_abs a n).symm
@[simp] theorem pow_bit1_neg_iff : a ^ bit1 n < 0 ↔ a < 0 :=
⟨λ h, not_le.1 $ λ h', not_le.2 h $ pow_nonneg h' _,
λ h, by { rw [bit1, pow_succ], exact mul_neg_of_neg_of_pos h (pow_bit0_pos h.ne _)}⟩
@[simp] theorem pow_bit1_nonneg_iff : 0 ≤ a ^ bit1 n ↔ 0 ≤ a :=
le_iff_le_iff_lt_iff_lt.2 pow_bit1_neg_iff
@[simp] theorem pow_bit1_nonpos_iff : a ^ bit1 n ≤ 0 ↔ a ≤ 0 :=
by simp only [le_iff_lt_or_eq, pow_bit1_neg_iff, pow_eq_zero_iff (bit1_pos (zero_le n))]
@[simp] theorem pow_bit1_pos_iff : 0 < a ^ bit1 n ↔ 0 < a :=
lt_iff_lt_of_le_iff_le pow_bit1_nonpos_iff
theorem pow_even_nonneg (a : R) (hn : even n) : 0 ≤ a ^ n :=
by cases hn with k hk; simpa only [hk, two_mul] using pow_bit0_nonneg a k
theorem pow_even_pos (ha : a ≠ 0) (hn : even n) : 0 < a ^ n :=
by cases hn with k hk; simpa only [hk, two_mul] using pow_bit0_pos ha k
theorem pow_odd_nonneg (ha : 0 ≤ a) (hn : odd n) : 0 ≤ a ^ n :=
by cases hn with k hk; simpa only [hk, two_mul] using pow_bit1_nonneg_iff.mpr ha
theorem pow_odd_pos (ha : 0 < a) (hn : odd n) : 0 < a ^ n :=
by cases hn with k hk; simpa only [hk, two_mul] using pow_bit1_pos_iff.mpr ha
theorem pow_odd_nonpos (ha : a ≤ 0) (hn : odd n) : a ^ n ≤ 0:=
by cases hn with k hk; simpa only [hk, two_mul] using pow_bit1_nonpos_iff.mpr ha
theorem pow_odd_neg (ha : a < 0) (hn : odd n) : a ^ n < 0:=
by cases hn with k hk; simpa only [hk, two_mul] using pow_bit1_neg_iff.mpr ha
lemma pow_even_abs (a : R) {p : ℕ} (hp : even p) :
abs a ^ p = a ^ p :=
begin
rw [←abs_pow, abs_eq_self],
exact pow_even_nonneg _ hp
end
@[simp] lemma pow_bit0_abs (a : R) (p : ℕ) :
abs a ^ bit0 p = a ^ bit0 p :=
pow_even_abs _ (even_bit0 _)
lemma strict_mono_pow_bit1 (n : ℕ) : strict_mono (λ a : R, a ^ bit1 n) :=
begin
intros a b hab,
cases le_total a 0 with ha ha,
{ cases le_or_lt b 0 with hb hb,
{ rw [← neg_lt_neg_iff, ← neg_pow_bit1, ← neg_pow_bit1],
exact pow_lt_pow_of_lt_left (neg_lt_neg hab) (neg_nonneg.2 hb) (bit1_pos (zero_le n)) },
{ exact (pow_bit1_nonpos_iff.2 ha).trans_lt (pow_bit1_pos_iff.2 hb) } },
{ exact pow_lt_pow_of_lt_left hab ha (bit1_pos (zero_le n)) }
end
/-- Bernoulli's inequality for `n : ℕ`, `-2 ≤ a`. -/
theorem one_add_mul_le_pow (H : -2 ≤ a) (n : ℕ) : 1 + (n : R) * a ≤ (1 + a) ^ n :=
one_add_mul_le_pow' (mul_self_nonneg _) (mul_self_nonneg _) (neg_le_iff_add_nonneg'.1 H) _
/-- Bernoulli's inequality reformulated to estimate `a^n`. -/
theorem one_add_mul_sub_le_pow (H : -1 ≤ a) (n : ℕ) : 1 + (n : R) * (a - 1) ≤ a ^ n :=
have -2 ≤ a - 1, by rwa [bit0, neg_add, ← sub_eq_add_neg, sub_le_sub_iff_right],
by simpa only [add_sub_cancel'_right] using one_add_mul_le_pow this n
end linear_ordered_ring
/-- Bernoulli's inequality reformulated to estimate `(n : K)`. -/
theorem nat.cast_le_pow_sub_div_sub {K : Type*} [linear_ordered_field K] {a : K} (H : 1 < a)
(n : ℕ) :
(n : K) ≤ (a ^ n - 1) / (a - 1) :=
(le_div_iff (sub_pos.2 H)).2 $ le_sub_left_of_add_le $
one_add_mul_sub_le_pow ((neg_le_self $ @zero_le_one K _).trans H.le) _
/-- For any `a > 1` and a natural `n` we have `n ≤ a ^ n / (a - 1)`. See also
`nat.cast_le_pow_sub_div_sub` for a stronger inequality with `a ^ n - 1` in the numerator. -/
theorem nat.cast_le_pow_div_sub {K : Type*} [linear_ordered_field K] {a : K} (H : 1 < a) (n : ℕ) :
(n : K) ≤ a ^ n / (a - 1) :=
(n.cast_le_pow_sub_div_sub H).trans $ div_le_div_of_le (sub_nonneg.2 H.le)
(sub_le_self _ zero_le_one)
namespace int
lemma units_sq (u : units ℤ) : u ^ 2 = 1 :=
(sq u).symm ▸ units_mul_self u
alias int.units_sq ← int.units_pow_two
lemma units_pow_eq_pow_mod_two (u : units ℤ) (n : ℕ) : u ^ n = u ^ (n % 2) :=
by conv {to_lhs, rw ← nat.mod_add_div n 2}; rw [pow_add, pow_mul, units_sq, one_pow, mul_one]
@[simp] lemma nat_abs_sq (x : ℤ) : (x.nat_abs ^ 2 : ℤ) = x ^ 2 :=
by rw [sq, int.nat_abs_mul_self', sq]
alias int.nat_abs_sq ← int.nat_abs_pow_two
lemma abs_le_self_sq (a : ℤ) : (int.nat_abs a : ℤ) ≤ a ^ 2 :=
by { rw [← int.nat_abs_sq a, sq], norm_cast, apply nat.le_mul_self }
alias int.abs_le_self_sq ← int.abs_le_self_pow_two
lemma le_self_sq (b : ℤ) : b ≤ b ^ 2 := le_trans (le_nat_abs) (abs_le_self_sq _)
alias int.le_self_sq ← int.le_self_pow_two
end int
variables (M G A)
/-- Monoid homomorphisms from `multiplicative ℕ` are defined by the image
of `multiplicative.of_add 1`. -/
def powers_hom [monoid M] : M ≃ (multiplicative ℕ →* M) :=
{ to_fun := λ x, ⟨λ n, x ^ n.to_add, by { convert pow_zero x, exact to_add_one },
λ m n, pow_add x m n⟩,
inv_fun := λ f, f (multiplicative.of_add 1),
left_inv := pow_one,
right_inv := λ f, monoid_hom.ext $ λ n, by { simp [← f.map_pow, ← of_add_nsmul] } }
/-- Monoid homomorphisms from `multiplicative ℤ` are defined by the image
of `multiplicative.of_add 1`. -/
def gpowers_hom [group G] : G ≃ (multiplicative ℤ →* G) :=
{ to_fun := λ x, ⟨λ n, x ^ n.to_add, gpow_zero x, λ m n, gpow_add x m n⟩,
inv_fun := λ f, f (multiplicative.of_add 1),
left_inv := gpow_one,
right_inv := λ f, monoid_hom.ext $ λ n, by { simp [← f.map_gpow, ← of_add_gsmul ] } }
/-- Additive homomorphisms from `ℕ` are defined by the image of `1`. -/
def multiples_hom [add_monoid A] : A ≃ (ℕ →+ A) :=
{ to_fun := λ x, ⟨λ n, n • x, zero_nsmul x, λ m n, add_nsmul _ _ _⟩,
inv_fun := λ f, f 1,
left_inv := one_nsmul,
right_inv := λ f, add_monoid_hom.ext_nat $ one_nsmul (f 1) }
/-- Additive homomorphisms from `ℤ` are defined by the image of `1`. -/
def gmultiples_hom [add_group A] : A ≃ (ℤ →+ A) :=
{ to_fun := λ x, ⟨λ n, n • x, zero_gsmul x, λ m n, add_gsmul _ _ _⟩,
inv_fun := λ f, f 1,
left_inv := one_gsmul,
right_inv := λ f, add_monoid_hom.ext_int $ one_gsmul (f 1) }
variables {M G A}
@[simp] lemma powers_hom_apply [monoid M] (x : M) (n : multiplicative ℕ) :
powers_hom M x n = x ^ n.to_add := rfl
@[simp] lemma powers_hom_symm_apply [monoid M] (f : multiplicative ℕ →* M) :
(powers_hom M).symm f = f (multiplicative.of_add 1) := rfl
@[simp] lemma gpowers_hom_apply [group G] (x : G) (n : multiplicative ℤ) :
gpowers_hom G x n = x ^ n.to_add := rfl
@[simp] lemma gpowers_hom_symm_apply [group G] (f : multiplicative ℤ →* G) :
(gpowers_hom G).symm f = f (multiplicative.of_add 1) := rfl
@[simp] lemma multiples_hom_apply [add_monoid A] (x : A) (n : ℕ) :
multiples_hom A x n = n • x := rfl
@[simp] lemma multiples_hom_symm_apply [add_monoid A] (f : ℕ →+ A) :
(multiples_hom A).symm f = f 1 := rfl
@[simp] lemma gmultiples_hom_apply [add_group A] (x : A) (n : ℤ) :
gmultiples_hom A x n = n • x := rfl
@[simp] lemma gmultiples_hom_symm_apply [add_group A] (f : ℤ →+ A) :
(gmultiples_hom A).symm f = f 1 := rfl
lemma monoid_hom.apply_mnat [monoid M] (f : multiplicative ℕ →* M) (n : multiplicative ℕ) :
f n = (f (multiplicative.of_add 1)) ^ n.to_add :=
by rw [← powers_hom_symm_apply, ← powers_hom_apply, equiv.apply_symm_apply]
@[ext] lemma monoid_hom.ext_mnat [monoid M] ⦃f g : multiplicative ℕ →* M⦄
(h : f (multiplicative.of_add 1) = g (multiplicative.of_add 1)) : f = g :=
monoid_hom.ext $ λ n, by rw [f.apply_mnat, g.apply_mnat, h]
lemma monoid_hom.apply_mint [group M] (f : multiplicative ℤ →* M) (n : multiplicative ℤ) :
f n = (f (multiplicative.of_add 1)) ^ n.to_add :=
by rw [← gpowers_hom_symm_apply, ← gpowers_hom_apply, equiv.apply_symm_apply]
/-! `monoid_hom.ext_mint` is defined in `data.int.cast` -/
lemma add_monoid_hom.apply_nat [add_monoid M] (f : ℕ →+ M) (n : ℕ) :
f n = n • (f 1) :=
by rw [← multiples_hom_symm_apply, ← multiples_hom_apply, equiv.apply_symm_apply]
/-! `add_monoid_hom.ext_nat` is defined in `data.nat.cast` -/
lemma add_monoid_hom.apply_int [add_group M] (f : ℤ →+ M) (n : ℤ) :
f n = n • (f 1) :=
by rw [← gmultiples_hom_symm_apply, ← gmultiples_hom_apply, equiv.apply_symm_apply]
/-! `add_monoid_hom.ext_int` is defined in `data.int.cast` -/
variables (M G A)
/-- If `M` is commutative, `powers_hom` is a multiplicative equivalence. -/
def powers_mul_hom [comm_monoid M] : M ≃* (multiplicative ℕ →* M) :=
{ map_mul' := λ a b, monoid_hom.ext $ by simp [mul_pow],
..powers_hom M}
/-- If `M` is commutative, `gpowers_hom` is a multiplicative equivalence. -/
def gpowers_mul_hom [comm_group G] : G ≃* (multiplicative ℤ →* G) :=
{ map_mul' := λ a b, monoid_hom.ext $ by simp [mul_gpow],
..gpowers_hom G}
/-- If `M` is commutative, `multiples_hom` is an additive equivalence. -/
def multiples_add_hom [add_comm_monoid A] : A ≃+ (ℕ →+ A) :=
{ map_add' := λ a b, add_monoid_hom.ext $ by simp [nsmul_add],
..multiples_hom A}
/-- If `M` is commutative, `gmultiples_hom` is an additive equivalence. -/
def gmultiples_add_hom [add_comm_group A] : A ≃+ (ℤ →+ A) :=
{ map_add' := λ a b, add_monoid_hom.ext $ by simp [gsmul_add],
..gmultiples_hom A}
variables {M G A}
@[simp] lemma powers_mul_hom_apply [comm_monoid M] (x : M) (n : multiplicative ℕ) :
powers_mul_hom M x n = x ^ n.to_add := rfl
@[simp] lemma powers_mul_hom_symm_apply [comm_monoid M] (f : multiplicative ℕ →* M) :
(powers_mul_hom M).symm f = f (multiplicative.of_add 1) := rfl
@[simp] lemma gpowers_mul_hom_apply [comm_group G] (x : G) (n : multiplicative ℤ) :
gpowers_mul_hom G x n = x ^ n.to_add := rfl
@[simp] lemma gpowers_mul_hom_symm_apply [comm_group G] (f : multiplicative ℤ →* G) :
(gpowers_mul_hom G).symm f = f (multiplicative.of_add 1) := rfl
@[simp] lemma multiples_add_hom_apply [add_comm_monoid A] (x : A) (n : ℕ) :
multiples_add_hom A x n = n • x := rfl
@[simp] lemma multiples_add_hom_symm_apply [add_comm_monoid A] (f : ℕ →+ A) :
(multiples_add_hom A).symm f = f 1 := rfl
@[simp] lemma gmultiples_add_hom_apply [add_comm_group A] (x : A) (n : ℤ) :
gmultiples_add_hom A x n = n • x := rfl
@[simp] lemma gmultiples_add_hom_symm_apply [add_comm_group A] (f : ℤ →+ A) :
(gmultiples_add_hom A).symm f = f 1 := rfl
/-!
### Commutativity (again)
Facts about `semiconj_by` and `commute` that require `gpow` or `gsmul`, or the fact that integer
multiplication equals semiring multiplication.
-/
namespace semiconj_by
section
variables [semiring R] {a x y : R}
@[simp] lemma cast_nat_mul_right (h : semiconj_by a x y) (n : ℕ) :
semiconj_by a ((n : R) * x) (n * y) :=
semiconj_by.mul_right (nat.commute_cast _ _) h
@[simp] lemma cast_nat_mul_left (h : semiconj_by a x y) (n : ℕ) : semiconj_by ((n : R) * a) x y :=
semiconj_by.mul_left (nat.cast_commute _ _) h
@[simp] lemma cast_nat_mul_cast_nat_mul (h : semiconj_by a x y) (m n : ℕ) :
semiconj_by ((m : R) * a) (n * x) (n * y) :=
(h.cast_nat_mul_left m).cast_nat_mul_right n
end
variables [monoid M] [group G] [ring R]
@[simp] lemma units_gpow_right {a : M} {x y : units M} (h : semiconj_by a x y) :
∀ m : ℤ, semiconj_by a (↑(x^m)) (↑(y^m))
| (n : ℕ) := by simp only [gpow_coe_nat, units.coe_pow, h, pow_right]
| -[1+n] := by simp only [gpow_neg_succ_of_nat, units.coe_pow, units_inv_right, h, pow_right]
variables {a b x y x' y' : R}
@[simp] lemma cast_int_mul_right (h : semiconj_by a x y) (m : ℤ) :
semiconj_by a ((m : ℤ) * x) (m * y) :=
semiconj_by.mul_right (int.commute_cast _ _) h
@[simp] lemma cast_int_mul_left (h : semiconj_by a x y) (m : ℤ) : semiconj_by ((m : R) * a) x y :=
semiconj_by.mul_left (int.cast_commute _ _) h
@[simp] lemma cast_int_mul_cast_int_mul (h : semiconj_by a x y) (m n : ℤ) :
semiconj_by ((m : R) * a) (n * x) (n * y) :=
(h.cast_int_mul_left m).cast_int_mul_right n
end semiconj_by
namespace commute
section
variables [semiring R] {a b : R}
@[simp] theorem cast_nat_mul_right (h : commute a b) (n : ℕ) : commute a ((n : R) * b) :=
h.cast_nat_mul_right n
@[simp] theorem cast_nat_mul_left (h : commute a b) (n : ℕ) : commute ((n : R) * a) b :=
h.cast_nat_mul_left n
@[simp] theorem cast_nat_mul_cast_nat_mul (h : commute a b) (m n : ℕ) :
commute ((m : R) * a) (n * b) :=
h.cast_nat_mul_cast_nat_mul m n
@[simp] theorem self_cast_nat_mul (n : ℕ) : commute a (n * a) :=
(commute.refl a).cast_nat_mul_right n
@[simp] theorem cast_nat_mul_self (n : ℕ) : commute ((n : R) * a) a :=
(commute.refl a).cast_nat_mul_left n
@[simp] theorem self_cast_nat_mul_cast_nat_mul (m n : ℕ) : commute ((m : R) * a) (n * a) :=
(commute.refl a).cast_nat_mul_cast_nat_mul m n
end
variables [monoid M] [group G] [ring R]
@[simp] lemma units_gpow_right {a : M} {u : units M} (h : commute a u) (m : ℤ) :
commute a (↑(u^m)) :=
h.units_gpow_right m
@[simp] lemma units_gpow_left {u : units M} {a : M} (h : commute ↑u a) (m : ℤ) :
commute (↑(u^m)) a :=
(h.symm.units_gpow_right m).symm
variables {a b : R}
@[simp] lemma cast_int_mul_right (h : commute a b) (m : ℤ) : commute a (m * b) :=
h.cast_int_mul_right m
@[simp] lemma cast_int_mul_left (h : commute a b) (m : ℤ) : commute ((m : R) * a) b :=
h.cast_int_mul_left m
lemma cast_int_mul_cast_int_mul (h : commute a b) (m n : ℤ) : commute ((m : R) * a) (n * b) :=
h.cast_int_mul_cast_int_mul m n
variables (a) (m n : ℤ)
@[simp] theorem self_cast_int_mul : commute a (n * a) := (commute.refl a).cast_int_mul_right n
@[simp] theorem cast_int_mul_self : commute ((n : R) * a) a := (commute.refl a).cast_int_mul_left n
theorem self_cast_int_mul_cast_int_mul : commute ((m : R) * a) (n * a) :=
(commute.refl a).cast_int_mul_cast_int_mul m n
end commute
section multiplicative
open multiplicative
@[simp] lemma nat.to_add_pow (a : multiplicative ℕ) (b : ℕ) : to_add (a ^ b) = to_add a * b :=
begin
induction b with b ih,
{ erw [pow_zero, to_add_one, mul_zero] },
{ simp [*, pow_succ, add_comm, nat.mul_succ] }
end
@[simp] lemma nat.of_add_mul (a b : ℕ) : of_add (a * b) = of_add a ^ b :=
(nat.to_add_pow _ _).symm
@[simp] lemma int.to_add_pow (a : multiplicative ℤ) (b : ℕ) : to_add (a ^ b) = to_add a * b :=
by induction b; simp [*, mul_add, pow_succ, add_comm]
@[simp] lemma int.to_add_gpow (a : multiplicative ℤ) (b : ℤ) : to_add (a ^ b) = to_add a * b :=
int.induction_on b (by simp)
(by simp [gpow_add, mul_add] {contextual := tt})
(by simp [gpow_add, mul_add, sub_eq_add_neg, -int.add_neg_one] {contextual := tt})
@[simp] lemma int.of_add_mul (a b : ℤ) : of_add (a * b) = of_add a ^ b :=
(int.to_add_gpow _ _).symm
end multiplicative
namespace units
variables [monoid M]
lemma conj_pow (u : units M) (x : M) (n : ℕ) : (↑u * x * ↑(u⁻¹))^n = u * x^n * ↑(u⁻¹) :=
(divp_eq_iff_mul_eq.2 ((u.mk_semiconj_by x).pow_right n).eq.symm).symm
lemma conj_pow' (u : units M) (x : M) (n : ℕ) : (↑(u⁻¹) * x * u)^n = ↑(u⁻¹) * x^n * u:=
(u⁻¹).conj_pow x n
open opposite
/-- Moving to the opposite monoid commutes with taking powers. -/
@[simp] lemma op_pow (x : M) (n : ℕ) : op (x ^ n) = (op x) ^ n :=
begin
induction n with n h,
{ simp },
{ rw [pow_succ', op_mul, h, pow_succ] }
end
@[simp] lemma unop_pow (x : Mᵒᵖ) (n : ℕ) : unop (x ^ n) = (unop x) ^ n :=
begin
induction n with n h,
{ simp },
{ rw [pow_succ', unop_mul, h, pow_succ] }
end
end units
|
import Mathlib.Tactic.GuardGoalNums
example : true ∧ true := by
constructor
guard_goal_nums 2
all_goals {constructor}
example : (true ∧ true) ∧ (true ∧ true) := by
constructor <;> constructor
guard_goal_nums 4
all_goals {constructor}
|
theory deMorgan3
imports Main
begin
text\<open> Apply style \<close>
lemma lem_k_1 : " (\<not>p \<or> \<not>q)\<longrightarrow> \<not>(p \<and> q)"
apply (rule impI)
apply (erule disjE)
apply (rule notI)
apply (erule notE)
apply (erule conjE)
apply assumption
apply (rule notI)
apply (erule conjE)
apply (erule notE)
apply assumption
done
end |
myTestRule {
msifilesystem_rename( "/tmp/raw/tests", "/tmp/raw/", "/tmp/processed/" );
writeLine("stdout","done");
}
OUTPUT ruleExecOut
|
module MachineLearning.NeuralNetwork.TopologyTest
(
tests
)
where
import Test.Framework (testGroup)
import Test.Framework.Providers.HUnit
import Test.HUnit
import Test.HUnit.Approx
import Test.HUnit.Plus
import qualified Numeric.LinearAlgebra as LA
import MachineLearning.NeuralNetwork.Topology
import qualified MachineLearning.NeuralNetwork.TopologyMaker as TM
nnt = TM.makeTopology TM.ASigmoid TM.LLogistic 15 2 [10]
flattenTest = do
theta <- initializeThetaIO nnt
let theta' = flatten $ unflatten nnt theta
norm = LA.norm_2 (theta - theta')
assertApproxEqual "flatten" 1e-10 0 norm
tests = [ testGroup "flatten" [
testCase "flatten" flattenTest
]
]
|
Require Export SystemFR.Syntax.
Require Export SystemFR.Tactics.
Require Export SystemFR.ListSetLemmas.
Require Export SystemFR.AssocList.
Require Export SystemFR.ListUtils.
Require Export SystemFR.EqualWithRelation.
Require Export SystemFR.EquivalentWithRelation.
Require Import PeanoNat.
Open Scope list_scope.
Fixpoint idrel (l: list nat) :=
match l with
| nil => nil
| x :: xs => (x,x) :: idrel xs
end.
Lemma idrel_lookup:
forall l x,
x ∈ l ->
lookup PeanoNat.Nat.eq_dec (idrel l) x = Some x.
Proof.
induction l; steps.
Qed.
Lemma idrel_lookup_swap:
forall l x,
x ∈ l ->
lookup PeanoNat.Nat.eq_dec (swap (idrel l)) x = Some x.
Proof.
induction l; steps.
Qed.
Lemma equal_with_idrel:
forall t, equal_with_relation type_var (idrel (pfv t type_var)) t t.
Proof.
intros; apply equal_with_relation_refl2; steps;
eauto using idrel_lookup, idrel_lookup_swap.
Qed.
Lemma idrel_lookup_fail:
forall l x,
(x ∈ l -> False) ->
lookup PeanoNat.Nat.eq_dec (idrel l) x = None.
Proof.
induction l; steps.
Qed.
Lemma idrel_lookup_swap_fail:
forall l x,
(x ∈ l -> False) ->
lookup PeanoNat.Nat.eq_dec (swap (idrel l)) x = None.
Proof.
induction l; steps.
Qed.
Lemma support_idrel:
forall l, support (idrel l) = l.
Proof.
induction l; steps.
Qed.
Lemma range_idrel:
forall l, range (idrel l) = l.
Proof.
induction l; steps.
Qed.
Lemma support_swap:
forall l, support (swap l) = range l.
Proof.
induction l; steps.
Qed.
Lemma range_swap:
forall l, range (swap l) = support l.
Proof.
induction l; steps.
Qed.
Lemma equivalent_rc_refl:
forall rc, equivalent_rc rc rc.
Proof.
unfold equivalent_rc; steps.
Qed.
Lemma equivalent_with_idrel:
forall T (l: list nat) (x: nat) ρ t (equiv: T -> T -> Prop),
(x ∈ l -> False) ->
(forall v, equiv v v) ->
equivalent_with_relation (idrel l) ρ ((x,t) :: ρ) equiv.
Proof.
unfold equivalent_with_relation;
repeat step || t_lookup ||
rewrite support_idrel in * ||
rewrite support_swap in * ||
rewrite range_idrel in * ||
rewrite range_swap in * ||
(rewrite idrel_lookup in * by auto) ||
(rewrite idrel_lookup_swap_fail in * by auto) ||
apply equivalent_with_right.
Qed.
Lemma equivalent_with_idrel2:
forall T (l: list nat) (x: nat) ρ t (equiv: T -> T -> Prop),
(x ∈ l -> False) ->
(forall v, equiv v v) ->
equivalent_with_relation (idrel l) ((x,t) :: ρ) ρ equiv.
Proof.
unfold equivalent_with_relation;
repeat step || t_lookup ||
rewrite support_idrel in * ||
rewrite support_swap in * ||
rewrite range_idrel in * ||
rewrite range_swap in * ||
(rewrite idrel_lookup in * by auto) ||
(rewrite idrel_lookup_swap_fail in * by auto) ||
apply equivalent_with_left.
Qed.
Ltac t_idrel :=
rewrite support_idrel in * ||
rewrite support_swap in * ||
rewrite range_idrel in * ||
rewrite range_swap in * ||
(rewrite idrel_lookup in * by auto) ||
(rewrite idrel_lookup_swap_fail in * by auto).
Lemma equivalent_with_relation_permute:
forall T ρ1 ρ2 v M l (equiv: T -> T -> Prop),
~(M ∈ support ρ1) ->
(forall v, equiv v v) ->
equivalent_with_relation
((M, M) :: idrel l)
(ρ1 ++ (M, v) :: ρ2)
((M, v) :: ρ1 ++ ρ2)
equiv
.
Proof.
unfold equivalent_with_relation, equivalent_with;
repeat match goal with
| |- exists r, Some ?R = Some r /\ _ => exists R
| |- exists r, _ /\ equivalent_rc r ?R => exists R
| H: _ |- _ => rewrite lookup_remove2 in H by steps
| _ => rewrite lookup_remove2 by steps
| _ => step || t_lookup_rewrite || t_idrel || t_lookup || list_utils ||
rewrite obvious_lookup in * by steps ||
t_lookupor || t_lookup_same
end;
eauto.
Qed.
Lemma idrel_lookup2:
forall x y l eq_dec, lookup eq_dec (idrel l) x = Some y -> x = y /\ x ∈ l.
Proof.
induction l; repeat step || eapply_any || instantiate_any.
Qed.
Ltac t_idrel_lookup2 :=
match goal with
| H: lookup _ (idrel ?l) ?x = Some ?y |- _ => pose proof (idrel_lookup2 _ _ _ _ H); clear H
end.
Lemma swap_idrel:
forall l, swap (idrel l) = idrel l.
Proof.
induction l; steps.
Qed.
Lemma equivalent_with_relation_permute2:
forall T ρ1 ρ2 v X Y l (equiv: T -> T -> Prop),
~(X ∈ support ρ1) ->
(forall v, equiv v v) ->
equivalent_with_relation
((Y, X) :: idrel l)
((Y, v) :: ρ1 ++ ρ2)
(ρ1 ++ (X, v) :: ρ2)
equiv
.
Proof.
unfold equivalent_with_relation, equivalent_with;
repeat match goal with
| |- exists r, Some ?R = Some r /\ _ => exists R
| |- exists r, _ /\ equivalent_rc r ?R => exists R
| H: _ |- _ => rewrite lookup_remove2 in H by steps
| _ => rewrite lookup_remove2 by steps
| _ => step || t_lookup_rewrite || t_idrel || t_lookup || list_utils ||
rewrite obvious_lookup in * by steps ||
t_lookupor || t_lookup_same
end;
eauto.
Qed.
|
From Coq.Unicode Require Import Utf8.
From Coq.Lists Require Import List.
From Coq.Relations Require Import Relations.
From Coq.micromega Require Import Lia.
Class valid_language {expr : Type}
(is_val : expr → Prop)
(is_ectx : (expr → expr) → Prop)
(head_step : expr → expr → Prop) : Type :=
ValidLang {
is_val_no_head_step : ∀ v, is_val v → ∀ e', ¬ head_step v e';
is_val_under_ectx : ∀ e K , is_ectx K → is_val (K e) → is_val e;
is_ectx_id : is_ectx (λ e, e);
is_val_dec : ∀ e, is_val e ∨ ¬ is_val e;
ectx_head_step : ∀ K e e', is_ectx K → head_step (K e) e' → (∀ f, K f = f) ∨ is_val e;
ectx_inj : ∀ K e e', is_ectx K → K e = K e' → e = e';
ectx_compose : ∀ K K', is_ectx K → is_ectx K' → is_ectx (λ e, K (K' e));
ectxs_nesting : ∀ K e K' e',
is_ectx K →
is_ectx K' →
K e = K' e' →
¬ is_val e →
¬ is_val e' →
(∃ K'', is_ectx K'' ∧ ∀ f, K f = K' (K'' f)) ∨ (∃ K'', is_ectx K'' ∧ ∀ f, K' f = K (K'' f))
}.
Inductive step {expr is_val is_ectx head_step} `{@valid_language expr is_val is_ectx head_step} :
expr → expr → Prop :=
| Step K e1 e2 : is_ectx K → head_step e1 e2 → step (K e1) (K e2).
Definition steps {expr is_val is_ectx head_step} `{@valid_language expr is_val is_ectx head_step} :=
clos_refl_trans _ step.
Inductive nsteps {expr is_val is_ectx head_step} `{@valid_language expr is_val is_ectx head_step} :
nat → expr → expr → Prop :=
| NSO e : nsteps 0 e e
| NSS n e1 e2 e3 : step e1 e2 → nsteps n e2 e3 → nsteps (S n) e1 e3.
Definition det_head_step
{expr is_val is_ectx head_step} `{@valid_language expr is_val is_ectx head_step} e e' :=
head_step e e' ∧ ∀ e'', head_step e e'' → e'' = e'.
Definition det_step
{expr is_val is_ectx head_step} `{@valid_language expr is_val is_ectx head_step} e e' :=
step e e' ∧ ∀ e'', step e e'' → e'' = e'.
Section language.
Context {expr is_val is_ectx head_step} `{@valid_language expr is_val is_ectx head_step}.
Lemma nsteps_refl e : nsteps 0 e e.
Proof. constructor; fail. Qed.
Lemma step_nsteps e e' : step e e' → nsteps 1 e e'.
Proof. econstructor; [eassumption|econstructor]. Qed.
Lemma nsteps_trans n n' e e' e'' : nsteps n e e' → nsteps n' e' e'' → nsteps (n + n') e e''.
Proof.
induction 1; [trivial; fail|].
simpl.
econstructor; [eassumption|auto].
Qed.
Lemma nsteps_take_step n e e' e'' :
step e e' → nsteps n e' e'' → nsteps (S n) e e''.
Proof. intros ? ?; eapply (nsteps_trans 1); [apply step_nsteps|]; eauto. Qed.
Lemma steps_ind (P : expr → expr → Prop) :
(∀ e, P e e) →
(∀ e e' e'', step e e' → steps e' e'' → P e' e'' → P e e'') →
∀ e e', steps e e' → P e e'.
Proof.
intros Hrfl Hstp e e' Hsteps.
apply clos_rt_rt1n_iff in Hsteps.
induction Hsteps; [apply Hrfl|].
eapply Hstp; [eassumption|apply clos_rt_rt1n_iff; assumption|assumption].
Qed.
Lemma steps_refl e : steps e e.
Proof. constructor; fail. Qed.
Lemma step_steps e e' : step e e' → steps e e'.
Proof. constructor; assumption. Qed.
Lemma steps_trans e e' e'' : steps e e' → steps e' e'' → steps e e''.
Proof. econstructor; eauto; fail. Qed.
Lemma steps_nsteps e e' : steps e e' → ∃ n, nsteps n e e'.
Proof.
induction 1 as [| |? ? ? ? [n Hn] ? [k Hk]];
[eexists; eapply step_nsteps; assumption|exists 0; apply nsteps_refl|].
eexists (_ + _); eapply nsteps_trans; eauto.
Qed.
Lemma nsteps_steps n e e' : nsteps n e e' → steps e e'.
Proof.
induction 1; [econstructor; fail|eapply steps_trans; [apply step_steps; eassumption|trivial]].
Qed.
Lemma val_no_step e : is_val e → ∀ e', ¬ step e e'.
Proof.
intros He e' Hstp.
inversion Hstp as [K e1 e2 HK Hhs]; subst; clear Hstp.
apply is_val_under_ectx in He; [|assumption].
eapply is_val_no_head_step; eauto.
Qed.
Lemma val_steps_eq e e' : is_val e → steps e e' → e = e'.
Proof.
intros Hiv Hstps; revert Hiv.
pattern e; pattern e'.
match goal with
| |- (λ e', (λ e, ?P) _) _ => simpl; apply (steps_ind (λ e e', P))
end; [| |assumption]; clear e' e Hstps.
- trivial.
- intros ???????.
exfalso; eapply val_no_step; eauto.
Qed.
Lemma head_step_step e e' : head_step e e' → step e e'.
Proof. intros; eapply (Step (λ e, e)); [apply is_ectx_id|assumption]. Qed.
Lemma ectx_step e e' K : is_ectx K → step e e' → step (K e) (K e').
Proof.
intros ?; inversion 1 as [K' e1 e2]; subst.
eapply (Step (λ e, K (K' e))); [apply ectx_compose; assumption|assumption].
Qed.
Lemma ectx_steps e e' K : is_ectx K → steps e e' → steps (K e) (K e').
Proof.
intros HK Hstep.
pattern e; pattern e'.
match goal with
| |- (λ e2, (λ e1, ?P) _) _ => simpl; apply (steps_ind (λ e1 e2, P))
end; [| |assumption]; clear e e' Hstep.
- intros ?; apply steps_refl.
- intros e e' e'' Hstep Hsteps HKsteps.
eapply steps_trans; [apply step_steps, ectx_step|]; eassumption.
Qed.
Lemma steps_eq_or_step_iff e e' : steps e e' ↔ e = e' ∨ ∃ e'', step e e'' ∧ steps e'' e'.
Proof.
split.
- intros Hsteps; apply clos_rt_rt1n_iff in Hsteps.
inversion Hsteps as [|??? Hsteps']; [eauto; fail|].
apply clos_rt_rt1n_iff in Hsteps'; eauto.
- intros [->|[? [? ?]]]; apply clos_rt_rt1n_iff;
[constructor; fail|econstructor; [|apply clos_rt_rt1n_iff]]; eauto.
Qed.
Lemma step_under_ectx K e e' :
is_ectx K → step (K e) e' →
(is_val e) ∨ (∃ e'', step e e'' ∧ e' = K e'').
Proof.
intros HK Hstp.
destruct (is_val_dec e) as [Hiv|Hniv].
- auto.
- right.
inversion Hstp as [K' e1 e2 HK' Hhs HKe1e]; subst.
destruct (ectxs_nesting _ _ _ _ HK' HK HKe1e) as [[K'' [HK''1 HK''2]]|[K'' [HK''1 HK''2]]];
[intros ?; contradict Hhs; apply is_val_no_head_step; assumption|assumption| |].
+ rewrite HK''2 in HKe1e.
apply ectx_inj in HKe1e; [|assumption].
subst.
exists (K'' e2); rewrite HK''2; split; [|reflexivity].
constructor; trivial.
+ rewrite HK''2 in HKe1e.
apply ectx_inj in HKe1e; [|assumption].
subst.
pose proof Hhs as Hhs'.
apply ectx_head_step in Hhs as [Hhs|Hhs]; [|tauto|assumption].
rewrite Hhs in Hhs'.
exists e2; split; [apply head_step_step; assumption|].
rewrite HK''2, Hhs; trivial.
Qed.
Definition Safe (P : expr → Prop) (e : expr) :=
∀ e', steps e e' → (is_val e' ∧ P e') ∨ ∃ e'', step e' e''.
Lemma Safe_mono (P Q : expr → Prop) e : (∀ v, P v → Q v) → Safe P e → Safe Q e.
Proof. unfold Safe; firstorder. Qed.
Lemma Safe_val (P : expr → Prop) e : is_val e → P e → Safe P e.
Proof.
unfold Safe; intros He HPe e' Hstp.
left.
apply val_steps_eq in Hstp; subst; auto.
Qed.
Lemma Safe_val_inv (P : expr → Prop) e : is_val e → Safe P e → P e.
Proof.
unfold Safe; intros He HSf.
destruct (HSf e) as [|[e' He']]; [apply steps_refl|tauto|].
contradict He'; apply val_no_step; trivial.
Qed.
Lemma Safe_step (P : expr → Prop) e e' : step e e' → Safe P e → Safe P e'.
Proof.
intros Hstep HSf ei Hsteps.
apply HSf.
apply steps_eq_or_step_iff; eauto.
Qed.
Lemma det_head_step_det_step e e' : det_head_step e e' → det_step e e'.
Proof.
intros [Hhs Hdt]; split; [apply head_step_step; assumption|].
intros e'' Hstp.
inversion Hstp as [? ? ? ? Hhs']; subst.
apply ectx_head_step in Hhs as [Hid|Hvl]; [| |assumption].
- rewrite Hid; rewrite Hid in Hdt. apply Hdt; assumption.
- contradict Hhs'; apply is_val_no_head_step; trivial.
Qed.
Lemma Safe_det_step_back (P : expr → Prop) e e' : det_step e e' → Safe P e' → Safe P e.
Proof.
intros Hdstep HSf ei Hsteps.
apply steps_eq_or_step_iff in Hsteps as [->|(e'' & He''1 & He''2)].
- right; eexists; apply Hdstep.
- apply Hdstep in He''1; subst.
apply HSf; assumption.
Qed.
Lemma Safe_head_step_back (P : expr → Prop) e e' : det_head_step e e' → Safe P e' → Safe P e.
Proof.
intros.
eapply Safe_det_step_back; [apply det_head_step_det_step|]; eassumption.
Qed.
Lemma steps_under_ectx K e e' :
is_ectx K → steps (K e) e' →
(∃ e'', e' = K e'' ∧ steps e e'') ∨ ∃ v, is_val v ∧ steps e v ∧ steps (K v) e'.
Proof.
intros HK [n Hstps]%steps_nsteps.
revert e e' HK Hstps.
induction n; intros e e' HK Hstps.
- inversion Hstps; subst; left; eexists _; split; [eauto|apply steps_refl].
- inversion Hstps as [|? ? ex]; subst.
destruct (step_under_ectx K e ex) as [|(e'' & He''1 & He''2)];
[assumption|assumption| |subst].
+ right; eexists e; split; [assumption|].
split; [apply steps_refl|eapply nsteps_steps; eassumption].
+ destruct (IHn e'' e') as [(? & -> &?)|(?&?&?&?)]; [assumption|assumption| |].
* left; eexists; split; [reflexivity|eapply steps_trans; [apply step_steps|]; eauto].
* right; eexists _; split; [eassumption|].
split; [eapply steps_trans; [apply step_steps|]; eauto|assumption].
Qed.
Lemma Safe_bind (P Q : expr → Prop) e K :
is_ectx K → Safe P e → (∀ v, is_val v → P v → Safe Q (K v)) → Safe Q (K e).
Proof.
intros HK He HKSf e' Hstps.
apply steps_under_ectx in Hstps as [(e'' & -> & He'')|(v & Hv & Hv1 & Hv2)]; [| |assumption].
- apply He in He'' as [[Hie'' HPe'']|[e3 He3]].
+ eapply HKSf; [eassumption|eassumption|apply steps_refl].
+ right; eexists; apply ectx_step; eauto.
- apply He in Hv1 as [[]|[]]; [|exfalso; eapply val_no_step; eauto; fail].
eapply HKSf; [eassumption|assumption|assumption].
Qed.
Definition Normalizes (P : expr → Prop) (e : expr) := ∃ v, is_val v ∧ steps e v ∧ P v.
Lemma Normalizes_mono (P Q : expr → Prop) e : (∀ v, P v → Q v) → Normalizes P e → Normalizes Q e.
Proof. unfold Safe; firstorder. Qed.
Lemma Normalizes_val (P : expr → Prop) e : is_val e → P e → Normalizes P e.
Proof.
intros ? ?; eexists; repeat split; [eassumption|apply steps_refl|eassumption].
Qed.
Lemma Normalizses_val_inv (P : expr → Prop) e : is_val e → Normalizes P e → P e.
Proof.
intros Hiv (e' & He'1 & He'2 & He'3).
apply val_steps_eq in He'2; [subst; trivial|assumption].
Qed.
Lemma Normalizes_step_back (P : expr → Prop) e e' : step e e' → Normalizes P e' → Normalizes P e.
Proof.
intros Hstep (v & Hv1 & Hv2 & Hv3).
exists v; repeat split; [assumption| |assumption].
apply steps_eq_or_step_iff; eauto.
Qed.
Lemma Normalizes_head_step_back (P : expr → Prop) e e' :
head_step e e' → Normalizes P e' → Normalizes P e.
Proof.
intros Hstep (v & Hv1 & Hv2 & Hv3).
exists v; repeat split; [assumption| |assumption].
apply steps_eq_or_step_iff; eauto using head_step_step.
Qed.
Lemma Normalizes_det_step (P : expr → Prop) e e' :
det_step e e' → Normalizes P e → Normalizes P e'.
Proof.
intros Hdstep (v & Hv1 & Hv2 & Hv3).
exists v; repeat split; [assumption| |assumption].
apply steps_eq_or_step_iff in Hv2 as [->|(e'' & He''1 & He''2)].
- destruct Hdstep as [Hstp%val_no_step ?]; tauto.
- pose proof He''1 as ->%Hdstep; assumption.
Qed.
Lemma Normalizes_bind (P Q : expr → Prop) e K :
is_ectx K → Normalizes P e → (∀ v, is_val v → P v → Normalizes Q (K v)) → Normalizes Q (K e).
Proof.
intros HK He HKnrm.
destruct He as (v & Hv1 & Hv2 & Hv3).
destruct (HKnrm v) as (w & Hw1 & Hw2 & Hw3); [assumption|assumption|].
exists w; repeat split; [assumption| |assumption].
eapply steps_trans; [|eassumption].
apply ectx_steps; assumption.
Qed.
Lemma val_nsteps_eq n e e' : is_val e → nsteps n e e' → n = 0 ∧ e = e'.
Proof.
inversion 2; subst; [split; reflexivity|].
exfalso; eapply val_no_step; eauto.
Qed.
Lemma nsteps_eq_or_step_iff n e e' :
nsteps n e e' ↔ (n = 0 ∧ e = e') ∨ ∃ n' e'', n = S n' ∧ step e e'' ∧ nsteps n' e'' e'.
Proof.
split.
- intros Hsteps.
inversion Hsteps; subst.
+ left; auto.
+ right; eexists _, _; split; [reflexivity|]; split; [eassumption|eassumption].
- intros [[-> ->]|(?&?&->&?&?)]; [constructor|econstructor; eauto].
Qed.
Lemma ectx_nsteps n e e' K : is_ectx K → nsteps n e e' → nsteps n (K e) (K e').
Proof. induction 2; econstructor; eauto using ectx_step. Qed.
Definition SISafe (P : nat → expr → Prop) (n : nat) (e : expr) :=
∀ k e', k ≤ n → nsteps k e e' → (is_val e' ∧ P (n - k) e') ∨ ∃ e'', step e' e''.
Lemma SISafe_mono (P Q : nat → expr → Prop) n e :
(∀ n' v, n' ≤ n → P n' v → Q n' v) → SISafe P n e → SISafe Q n e.
Proof.
intros HPQ HSf ??? Hstps.
apply HSf in Hstps as [?|?]; [|auto; fail|lia].
left; split; [tauto|apply HPQ; [lia|tauto]].
Qed.
Lemma SISafe_down_closed (P : nat → expr → Prop) n n' e :
n' ≤ n → (∀ k k' e, k' ≤ k → k ≤ n → P k e → P k' e) → SISafe P n e → SISafe P n' e.
Proof.
intros Hle HP Hne z e' Hz Hnstps.
destruct (λ Hle, Hne z e' Hle Hnstps) as [[? ?]|]; [lia| |right; assumption].
left; split; [assumption|].
eapply HP; [| |eassumption]; [lia|lia].
Qed.
Lemma SISafe_down_closed' (P : nat → expr → Prop) n n' e :
¬ is_val e → n' ≤ n → (∀ k k' e, k' ≤ k → k < n → P k e → P k' e) → SISafe P n e → SISafe P n' e.
Proof.
intros Hniv Hle HP Hne z e' Hz Hnstps.
destruct (λ Hle, Hne z e' Hle Hnstps) as [[? ?]|]; [lia| |right; assumption].
inversion Hnstps; subst; [tauto|].
left; split; [assumption|].
eapply HP; [| |eassumption]; [lia|lia].
Qed.
Lemma SISafe_val (P : nat → expr → Prop) n e : is_val e → P n e → SISafe P n e.
Proof.
intros He HPe k e' Hk Hstp.
left.
apply val_nsteps_eq in Hstp as [? ?]; subst; [|assumption].
replace (n - 0) with n by lia; auto.
Qed.
Lemma SISafe_val_inv (P : nat → expr → Prop) n e : is_val e → SISafe P n e → P n e.
Proof.
unfold Safe; intros He HSf.
destruct (HSf 0 e) as [[Hiv HP]|[e' He']]; [lia|apply nsteps_refl| |].
- replace (n - 0) with n in HP by lia; trivial.
- contradict He'; apply val_no_step; trivial.
Qed.
Lemma SISafe_step (P : nat → expr → Prop) e e' n :
step e e' → SISafe P (S n) e → SISafe P n e'.
Proof.
intros Hstep HSf k ei Hk Hsteps.
apply (HSf (S k)); [lia|].
econstructor; eauto.
Qed.
Lemma SISafe_det_step_back (P : nat → expr → Prop) e e' n :
det_step e e' → (0 < n → SISafe P (n - 1) e') → SISafe P n e.
Proof.
intros Hdstep HSf k ei Hk Hsteps.
apply nsteps_eq_or_step_iff in Hsteps as [[-> ->]|(m & e'' & -> & He''1 & He''2)].
- right; eexists; apply Hdstep.
- apply Hdstep in He''1; subst.
destruct n as [|n]; [lia|].
pose proof (λ H, HSf H m ei) as HSf'. simpl in *.
replace (n - 0) with n in HSf' by lia.
apply HSf'; [lia|lia|assumption].
Qed.
Lemma SISafe_head_step_back (P : nat → expr → Prop) e e' n :
det_head_step e e' → (0 < n → SISafe P (n - 1) e') → SISafe P n e.
Proof.
intros.
eapply SISafe_det_step_back; [apply det_head_step_det_step|]; eassumption.
Qed.
Lemma nsteps_under_ectx n K e e' :
is_ectx K → nsteps n (K e) e' →
(∃ e'', e' = K e'' ∧ nsteps n e e'') ∨
∃ k v, k ≤ n ∧ is_val v ∧ nsteps k e v ∧ nsteps (n - k) (K v) e'.
Proof.
revert e e'.
induction n; intros e e' HK Hstps.
- inversion Hstps; subst; left; eexists _; split; [eauto|econstructor].
- inversion Hstps as [|? ? ex]; subst.
destruct (step_under_ectx K e ex) as [|(e'' & He''1 & He''2)];
[assumption|assumption| |subst].
+ right; eexists 0, e; split; [lia|split]; [assumption|].
split; [econstructor|].
rewrite PeanoNat.Nat.sub_0_r; trivial.
+ destruct (IHn e'' e') as [(? & -> &?)|(?&?&?&?&?&?)]; [assumption|assumption| |].
* left; eexists; split; [reflexivity|econstructor; eauto].
* right; eexists (S _), _; repeat split; [|eassumption| |eassumption]; [lia|].
econstructor; eauto.
Qed.
Lemma SISafe_bind (P Q : nat → expr → Prop) e K n :
is_ectx K →
SISafe P n e →
(∀ k v, k ≤ n → is_val v → P k v → SISafe Q k (K v)) →
SISafe Q n (K e).
Proof.
intros HK He HKSf k e' Hk Hstps.
apply nsteps_under_ectx in Hstps as [(e'' & -> & He'')|(m & ? & v & Hv & Hv1 & Hv2)];
[| |assumption].
- apply He in He'' as [[Hie'' HPe'']|[e3 He3]]; [| |lia].
+ apply HKSf in HPe''; [|lia|assumption].
pose proof (HPe'' 0) as HPe3.
replace (n - k - 0) with (n - k) in HPe3 by lia.
apply HPe3; [lia|]; apply nsteps_refl.
+ right; eexists; apply ectx_step; eauto.
- apply He in Hv1 as [[? HPkv]|[]]; [|exfalso; eapply val_no_step; eauto; fail|lia].
apply HKSf in HPkv; [|lia|assumption].
specialize (HPkv (k - m) e'); simpl in *.
replace (n - m - (k - m)) with (n - k) in HPkv by lia.
apply HPkv; [lia |assumption].
Qed.
Lemma SISafe_adequacy P e : (∀ n, SISafe (λ _ v, P v) n e) → Safe P e.
Proof.
intros HSI e' [n Hstps]%steps_nsteps.
eapply (HSI n); [|eassumption]; lia.
Qed.
End language.
|
lemmas linear_scaleR_left = linear_scale_left |
(** Proof that for every two-parameter uncurried function, there
exists an equivalent curried function *)
Definition curry (f : Type * Type -> Type) x y := f (x, y).
Theorem curry_exists :
forall (f : (Type * Type) -> Type) x y, exists g, f (x, y) = g x y.
Proof.
intros.
exists (curry f).
unfold curry.
reflexivity.
Qed.
|
------------------------------------------------------------------------
-- The Agda standard library
--
-- Basic definitions for morphisms between algebraic structures
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Relation.Binary.Core
module Algebra.Morphism.Definitions
{a} (A : Set a) -- The domain of the morphism
{b} (B : Set b) -- The codomain of the morphism
{ℓ} (_≈_ : Rel B ℓ) -- The equality relation over the codomain
where
open import Algebra.Core
open import Function.Core
------------------------------------------------------------------------
-- Basic definitions
Homomorphic₀ : (A → B) → A → B → Set _
Homomorphic₀ ⟦_⟧ ∙ ∘ = ⟦ ∙ ⟧ ≈ ∘
Homomorphic₁ : (A → B) → Op₁ A → Op₁ B → Set _
Homomorphic₁ ⟦_⟧ ∙_ ∘_ = ∀ x → ⟦ ∙ x ⟧ ≈ (∘ ⟦ x ⟧)
Homomorphic₂ : (A → B) → Op₂ A → Op₂ B → Set _
Homomorphic₂ ⟦_⟧ _∙_ _∘_ = ∀ x y → ⟦ x ∙ y ⟧ ≈ (⟦ x ⟧ ∘ ⟦ y ⟧)
------------------------------------------------------------------------
-- DEPRECATED NAMES
------------------------------------------------------------------------
-- Please use the new names as continuing support for the old names is
-- not guaranteed.
-- Version 1.3
Morphism : Set _
Morphism = A → B
{-# WARNING_ON_USAGE Morphism
"Warning: Morphism was deprecated in v1.3.
Please use the standard function notation (e.g. A → B) instead."
#-}
|
lemma snd_quot_of_fract_to_fract [simp]: "snd (quot_of_fract (to_fract x)) = 1" |
typealias IntegerVector{I<:Integer} Vector{I}
typealias RealVector{N<:Real} Vector{N}
typealias RealMatrix{N<:Real} Matrix{N}
typealias RealLowerTriangular{T<:Real, S<:AbstractMatrix} LowerTriangular{T, S}
multivecs{T}(::Type{T}, n::Int) = [T[] for _ =1:n]
|
open nat
example (P : ℕ → Prop) (h₀ : P 0) (h₁ : ∀ n, P (succ n)) (m : ℕ) :
P m :=
begin
cases m with m',
exact h₀,
exact h₁ m'
end
|
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : Discrete PUnit ⥤ C
⊢ ∀ ⦃X Y : Discrete PUnit⦄ (f : X ⟶ Y),
((const (Discrete PUnit)).obj (F.obj { as := PUnit.unit })).map f ≫
(fun x =>
match x with
| { as := PUnit.unit } =>
𝟙 (((const (Discrete PUnit)).obj (F.obj { as := PUnit.unit })).obj { as := PUnit.unit }))
Y =
(fun x =>
match x with
| { as := PUnit.unit } =>
𝟙 (((const (Discrete PUnit)).obj (F.obj { as := PUnit.unit })).obj { as := PUnit.unit }))
X ≫
F.map f
[PROOFSTEP]
intro X Y f
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : Discrete PUnit ⥤ C
X Y : Discrete PUnit
f : X ⟶ Y
⊢ ((const (Discrete PUnit)).obj (F.obj { as := PUnit.unit })).map f ≫
(fun x =>
match x with
| { as := PUnit.unit } =>
𝟙 (((const (Discrete PUnit)).obj (F.obj { as := PUnit.unit })).obj { as := PUnit.unit }))
Y =
(fun x =>
match x with
| { as := PUnit.unit } =>
𝟙 (((const (Discrete PUnit)).obj (F.obj { as := PUnit.unit })).obj { as := PUnit.unit }))
X ≫
F.map f
[PROOFSTEP]
match X, Y, f with
| .mk A, .mk B, .up g => aesop_cat
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : Discrete PUnit ⥤ C
X Y : Discrete PUnit
f : X ⟶ Y
A B : PUnit
g : PLift ({ as := A }.as = { as := B }.as)
⊢ ((const (Discrete PUnit)).obj (F.obj { as := PUnit.unit })).map { down := g } ≫
(fun x =>
match x with
| { as := PUnit.unit } =>
𝟙 (((const (Discrete PUnit)).obj (F.obj { as := PUnit.unit })).obj { as := PUnit.unit }))
{ as := B } =
(fun x =>
match x with
| { as := PUnit.unit } =>
𝟙 (((const (Discrete PUnit)).obj (F.obj { as := PUnit.unit })).obj { as := PUnit.unit }))
{ as := A } ≫
F.map { down := g }
[PROOFSTEP]
aesop_cat
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
c : Cone F
j j' : J
f : j ⟶ j'
⊢ NatTrans.app c.π j ≫ F.map f = NatTrans.app c.π j'
[PROOFSTEP]
rw [← c.π.naturality f]
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
c : Cone F
j j' : J
f : j ⟶ j'
⊢ ((const J).obj c.pt).map f ≫ NatTrans.app c.π j' = NatTrans.app c.π j'
[PROOFSTEP]
apply id_comp
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : Discrete PUnit ⥤ C
⊢ ∀ ⦃X Y : Discrete PUnit⦄ (f : X ⟶ Y),
F.map f ≫
(fun x =>
match x with
| { as := PUnit.unit } => 𝟙 (F.obj { as := PUnit.unit }))
Y =
(fun x =>
match x with
| { as := PUnit.unit } => 𝟙 (F.obj { as := PUnit.unit }))
X ≫
((const (Discrete PUnit)).obj (F.obj { as := PUnit.unit })).map f
[PROOFSTEP]
intro X Y f
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : Discrete PUnit ⥤ C
X Y : Discrete PUnit
f : X ⟶ Y
⊢ F.map f ≫
(fun x =>
match x with
| { as := PUnit.unit } => 𝟙 (F.obj { as := PUnit.unit }))
Y =
(fun x =>
match x with
| { as := PUnit.unit } => 𝟙 (F.obj { as := PUnit.unit }))
X ≫
((const (Discrete PUnit)).obj (F.obj { as := PUnit.unit })).map f
[PROOFSTEP]
match X, Y, f with
| .mk A, .mk B, .up g => aesop_cat
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : Discrete PUnit ⥤ C
X Y : Discrete PUnit
f : X ⟶ Y
A B : PUnit
g : PLift ({ as := A }.as = { as := B }.as)
⊢ F.map { down := g } ≫
(fun x =>
match x with
| { as := PUnit.unit } => 𝟙 (F.obj { as := PUnit.unit }))
{ as := B } =
(fun x =>
match x with
| { as := PUnit.unit } => 𝟙 (F.obj { as := PUnit.unit }))
{ as := A } ≫
((const (Discrete PUnit)).obj (F.obj { as := PUnit.unit })).map { down := g }
[PROOFSTEP]
aesop_cat
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
c : Cocone F
j j' : J
f : j ⟶ j'
⊢ F.map f ≫ NatTrans.app c.ι j' = NatTrans.app c.ι j
[PROOFSTEP]
rw [c.ι.naturality f]
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
c : Cocone F
j j' : J
f : j ⟶ j'
⊢ NatTrans.app c.ι j ≫ ((const J).obj c.pt).map f = NatTrans.app c.ι j
[PROOFSTEP]
apply comp_id
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F✝ F : J ⥤ C
⊢ ((fun c => { fst := op c.pt, snd := c.π }) ≫ fun c => { pt := c.fst.unop, π := c.snd }) = 𝟙 (Cone F)
[PROOFSTEP]
funext X
[GOAL]
case h
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F✝ F : J ⥤ C
X : Cone F
⊢ ((fun c => { fst := op c.pt, snd := c.π }) ≫ fun c => { pt := c.fst.unop, π := c.snd }) X = 𝟙 (Cone F) X
[PROOFSTEP]
cases X
[GOAL]
case h.mk
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F✝ F : J ⥤ C
pt✝ : C
π✝ : (const J).obj pt✝ ⟶ F
⊢ ((fun c => { fst := op c.pt, snd := c.π }) ≫ fun c => { pt := c.fst.unop, π := c.snd }) { pt := pt✝, π := π✝ } =
𝟙 (Cone F) { pt := pt✝, π := π✝ }
[PROOFSTEP]
rfl
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F✝ F : J ⥤ C
⊢ ((fun c => { pt := c.fst.unop, π := c.snd }) ≫ fun c => { fst := op c.pt, snd := c.π }) =
𝟙 ((X : Cᵒᵖ) × (Functor.cones F).obj X)
[PROOFSTEP]
funext X
[GOAL]
case h
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F✝ F : J ⥤ C
X : (X : Cᵒᵖ) × (Functor.cones F).obj X
⊢ ((fun c => { pt := c.fst.unop, π := c.snd }) ≫ fun c => { fst := op c.pt, snd := c.π }) X =
𝟙 ((X : Cᵒᵖ) × (Functor.cones F).obj X) X
[PROOFSTEP]
cases X
[GOAL]
case h.mk
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F✝ F : J ⥤ C
fst✝ : Cᵒᵖ
snd✝ : (Functor.cones F).obj fst✝
⊢ ((fun c => { pt := c.fst.unop, π := c.snd }) ≫ fun c => { fst := op c.pt, snd := c.π }) { fst := fst✝, snd := snd✝ } =
𝟙 ((X : Cᵒᵖ) × (Functor.cones F).obj X) { fst := fst✝, snd := snd✝ }
[PROOFSTEP]
rfl
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F✝ F : J ⥤ C
⊢ ((fun c => { fst := c.pt, snd := c.ι }) ≫ fun c => { pt := c.fst, ι := c.snd }) = 𝟙 (Cocone F)
[PROOFSTEP]
funext X
[GOAL]
case h
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F✝ F : J ⥤ C
X : Cocone F
⊢ ((fun c => { fst := c.pt, snd := c.ι }) ≫ fun c => { pt := c.fst, ι := c.snd }) X = 𝟙 (Cocone F) X
[PROOFSTEP]
cases X
[GOAL]
case h.mk
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F✝ F : J ⥤ C
pt✝ : C
ι✝ : F ⟶ (const J).obj pt✝
⊢ ((fun c => { fst := c.pt, snd := c.ι }) ≫ fun c => { pt := c.fst, ι := c.snd }) { pt := pt✝, ι := ι✝ } =
𝟙 (Cocone F) { pt := pt✝, ι := ι✝ }
[PROOFSTEP]
rfl
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F✝ F : J ⥤ C
⊢ ((fun c => { pt := c.fst, ι := c.snd }) ≫ fun c => { fst := c.pt, snd := c.ι }) =
𝟙 ((X : C) × (Functor.cocones F).obj X)
[PROOFSTEP]
funext X
[GOAL]
case h
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F✝ F : J ⥤ C
X : (X : C) × (Functor.cocones F).obj X
⊢ ((fun c => { pt := c.fst, ι := c.snd }) ≫ fun c => { fst := c.pt, snd := c.ι }) X =
𝟙 ((X : C) × (Functor.cocones F).obj X) X
[PROOFSTEP]
cases X
[GOAL]
case h.mk
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F✝ F : J ⥤ C
fst✝ : C
snd✝ : (Functor.cocones F).obj fst✝
⊢ ((fun c => { pt := c.fst, ι := c.snd }) ≫ fun c => { fst := c.pt, snd := c.ι }) { fst := fst✝, snd := snd✝ } =
𝟙 ((X : C) × (Functor.cocones F).obj X) { fst := fst✝, snd := snd✝ }
[PROOFSTEP]
rfl
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
c c' : Cone F
f g : c ⟶ c'
w : f.Hom = g.Hom
⊢ f = g
[PROOFSTEP]
cases f
[GOAL]
case mk
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
c c' : Cone F
g : c ⟶ c'
Hom✝ : c.pt ⟶ c'.pt
w✝ : ∀ (j : J), Hom✝ ≫ NatTrans.app c'.π j = NatTrans.app c.π j
w : (mk Hom✝).Hom = g.Hom
⊢ mk Hom✝ = g
[PROOFSTEP]
cases g
[GOAL]
case mk.mk
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
c c' : Cone F
Hom✝¹ : c.pt ⟶ c'.pt
w✝¹ : ∀ (j : J), Hom✝¹ ≫ NatTrans.app c'.π j = NatTrans.app c.π j
Hom✝ : c.pt ⟶ c'.pt
w✝ : ∀ (j : J), Hom✝ ≫ NatTrans.app c'.π j = NatTrans.app c.π j
w : (mk Hom✝¹).Hom = (mk Hom✝).Hom
⊢ mk Hom✝¹ = mk Hom✝
[PROOFSTEP]
congr
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K✝ : Type u₂
inst✝² : Category.{v₂, u₂} K✝
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F K : J ⥤ C
c d : Cone K
f : c ⟶ d
i : IsIso f.Hom
⊢ f ≫ ConeMorphism.mk (inv f.Hom) = 𝟙 c ∧ ConeMorphism.mk (inv f.Hom) ≫ f = 𝟙 d
[PROOFSTEP]
aesop_cat
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
e : K ≌ J
s : Cone (e.functor ⋙ F)
⊢ ∀ (j : K),
NatTrans.app
(((whiskering e.inverse ⋙ postcompose (Equivalence.invFunIdAssoc e F).hom) ⋙ whiskering e.functor).obj s).π j =
(Iso.refl
(((whiskering e.inverse ⋙ postcompose (Equivalence.invFunIdAssoc e F).hom) ⋙ whiskering e.functor).obj
s).pt).hom ≫
NatTrans.app ((𝟭 (Cone (e.functor ⋙ F))).obj s).π j
[PROOFSTEP]
intro k
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
e : K ≌ J
s : Cone (e.functor ⋙ F)
k : K
⊢ NatTrans.app
(((whiskering e.inverse ⋙ postcompose (Equivalence.invFunIdAssoc e F).hom) ⋙ whiskering e.functor).obj s).π k =
(Iso.refl
(((whiskering e.inverse ⋙ postcompose (Equivalence.invFunIdAssoc e F).hom) ⋙ whiskering e.functor).obj
s).pt).hom ≫
NatTrans.app ((𝟭 (Cone (e.functor ⋙ F))).obj s).π k
[PROOFSTEP]
simpa [e.counit_app_functor] using s.w (e.unitInv.app k)
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
G : C ⥤ D
A : Cone F
⊢ ∀ ⦃X Y : J⦄ (f : X ⟶ Y),
((const J).obj (G.obj A.pt)).map f ≫ (fun j => G.map (NatTrans.app A.π j)) Y =
(fun j => G.map (NatTrans.app A.π j)) X ≫ (F ⋙ G).map f
[PROOFSTEP]
intros
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
G : C ⥤ D
A : Cone F
X✝ Y✝ : J
f✝ : X✝ ⟶ Y✝
⊢ ((const J).obj (G.obj A.pt)).map f✝ ≫ (fun j => G.map (NatTrans.app A.π j)) Y✝ =
(fun j => G.map (NatTrans.app A.π j)) X✝ ≫ (F ⋙ G).map f✝
[PROOFSTEP]
erw [← G.map_comp]
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
G : C ⥤ D
A : Cone F
X✝ Y✝ : J
f✝ : X✝ ⟶ Y✝
⊢ ((const J).obj (G.obj A.pt)).map f✝ ≫ (fun j => G.map (NatTrans.app A.π j)) Y✝ =
G.map (NatTrans.app A.π X✝ ≫ F.map f✝)
[PROOFSTEP]
aesop_cat
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
G : C ⥤ D
X✝ Y✝ : Cone F
f : X✝ ⟶ Y✝
j : J
⊢ G.map f.Hom ≫
NatTrans.app ((fun A => { pt := G.obj A.pt, π := NatTrans.mk fun j => G.map (NatTrans.app A.π j) }) Y✝).π j =
NatTrans.app ((fun A => { pt := G.obj A.pt, π := NatTrans.mk fun j => G.map (NatTrans.app A.π j) }) X✝).π j
[PROOFSTEP]
simp [-ConeMorphism.w, ← f.w j]
[GOAL]
J : Type u₁
inst✝⁵ : Category.{v₁, u₁} J
K : Type u₂
inst✝⁴ : Category.{v₂, u₂} K
C : Type u₃
inst✝³ : Category.{v₃, u₃} C
D : Type u₄
inst✝² : Category.{v₄, u₄} D
F : J ⥤ C
G : C ⥤ D
inst✝¹ : Full G
inst✝ : Faithful G
X✝ Y✝ : Cone F
t : (functoriality F G).obj X✝ ⟶ (functoriality F G).obj Y✝
j : J
⊢ G.map (G.preimage t.Hom ≫ NatTrans.app Y✝.π j) = G.map (NatTrans.app X✝.π j)
[PROOFSTEP]
simpa using t.w j
[GOAL]
J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u₃
inst✝² : Category.{v₃, u₃} C
D : Type u₄
inst✝¹ : Category.{v₄, u₄} D
F : J ⥤ C
G : C ⥤ D
inst✝ : Faithful G
c c' : Cone F
f g : c ⟶ c'
e : (functoriality F G).map f = (functoriality F G).map g
⊢ f = g
[PROOFSTEP]
apply ConeMorphism.ext f g
[GOAL]
J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u₃
inst✝² : Category.{v₃, u₃} C
D : Type u₄
inst✝¹ : Category.{v₄, u₄} D
F : J ⥤ C
G : C ⥤ D
inst✝ : Faithful G
c c' : Cone F
f g : c ⟶ c'
e : (functoriality F G).map f = (functoriality F G).map g
⊢ f.Hom = g.Hom
[PROOFSTEP]
let f := ConeMorphism.mk.inj e
[GOAL]
J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u₃
inst✝² : Category.{v₃, u₃} C
D : Type u₄
inst✝¹ : Category.{v₄, u₄} D
F : J ⥤ C
G : C ⥤ D
inst✝ : Faithful G
c c' : Cone F
f✝ g : c ⟶ c'
e : (functoriality F G).map f✝ = (functoriality F G).map g
f : G.map f✝.Hom = G.map g.Hom := ConeMorphism.mk.inj e
⊢ f✝.Hom = g.Hom
[PROOFSTEP]
apply G.map_injective f
[GOAL]
J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K✝ : Type u₂
inst✝³ : Category.{v₂, u₂} K✝
C : Type u₃
inst✝² : Category.{v₃, u₃} C
D : Type u₄
inst✝¹ : Category.{v₄, u₄} D
F✝ : J ⥤ C
G F : C ⥤ D
inst✝ : ReflectsIsomorphisms F
K : J ⥤ C
⊢ ReflectsIsomorphisms (functoriality K F)
[PROOFSTEP]
constructor
[GOAL]
case reflects
J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K✝ : Type u₂
inst✝³ : Category.{v₂, u₂} K✝
C : Type u₃
inst✝² : Category.{v₃, u₃} C
D : Type u₄
inst✝¹ : Category.{v₄, u₄} D
F✝ : J ⥤ C
G F : C ⥤ D
inst✝ : ReflectsIsomorphisms F
K : J ⥤ C
⊢ ∀ {A B : Cone K} (f : A ⟶ B) [inst : IsIso ((functoriality K F).map f)], IsIso f
[PROOFSTEP]
intro A B f _
[GOAL]
case reflects
J : Type u₁
inst✝⁵ : Category.{v₁, u₁} J
K✝ : Type u₂
inst✝⁴ : Category.{v₂, u₂} K✝
C : Type u₃
inst✝³ : Category.{v₃, u₃} C
D : Type u₄
inst✝² : Category.{v₄, u₄} D
F✝ : J ⥤ C
G F : C ⥤ D
inst✝¹ : ReflectsIsomorphisms F
K : J ⥤ C
A B : Cone K
f : A ⟶ B
inst✝ : IsIso ((functoriality K F).map f)
⊢ IsIso f
[PROOFSTEP]
haveI : IsIso (F.map f.Hom) := (Cones.forget (K ⋙ F)).map_isIso ((Cones.functoriality K F).map f)
[GOAL]
case reflects
J : Type u₁
inst✝⁵ : Category.{v₁, u₁} J
K✝ : Type u₂
inst✝⁴ : Category.{v₂, u₂} K✝
C : Type u₃
inst✝³ : Category.{v₃, u₃} C
D : Type u₄
inst✝² : Category.{v₄, u₄} D
F✝ : J ⥤ C
G F : C ⥤ D
inst✝¹ : ReflectsIsomorphisms F
K : J ⥤ C
A B : Cone K
f : A ⟶ B
inst✝ : IsIso ((functoriality K F).map f)
this : IsIso (F.map f.Hom)
⊢ IsIso f
[PROOFSTEP]
haveI := ReflectsIsomorphisms.reflects F f.Hom
[GOAL]
case reflects
J : Type u₁
inst✝⁵ : Category.{v₁, u₁} J
K✝ : Type u₂
inst✝⁴ : Category.{v₂, u₂} K✝
C : Type u₃
inst✝³ : Category.{v₃, u₃} C
D : Type u₄
inst✝² : Category.{v₄, u₄} D
F✝ : J ⥤ C
G F : C ⥤ D
inst✝¹ : ReflectsIsomorphisms F
K : J ⥤ C
A B : Cone K
f : A ⟶ B
inst✝ : IsIso ((functoriality K F).map f)
this✝ : IsIso (F.map f.Hom)
this : IsIso f.Hom
⊢ IsIso f
[PROOFSTEP]
apply cone_iso_of_hom_iso
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
c c' : Cocone F
f g : c ⟶ c'
w : f.Hom = g.Hom
⊢ f = g
[PROOFSTEP]
cases f
[GOAL]
case mk
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
c c' : Cocone F
g : c ⟶ c'
Hom✝ : c.pt ⟶ c'.pt
w✝ : ∀ (j : J), NatTrans.app c.ι j ≫ Hom✝ = NatTrans.app c'.ι j
w : (mk Hom✝).Hom = g.Hom
⊢ mk Hom✝ = g
[PROOFSTEP]
cases g
[GOAL]
case mk.mk
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
c c' : Cocone F
Hom✝¹ : c.pt ⟶ c'.pt
w✝¹ : ∀ (j : J), NatTrans.app c.ι j ≫ Hom✝¹ = NatTrans.app c'.ι j
Hom✝ : c.pt ⟶ c'.pt
w✝ : ∀ (j : J), NatTrans.app c.ι j ≫ Hom✝ = NatTrans.app c'.ι j
w : (mk Hom✝¹).Hom = (mk Hom✝).Hom
⊢ mk Hom✝¹ = mk Hom✝
[PROOFSTEP]
congr
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K✝ : Type u₂
inst✝² : Category.{v₂, u₂} K✝
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F K : J ⥤ C
c d : Cocone K
f : c ⟶ d
i : IsIso f.Hom
⊢ f ≫ CoconeMorphism.mk (inv f.Hom) = 𝟙 c ∧ CoconeMorphism.mk (inv f.Hom) ≫ f = 𝟙 d
[PROOFSTEP]
aesop_cat
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
e : K ≌ J
s : Cocone (e.functor ⋙ F)
k : K
⊢ NatTrans.app
(((whiskering e.inverse ⋙
precompose
((leftUnitor F).inv ≫ whiskerRight e.counitIso.inv F ≫ (associator e.inverse e.functor F).inv)) ⋙
whiskering e.functor).obj
s).ι
k ≫
(Iso.refl
(((whiskering e.inverse ⋙
precompose
((leftUnitor F).inv ≫ whiskerRight e.counitIso.inv F ≫ (associator e.inverse e.functor F).inv)) ⋙
whiskering e.functor).obj
s).pt).hom =
NatTrans.app ((𝟭 (Cocone (e.functor ⋙ F))).obj s).ι k
[PROOFSTEP]
simpa [e.counitInv_app_functor k] using s.w (e.unit.app k)
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
G : C ⥤ D
A : Cocone F
⊢ ∀ ⦃X Y : J⦄ (f : X ⟶ Y),
(F ⋙ G).map f ≫ (fun j => G.map (NatTrans.app A.ι j)) Y =
(fun j => G.map (NatTrans.app A.ι j)) X ≫ ((const J).obj (G.obj A.pt)).map f
[PROOFSTEP]
intros
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
G : C ⥤ D
A : Cocone F
X✝ Y✝ : J
f✝ : X✝ ⟶ Y✝
⊢ (F ⋙ G).map f✝ ≫ (fun j => G.map (NatTrans.app A.ι j)) Y✝ =
(fun j => G.map (NatTrans.app A.ι j)) X✝ ≫ ((const J).obj (G.obj A.pt)).map f✝
[PROOFSTEP]
erw [← G.map_comp]
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
G : C ⥤ D
A : Cocone F
X✝ Y✝ : J
f✝ : X✝ ⟶ Y✝
⊢ G.map (F.map f✝ ≫ NatTrans.app A.ι Y✝) =
(fun j => G.map (NatTrans.app A.ι j)) X✝ ≫ ((const J).obj (G.obj A.pt)).map f✝
[PROOFSTEP]
aesop_cat
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
G : C ⥤ D
X✝ Y✝ : Cocone F
f : X✝ ⟶ Y✝
⊢ ∀ (j : J),
NatTrans.app ((fun A => { pt := G.obj A.pt, ι := NatTrans.mk fun j => G.map (NatTrans.app A.ι j) }) X✝).ι j ≫
G.map f.Hom =
NatTrans.app ((fun A => { pt := G.obj A.pt, ι := NatTrans.mk fun j => G.map (NatTrans.app A.ι j) }) Y✝).ι j
[PROOFSTEP]
intros
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
G : C ⥤ D
X✝ Y✝ : Cocone F
f : X✝ ⟶ Y✝
j✝ : J
⊢ NatTrans.app ((fun A => { pt := G.obj A.pt, ι := NatTrans.mk fun j => G.map (NatTrans.app A.ι j) }) X✝).ι j✝ ≫
G.map f.Hom =
NatTrans.app ((fun A => { pt := G.obj A.pt, ι := NatTrans.mk fun j => G.map (NatTrans.app A.ι j) }) Y✝).ι j✝
[PROOFSTEP]
rw [← Functor.map_comp, CoconeMorphism.w]
[GOAL]
J : Type u₁
inst✝⁵ : Category.{v₁, u₁} J
K : Type u₂
inst✝⁴ : Category.{v₂, u₂} K
C : Type u₃
inst✝³ : Category.{v₃, u₃} C
D : Type u₄
inst✝² : Category.{v₄, u₄} D
F : J ⥤ C
G : C ⥤ D
inst✝¹ : Full G
inst✝ : Faithful G
X✝ Y✝ : Cocone F
t : (functoriality F G).obj X✝ ⟶ (functoriality F G).obj Y✝
j : J
⊢ G.map (NatTrans.app X✝.ι j ≫ G.preimage t.Hom) = G.map (NatTrans.app Y✝.ι j)
[PROOFSTEP]
simpa using t.w j
[GOAL]
J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u₃
inst✝² : Category.{v₃, u₃} C
D : Type u₄
inst✝¹ : Category.{v₄, u₄} D
F : J ⥤ C
G : C ⥤ D
inst✝ : Faithful G
X Y : Cocone F
f g : X ⟶ Y
e : (functoriality F G).map f = (functoriality F G).map g
⊢ f = g
[PROOFSTEP]
apply CoconeMorphism.ext
[GOAL]
case w
J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u₃
inst✝² : Category.{v₃, u₃} C
D : Type u₄
inst✝¹ : Category.{v₄, u₄} D
F : J ⥤ C
G : C ⥤ D
inst✝ : Faithful G
X Y : Cocone F
f g : X ⟶ Y
e : (functoriality F G).map f = (functoriality F G).map g
⊢ f.Hom = g.Hom
[PROOFSTEP]
let h := CoconeMorphism.mk.inj e
[GOAL]
case w
J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u₃
inst✝² : Category.{v₃, u₃} C
D : Type u₄
inst✝¹ : Category.{v₄, u₄} D
F : J ⥤ C
G : C ⥤ D
inst✝ : Faithful G
X Y : Cocone F
f g : X ⟶ Y
e : (functoriality F G).map f = (functoriality F G).map g
h : G.map f.Hom = G.map g.Hom := CoconeMorphism.mk.inj e
⊢ f.Hom = g.Hom
[PROOFSTEP]
apply G.map_injective h
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
G : C ⥤ D
e : C ≌ D
f : (F ⋙ e.functor) ⋙ e.inverse ≅ F :=
associator F e.functor e.inverse ≪≫ isoWhiskerLeft F e.unitIso.symm ≪≫ rightUnitor F
c : Cocone (F ⋙ e.functor)
j : J
⊢ NatTrans.app
(((functoriality (F ⋙ e.functor) e.inverse ⋙ (precomposeEquivalence f.symm).functor) ⋙
functoriality F e.functor).obj
c).ι
j ≫
(e.counitIso.app c.pt).hom =
NatTrans.app ((𝟭 (Cocone (F ⋙ e.functor))).obj c).ι j
[PROOFSTEP]
simp [← Equivalence.counitInv_app_functor]
[GOAL]
J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K✝ : Type u₂
inst✝³ : Category.{v₂, u₂} K✝
C : Type u₃
inst✝² : Category.{v₃, u₃} C
D : Type u₄
inst✝¹ : Category.{v₄, u₄} D
F✝ : J ⥤ C
G F : C ⥤ D
inst✝ : ReflectsIsomorphisms F
K : J ⥤ C
⊢ ReflectsIsomorphisms (functoriality K F)
[PROOFSTEP]
constructor
[GOAL]
case reflects
J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K✝ : Type u₂
inst✝³ : Category.{v₂, u₂} K✝
C : Type u₃
inst✝² : Category.{v₃, u₃} C
D : Type u₄
inst✝¹ : Category.{v₄, u₄} D
F✝ : J ⥤ C
G F : C ⥤ D
inst✝ : ReflectsIsomorphisms F
K : J ⥤ C
⊢ ∀ {A B : Cocone K} (f : A ⟶ B) [inst : IsIso ((functoriality K F).map f)], IsIso f
[PROOFSTEP]
intro A B f _
[GOAL]
case reflects
J : Type u₁
inst✝⁵ : Category.{v₁, u₁} J
K✝ : Type u₂
inst✝⁴ : Category.{v₂, u₂} K✝
C : Type u₃
inst✝³ : Category.{v₃, u₃} C
D : Type u₄
inst✝² : Category.{v₄, u₄} D
F✝ : J ⥤ C
G F : C ⥤ D
inst✝¹ : ReflectsIsomorphisms F
K : J ⥤ C
A B : Cocone K
f : A ⟶ B
inst✝ : IsIso ((functoriality K F).map f)
⊢ IsIso f
[PROOFSTEP]
haveI : IsIso (F.map f.Hom) := (Cocones.forget (K ⋙ F)).map_isIso ((Cocones.functoriality K F).map f)
[GOAL]
case reflects
J : Type u₁
inst✝⁵ : Category.{v₁, u₁} J
K✝ : Type u₂
inst✝⁴ : Category.{v₂, u₂} K✝
C : Type u₃
inst✝³ : Category.{v₃, u₃} C
D : Type u₄
inst✝² : Category.{v₄, u₄} D
F✝ : J ⥤ C
G F : C ⥤ D
inst✝¹ : ReflectsIsomorphisms F
K : J ⥤ C
A B : Cocone K
f : A ⟶ B
inst✝ : IsIso ((functoriality K F).map f)
this : IsIso (F.map f.Hom)
⊢ IsIso f
[PROOFSTEP]
haveI := ReflectsIsomorphisms.reflects F f.Hom
[GOAL]
case reflects
J : Type u₁
inst✝⁵ : Category.{v₁, u₁} J
K✝ : Type u₂
inst✝⁴ : Category.{v₂, u₂} K✝
C : Type u₃
inst✝³ : Category.{v₃, u₃} C
D : Type u₄
inst✝² : Category.{v₄, u₄} D
F✝ : J ⥤ C
G F : C ⥤ D
inst✝¹ : ReflectsIsomorphisms F
K : J ⥤ C
A B : Cocone K
f : A ⟶ B
inst✝ : IsIso ((functoriality K F).map f)
this✝ : IsIso (F.map f.Hom)
this : IsIso f.Hom
⊢ IsIso f
[PROOFSTEP]
apply cocone_iso_of_hom_iso
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
X Y : Cocone F
f : X ⟶ Y
j : Jᵒᵖ
⊢ f.Hom.op ≫ NatTrans.app (Cocone.op X).π j = NatTrans.app (Cocone.op Y).π j
[PROOFSTEP]
apply Quiver.Hom.unop_inj
[GOAL]
case a
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
X Y : Cocone F
f : X ⟶ Y
j : Jᵒᵖ
⊢ (f.Hom.op ≫ NatTrans.app (Cocone.op X).π j).unop = (NatTrans.app (Cocone.op Y).π j).unop
[PROOFSTEP]
dsimp
[GOAL]
case a
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
X Y : Cocone F
f : X ⟶ Y
j : Jᵒᵖ
⊢ NatTrans.app X.ι j.unop ≫ f.Hom = NatTrans.app Y.ι j.unop
[PROOFSTEP]
apply CoconeMorphism.w
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
X Y : (Cone F.op)ᵒᵖ
f : X ⟶ Y
j : J
⊢ NatTrans.app ((fun c => Cone.unop c.unop) X).ι j ≫ f.unop.Hom.unop = NatTrans.app ((fun c => Cone.unop c.unop) Y).ι j
[PROOFSTEP]
apply Quiver.Hom.op_inj
[GOAL]
case a
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
X Y : (Cone F.op)ᵒᵖ
f : X ⟶ Y
j : J
⊢ (NatTrans.app ((fun c => Cone.unop c.unop) X).ι j ≫ f.unop.Hom.unop).op =
(NatTrans.app ((fun c => Cone.unop c.unop) Y).ι j).op
[PROOFSTEP]
dsimp
[GOAL]
case a
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
X Y : (Cone F.op)ᵒᵖ
f : X ⟶ Y
j : J
⊢ f.unop.Hom ≫ NatTrans.app X.unop.π (op j) = NatTrans.app Y.unop.π (op j)
[PROOFSTEP]
apply ConeMorphism.w
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
c : (Cone F.op)ᵒᵖ
⊢ (Functor.mk { obj := fun c => Cone.unop c.unop, map := fun {X Y} f => CoconeMorphism.mk f.unop.Hom.unop } ⋙
Functor.mk { obj := fun c => op (Cocone.op c), map := fun {X Y} f => (ConeMorphism.mk f.Hom.op).op }).obj
c ≅
(𝟭 (Cone F.op)ᵒᵖ).obj c
[PROOFSTEP]
induction c
[GOAL]
case h
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
X✝ : Cone F.op
⊢ (Functor.mk { obj := fun c => Cone.unop c.unop, map := fun {X Y} f => CoconeMorphism.mk f.unop.Hom.unop } ⋙
Functor.mk { obj := fun c => op (Cocone.op c), map := fun {X Y} f => (ConeMorphism.mk f.Hom.op).op }).obj
(op X✝) ≅
(𝟭 (Cone F.op)ᵒᵖ).obj (op X✝)
[PROOFSTEP]
apply Iso.op
[GOAL]
case h.α
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
X✝ : Cone F.op
⊢ X✝ ≅
Cocone.op
((Functor.mk { obj := fun c => Cone.unop c.unop, map := fun {X Y} f => CoconeMorphism.mk f.unop.Hom.unop }).obj
(op X✝))
[PROOFSTEP]
exact Cones.ext (Iso.refl _)
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
X Y : (Cone F.op)ᵒᵖ
f : X ⟶ Y
⊢ ((Functor.mk { obj := fun c => Cone.unop c.unop, map := fun {X Y} f => CoconeMorphism.mk f.unop.Hom.unop } ⋙
Functor.mk
{ obj := fun c => op (Cocone.op c), map := fun {X Y} f => (ConeMorphism.mk f.Hom.op).op }).map
f ≫
((fun c => Opposite.rec' (fun X => Iso.op (Cones.ext (Iso.refl X.pt))) c) Y).hom).unop.Hom =
(((fun c => Opposite.rec' (fun X => Iso.op (Cones.ext (Iso.refl X.pt))) c) X).hom ≫
(𝟭 (Cone F.op)ᵒᵖ).map f).unop.Hom
[PROOFSTEP]
simp
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
c : Cocone F
⊢ (Functor.mk { obj := fun c => op (Cocone.op c), map := fun {X Y} f => (ConeMorphism.mk f.Hom.op).op }).map
(NatTrans.app (NatIso.ofComponents fun c => Cocones.ext (Iso.refl ((𝟭 (Cocone F)).obj c).pt)).hom c) ≫
NatTrans.app (NatIso.ofComponents fun c => Opposite.rec' (fun X => Iso.op (Cones.ext (Iso.refl X.pt))) c).hom
((Functor.mk { obj := fun c => op (Cocone.op c), map := fun {X Y} f => (ConeMorphism.mk f.Hom.op).op }).obj c) =
𝟙 ((Functor.mk { obj := fun c => op (Cocone.op c), map := fun {X Y} f => (ConeMorphism.mk f.Hom.op).op }).obj c)
[PROOFSTEP]
apply Quiver.Hom.unop_inj
[GOAL]
case a
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
c : Cocone F
⊢ ((Functor.mk { obj := fun c => op (Cocone.op c), map := fun {X Y} f => (ConeMorphism.mk f.Hom.op).op }).map
(NatTrans.app (NatIso.ofComponents fun c => Cocones.ext (Iso.refl ((𝟭 (Cocone F)).obj c).pt)).hom c) ≫
NatTrans.app (NatIso.ofComponents fun c => Opposite.rec' (fun X => Iso.op (Cones.ext (Iso.refl X.pt))) c).hom
((Functor.mk { obj := fun c => op (Cocone.op c), map := fun {X Y} f => (ConeMorphism.mk f.Hom.op).op }).obj
c)).unop =
(𝟙
((Functor.mk { obj := fun c => op (Cocone.op c), map := fun {X Y} f => (ConeMorphism.mk f.Hom.op).op }).obj
c)).unop
[PROOFSTEP]
apply ConeMorphism.ext
[GOAL]
case a.w
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
c : Cocone F
⊢ ((Functor.mk { obj := fun c => op (Cocone.op c), map := fun {X Y} f => (ConeMorphism.mk f.Hom.op).op }).map
(NatTrans.app (NatIso.ofComponents fun c => Cocones.ext (Iso.refl ((𝟭 (Cocone F)).obj c).pt)).hom c) ≫
NatTrans.app (NatIso.ofComponents fun c => Opposite.rec' (fun X => Iso.op (Cones.ext (Iso.refl X.pt))) c).hom
((Functor.mk { obj := fun c => op (Cocone.op c), map := fun {X Y} f => (ConeMorphism.mk f.Hom.op).op }).obj
c)).unop.Hom =
(𝟙
((Functor.mk { obj := fun c => op (Cocone.op c), map := fun {X Y} f => (ConeMorphism.mk f.Hom.op).op }).obj
c)).unop.Hom
[PROOFSTEP]
dsimp
[GOAL]
case a.w
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
c : Cocone F
⊢ 𝟙 (op c.pt) ≫ 𝟙 (op c.pt) = 𝟙 (op c.pt)
[PROOFSTEP]
apply comp_id
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ Cᵒᵖ
c : Cone F.leftOp
j : J
⊢ NatTrans.app (coconeOfConeLeftOp c).ι j = (NatTrans.app c.π (op j)).op
[PROOFSTEP]
dsimp only [coconeOfConeLeftOp]
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ Cᵒᵖ
c : Cone F.leftOp
j : J
⊢ NatTrans.app (NatTrans.removeLeftOp c.π) j = (NatTrans.app c.π (op j)).op
[PROOFSTEP]
simp
|
lemma interior_UNIV [simp]: "interior UNIV = UNIV" |
Check Engine Light - What Does It Mean?
The Check Engine Light (CEL) is an integral part of your vehicle’s Onboard Diagnostics System. The problem is that an illuminated CEL can mean pretty much anything: Your gas cap could be loose or, in a worst case scenario, your engine could be malfunctioning.
Really, the CEL is merely an indicator something in or on the vehicle is (most likely) not performing as it should. Once the vehicle’s electronic control system finds a problem it cannot adjust it will illuminate the warning light and store a code in its memory indicating the problem.
In 1996 vehicle manufacturers were required to adopt standardized diagnostic trouble codes, and nowadays mechanics can quickly diagnose problems simply by inserting a device into the vehicle that reads these codes (called a ‘Code Reader’). In fact, mechanically inclined readers can even purchase a Code Reader at a hardware store and insert and read the vehicles code themselves.
However, there a few things to consider before you purchase a code reader: For example, the problem isn’t always what’s indicated in the code. The code could indicate a faulty battery, when in fact the wires connected to the battery have simply been frayed over time. Purchasing a new battery might also be a good idea, but the CEL likely won’t turn off until the faulty wires are also replaced.
In truth, your dealer or mechanic is best suited to fix your CEL. They have invested thousands in equipment to be able to properly service your vehicle and no one knows your vehicle better than a certified mechanic.
Best of all, the ODB scan is (likely) covered under your factory warranty, so you won’t pay a cent. Those not covered under warranty will pay $125 at WallceChev, which includes a full scan, diagnostic assessment, and work order. We’ll also fully explain the problem, what caused it and the steps to get you back on the road, safely.
Ignoring the problem can also be a bad idea: We frequently see vehicles with repairs that could be avoided had the issue been diagnosed earlier. A healthy car is a happy car!
Now that you know how to turn off the CEL… do you know what could cause your Check Engline Light to switch on? |
(* Author: Lukas Bulwahn <lukas.bulwahn-at-gmail.com> *)
section \<open>Cardinality of Number Partitions\<close>
theory Card_Number_Partitions
imports Number_Partition
begin
subsection \<open>The Partition Function\<close>
fun Partition :: "nat \<Rightarrow> nat \<Rightarrow> nat"
where
"Partition 0 0 = 1"
| "Partition 0 (Suc k) = 0"
| "Partition (Suc m) 0 = 0"
| "Partition (Suc m) (Suc k) = Partition m k + Partition (m - k) (Suc k)"
lemma Partition_less:
assumes "m < k"
shows "Partition m k = 0"
using assms by (induct m k rule: Partition.induct) auto
lemma Partition_sum_Partition_diff:
assumes "k \<le> m"
shows "Partition m k = (\<Sum>i\<le>k. Partition (m - k) i)"
using assms by (induct m k rule: Partition.induct) auto
lemma Partition_parts1:
"Partition (Suc m) (Suc 0) = 1"
by (induct m) auto
lemma Partition_diag:
"Partition (Suc m) (Suc m) = 1"
by (induct m) auto
lemma Partition_diag1:
"Partition (Suc (Suc m)) (Suc m) = 1"
by (induct m) auto
lemma Partition_parts2:
shows "Partition m 2 = m div 2"
proof (induct m rule: nat_less_induct)
fix m
assume hypothesis: "\<forall>n<m. Partition n 2 = n div 2"
have "(m = 0 \<or> m = 1) \<or> m \<ge> 2" by auto
from this show "Partition m 2 = m div 2"
proof
assume "m = 0 \<or> m = 1"
from this show ?thesis by (auto simp add: numerals(2))
next
assume "2 \<le> m"
from this obtain m' where m': "m = Suc (Suc m')" by (metis add_2_eq_Suc le_Suc_ex)
from hypothesis this have "Partition m' 2 = m' div 2" by simp
from this m' show ?thesis
using Partition_parts1 Partition.simps(4)[of "Suc m'" "Suc 0"] div2_Suc_Suc
by (simp add: numerals(2) del: Partition.simps)
qed
qed
subsection \<open>Cardinality of Number Partitions\<close>
lemma set_rewrite1:
"{p. p partitions Suc m \<and> sum p {..Suc m} = Suc k \<and> p 1 \<noteq> 0}
= (\<lambda>p. p(1 := p 1 + 1)) ` {p. p partitions m \<and> sum p {..m} = k}" (is "?S = ?T")
proof
{
fix p
assume assms: "p partitions Suc m" "sum p {..Suc m} = Suc k" "0 < p 1"
have "p(1 := p 1 - 1) partitions m"
using assms by (metis partitions_remove1 diff_Suc_1)
moreover have "(\<Sum>i\<le>m. (p(1 := p 1 - 1)) i) = k"
using assms by (metis count_remove1 diff_Suc_1)
ultimately have "p(1 := p 1 - 1) \<in> {p. p partitions m \<and> sum p {..m} = k}" by simp
moreover have "p = p(1 := p 1 - 1, 1 := (p(1 := p 1 - 1)) 1 + 1)"
using \<open>0 < p 1\<close> by auto
ultimately have "p \<in> (\<lambda>p. p(1 := p 1 + 1)) ` {p. p partitions m \<and> sum p {..m} = k}" by blast
}
from this show "?S \<subseteq> ?T" by blast
next
{
fix p
assume assms: "p partitions m" "sum p {..m} = k"
have "(p(1 := p 1 + 1)) partitions Suc m" (is ?g1)
using assms by (metis partitions_insert1 Suc_eq_plus1 zero_less_one)
moreover have "sum (p(1 := p 1 + 1)) {..Suc m} = Suc k" (is ?g2)
using assms by (metis count_insert1 Suc_eq_plus1)
moreover have "(p(1 := p 1 + 1)) 1 \<noteq> 0" (is ?g3) by auto
ultimately have "?g1 \<and> ?g2 \<and> ?g3" by simp
}
from this show "?T \<subseteq> ?S" by auto
qed
lemma set_rewrite2:
"{p. p partitions m \<and> sum p {..m} = k \<and> p 1 = 0}
= (\<lambda>p. (\<lambda>i. p (i - 1))) ` {p. p partitions (m - k) \<and> sum p {..m - k} = k}"
(is "?S = ?T")
proof
{
fix p
assume assms: "p partitions m" "sum p {..m} = k" "p 1 = 0"
have "(\<lambda>i. p (i + 1)) partitions m - k"
using assms partitions_decrease1 by blast
moreover from assms have "sum (\<lambda>i. p (i + 1)) {..m - k} = k"
using assms count_decrease1 by blast
ultimately have "(\<lambda>i. p (i + 1)) \<in> {p. p partitions m - k \<and> sum p {..m - k} = k}" by simp
moreover have "p = (\<lambda>i. p ((i - 1) + 1))"
proof (rule ext)
fix i show "p i = p (i - 1 + 1)"
using assms by (cases i) (auto elim!: partitionsE)
qed
ultimately have "p \<in> (\<lambda>p. (\<lambda>i. p (i - 1))) ` {p. p partitions m - k \<and> sum p {..m - k} = k}" by auto
}
from this show "?S \<subseteq> ?T" by auto
next
{
fix p
assume assms: "p partitions m - k" "sum p {..m - k} = k"
from assms have "(\<lambda>i. p (i - 1)) partitions m" (is ?g1)
using partitions_increase1 by blast
moreover from assms have "(\<Sum>i\<le>m. p (i - 1)) = k" (is ?g2)
using count_increase1 by blast
moreover from assms have "p 0 = 0" (is ?g3)
by (auto elim!: partitionsE)
ultimately have "?g1 \<and> ?g2 \<and> ?g3" by simp
}
from this show "?T \<subseteq> ?S" by auto
qed
theorem card_partitions_k_parts:
"card {p. p partitions n \<and> (\<Sum>i\<le>n. p i) = k} = Partition n k"
proof (induct n k rule: Partition.induct)
case 1
have eq: "{p. p = (\<lambda>x. 0) \<and> p 0 = 0} = {(\<lambda>x. 0)}" by auto
show "card {p. p partitions 0 \<and> sum p {..0} = 0} = Partition 0 0"
by (simp add: partitions_zero eq)
next
case (2 k)
have eq: "{p. p = (\<lambda>x. 0) \<and> p 0 = Suc k} = {}" by auto
show "card {p. p partitions 0 \<and> sum p {..0} = Suc k} = Partition 0 (Suc k)"
by (simp add: partitions_zero eq)
next
case (3 m)
have eq: "{p. p partitions Suc m \<and> sum p {..Suc m} = 0} = {}"
by (fastforce elim!: partitionsE simp add: le_Suc_eq)
from this show "card {p. p partitions Suc m \<and> sum p {..Suc m} = 0} = Partition (Suc m) 0"
by (simp only: Partition.simps card_empty)
next
case (4 m k)
let ?set1 = "{p. p partitions Suc m \<and> sum p {..Suc m} = Suc k \<and> p 1 \<noteq> 0}"
let ?set2 = "{p. p partitions Suc m \<and> sum p {..Suc m} = Suc k \<and> p 1 = 0}"
have "finite {p. p partitions Suc m}"
by (simp add: finite_partitions)
from this have finite_sets: "finite ?set1" "finite ?set2" by simp+
have set_eq: "{p. p partitions Suc m \<and> sum p {..Suc m} = Suc k} = ?set1 \<union> ?set2" by auto
have disjoint: "?set1 \<inter> ?set2 = {}" by auto
have inj1: "inj_on (\<lambda>p. p(1 := p 1 + 1)) {p. p partitions m \<and> sum p {..m} = k}"
by (auto intro!: inj_onI) (metis diff_Suc_1 fun_upd_idem_iff fun_upd_upd)
have inj2: "inj_on (\<lambda>p i. p (i - 1)) {p. p partitions m - k \<and> sum p {..m - k} = Suc k}"
by (auto intro!: inj_onI simp add: fun_eq_iff) (metis add_diff_cancel_right')
have card1: "card ?set1 = Partition m k"
using inj1 4(1) by (simp only: set_rewrite1 card_image)
have card2: "card ?set2 = Partition (m - k) (Suc k)"
using inj2 4(2) by (simp only: set_rewrite2 card_image diff_Suc_Suc)
have "card {p. p partitions Suc m \<and> sum p {..Suc m} = Suc k} = Partition m k + Partition (m - k) (Suc k)"
using finite_sets disjoint by (simp only: set_eq card_Un_disjoint card1 card2)
from this show "card {p. p partitions Suc m \<and> sum p {..Suc m} = Suc k} = Partition (Suc m) (Suc k)"
by auto
qed
theorem card_partitions:
"card {p. p partitions n} = (\<Sum>k\<le>n. Partition n k)"
proof -
have seteq: "{p. p partitions n} = \<Union>((\<lambda>k. {p. p partitions n \<and> (\<Sum>i\<le>n. p i) = k}) ` {..n})"
by (auto intro: partitions_parts_bounded)
have finite: "\<And>k. finite {p. p partitions n \<and> sum p {..n} = k}"
by (simp add: finite_partitions)
have "card {p. p partitions n} = card (\<Union>((\<lambda>k. {p. p partitions n \<and> (\<Sum>i\<le>n. p i) = k}) ` {..n}))"
using finite by (simp add: seteq)
also have "... = (\<Sum>x\<le>n. card {p. p partitions n \<and> sum p {..n} = x})"
using finite by (subst card_UN_disjoint) auto
also have "... = (\<Sum>k\<le>n. Partition n k)"
by (simp add: card_partitions_k_parts)
finally show ?thesis .
qed
lemma card_partitions_atmost_k_parts:
"card {p. p partitions n \<and> sum p {..n} \<le> k} = Partition (n + k) k"
proof -
have "card {p. p partitions n \<and> sum p {..n} \<le> k} =
card (\<Union>((\<lambda>k'. {p. p partitions n \<and> sum p {..n} = k'}) ` {..k}))"
proof -
have "{p. p partitions n \<and> sum p {..n} \<le> k} =
(\<Union>k'\<le>k. {p. p partitions n \<and> sum p {..n} = k'})" by auto
from this show ?thesis by simp
qed
also have "card (\<Union>((\<lambda>k'. {p. p partitions n \<and> sum p {..n} = k'}) ` {..k})) =
sum (\<lambda>k'. card {p. p partitions n \<and> sum p {..n} = k'}) {..k}"
using finite_partitions_k_parts by (subst card_UN_disjoint) auto
also have "\<dots> = sum (\<lambda>k'. Partition n k') {..k}"
using card_partitions_k_parts by simp
also have "\<dots> = Partition (n + k) k"
using Partition_sum_Partition_diff by simp
finally show ?thesis .
qed
subsection \<open>Cardinality of Number Partitions as Multisets of Natural Numbers\<close>
lemma bij_betw_multiset_number_partition_with_size:
"bij_betw count {N. number_partition n N \<and> size N = k} {p. p partitions n \<and> sum p {..n} = k}"
proof (rule bij_betw_byWitness[where f'="Abs_multiset"])
show "\<forall>N\<in>{N. number_partition n N \<and> size N = k}. Abs_multiset (count N) = N"
using count_inverse by blast
show "\<forall>p\<in>{p. p partitions n \<and> sum p {..n} = k}. count (Abs_multiset p) = p"
by (auto simp add: multiset_def partitions_imp_finite_elements)
show "count ` {N. number_partition n N \<and> size N = k} \<subseteq> {p. p partitions n \<and> sum p {..n} = k}"
by (auto simp add: count_partitions_iff size_nat_multiset_eq)
show "Abs_multiset ` {p. p partitions n \<and> sum p {..n} = k} \<subseteq> {N. number_partition n N \<and> size N = k}"
using partitions_iff_Abs_multiset size_nat_multiset_eq partitions_imp_multiset by fastforce
qed
lemma bij_betw_multiset_number_partition_with_atmost_size:
"bij_betw count {N. number_partition n N \<and> size N \<le> k} {p. p partitions n \<and> sum p {..n} \<le> k}"
proof (rule bij_betw_byWitness[where f'="Abs_multiset"])
show "\<forall>N\<in>{N. number_partition n N \<and> size N \<le> k}. Abs_multiset (count N) = N"
using count_inverse by blast
show "\<forall>p\<in>{p. p partitions n \<and> sum p {..n} \<le> k}. count (Abs_multiset p) = p"
by (auto simp add: multiset_def partitions_imp_finite_elements)
show "count ` {N. number_partition n N \<and> size N \<le> k} \<subseteq> {p. p partitions n \<and> sum p {..n} \<le> k}"
by (auto simp add: count_partitions_iff size_nat_multiset_eq)
show "Abs_multiset ` {p. p partitions n \<and> sum p {..n} \<le> k} \<subseteq> {N. number_partition n N\<and> size N \<le> k}"
using partitions_iff_Abs_multiset size_nat_multiset_eq partitions_imp_multiset by fastforce
qed
theorem card_number_partitions_with_atmost_k_parts:
shows "card {N. number_partition n N \<and> size N \<le> x} = Partition (n + x) x"
proof -
have "bij_betw count {N. number_partition n N \<and> size N \<le> x} {p. p partitions n \<and> sum p {..n} \<le> x}"
by (rule bij_betw_multiset_number_partition_with_atmost_size)
from this have "card {N. number_partition n N \<and> size N \<le> x} = card {p. p partitions n \<and> sum p {..n} \<le> x}"
by (rule bij_betw_same_card)
also have "card {p. p partitions n \<and> sum p {..n} \<le> x} = Partition (n + x) x"
by (rule card_partitions_atmost_k_parts)
finally show ?thesis .
qed
theorem card_partitions_with_k_parts:
"card {N. number_partition n N \<and> size N = k} = Partition n k"
proof -
have "bij_betw count {N. number_partition n N \<and> size N = k} {p. p partitions n \<and> sum p {..n} = k}"
by (rule bij_betw_multiset_number_partition_with_size)
from this have "card {N. number_partition n N \<and> size N = k} = card {p. p partitions n \<and> sum p {..n} = k}"
by (rule bij_betw_same_card)
also have "\<dots> = Partition n k" by (rule card_partitions_k_parts)
finally show ?thesis .
qed
subsection \<open>Cardinality of Number Partitions with only 1-parts\<close>
lemma number_partition1_eq_replicate_mset:
"{N. (\<forall>n. n\<in># N \<longrightarrow> n = 1) \<and> number_partition n N} = {replicate_mset n 1}"
proof
show "{N. (\<forall>n. n \<in># N \<longrightarrow> n = 1) \<and> number_partition n N} \<subseteq> {replicate_mset n 1}"
proof
fix N
assume N: "N \<in> {N. (\<forall>n. n \<in># N \<longrightarrow> n = 1) \<and> number_partition n N}"
have "N = replicate_mset n 1"
proof (rule multiset_eqI)
fix i
have "count N 1 = sum_mset N"
proof cases
assume "N = {#}"
from this show ?thesis by auto
next
assume "N \<noteq> {#}"
from this N have "1 \<in># N" by blast
from this N show ?thesis
by (auto simp add: sum_mset_sum_count sum.remove[where x="1"] simp del: One_nat_def)
qed
from N this show "count N i = count (replicate_mset n 1) i"
unfolding number_partition_def by (auto intro: count_inI)
qed
from this show "N \<in> {replicate_mset n 1}" by simp
qed
next
show "{replicate_mset n 1} \<subseteq> {N. (\<forall>n. n \<in># N \<longrightarrow> n = 1) \<and> number_partition n N}"
unfolding number_partition_def by auto
qed
lemma card_number_partitions_with_only_parts_1_eq_0:
assumes "x < n"
shows "card {N. (\<forall>n. n\<in># N \<longrightarrow> n = 1) \<and> number_partition n N \<and> size N \<le> x} = 0" (is "card ?N = _")
proof -
have "\<forall>N \<in> {N. (\<forall>n. n \<in># N \<longrightarrow> n = 1) \<and> number_partition n N}. size N = n"
unfolding number_partition1_eq_replicate_mset by simp
from this number_partition1_eq_replicate_mset\<open>x < n\<close> have "?N = {}" by auto
from this show ?thesis by (simp only: card_empty)
qed
end
|
lemmas swap_apply1 = swap_apply(1) |
(* Practice of Natural Deduction *)
(* http://rainyday.blog.so-net.ne.jp/2017-09-24 *)
theory NaturalDeduction
imports Main
begin
theorem Example_1_4:
(*fixes P Q*)
assumes 1: "P \<and> Q"
assumes 2: "R"
shows "Q \<and> R"
proof -
have 3: "Q" using 1 by (rule conjunct2)
show 4: "Q \<and> R" using 3 2 by (rule conjI)
qed
find_theorems "\<not>\<not> _ \<Longrightarrow> _" (* notnotD *)
theorem notnotI: "P \<Longrightarrow> \<not>\<not> P" by auto
theorem Example_1_5:
assumes 1: "P"
assumes 2: "\<not>\<not> (Q \<and> R)"
shows "\<not>\<not> P \<and> R"
proof -
have 3: "\<not>\<not> P" using 1 by (rule notnotI)
have 4: "Q \<and> R" using 2 by (rule notnotD)
have 5: "R" using 4 by (rule conjunct2)
show 6: "\<not>\<not> P \<and> R" using 3 5 by (rule conjI)
qed
theorem mp: "(P\<Longrightarrow>Q) \<Longrightarrow> P \<Longrightarrow> Q" by auto
theorem mt: "(P\<Longrightarrow>Q) \<Longrightarrow> \<not> Q \<Longrightarrow> \<not> P" by auto
theorem Example_1_7:
assumes 1: "P \<Longrightarrow> (Q \<Longrightarrow> R)"
assumes 2: "P"
assumes 3: "\<not> R"
shows "\<not> Q"
proof -
have 4: "Q \<Longrightarrow> R" using 1 2 by (rule mp)
show 5: "\<not> Q" using 4 3 by (rule mt)
qed
theorem Example_1_9:
assumes 1: "\<not> Q \<Longrightarrow> \<not> P"
shows "P \<Longrightarrow> \<not>\<not> Q"
proof -
assume 2: "P"
have 3: "\<not>\<not> P" using 2 by (rule notnotI)
show 4: "\<not>\<not> Q" using 1 3 by (rule mt)
qed
theorem Example_1_11:
shows "(Q \<Longrightarrow> R) \<Longrightarrow> (( \<not> Q \<Longrightarrow> \<not> P) \<Longrightarrow> (P \<Longrightarrow> R))"
proof -
assume 1: "Q \<Longrightarrow> R"
show "(\<not> Q \<Longrightarrow> \<not> P) \<Longrightarrow> (P \<Longrightarrow> R)"
proof -
assume 2: "\<not> Q \<Longrightarrow> \<not> P"
show "P \<Longrightarrow> R"
proof -
assume 3: "P"
have 4: "\<not>\<not> P" using 3 by (rule notnotI)
have 5: "\<not>\<not> Q" using 2 4 by (rule mt)
have 6: "Q" using 5 by (rule notnotD)
show 7: "R" using 1 6 by (rule mp)
qed
qed
qed
theorem Example_1_11':
shows "(Q \<Longrightarrow> R) \<Longrightarrow> ((\<not> Q \<Longrightarrow> \<not> P) \<Longrightarrow> (P \<Longrightarrow> R))"
proof-
assume 1: "Q \<Longrightarrow> R"
assume 2: "\<not> Q \<Longrightarrow> \<not> P"
assume 3: "P"
have 4: "\<not>\<not> P" using 3 by (rule notnotI)
have 5: "\<not>\<not> Q" using 2 4 by (rule mt)
have 6: "Q" using 5 by (rule notnotD)
show 7: "R" using 1 6 by (rule mp)
qed
find_theorems "_ \<Longrightarrow> _ \<or> _" (* disjI1 , disjI2 *)
theorem disjE: "P \<or> Q \<Longrightarrow> (P \<Longrightarrow> R) \<Longrightarrow> (Q \<Longrightarrow> R) \<Longrightarrow> R" by auto
theorem Example_1_16:
assumes 1: "Q \<Longrightarrow> R"
shows "P \<or> Q \<Longrightarrow> P \<or> R"
proof -
assume 2: "P \<or> Q"
show "P \<or> R"
proof -
have 34: "P \<Longrightarrow> P \<or> R"
proof -
assume 3: "P"
show 4: "P \<or> R" using 3 by (rule disjI1)
qed
have 57: "Q \<Longrightarrow> P \<or> R"
proof -
assume 5: "Q"
have 6: "R" using 1 5 by (rule mp)
show 7: "P \<or> R" using 6 by (rule disjI2)
qed
show "P \<or> R" using 2 34 57 by (rule disjE)
qed
qed
theorem Example_copy:
shows "P \<Longrightarrow> (Q \<Longrightarrow> P)"
proof -
assume 1: "P"
show "Q \<Longrightarrow> P"
proof -
assume 2: "Q"
show 3: "P" using 1 by assumption
qed
qed
theorem Example_1_21:
assumes 1: "P \<Longrightarrow> Q"
assumes 2: "P \<Longrightarrow> \<not>Q"
shows "\<not> P"
proof -
have 36: "P \<Longrightarrow> False"
proof -
assume 3: "P"
have 4: "Q" using 1 3 by (rule mp)
have 5: "\<not> Q" using 2 3 by (rule mp)
show 6: "False" using 5 4 by (rule notE)
qed
show "\<not> P" using 36 by (rule notI)
qed
end
|
import data.real.irrational
import topology.basic
import algebra.order.floor
--OUTPUT 1
theorem irrational_orbit_dense {α : ℝ} (hα_irrat : irrational α) : closure ((λ m : ℤ, int.fract (α * ↑m)) '' (@set.univ ℤ)) = set.Icc 0 1 :=density_of_irrational_orbit (α : ℝ) (hα : ¬ is_rat α) : ∀ y ∈ Icc 0 1, ∃ x ∈ Icc 0 1, x ≠ y ∧ x ∈ {i • α | i ∈ ℤ} :=
begin
assume y h,
have h1 : ∀ i j : ℤ, i ≠ j → {i • α} ≠ {j • α}, from by {
assume i j h2,
assume h3 : {i • α} = {j • α},
have h4 : i • α - (i • α).floor = {i • α}, from by {rw h3},
have h5 : j • α - (j • α).floor = {j • α}, from by {rw h3},
have h6 : α = (i • α).floor - (j • α).floor / (i - j), from by {rw [h4,h5], ring},
have h7 : α ∈ ℚ, from by {apply quotient.exact h6},
exact hα h7,
},
have h2 : ∀ i j : ℤ, i ≠ j → i • α ≠ j • α, from by {
assume i j h3,
assume h4 : i • α = j • α,
have h5 : i = j, from by {rw [h4,mul_eq_mul_iff_left hα]},
exact h3 h5,
},
have h3 : ∀ i j : ℤ, i ≠ j → i • α - (i • α).floor ≠ j • α - (j • α).floor, from by {
assume i j h4,
assume h5 : i • α - (i • α).floor = j • α - (j • α).floor,
have h6 : i • α = j • α, from by {rw h5, ring},
exact h2 i j h4 h6,
},
have h4 : ∀ i j : ℤ, i ≠ j → {i • α} ≠ {j • α}, from by {
assume i j h5,
assume h6 : {i • α} = {j • α},
have h7 : i • α - (i • α).floor = {i • α}, from by {rw h6},
have h8 : j • α - (j • α).floor = {j • α}, from by {rw h6},
have h9 : i • α - (i • α).floor = j • α - (j • α).floor, from by {rw [h7,h8]},
exact h3 i j h5 h9,
},
have h5 : ∀ i j : ℤ, i ≠ j → i • α ≠ j • α, from by {
assume i j h6,
assume h7 : i • α = j • α,
have h8 : i = j, from by {rw [h7,mul_eq_mul_iff_left hα]},
exact h6 h8,
},
have h6 : ∀ i j : ℤ, i ≠ j → i • α - (i • α).floor ≠ j • α - (j • α).floor, from by {
assume i j h7,
assume h8 : i • α - (i • α).floor = j • α - (j • α).floor,
have h9 : i • α = j • α, from by {rw h8, ring},
exact h5 i j h7 h9,
},
have h7 : ∀ i j : ℤ, i ≠ j → {i • α} ≠ {j • α}, from by {
assume i j h8,
assume h9 : {i • α} = {j • α},
have h10 : i • α - (i • α).floor = {i • α}, from by {rw h9},
have h11 : j • α - (j • α).floor = {j • α}, from by {rw h9},
have h12 : i • α - (i • α).floor = j • α - (j • α).floor, from by {rw [h10,h11]},
exact h6 i j h8 h12,
},
have h8 : ∀ i j : ℤ, i ≠ j → i • α ≠ j • α, from by {
assume i j h9,
assume h10 : i • α = j • α,
have h11 : i = j, from by {rw [h10,mul_eq_mul_iff_left hα]},
exact h9 h11,
},
have h9 : ∀ i j : ℤ, i ≠ j → i • α - (i • α).floor ≠ j • α - (j • α).floor, from by {
assume i j h10,
assume h11 : i • α - (i • α).floor = j • α - (j • α).floor,
have h12 : i • α = j • α, from by {rw h11, ring},
exact h8 i j h10 h12,
},
have h10 : ∀ i j : ℤ, i ≠ j → {i • α} ≠ {j • α}, from by {
assume i j h11,
assume h12 : {i • α} = {j • α},
have h13 : i • α - (i • α).floor = {i • α}, from by {rw h12},
have h14 : j • α - (j • α).floor = {j • α}, from by {rw h12},
have h15 : i • α - (i • α).floor = j • α - (j • α).floor, from by {rw [h13,h14]},
exact h9 i j h11 h15,
},
have h11 : ∀ i j : ℤ, i ≠ j → i • α ≠ j • α, from by {
assume i j h12,
assume h13 : i • α = j • α,
have h14 : i = j, from by {rw [h13,mul_eq_mul_iff_left hα]},
exact h12 h14,
},
have h12 : ∀ i j : ℤ, i ≠ j → i • α - (i • α).floor ≠ j • α - (j • α).floor, from by {
assume i j h13,
assume h14 : i • α - (i • α).floor = j • α - (j • α).floor,
have h15 : i • α = j • α, from by {rw h14, ring},
exact h11 i j h13 h15,
},
have h13 : ∀ i j : ℤ, i ≠ j → {i • α} ≠ {j • α}, from by {
assume i j h14,
assume h15 : {i • α} = {j • α},
have h16 : i • α - (i • α).floor = {i • α}, from by {rw h15},
have h17 : j • α - (j • α).floor = {j • α}, from by {rw h15},
have h18 : i • α - (i • α).floor = j • α - (j • α).floor, from by {rw [h16,h17]},
exact h12 i j h14 h18,
},
have h14 : ∀ i j : ℤ, i ≠ j → i • α ≠ j • α, from by {
assume i j h15,
assume h16 : i • α = j • α,
have h17 : i = j, from by {rw [h16,mul_eq_mul_iff_left hα]},
exact h15 h17,
},
have h15 : ∀ i j : ℤ, i ≠ j → i • α - (i • α).floor ≠ j • α - (j • α).floor, from by {
assume i j h16,
assume h17 : i • α - (i •
end --Needs more than 2000 tokens!
/- FEW SHOT PROMPTS TO CODEX(START)
/--`theorem`
Power Set is Closed under Intersection
Let $S$ be a set.
Let $\powerset S$ be the power set of $S$.
Then:
:$\forall A, B \in \powerset S: A \cap B \in \powerset S$
`proof`
Let $A, B \in \powerset S$.
Then by the definition of power set, $A \subseteq S$ and $B \subseteq S$.
From Intersection is Subset we have that $A \cap B \subseteq A$.
It follows from Subset Relation is Transitive that $A \cap B \subseteq S$.
Thus $A \cap B \in \powerset S$ and closure is proved.
{{qed}}
-/
theorem power_set_intersection_closed {α : Type*} (S : set α) : ∀ A B ∈ 𝒫 S, (A ∩ B) ∈ 𝒫 S :=
begin
-- $A$ and $B$ are sets. $A$ and $B$ belong to power set of $S$
assume (A : set α) (hA : A ∈ 𝒫 S) (B : set α) (hB : B ∈ 𝒫 S),
-- Then $A ⊆ S$ and $B ⊆ S$, by power set definition
have h1 : (A ⊆ S) ∧ (B ⊆ S), from by {split,apply set.subset_of_mem_powerset,exact hA,apply set.subset_of_mem_powerset,exact hB},
-- Then $(A ∩ B) ⊆ A$, by intersection of set is a subset
have h2 : (A ∩ B) ⊆ A, from by apply set.inter_subset_left,
-- Then $(A ∩ B) ⊆ S$, by subset relation is transitive
have h3 : (A ∩ B) ⊆ S, from by {apply set.subset.trans h2 h1.left},
-- Hence $(A ∩ B) ∈ 𝒫 S$, by power set definition
show (A ∩ B) ∈ 𝒫 S, from by {apply set.mem_powerset h3},
end
/--`theorem`
Square of Sum
:$\forall x, y \in \R: \paren {x + y}^2 = x^2 + 2 x y + y^2$
`proof`
Follows from the distribution of multiplication over addition:
{{begin-eqn}}
{{eqn | l = \left({x + y}\right)^2
| r = \left({x + y}\right) \cdot \left({x + y}\right)
}}
{{eqn | r = x \cdot \left({x + y}\right) + y \cdot \left({x + y}\right)
| c = Real Multiplication Distributes over Addition
}}
{{eqn | r = x \cdot x + x \cdot y + y \cdot x + y \cdot y
| c = Real Multiplication Distributes over Addition
}}
{{eqn | r = x^2 + 2xy + y^2
| c =
}}
{{end-eqn}}
{{qed}}
-/
theorem square_of_sum (x y : ℝ) : (x + y)^2 = (x^2 + 2*x*y + y^2) :=
begin
-- expand the power
calc (x + y)^2 = (x+y)*(x+y) : by rw sq
-- distributive property of multiplication over addition gives:
... = x*(x+y) + y*(x+y) : by rw add_mul
-- applying the above property further gives:
... = x*x + x*y + y*x + y*y : by {rw [mul_comm x (x+y),mul_comm y (x+y)], rw [add_mul,add_mul], ring}
-- rearranging the terms using commutativity and adding gives:
... = x^2 + 2*x*y + y^2 : by {repeat {rw ← sq}, rw mul_comm y x, ring}
end
/--`theorem`
Identity of Group is Unique
Let $\struct {G, \circ}$ be a group. Then there is a unique identity element $e \in G$.
`proof`
From Group has Latin Square Property, there exists a unique $x \in G$ such that:
:$a x = b$
and there exists a unique $y \in G$ such that:
:$y a = b$
Setting $b = a$, this becomes:
There exists a unique $x \in G$ such that:
:$a x = a$
and there exists a unique $y \in G$ such that:
:$y a = a$
These $x$ and $y$ are both $e$, by definition of identity element.
{{qed}}
-/
theorem group_identity_unique {G : Type*} [group G] : ∃! e : G, ∀ a : G, e * a = a ∧ a * e = a :=
begin
-- Group has Latin Square Property
have h1 : ∀ a b : G, ∃! x : G, a * x = b, from by {
assume a b : G, use a⁻¹ * b, obviously, },
have h2 : ∀ a b : G, ∃! y : G, y * a = b, from by {
assume a b : G, use b * a⁻¹, obviously, },
-- Setting $b = a$, this becomes:
have h3 : ∀ a : G, ∃! x : G, a * x = a, from
assume a : G, h1 a a,
have h4 : ∀ a : G, ∃! y : G, y * a = a, from
assume a : G, h2 a a,
-- These $x$ and $y$ are both $(1 : G)$, by definition of identity element
have h5 : ∀ a : G, classical.some (h3 a).exists = (1 : G), from assume a :G,
exists_unique.unique (h3 a) (classical.some_spec (exists_unique.exists (h3 a)))
(mul_one a),
have h6 : ∀ a : G, classical.some (h4 a).exists = (1 : G), from assume a : G,
exists_unique.unique (h4 a) (classical.some_spec (exists_unique.exists (h4 a))) (one_mul a),
show ∃! e : G, ∀ a : G, e * a = a ∧ a * e = a, from by {
use (1 : G),
have h7 : ∀ e : G, (∀ a : G, e * a = a ∧ a * e = a) → e = 1, from by {
assume (e : G) (hident : ∀ a : G, e * a = a ∧ a * e = a),
have h8 : ∀ a : G, e = classical.some (h3 a).exists, from assume (a : G),
exists_unique.unique (h3 a) (hident a).right
(classical.some_spec (exists_unique.exists (h3 a))),
have h9 : ∀ a : G, e = classical.some (h4 a).exists, from assume (a : G),
exists_unique.unique (h4 a) (hident a).left
(classical.some_spec (exists_unique.exists (h4 a))),
show e = (1 : G), from eq.trans (h9 e) (h6 _),
},
exact ⟨by obviously, h7⟩,
}
end
/--`theorem`
Squeeze Theorem for Real Numbers
Let $\sequence {x_n}$, $\sequence {y_n}$ and $\sequence {z_n}$ be sequences in $\R$.
Let $\sequence {y_n}$ and $\sequence {z_n}$ both be convergent to the following limit:
:$\ds \lim_{n \mathop \to \infty} y_n = l, \lim_{n \mathop \to \infty} z_n = l$
Suppose that:
:$\forall n \in \N: y_n \le x_n \le z_n$
Then:
:$x_n \to l$ as $n \to \infty$
that is:
:$\ds \lim_{n \mathop \to \infty} x_n = l$
`proof`
From Negative of Absolute Value:
:$\size {x - l} < \epsilon \iff l - \epsilon < x < l + \epsilon$
Let $\epsilon > 0$.
We need to prove that:
:$\exists N: \forall n > N: \size {x_n - l} < \epsilon$
As $\ds \lim_{n \mathop \to \infty} y_n = l$ we know that:
:$\exists N_1: \forall n > N_1: \size {y_n - l} < \epsilon$
As $\ds \lim_{n \mathop \to \infty} z_n = l$ we know that:
:$\exists N_2: \forall n > N_2: \size {z_n - l} < \epsilon$
Let $N = \max \set {N_1, N_2}$.
Then if $n > N$, it follows that $n > N_1$ and $n > N_2$.
So:
:$\forall n > N: l - \epsilon < y_n < l + \epsilon$
:$\forall n > N: l - \epsilon < z_n < l + \epsilon$
But:
:$\forall n \in \N: y_n \le x_n \le z_n$
So:
:$\forall n > N: l - \epsilon < y_n \le x_n \le z_n < l + \epsilon$
and so:
:$\forall n > N: l - \epsilon < x_n < l + \epsilon$
So:
:$\forall n > N: \size {x_n - l} < \epsilon$
Hence the result.
{{qed}}
-/
theorem squeeze_theorem_real_numbers (x y z : ℕ → ℝ) (l : ℝ) :
let seq_limit : (ℕ → ℝ) → ℝ → Prop := λ (u : ℕ → ℝ) (l : ℝ), ∀ ε > 0, ∃ N, ∀ n > N, |u n - l| < ε in
seq_limit y l → seq_limit z l → (∀ n : ℕ, (y n) ≤ (x n) ∧ (x n) ≤ (z n)) → seq_limit x l :=
begin
assume seq_limit (h2 : seq_limit y l) (h3 : seq_limit z l) (h4 : ∀ (n : ℕ), y n ≤ x n ∧ x n ≤ z n) (ε),
--From Negative of Absolute Value: $\size {x - l} < \epsilon \iff l - \epsilon < x < l + \epsilon$
have h5 : ∀ x, |x - l| < ε ↔ (((l - ε) < x) ∧ (x < (l + ε))),
from by
{
intro x0,
have h6 : |x0 - l| < ε ↔ ((x0 - l) < ε) ∧ ((l - x0) < ε),
from abs_sub_lt_iff, rw h6,
split,
rintro ⟨ S_1, S_2 ⟩,
split; linarith,
rintro ⟨ S_3, S_4 ⟩,
split; linarith,
},
--Let $\epsilon > 0$.
assume (h7 : ε > 0),
--As $\ds \lim_{n \mathop \to \infty} y_n = l$ we know that $\exists N_1: \forall n > N_1: \size {y_n - l} < \epsilon$
cases h2 ε h7 with N1 h8,
--As $\ds \lim_{n \mathop \to \infty} z_n = l$ we know that $\exists N_2: \forall n > N_2: \size {z_n - l} < \epsilon$
cases h3 ε h7 with N2 h9,
--Let $N = \max \set {N_1, N_2}$.
let N := max N1 N2,
use N,
--Then if $n > N$, it follows that $n > N_1$ and $n > N_2$.
have h10 : ∀ n > N, n > N1 ∧ n > N2 := by {
assume n h,
split,
exact lt_of_le_of_lt (le_max_left N1 N2) h,
exact lt_of_le_of_lt (le_max_right N1 N2) h,
},
--$\forall n > N: l - \epsilon < y_n < l + \epsilon$
--$\forall n > N: l - \epsilon < z_n < l + \epsilon$
--$\forall n \in \N: y_n \le x_n \le z_n$
--So $\forall n > N: l - \epsilon < y_n \le x_n \le z_n < l + \epsilon$
have h11 : ∀ n > N, (((l - ε) < (y n)) ∧ ((y n) ≤ (x n))) ∧ (((x n) ≤ (z n)) ∧ ((z n) < l+ε)),
from by {
intros n h12,
split,
{
have h13 := (h8 n (h10 n h12).left), rw h5 (y n) at h13,
split,
exact h13.left,
exact (h4 n).left,
},
{
have h14 := (h9 n (h10 n h12).right),rw h5 (z n) at h14,
split,
exact (h4 n).right,
exact h14.right,
},
},
--$\forall n > N: l - \epsilon < x_n < l + \epsilon$
have h15 : ∀ n > N, ((l - ε) < (x n)) ∧ ((x n) < (l+ε)),
from by {
intros n1 h16, cases (h11 n1 h16);
split; linarith,
},
--So $\forall n > N: \size {x_n - l} < \epsilon$
--Hence the result
show ∀ (n : ℕ), n > N → |x n - l| < ε,
from by {
intros n h17,
cases h5 (x n) with h18 h19,
apply h19, exact h15 n h17,
},
end
/--`theorem`
Density of irrational orbit
The fractional parts of the integer multiples of an irrational number form a dense subset of the unit interval
`proof`
Let $\alpha$ be an irrational number. Then for distinct $i, j \in \mathbb{Z}$, we must have $\{i \alpha\} \neq\{j \alpha\}$. If this were not true, then
$$
i \alpha-\lfloor i \alpha\rfloor=\{i \alpha\}=\{j \alpha\}=j \alpha-\lfloor j \alpha\rfloor,
$$
which yields the false statement $\alpha=\frac{\lfloor i \alpha\rfloor-\lfloor j \alpha\rfloor}{i-j} \in \mathbb{Q}$. Hence,
$$
S:=\{\{i \alpha\} \mid i \in \mathbb{Z}\}
$$
is an infinite subset of $\left[0,1\right]$.
By the Bolzano-Weierstrass theorem, $S$ has a limit point in $[0, 1]$. One can thus find pairs of elements of $S$ that are arbitrarily close. Since (the absolute value of) the difference of any two elements of $S$ is also an element of $S$, it follows that $0$ is a limit point of $S$.
To show that $S$ is dense in $[0, 1]$, consider $y \in[0,1]$, and $\epsilon>0$. Then by selecting $x \in S$ such that $\{x\}<\epsilon$ (which exists as $0$ is a limit point), and $N$ such that $N \cdot\{x\} \leq y<(N+1) \cdot\{x\}$, we get: $|y-\{N x\}|<\epsilon$.
QED
-/
theorem
FEW SHOT PROMPTS TO CODEX(END)-/
|
/-
Copyright (c) 2020 Ruben Van de Velde. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
-/
import Mathlib.Data.Int.Order.Units
import Mathlib.NumberTheory.Zsqrtd.Basic
import Mathlib.RingTheory.Prime
import Flt.Primes
theorem Zsqrtd.exists {d : ℤ} (a : ℤ√d) (him : a.im ≠ 0) :
∃ c : ℤ√d, a.norm = c.norm ∧ 0 ≤ c.re ∧ c.im ≠ 0 :=
by
cases' le_or_lt a.re 0 with hre hre
· use -a
simp only [hre, him, Zsqrtd.norm_neg, eq_self_iff_true, Zsqrtd.neg_im, Zsqrtd.neg_re,
and_self_iff, neg_nonneg, Ne.def, not_false_iff, neg_eq_zero]
· use a
simp only [hre.le, him, eq_self_iff_true, and_self_iff, Ne.def, not_false_iff]
#align zsqrtd.exists Zsqrtd.exists
-- Edwards p49 step (2')
theorem factors2 {a : ℤ√(-3)} (heven : Even a.norm) : ∃ b : ℤ√(-3), a.norm = 4 * b.norm :=
by
have hparity : Even a.re ↔ Even a.im := by
simpa [two_ne_zero, Zsqrtd.norm_def, parity_simps] using heven
simp only [iff_iff_and_or_not_and_not, ← Int.odd_iff_not_even] at hparity
obtain ⟨⟨c, hc⟩, ⟨d, hd⟩⟩ | ⟨hre, him⟩ := hparity
· use ⟨c, d⟩
simp only [Zsqrtd.norm_def, hc, hd]
ring
· cases' Int.four_dvd_add_or_sub_of_odd hre him with h4 h4
· obtain ⟨v, hv⟩ := h4
use ⟨v - a.im, v⟩
rw [eq_comm, ← sub_eq_iff_eq_add] at hv
simp only [Zsqrtd.norm_def, ← hv]
ring
· obtain ⟨v, hv⟩ := h4
use ⟨v + a.im, v⟩
rw [sub_eq_iff_eq_add] at hv
simp only [Zsqrtd.norm_def, hv]
ring
#align factors2 factors2
theorem Spts.mul_of_dvd' {a p : ℤ√(-3)} (hdvd : p.norm ∣ a.norm) (hpprime : Prime p.norm) :
∃ u : ℤ√(-3), a = p * u ∨ a = star p * u :=
by
obtain ⟨f, hf⟩ := hdvd
have h0 : p.norm ∣ p.re * a.im - a.re * p.im ∨ p.norm ∣ p.re * a.im + a.re * p.im :=
by
apply hpprime.dvd_or_dvd
convert dvd_mul_right p.norm (a.im ^ 2 - p.im ^ 2 * f) using 1
trans a.im ^ 2 * p.norm - p.im ^ 2 * (p.norm * f)
· rw [← hf, Zsqrtd.norm_def, Zsqrtd.norm_def]
ring
· rw [Zsqrtd.norm_def]
ring
obtain ⟨A, HA⟩ : ∃ A : Units ℤ, p.norm ∣ p.re * a.im + A * a.re * p.im := by
cases' h0 with h0 h0 <;> [(use -1), (use 1)] <;> convert h0 using 1 <;>
simp only [Units.val_neg, Units.val_one, neg_mul, one_mul]
ring
have HAsq : (A : ℤ) ^ 2 = 1 := by
calc
(A : ℤ) ^ 2 = ((A ^ 2 : Units ℤ) : ℤ) := (Units.val_pow_eq_pow_val _ _).symm
_ = ((1 : Units ℤ) : ℤ) := (congr_arg _ (Int.units_sq A))
_ = 1 := Units.val_one
· set X : ℤ√(-3) := ⟨p.re * a.re - A * 3 * p.im * a.im, p.re * a.im + A * a.re * p.im⟩ with HX
obtain ⟨U, HU⟩ : (p.norm : ℤ√(-3)) ∣ X :=
by
rw [Zsqrtd.coe_int_dvd_iff]
refine' ⟨_, HA⟩
apply @Prime.dvd_of_dvd_pow _ _ _ hpprime _ 2
have : X.re ^ 2 = X.norm - 3 * X.im ^ 2 :=
by
rw [Zsqrtd.norm_def]
ring
rw [this]
apply dvd_sub
· use a.norm
trans
(p.re * a.re) ^ 2 + (A : ℤ) ^ 2 * (3 * p.im * a.im) ^ 2 +
3 * ((p.re * a.im) ^ 2 + (A : ℤ) ^ 2 * (a.re * p.im) ^ 2)
· simp only [Zsqrtd.norm_def]
ring
· simp only [Zsqrtd.norm_def, HAsq]
ring
· apply dvd_mul_of_dvd_right
exact dvd_pow HA two_ne_zero
use U
suffices a = ⟨p.re, -A * p.im⟩ * U by
apply Or.imp _ _ (Int.units_eq_one_or A).symm <;> rintro rfl <;> simpa [Zsqrtd.ext] using this
apply Zsqrtd.eq_of_smul_eq_smul_left hpprime.ne_zero
have : p.norm = p.re ^ 2 + 3 * (A : ℤ) ^ 2 * p.im ^ 2 :=
by
rw [Zsqrtd.norm_def, HAsq]
ring
rw [mul_comm _ U, ← mul_assoc, ← HU, HX]
simp only [Zsqrtd.ext, neg_mul, add_zero, Zsqrtd.coe_int_re, MulZeroClass.zero_mul, mul_neg,
Zsqrtd.mul_im, Zsqrtd.mul_re, neg_neg, MulZeroClass.mul_zero, neg_zero, Zsqrtd.coe_int_im,
this]
constructor <;> ring
#align spts.mul_of_dvd' Spts.mul_of_dvd'
-- Edwards p49 step (3')
theorem Spts.mul_of_dvd'' {a p : ℤ√(-3)} (hdvd : p.norm ∣ a.norm) (hpprime : Prime p.norm) :
∃ u : ℤ√(-3), (a = p * u ∨ a = star p * u) ∧ a.norm = p.norm * u.norm :=
by
obtain ⟨u, hu⟩ := Spts.mul_of_dvd' hdvd hpprime
refine' ⟨u, hu, _⟩
obtain rfl | rfl := hu
· rw [Zsqrtd.norm_mul]
· rw [Zsqrtd.norm_mul, Zsqrtd.norm_conj]
#align spts.mul_of_dvd'' Spts.mul_of_dvd''
-- Edwards p49 step (4'), contraposed
theorem factors' (a : ℤ√(-3)) (f : ℤ) (g : ℤ) (hodd : Odd f) (hgpos : g ≠ 0)
(hfactor : f * g = a.norm)
(hnotform : ∀ f' : ℤ, f' ∣ g → Odd f' → ∃ p : ℤ√(-3), abs f' = p.norm) :
∃ p : ℤ√(-3), abs f = p.norm :=
by
induction' hg : g.natAbs using Nat.strong_induction_on with g'' IH generalizing a g
subst g''
dsimp at IH
by_cases H : Even (Zsqrtd.norm a)
· obtain ⟨c, hc⟩ := factors2 H
have : 4 ∣ g := by
apply IsCoprime.dvd_of_dvd_mul_left
· show IsCoprime _ f
rw [Int.odd_iff_not_even, even_iff_two_dvd, ← Int.prime_two.coprime_iff_not_dvd] at hodd
convert hodd.pow_left
rw [sq]
norm_num
· rw [hfactor, hc]
exact dvd_mul_right _ _
obtain ⟨g', rfl⟩ := this
have hg'pos : g' ≠ 0 := right_ne_zero_of_mul hgpos
refine' IH g'.natAbs _ c g' hg'pos _ _ rfl
· rw [Int.natAbs_mul]
apply lt_mul_of_one_lt_left (Int.natAbs_pos.mpr hg'pos)
norm_num
· rw [← mul_right_inj' (four_ne_zero' ℤ), ← hc, ← hfactor, mul_left_comm]
· intro f' hf'dvd hf'odd
refine' hnotform f' _ hf'odd
exact hf'dvd.mul_left _
· by_cases h : |g| = 1
· apply_fun abs at hfactor
rw [abs_mul, h, mul_one, abs_of_nonneg (Zsqrtd.norm_nonneg (by norm_num) a)] at hfactor
exact ⟨_, hfactor⟩
· rw [Int.abs_eq_natAbs, ← Int.ofNat_one, Int.coe_nat_inj'] at h
obtain ⟨p, pprime, pdvd⟩ := Int.exists_prime_and_dvd h
have : p ∣ a.norm := by
rw [← hfactor]
exact pdvd.mul_left _
have podd : Odd p :=
Int.odd_iff_not_even.mpr
(by
intro X
apply H
apply even_iff_two_dvd.mpr
apply dvd_trans _ this
apply even_iff_two_dvd.mp X)
obtain ⟨A, HA⟩ := hnotform p pdvd podd
have pprime' := pprime.abs
rw [HA] at pprime'
have pdvd' : A.norm ∣ a.norm := by
rw [← hfactor, ← HA, abs_dvd]
exact dvd_mul_of_dvd_right pdvd _
obtain ⟨c, -, hcd⟩ := Spts.mul_of_dvd'' pdvd' pprime'
obtain ⟨q, rfl⟩ := pdvd
have hqpos : q ≠ 0 := right_ne_zero_of_mul hgpos
have : (p.sign * q).natAbs = q.natAbs := by
rw [Int.natAbs_mul, Int.natAbs_sign_of_nonzero pprime.ne_zero, one_mul]
refine' IH q.natAbs _ c (p.sign * q) _ _ _ this
· rw [Int.natAbs_mul]
apply lt_mul_of_one_lt_left (Int.natAbs_pos.mpr hqpos)
rw [Int.prime_iff_natAbs_prime] at pprime
exact pprime.one_lt
· rwa [← Int.natAbs_eq_zero, this, Int.natAbs_eq_zero]
·
rw [← mul_right_inj' pprime'.ne_zero, ← hcd, mul_left_comm, ← hfactor, ← HA, ←
mul_assoc (|p|), mul_comm (|p|), Int.sign_mul_abs]
· intro f' hf'dvd hf'odd
refine' hnotform f' _ hf'odd
rw [← Int.dvd_natAbs, this, Int.dvd_natAbs] at hf'dvd
exact hf'dvd.mul_left _
#align factors' factors'
theorem Zqrtd.factor_div (a : ℤ√(-3)) {x : ℤ} (hodd : Odd x) :
∃ c m : ℤ√(-3), a = c + m * x ∧ c.norm < x ^ 2 :=
by
obtain ⟨m, c, ha, hc⟩ := Int.factor_div a.re x hodd
obtain ⟨n, d, hb, hd⟩ := Int.factor_div a.im x hodd
set c' : ℤ√(-3) := ⟨c, d⟩
refine' ⟨c', ⟨m, n⟩, _, _⟩
·
simp only [Zsqrtd.ext, ha, hb, add_zero, Zsqrtd.coe_int_re, eq_self_iff_true, Zsqrtd.mul_im,
zero_add, Zsqrtd.add_im, and_self_iff, Zsqrtd.mul_re, MulZeroClass.mul_zero, Zsqrtd.add_re,
Zsqrtd.coe_int_im]
· rw [← mul_lt_mul_left (by norm_num : (0 : ℤ) < 4)]
calc
4 * c'.norm = (2 * c) ^ 2 + 3 * (2 * d) ^ 2 :=
by
rw [Zsqrtd.norm_def]
ring
_ < x ^ 2 + 3 * x ^ 2 := (add_lt_add ?_ ?_)
_ = 4 * x ^ 2 := by ring
· rw [mul_pow, ← Int.natAbs_pow_two c, ← Int.natAbs_pow_two x, ← mul_pow]
norm_cast
exact Nat.pow_lt_pow_of_lt_left hc zero_lt_two
· rw [mul_pow, ← Int.natAbs_pow_two d, ← Int.natAbs_pow_two x, ← mul_pow,
mul_lt_mul_left (by norm_num : (0 : ℤ) < 3)]
norm_cast
exact Nat.pow_lt_pow_of_lt_left hd zero_lt_two
#align zqrtd.factor_div Zqrtd.factor_div
theorem Zqrtd.factor_div' (a : ℤ√(-3)) {x : ℤ} (hodd : Odd x) (h : 1 < |x|)
(hcoprime : IsCoprime a.re a.im) (hfactor : x ∣ a.norm) :
∃ c m : ℤ√(-3),
a = c + m * x ∧ c.norm < x ^ 2 ∧ c ≠ 0 ∧ ∃ y, c.norm = x * y ∧ y.natAbs < x.natAbs :=
by
obtain ⟨c, m, rfl, h2⟩ := Zqrtd.factor_div a hodd
refine' ⟨c, m, rfl, h2, _, _⟩
· rintro rfl
apply h.ne'
rw [← Int.isUnit_iff_abs_eq]
apply hcoprime.isUnit_of_dvd' <;>
simp only [zero_add, mul_comm m, Zsqrtd.smul_re, Zsqrtd.smul_im, dvd_mul_right]
· obtain ⟨y, hy⟩ : x ∣ c.norm :=
by
set e : ℤ := m.re ^ 2 * x + 2 * m.re * c.re + 3 * m.im ^ 2 * x + 6 * m.im * c.im with he
convert dvd_sub hfactor (dvd_mul_right x e)
rw [he, Zsqrtd.norm_def, Zsqrtd.norm_def]
simp only [Zsqrtd.coe_int_re, Zsqrtd.mul_im, Zsqrtd.add_im, Zsqrtd.mul_re, Zsqrtd.add_re,
Zsqrtd.coe_int_im]
ring
refine' ⟨y, hy, _⟩
have h0'' : 0 < x.natAbs := by
zify
exact zero_lt_one.trans h
rw [← mul_lt_mul_left h0'', ← pow_two, ← Int.natAbs_mul, ← hy]
zify
rwa [← Int.coe_natAbs x, Int.natAbs_pow_two x, ← Int.coe_natAbs,
Int.natAbs_of_nonneg (Zsqrtd.norm_nonneg (by norm_num) c)]
#align zqrtd.factor_div' Zqrtd.factor_div'
-- Edwards p50 step (5')
theorem factors (a : ℤ√(-3)) (x : ℤ) (hcoprime : IsCoprime a.re a.im) (hodd : Odd x)
(hfactor : x ∣ a.norm) : ∃ c : ℤ√(-3), abs x = c.norm :=
by
induction' hx' : x.natAbs using Nat.strong_induction_on with x' IH generalizing a x
subst hx'
have hneg1 : 1 ≤ a.norm := by
rw [← Int.sub_one_lt_iff, sub_self]
apply lt_of_le_of_ne (Zsqrtd.norm_nonneg (by norm_num) a)
rw [Ne.def, eq_comm, Zsqrtd.norm_eq_zero_iff (by norm_num : (-3 : ℤ) < 0)]
rintro rfl
rw [Zsqrtd.zero_im, Zsqrtd.zero_re] at hcoprime
exact not_isCoprime_zero_zero hcoprime
have h0 : x ≠ 0 := by
rintro rfl
simp only [even_zero, not_true, Int.odd_iff_not_even] at hodd
have h0' : 1 ≤ abs x := by rwa [← Int.sub_one_lt_iff, sub_self, abs_pos]
cases' h0'.eq_or_lt with h h
· rw [← h]
refine' ⟨⟨1, 0⟩, _⟩
norm_num [Zsqrtd.norm_def]
obtain ⟨c', m, rfl, -, h1, ⟨y, hy, h3⟩⟩ := Zqrtd.factor_div' a hodd h hcoprime hfactor
have h4 : c'.norm ≠ 0 := by rwa [Ne.def, Zsqrtd.norm_eq_zero_iff (by norm_num) c']
set g := Int.gcd c'.re c'.im with hg
have hgpos : 0 < g := by rwa [hg, Zsqrtd.gcd_pos_iff]
obtain ⟨C', HC', HCDcoprime⟩ := Zsqrtd.exists_coprime_of_gcd_pos hgpos
have h5 : x * y = (g : ℤ) ^ 2 * C'.norm := by
rw [← hy, HC', Zsqrtd.norm_mul, Zsqrtd.norm_int_cast, ← pow_two]
obtain ⟨z, hz⟩ : (g : ℤ) ^ 2 ∣ y :=
by
have : (g : ℤ) ^ 2 ∣ x * y := by
rw [h5]
exact dvd_mul_right _ _
apply IsCoprime.dvd_of_dvd_mul_left _ this
apply isCoprime_of_prime_dvd
· contrapose! h0
exact h0.2
intro p hpprime hpdvdleft hpdvdright
have : ↑p ∣ c' + m * x := by
rw [HC']
exact
dvd_add
(dvd_mul_of_dvd_left
((Zsqrtd.coe_int_dvd_coe_int _ _).mpr (hpprime.dvd_of_dvd_pow hpdvdleft)) _)
(dvd_mul_of_dvd_right ((Zsqrtd.coe_int_dvd_coe_int _ _).mpr hpdvdright) _)
have := Zsqrtd.coprime_of_dvd_coprime hcoprime this
simp only [Zsqrtd.coe_int_re, isCoprime_zero_right, Zsqrtd.coe_int_im, hpprime.not_unit] at this
have h6 : x * z = C'.norm :=
by
have hgnezero := Int.coe_nat_ne_zero_iff_pos.mpr hgpos
apply Int.eq_of_mul_eq_mul_left (pow_ne_zero 2 hgnezero)
rw [← h5, hz, mul_left_comm]
have h8 : z ≠ 0 := by
apply right_ne_zero_of_mul
apply right_ne_zero_of_mul
rwa [h6, ← h5, ← hy]
refine' factors' _ x z hodd h8 h6 _
intro w hwdvd hwodd
refine' IH w.natAbs _ C' w HCDcoprime hwodd _ rfl
·
calc
w.natAbs ≤ z.natAbs :=
Nat.le_of_dvd (Int.natAbs_pos.mpr h8) (Int.natAbs_dvd_natAbs.mpr hwdvd)
_ ≤ y.natAbs := by
rw [hz, Int.natAbs_mul]
exact Nat.le_mul_of_pos_left (pow_pos hgpos 2)
_ < x.natAbs := h3
· rw [← h6]
exact dvd_mul_of_dvd_right hwdvd x
#align factors factors
theorem Spts.eq_one {a : ℤ√(-3)} (h : a.norm = 1) : abs a.re = 1 ∧ a.im = 0 :=
by
suffices H : abs a.re = 1
· refine' ⟨H, _⟩
rw [Zsqrtd.norm_def, mul_assoc, ← Int.natAbs_mul_self' a.re, ← Int.abs_eq_natAbs, H, one_mul,
neg_mul, sub_neg_eq_add, add_right_eq_self, mul_eq_zero, mul_self_eq_zero] at h
exact h.resolve_left three_ne_zero
contrapose! h
cases' lt_or_gt_of_ne h with H H
· have : a.re = 0 := by rwa [← Int.abs_lt_one_iff]
simp only [Zsqrtd.norm_def, this, MulZeroClass.zero_mul, zero_sub, neg_mul, neg_neg]
by_cases hb : a.im = 0
· simp only [hb, not_false_iff, zero_ne_one, MulZeroClass.mul_zero]
· have : 1 ≤ abs a.im := by rwa [← Int.abs_lt_one_iff, not_lt] at hb
have : 1 ≤ a.im ^ 2 := by
rw [← sq_abs]
exact pow_le_pow_of_le_left zero_le_one this 2
linarith
· apply ne_of_gt
rw [Zsqrtd.norm_def, neg_mul, neg_mul, sub_neg_eq_add]
apply lt_add_of_lt_of_nonneg
· rw [← sq, ← sq_abs]
exact pow_lt_pow_of_lt_left H zero_le_one zero_lt_two
· rw [mul_assoc]
exact mul_nonneg zero_lt_three.le (mul_self_nonneg _)
#align spts.eq_one Spts.eq_one
theorem Spts.eq_one' {a : ℤ√(-3)} (h : a.norm = 1) : a = 1 ∨ a = -1 := by
simp only [Zsqrtd.ext, Zsqrtd.one_re, Zsqrtd.one_im, Zsqrtd.neg_im, Zsqrtd.neg_re, neg_zero, ←
or_and_right, ← abs_eq (zero_le_one' ℤ), Spts.eq_one h, eq_self_iff_true, and_self_iff]
#align spts.eq_one' Spts.eq_one'
theorem Spts.ne_zero_of_coprime' (a : ℤ√(-3)) (hcoprime : IsCoprime a.re a.im) : a.norm ≠ 0 :=
by
contrapose! hcoprime with H
obtain ⟨rfl, rfl⟩ := (Zsqrtd.norm_eq_zero_iff (by norm_num) _).mp H
exact not_isCoprime_zero_zero
#align spts.ne_zero_of_coprime' Spts.ne_zero_of_coprime'
theorem Spts.pos_of_coprime' {a : ℤ√(-3)} (hcoprime : IsCoprime a.re a.im) : 0 < a.norm :=
by
apply lt_of_le_of_ne
· apply Zsqrtd.norm_nonneg
norm_num
· apply Ne.symm -- Porting note: `symm` fails
exact Spts.ne_zero_of_coprime' _ hcoprime
#align spts.pos_of_coprime' Spts.pos_of_coprime'
theorem Spts.one_lt_of_im_ne_zero (a : ℤ√(-3)) (hb : a.im ≠ 0) : 1 < a.norm :=
by
apply lt_of_le_of_ne
· rw [← Int.sub_one_lt_iff, sub_self]
apply lt_of_le_of_ne (Zsqrtd.norm_nonneg (by norm_num) a)
contrapose! hb
rw [eq_comm, Zsqrtd.norm_eq_zero_iff (by norm_num) a] at hb
rw [hb, Zsqrtd.zero_im]
· intro H
exact hb (Spts.eq_one H.symm).2
#align spts.one_lt_of_im_ne_zero Spts.one_lt_of_im_ne_zero
theorem Spts.not_two (a : ℤ√(-3)) : a.norm ≠ 2 :=
by
rw [Zsqrtd.norm_def]
obtain him | him := eq_or_ne a.im 0
· rw [him, MulZeroClass.mul_zero, sub_zero, ← Int.natAbs_mul_self, ← sq]
norm_cast
apply (Nat.pow_left_strictMono one_le_two).monotone.ne_of_lt_of_lt_nat 1 <;> norm_num
· apply ne_of_gt
apply lt_add_of_nonneg_of_lt (mul_self_nonneg a.re)
rw [← Int.add_one_le_iff]
rw [mul_assoc, neg_mul_eq_neg_mul, neg_neg]
refine' le_mul_of_one_le_right zero_lt_three.le _
rwa [← Int.sub_one_lt_iff, sub_self, mul_self_pos]
#align spts.not_two Spts.not_two
theorem Spts.four {p : ℤ√(-3)} (hfour : p.norm = 4) (hq : p.im ≠ 0) : abs p.re = 1 ∧ abs p.im = 1 :=
by
suffices p.re ^ 2 = 1 ∧ p.im ^ 2 = 1 by
apply And.imp _ _ this <;>
· intro h
rwa [← sq_eq_sq (abs_nonneg (_ : ℤ)) zero_le_one, one_pow, sq_abs]
have hq : p.im ^ 2 = 1 := by
apply le_antisymm
· contrapose! hfour with hq'
apply ne_of_gt
rw [← Int.add_one_le_iff] at hq'
calc
4 < 3 * 2 := by norm_num
_ ≤ 3 * p.im ^ 2 := (Int.mul_le_mul_of_nonneg_left hq' (by norm_num))
_ ≤ p.re ^ 2 + 3 * p.im ^ 2 := (le_add_of_nonneg_left (pow_two_nonneg p.re))
_ = p.norm := by
rw [Zsqrtd.norm_def]
ring
· rw [← Int.sub_one_lt_iff, sub_self]
exact sq_pos_of_ne_zero _ hq
refine' ⟨_, hq⟩
calc
p.re ^ 2 = p.re ^ 2 + 3 * p.im ^ 2 - 3 := by rw [hq, mul_one, add_sub_cancel]
_ = p.norm - 3 := by
rw [Zsqrtd.norm_def]
ring
_ = 1 := by
rw [hfour]
norm_num
#align spts.four Spts.four
theorem Spts.four_of_coprime {p : ℤ√(-3)} (hcoprime : IsCoprime p.re p.im) (hfour : p.norm = 4) :
abs p.re = 1 ∧ abs p.im = 1 := by
apply Spts.four hfour
rintro him
rw [him, isCoprime_zero_right, Int.isUnit_iff_abs_eq] at hcoprime
rw [Zsqrtd.norm_def, him, MulZeroClass.mul_zero, sub_zero, ← sq, ← sq_abs, hcoprime] at hfour
norm_num at hfour
#align spts.four_of_coprime Spts.four_of_coprime
|
[GOAL]
⊢ StrictConvexOn ℝ univ exp
[PROOFSTEP]
apply strictConvexOn_of_slope_strict_mono_adjacent convex_univ
[GOAL]
⊢ ∀ {x y z : ℝ}, x ∈ univ → z ∈ univ → x < y → y < z → (exp y - exp x) / (y - x) < (exp z - exp y) / (z - y)
[PROOFSTEP]
rintro x y z - - hxy hyz
[GOAL]
x y z : ℝ
hxy : x < y
hyz : y < z
⊢ (exp y - exp x) / (y - x) < (exp z - exp y) / (z - y)
[PROOFSTEP]
trans exp y
[GOAL]
x y z : ℝ
hxy : x < y
hyz : y < z
⊢ (exp y - exp x) / (y - x) < exp y
[PROOFSTEP]
have h1 : 0 < y - x := by linarith
[GOAL]
x y z : ℝ
hxy : x < y
hyz : y < z
⊢ 0 < y - x
[PROOFSTEP]
linarith
[GOAL]
x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < y - x
⊢ (exp y - exp x) / (y - x) < exp y
[PROOFSTEP]
have h2 : x - y < 0 := by linarith
[GOAL]
x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < y - x
⊢ x - y < 0
[PROOFSTEP]
linarith
[GOAL]
x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < y - x
h2 : x - y < 0
⊢ (exp y - exp x) / (y - x) < exp y
[PROOFSTEP]
rw [div_lt_iff h1]
[GOAL]
x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < y - x
h2 : x - y < 0
⊢ exp y - exp x < exp y * (y - x)
[PROOFSTEP]
calc
exp y - exp x = exp y - exp y * exp (x - y) := by rw [← exp_add]; ring_nf
_ = exp y * (1 - exp (x - y)) := by ring
_ < exp y * -(x - y) := by gcongr; linarith [add_one_lt_exp_of_nonzero h2.ne]
_ = exp y * (y - x) := by ring
[GOAL]
x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < y - x
h2 : x - y < 0
⊢ exp y - exp x = exp y - exp y * exp (x - y)
[PROOFSTEP]
rw [← exp_add]
[GOAL]
x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < y - x
h2 : x - y < 0
⊢ exp y - exp x = exp y - exp (y + (x - y))
[PROOFSTEP]
ring_nf
[GOAL]
x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < y - x
h2 : x - y < 0
⊢ exp y - exp y * exp (x - y) = exp y * (1 - exp (x - y))
[PROOFSTEP]
ring
[GOAL]
x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < y - x
h2 : x - y < 0
⊢ exp y * (1 - exp (x - y)) < exp y * -(x - y)
[PROOFSTEP]
gcongr
[GOAL]
case bc
x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < y - x
h2 : x - y < 0
⊢ 1 - exp (x - y) < -(x - y)
[PROOFSTEP]
linarith [add_one_lt_exp_of_nonzero h2.ne]
[GOAL]
x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < y - x
h2 : x - y < 0
⊢ exp y * -(x - y) = exp y * (y - x)
[PROOFSTEP]
ring
[GOAL]
x y z : ℝ
hxy : x < y
hyz : y < z
⊢ exp y < (exp z - exp y) / (z - y)
[PROOFSTEP]
have h1 : 0 < z - y := by linarith
[GOAL]
x y z : ℝ
hxy : x < y
hyz : y < z
⊢ 0 < z - y
[PROOFSTEP]
linarith
[GOAL]
x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < z - y
⊢ exp y < (exp z - exp y) / (z - y)
[PROOFSTEP]
rw [lt_div_iff h1]
[GOAL]
x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < z - y
⊢ exp y * (z - y) < exp z - exp y
[PROOFSTEP]
calc
exp y * (z - y) < exp y * (exp (z - y) - 1) := by
gcongr _ * ?_
linarith [add_one_lt_exp_of_nonzero h1.ne']
_ = exp (z - y) * exp y - exp y := by ring
_ ≤ exp z - exp y := by rw [← exp_add]; ring_nf; rfl
[GOAL]
x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < z - y
⊢ exp y * (z - y) < exp y * (exp (z - y) - 1)
[PROOFSTEP]
gcongr _ * ?_
[GOAL]
case bc
x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < z - y
⊢ z - y < exp (z - y) - 1
[PROOFSTEP]
linarith [add_one_lt_exp_of_nonzero h1.ne']
[GOAL]
x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < z - y
⊢ exp y * (exp (z - y) - 1) = exp (z - y) * exp y - exp y
[PROOFSTEP]
ring
[GOAL]
x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < z - y
⊢ exp (z - y) * exp y - exp y ≤ exp z - exp y
[PROOFSTEP]
rw [← exp_add]
[GOAL]
x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < z - y
⊢ exp (z - y + y) - exp y ≤ exp z - exp y
[PROOFSTEP]
ring_nf
[GOAL]
x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < z - y
⊢ exp z - exp y ≤ exp z - exp y
[PROOFSTEP]
rfl
[GOAL]
n : ℕ
⊢ ConvexOn ℝ (Ici 0) fun x => x ^ n
[PROOFSTEP]
induction' n with k IH
[GOAL]
case zero
⊢ ConvexOn ℝ (Ici 0) fun x => x ^ Nat.zero
[PROOFSTEP]
exact convexOn_const (1 : ℝ) (convex_Ici _)
[GOAL]
case succ
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
⊢ ConvexOn ℝ (Ici 0) fun x => x ^ Nat.succ k
[PROOFSTEP]
refine' ⟨convex_Ici _, _⟩
[GOAL]
case succ
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
⊢ ∀ ⦃x : ℝ⦄,
x ∈ Ici 0 →
∀ ⦃y : ℝ⦄,
y ∈ Ici 0 →
∀ ⦃a b : ℝ⦄,
0 ≤ a →
0 ≤ b →
a + b = 1 →
(fun x => x ^ Nat.succ k) (a • x + b • y) ≤
a • (fun x => x ^ Nat.succ k) x + b • (fun x => x ^ Nat.succ k) y
[PROOFSTEP]
rintro a (ha : 0 ≤ a) b (hb : 0 ≤ b) μ ν hμ hν h
[GOAL]
case succ
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
a : ℝ
ha : 0 ≤ a
b : ℝ
hb : 0 ≤ b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
⊢ (fun x => x ^ Nat.succ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ Nat.succ k) a + ν • (fun x => x ^ Nat.succ k) b
[PROOFSTEP]
have H := IH.2 ha hb hμ hν h
[GOAL]
case succ
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
a : ℝ
ha : 0 ≤ a
b : ℝ
hb : 0 ≤ b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
H : (fun x => x ^ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ k) a + ν • (fun x => x ^ k) b
⊢ (fun x => x ^ Nat.succ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ Nat.succ k) a + ν • (fun x => x ^ Nat.succ k) b
[PROOFSTEP]
have : 0 ≤ (b ^ k - a ^ k) * (b - a) * μ * ν :=
by
cases' le_or_lt a b with hab hab
· have : a ^ k ≤ b ^ k := by gcongr
have : 0 ≤ (b ^ k - a ^ k) * (b - a) := by nlinarith
positivity
· have : b ^ k ≤ a ^ k := by gcongr
have : 0 ≤ (b ^ k - a ^ k) * (b - a) := by nlinarith
positivity
[GOAL]
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
a : ℝ
ha : 0 ≤ a
b : ℝ
hb : 0 ≤ b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
H : (fun x => x ^ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ k) a + ν • (fun x => x ^ k) b
⊢ 0 ≤ (b ^ k - a ^ k) * (b - a) * μ * ν
[PROOFSTEP]
cases' le_or_lt a b with hab hab
[GOAL]
case inl
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
a : ℝ
ha : 0 ≤ a
b : ℝ
hb : 0 ≤ b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
H : (fun x => x ^ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ k) a + ν • (fun x => x ^ k) b
hab : a ≤ b
⊢ 0 ≤ (b ^ k - a ^ k) * (b - a) * μ * ν
[PROOFSTEP]
have : a ^ k ≤ b ^ k := by gcongr
[GOAL]
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
a : ℝ
ha : 0 ≤ a
b : ℝ
hb : 0 ≤ b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
H : (fun x => x ^ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ k) a + ν • (fun x => x ^ k) b
hab : a ≤ b
⊢ a ^ k ≤ b ^ k
[PROOFSTEP]
gcongr
[GOAL]
case inl
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
a : ℝ
ha : 0 ≤ a
b : ℝ
hb : 0 ≤ b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
H : (fun x => x ^ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ k) a + ν • (fun x => x ^ k) b
hab : a ≤ b
this : a ^ k ≤ b ^ k
⊢ 0 ≤ (b ^ k - a ^ k) * (b - a) * μ * ν
[PROOFSTEP]
have : 0 ≤ (b ^ k - a ^ k) * (b - a) := by nlinarith
[GOAL]
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
a : ℝ
ha : 0 ≤ a
b : ℝ
hb : 0 ≤ b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
H : (fun x => x ^ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ k) a + ν • (fun x => x ^ k) b
hab : a ≤ b
this : a ^ k ≤ b ^ k
⊢ 0 ≤ (b ^ k - a ^ k) * (b - a)
[PROOFSTEP]
nlinarith
[GOAL]
case inl
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
a : ℝ
ha : 0 ≤ a
b : ℝ
hb : 0 ≤ b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
H : (fun x => x ^ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ k) a + ν • (fun x => x ^ k) b
hab : a ≤ b
this✝ : a ^ k ≤ b ^ k
this : 0 ≤ (b ^ k - a ^ k) * (b - a)
⊢ 0 ≤ (b ^ k - a ^ k) * (b - a) * μ * ν
[PROOFSTEP]
positivity
[GOAL]
case inr
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
a : ℝ
ha : 0 ≤ a
b : ℝ
hb : 0 ≤ b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
H : (fun x => x ^ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ k) a + ν • (fun x => x ^ k) b
hab : b < a
⊢ 0 ≤ (b ^ k - a ^ k) * (b - a) * μ * ν
[PROOFSTEP]
have : b ^ k ≤ a ^ k := by gcongr
[GOAL]
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
a : ℝ
ha : 0 ≤ a
b : ℝ
hb : 0 ≤ b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
H : (fun x => x ^ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ k) a + ν • (fun x => x ^ k) b
hab : b < a
⊢ b ^ k ≤ a ^ k
[PROOFSTEP]
gcongr
[GOAL]
case inr
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
a : ℝ
ha : 0 ≤ a
b : ℝ
hb : 0 ≤ b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
H : (fun x => x ^ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ k) a + ν • (fun x => x ^ k) b
hab : b < a
this : b ^ k ≤ a ^ k
⊢ 0 ≤ (b ^ k - a ^ k) * (b - a) * μ * ν
[PROOFSTEP]
have : 0 ≤ (b ^ k - a ^ k) * (b - a) := by nlinarith
[GOAL]
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
a : ℝ
ha : 0 ≤ a
b : ℝ
hb : 0 ≤ b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
H : (fun x => x ^ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ k) a + ν • (fun x => x ^ k) b
hab : b < a
this : b ^ k ≤ a ^ k
⊢ 0 ≤ (b ^ k - a ^ k) * (b - a)
[PROOFSTEP]
nlinarith
[GOAL]
case inr
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
a : ℝ
ha : 0 ≤ a
b : ℝ
hb : 0 ≤ b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
H : (fun x => x ^ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ k) a + ν • (fun x => x ^ k) b
hab : b < a
this✝ : b ^ k ≤ a ^ k
this : 0 ≤ (b ^ k - a ^ k) * (b - a)
⊢ 0 ≤ (b ^ k - a ^ k) * (b - a) * μ * ν
[PROOFSTEP]
positivity
[GOAL]
case succ
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
a : ℝ
ha : 0 ≤ a
b : ℝ
hb : 0 ≤ b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
H : (fun x => x ^ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ k) a + ν • (fun x => x ^ k) b
this : 0 ≤ (b ^ k - a ^ k) * (b - a) * μ * ν
⊢ (fun x => x ^ Nat.succ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ Nat.succ k) a + ν • (fun x => x ^ Nat.succ k) b
[PROOFSTEP]
calc
(μ * a + ν * b) ^ k.succ = (μ * a + ν * b) * (μ * a + ν * b) ^ k := pow_succ _ _
_ ≤ (μ * a + ν * b) * (μ * a ^ k + ν * b ^ k) := by gcongr; exact H
_ ≤ (μ * a + ν * b) * (μ * a ^ k + ν * b ^ k) + (b ^ k - a ^ k) * (b - a) * μ * ν := by linarith
_ = (μ + ν) * (μ * a ^ k.succ + ν * b ^ k.succ) := by rw [Nat.succ_eq_add_one]; ring
_ = μ * a ^ k.succ + ν * b ^ k.succ := by rw [h]; ring
[GOAL]
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
a : ℝ
ha : 0 ≤ a
b : ℝ
hb : 0 ≤ b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
H : (fun x => x ^ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ k) a + ν • (fun x => x ^ k) b
this : 0 ≤ (b ^ k - a ^ k) * (b - a) * μ * ν
⊢ (μ * a + ν * b) * (μ * a + ν * b) ^ k ≤ (μ * a + ν * b) * (μ * a ^ k + ν * b ^ k)
[PROOFSTEP]
gcongr
[GOAL]
case h
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
a : ℝ
ha : 0 ≤ a
b : ℝ
hb : 0 ≤ b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
H : (fun x => x ^ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ k) a + ν • (fun x => x ^ k) b
this : 0 ≤ (b ^ k - a ^ k) * (b - a) * μ * ν
⊢ (μ * a + ν * b) ^ k ≤ μ * a ^ k + ν * b ^ k
[PROOFSTEP]
exact H
[GOAL]
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
a : ℝ
ha : 0 ≤ a
b : ℝ
hb : 0 ≤ b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
H : (fun x => x ^ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ k) a + ν • (fun x => x ^ k) b
this : 0 ≤ (b ^ k - a ^ k) * (b - a) * μ * ν
⊢ (μ * a + ν * b) * (μ * a ^ k + ν * b ^ k) ≤
(μ * a + ν * b) * (μ * a ^ k + ν * b ^ k) + (b ^ k - a ^ k) * (b - a) * μ * ν
[PROOFSTEP]
linarith
[GOAL]
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
a : ℝ
ha : 0 ≤ a
b : ℝ
hb : 0 ≤ b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
H : (fun x => x ^ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ k) a + ν • (fun x => x ^ k) b
this : 0 ≤ (b ^ k - a ^ k) * (b - a) * μ * ν
⊢ (μ * a + ν * b) * (μ * a ^ k + ν * b ^ k) + (b ^ k - a ^ k) * (b - a) * μ * ν =
(μ + ν) * (μ * a ^ Nat.succ k + ν * b ^ Nat.succ k)
[PROOFSTEP]
rw [Nat.succ_eq_add_one]
[GOAL]
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
a : ℝ
ha : 0 ≤ a
b : ℝ
hb : 0 ≤ b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
H : (fun x => x ^ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ k) a + ν • (fun x => x ^ k) b
this : 0 ≤ (b ^ k - a ^ k) * (b - a) * μ * ν
⊢ (μ * a + ν * b) * (μ * a ^ k + ν * b ^ k) + (b ^ k - a ^ k) * (b - a) * μ * ν =
(μ + ν) * (μ * a ^ (k + 1) + ν * b ^ (k + 1))
[PROOFSTEP]
ring
[GOAL]
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
a : ℝ
ha : 0 ≤ a
b : ℝ
hb : 0 ≤ b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
H : (fun x => x ^ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ k) a + ν • (fun x => x ^ k) b
this : 0 ≤ (b ^ k - a ^ k) * (b - a) * μ * ν
⊢ (μ + ν) * (μ * a ^ Nat.succ k + ν * b ^ Nat.succ k) = μ * a ^ Nat.succ k + ν * b ^ Nat.succ k
[PROOFSTEP]
rw [h]
[GOAL]
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
a : ℝ
ha : 0 ≤ a
b : ℝ
hb : 0 ≤ b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
H : (fun x => x ^ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ k) a + ν • (fun x => x ^ k) b
this : 0 ≤ (b ^ k - a ^ k) * (b - a) * μ * ν
⊢ 1 * (μ * a ^ Nat.succ k + ν * b ^ Nat.succ k) = μ * a ^ Nat.succ k + ν * b ^ Nat.succ k
[PROOFSTEP]
ring
[GOAL]
n : ℕ
hn : Even n
⊢ ConvexOn ℝ univ fun x => x ^ n
[PROOFSTEP]
refine' ⟨convex_univ, _⟩
[GOAL]
n : ℕ
hn : Even n
⊢ ∀ ⦃x : ℝ⦄,
x ∈ univ →
∀ ⦃y : ℝ⦄,
y ∈ univ →
∀ ⦃a b : ℝ⦄,
0 ≤ a →
0 ≤ b → a + b = 1 → (fun x => x ^ n) (a • x + b • y) ≤ a • (fun x => x ^ n) x + b • (fun x => x ^ n) y
[PROOFSTEP]
rintro a - b - μ ν hμ hν h
[GOAL]
n : ℕ
hn : Even n
a b μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
⊢ (fun x => x ^ n) (μ • a + ν • b) ≤ μ • (fun x => x ^ n) a + ν • (fun x => x ^ n) b
[PROOFSTEP]
obtain ⟨k, rfl⟩ :=
hn.exists_two_nsmul
_
-- Porting note: added type ascription to LHS
[GOAL]
case intro
a b μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
k : ℕ
hn : Even (2 • k)
⊢ (fun x => x ^ (2 • k)) (μ • a + ν • b) ≤ μ • (fun x => x ^ (2 • k)) a + ν • (fun x => x ^ (2 • k)) b
[PROOFSTEP]
have : (0 : ℝ) ≤ (a - b) ^ 2 * μ * ν := by positivity
[GOAL]
a b μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
k : ℕ
hn : Even (2 • k)
⊢ 0 ≤ (a - b) ^ 2 * μ * ν
[PROOFSTEP]
positivity
[GOAL]
case intro
a b μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
k : ℕ
hn : Even (2 • k)
this : 0 ≤ (a - b) ^ 2 * μ * ν
⊢ (fun x => x ^ (2 • k)) (μ • a + ν • b) ≤ μ • (fun x => x ^ (2 • k)) a + ν • (fun x => x ^ (2 • k)) b
[PROOFSTEP]
calc
(μ * a + ν * b) ^ (2 * k) = ((μ * a + ν * b) ^ 2) ^ k := by rw [pow_mul]
_ ≤ ((μ + ν) * (μ * a ^ 2 + ν * b ^ 2)) ^ k := by gcongr; linarith
_ = (μ * a ^ 2 + ν * b ^ 2) ^ k := by rw [h]; ring
_ ≤ μ * (a ^ 2) ^ k + ν * (b ^ 2) ^ k := ?_
_ ≤ μ * a ^ (2 * k) + ν * b ^ (2 * k) := by ring_nf;
rfl
-- Porting note: `rw [mem_Ici]` was `dsimp`
[GOAL]
a b μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
k : ℕ
hn : Even (2 • k)
this : 0 ≤ (a - b) ^ 2 * μ * ν
⊢ (μ * a + ν * b) ^ (2 * k) = ((μ * a + ν * b) ^ 2) ^ k
[PROOFSTEP]
rw [pow_mul]
[GOAL]
a b μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
k : ℕ
hn : Even (2 • k)
this : 0 ≤ (a - b) ^ 2 * μ * ν
⊢ ((μ * a + ν * b) ^ 2) ^ k ≤ ((μ + ν) * (μ * a ^ 2 + ν * b ^ 2)) ^ k
[PROOFSTEP]
gcongr
[GOAL]
case hab
a b μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
k : ℕ
hn : Even (2 • k)
this : 0 ≤ (a - b) ^ 2 * μ * ν
⊢ (μ * a + ν * b) ^ 2 ≤ (μ + ν) * (μ * a ^ 2 + ν * b ^ 2)
[PROOFSTEP]
linarith
[GOAL]
a b μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
k : ℕ
hn : Even (2 • k)
this : 0 ≤ (a - b) ^ 2 * μ * ν
⊢ ((μ + ν) * (μ * a ^ 2 + ν * b ^ 2)) ^ k = (μ * a ^ 2 + ν * b ^ 2) ^ k
[PROOFSTEP]
rw [h]
[GOAL]
a b μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
k : ℕ
hn : Even (2 • k)
this : 0 ≤ (a - b) ^ 2 * μ * ν
⊢ (1 * (μ * a ^ 2 + ν * b ^ 2)) ^ k = (μ * a ^ 2 + ν * b ^ 2) ^ k
[PROOFSTEP]
ring
[GOAL]
a b μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
k : ℕ
hn : Even (2 • k)
this : 0 ≤ (a - b) ^ 2 * μ * ν
⊢ μ * (a ^ 2) ^ k + ν * (b ^ 2) ^ k ≤ μ * a ^ (2 * k) + ν * b ^ (2 * k)
[PROOFSTEP]
ring_nf
[GOAL]
a b μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
k : ℕ
hn : Even (2 • k)
this : 0 ≤ (a - b) ^ 2 * μ * ν
⊢ μ * a ^ (k * 2) + ν * b ^ (k * 2) ≤ μ * a ^ (k * 2) + ν * b ^ (k * 2)
[PROOFSTEP]
rfl
-- Porting note: `rw [mem_Ici]` was `dsimp`
[GOAL]
case intro
a b μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
k : ℕ
hn : Even (2 • k)
this : 0 ≤ (a - b) ^ 2 * μ * ν
⊢ (μ * a ^ 2 + ν * b ^ 2) ^ k ≤ μ * (a ^ 2) ^ k + ν * (b ^ 2) ^ k
[PROOFSTEP]
refine' (convexOn_pow k).2 _ _ hμ hν h
[GOAL]
case intro.refine'_1
a b μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
k : ℕ
hn : Even (2 • k)
this : 0 ≤ (a - b) ^ 2 * μ * ν
⊢ a ^ 2 ∈ Ici 0
[PROOFSTEP]
rw [mem_Ici]
[GOAL]
case intro.refine'_2
a b μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
k : ℕ
hn : Even (2 • k)
this : 0 ≤ (a - b) ^ 2 * μ * ν
⊢ b ^ 2 ∈ Ici 0
[PROOFSTEP]
rw [mem_Ici]
[GOAL]
case intro.refine'_1
a b μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
k : ℕ
hn : Even (2 • k)
this : 0 ≤ (a - b) ^ 2 * μ * ν
⊢ 0 ≤ a ^ 2
[PROOFSTEP]
positivity
[GOAL]
case intro.refine'_2
a b μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
k : ℕ
hn : Even (2 • k)
this : 0 ≤ (a - b) ^ 2 * μ * ν
⊢ 0 ≤ b ^ 2
[PROOFSTEP]
positivity
[GOAL]
n : ℕ
⊢ ConvexOn ℝ (Ioi 0) fun x => x ^ ↑n
[PROOFSTEP]
simp_rw [zpow_ofNat]
[GOAL]
n : ℕ
⊢ ConvexOn ℝ (Ioi 0) fun x => x ^ n
[PROOFSTEP]
exact (convexOn_pow n).subset Ioi_subset_Ici_self (convex_Ioi _)
[GOAL]
n : ℕ
⊢ ConvexOn ℝ (Ioi 0) fun x => x ^ -[n+1]
[PROOFSTEP]
simp_rw [zpow_negSucc]
[GOAL]
n : ℕ
⊢ ConvexOn ℝ (Ioi 0) fun x => (x ^ (n + 1))⁻¹
[PROOFSTEP]
refine' ⟨convex_Ioi _, _⟩
[GOAL]
n : ℕ
⊢ ∀ ⦃x : ℝ⦄,
x ∈ Ioi 0 →
∀ ⦃y : ℝ⦄,
y ∈ Ioi 0 →
∀ ⦃a b : ℝ⦄,
0 ≤ a →
0 ≤ b →
a + b = 1 →
(fun x => (x ^ (n + 1))⁻¹) (a • x + b • y) ≤
a • (fun x => (x ^ (n + 1))⁻¹) x + b • (fun x => (x ^ (n + 1))⁻¹) y
[PROOFSTEP]
rintro a (ha : 0 < a) b (hb : 0 < b) μ ν hμ hν h
[GOAL]
n : ℕ
a : ℝ
ha : 0 < a
b : ℝ
hb : 0 < b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
⊢ (fun x => (x ^ (n + 1))⁻¹) (μ • a + ν • b) ≤ μ • (fun x => (x ^ (n + 1))⁻¹) a + ν • (fun x => (x ^ (n + 1))⁻¹) b
[PROOFSTEP]
field_simp [ha.ne', hb.ne']
[GOAL]
n : ℕ
a : ℝ
ha : 0 < a
b : ℝ
hb : 0 < b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
⊢ 1 / (μ * a + ν * b) ^ (n + 1) ≤ (μ * b ^ (n + 1) + ν * a ^ (n + 1)) / (a ^ (n + 1) * b ^ (n + 1))
[PROOFSTEP]
rw [div_le_div_iff]
[GOAL]
n : ℕ
a : ℝ
ha : 0 < a
b : ℝ
hb : 0 < b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
⊢ 1 * (a ^ (n + 1) * b ^ (n + 1)) ≤ (μ * b ^ (n + 1) + ν * a ^ (n + 1)) * (μ * a + ν * b) ^ (n + 1)
[PROOFSTEP]
calc
(1 : ℝ) * (a ^ (n + 1) * b ^ (n + 1)) = ((μ + ν) ^ 2 * (a * b)) ^ (n + 1) := by rw [h]; ring
_ ≤ ((μ * b + ν * a) * (μ * a + ν * b)) ^ (n + 1) := ?_
_ = (μ * b + ν * a) ^ (n + 1) * (μ * a + ν * b) ^ (n + 1) := by rw [mul_pow]
_ ≤ (μ * b ^ (n + 1) + ν * a ^ (n + 1)) * (μ * a + ν * b) ^ (n + 1) := ?_
[GOAL]
n : ℕ
a : ℝ
ha : 0 < a
b : ℝ
hb : 0 < b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
⊢ 1 * (a ^ (n + 1) * b ^ (n + 1)) = ((μ + ν) ^ 2 * (a * b)) ^ (n + 1)
[PROOFSTEP]
rw [h]
[GOAL]
n : ℕ
a : ℝ
ha : 0 < a
b : ℝ
hb : 0 < b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
⊢ 1 * (a ^ (n + 1) * b ^ (n + 1)) = (1 ^ 2 * (a * b)) ^ (n + 1)
[PROOFSTEP]
ring
[GOAL]
n : ℕ
a : ℝ
ha : 0 < a
b : ℝ
hb : 0 < b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
⊢ ((μ * b + ν * a) * (μ * a + ν * b)) ^ (n + 1) = (μ * b + ν * a) ^ (n + 1) * (μ * a + ν * b) ^ (n + 1)
[PROOFSTEP]
rw [mul_pow]
[GOAL]
case calc_1
n : ℕ
a : ℝ
ha : 0 < a
b : ℝ
hb : 0 < b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
⊢ ((μ + ν) ^ 2 * (a * b)) ^ (n + 1) ≤ ((μ * b + ν * a) * (μ * a + ν * b)) ^ (n + 1)
[PROOFSTEP]
gcongr(?_ : ℝ) ^ _
[GOAL]
case calc_1.hab
n : ℕ
a : ℝ
ha : 0 < a
b : ℝ
hb : 0 < b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
⊢ (μ + ν) ^ 2 * (a * b) ≤ (μ * b + ν * a) * (μ * a + ν * b)
[PROOFSTEP]
have : (0 : ℝ) ≤ μ * ν * (a - b) ^ 2 := by positivity
[GOAL]
n : ℕ
a : ℝ
ha : 0 < a
b : ℝ
hb : 0 < b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
⊢ 0 ≤ μ * ν * (a - b) ^ 2
[PROOFSTEP]
positivity
[GOAL]
case calc_1.hab
n : ℕ
a : ℝ
ha : 0 < a
b : ℝ
hb : 0 < b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
this : 0 ≤ μ * ν * (a - b) ^ 2
⊢ (μ + ν) ^ 2 * (a * b) ≤ (μ * b + ν * a) * (μ * a + ν * b)
[PROOFSTEP]
linarith
[GOAL]
case calc_2
n : ℕ
a : ℝ
ha : 0 < a
b : ℝ
hb : 0 < b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
⊢ (μ * b + ν * a) ^ (n + 1) * (μ * a + ν * b) ^ (n + 1) ≤
(μ * b ^ (n + 1) + ν * a ^ (n + 1)) * (μ * a + ν * b) ^ (n + 1)
[PROOFSTEP]
gcongr
[GOAL]
case calc_2.h
n : ℕ
a : ℝ
ha : 0 < a
b : ℝ
hb : 0 < b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
⊢ (μ * b + ν * a) ^ (n + 1) ≤ μ * b ^ (n + 1) + ν * a ^ (n + 1)
[PROOFSTEP]
apply (convexOn_pow (n + 1)).2 hb.le ha.le hμ hν h
[GOAL]
case b0
n : ℕ
a : ℝ
ha : 0 < a
b : ℝ
hb : 0 < b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
⊢ 0 < (μ * a + ν * b) ^ (n + 1)
[PROOFSTEP]
have : 0 < μ * a + ν * b := by cases le_or_lt a b <;> nlinarith
[GOAL]
n : ℕ
a : ℝ
ha : 0 < a
b : ℝ
hb : 0 < b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
⊢ 0 < μ * a + ν * b
[PROOFSTEP]
cases le_or_lt a b
[GOAL]
case inl
n : ℕ
a : ℝ
ha : 0 < a
b : ℝ
hb : 0 < b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
h✝ : a ≤ b
⊢ 0 < μ * a + ν * b
[PROOFSTEP]
nlinarith
[GOAL]
case inr
n : ℕ
a : ℝ
ha : 0 < a
b : ℝ
hb : 0 < b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
h✝ : b < a
⊢ 0 < μ * a + ν * b
[PROOFSTEP]
nlinarith
[GOAL]
case b0
n : ℕ
a : ℝ
ha : 0 < a
b : ℝ
hb : 0 < b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
this : 0 < μ * a + ν * b
⊢ 0 < (μ * a + ν * b) ^ (n + 1)
[PROOFSTEP]
positivity
[GOAL]
case d0
n : ℕ
a : ℝ
ha : 0 < a
b : ℝ
hb : 0 < b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
⊢ 0 < a ^ (n + 1) * b ^ (n + 1)
[PROOFSTEP]
positivity
[GOAL]
⊢ StrictConcaveOn ℝ (Ioi 0) log
[PROOFSTEP]
apply strictConcaveOn_of_slope_strict_anti_adjacent (convex_Ioi (0 : ℝ))
[GOAL]
⊢ ∀ {x y z : ℝ}, x ∈ Ioi 0 → z ∈ Ioi 0 → x < y → y < z → (log z - log y) / (z - y) < (log y - log x) / (y - x)
[PROOFSTEP]
rintro x y z (hx : 0 < x) (hz : 0 < z) hxy hyz
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
⊢ (log z - log y) / (z - y) < (log y - log x) / (y - x)
[PROOFSTEP]
have hy : 0 < y := hx.trans hxy
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
⊢ (log z - log y) / (z - y) < (log y - log x) / (y - x)
[PROOFSTEP]
trans y⁻¹
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
⊢ (log z - log y) / (z - y) < y⁻¹
[PROOFSTEP]
have h : 0 < z - y := by linarith
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
⊢ 0 < z - y
[PROOFSTEP]
linarith
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
h : 0 < z - y
⊢ (log z - log y) / (z - y) < y⁻¹
[PROOFSTEP]
rw [div_lt_iff h]
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
h : 0 < z - y
⊢ log z - log y < y⁻¹ * (z - y)
[PROOFSTEP]
have hyz' : 0 < z / y := by positivity
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
h : 0 < z - y
⊢ 0 < z / y
[PROOFSTEP]
positivity
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
h : 0 < z - y
hyz' : 0 < z / y
⊢ log z - log y < y⁻¹ * (z - y)
[PROOFSTEP]
have hyz'' : z / y ≠ 1 := by
contrapose! h
rw [div_eq_one_iff_eq hy.ne'] at h
simp [h]
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
h : 0 < z - y
hyz' : 0 < z / y
⊢ z / y ≠ 1
[PROOFSTEP]
contrapose! h
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
hyz' : 0 < z / y
h : z / y = 1
⊢ z - y ≤ 0
[PROOFSTEP]
rw [div_eq_one_iff_eq hy.ne'] at h
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
hyz' : 0 < z / y
h : z = y
⊢ z - y ≤ 0
[PROOFSTEP]
simp [h]
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
h : 0 < z - y
hyz' : 0 < z / y
hyz'' : z / y ≠ 1
⊢ log z - log y < y⁻¹ * (z - y)
[PROOFSTEP]
calc
log z - log y = log (z / y) := by rw [← log_div hz.ne' hy.ne']
_ < z / y - 1 := (log_lt_sub_one_of_pos hyz' hyz'')
_ = y⁻¹ * (z - y) := by field_simp [hy.ne']
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
h : 0 < z - y
hyz' : 0 < z / y
hyz'' : z / y ≠ 1
⊢ log z - log y = log (z / y)
[PROOFSTEP]
rw [← log_div hz.ne' hy.ne']
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
h : 0 < z - y
hyz' : 0 < z / y
hyz'' : z / y ≠ 1
⊢ z / y - 1 = y⁻¹ * (z - y)
[PROOFSTEP]
field_simp [hy.ne']
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
⊢ y⁻¹ < (log y - log x) / (y - x)
[PROOFSTEP]
have h : 0 < y - x := by linarith
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
⊢ 0 < y - x
[PROOFSTEP]
linarith
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
h : 0 < y - x
⊢ y⁻¹ < (log y - log x) / (y - x)
[PROOFSTEP]
rw [lt_div_iff h]
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
h : 0 < y - x
⊢ y⁻¹ * (y - x) < log y - log x
[PROOFSTEP]
have hxy' : 0 < x / y := by positivity
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
h : 0 < y - x
⊢ 0 < x / y
[PROOFSTEP]
positivity
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
h : 0 < y - x
hxy' : 0 < x / y
⊢ y⁻¹ * (y - x) < log y - log x
[PROOFSTEP]
have hxy'' : x / y ≠ 1 := by
contrapose! h
rw [div_eq_one_iff_eq hy.ne'] at h
simp [h]
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
h : 0 < y - x
hxy' : 0 < x / y
⊢ x / y ≠ 1
[PROOFSTEP]
contrapose! h
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
hxy' : 0 < x / y
h : x / y = 1
⊢ y - x ≤ 0
[PROOFSTEP]
rw [div_eq_one_iff_eq hy.ne'] at h
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
hxy' : 0 < x / y
h : x = y
⊢ y - x ≤ 0
[PROOFSTEP]
simp [h]
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
h : 0 < y - x
hxy' : 0 < x / y
hxy'' : x / y ≠ 1
⊢ y⁻¹ * (y - x) < log y - log x
[PROOFSTEP]
calc
y⁻¹ * (y - x) = 1 - x / y := by field_simp [hy.ne']
_ < -log (x / y) := by linarith [log_lt_sub_one_of_pos hxy' hxy'']
_ = -(log x - log y) := by rw [log_div hx.ne' hy.ne']
_ = log y - log x := by ring
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
h : 0 < y - x
hxy' : 0 < x / y
hxy'' : x / y ≠ 1
⊢ y⁻¹ * (y - x) = 1 - x / y
[PROOFSTEP]
field_simp [hy.ne']
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
h : 0 < y - x
hxy' : 0 < x / y
hxy'' : x / y ≠ 1
⊢ 1 - x / y < -log (x / y)
[PROOFSTEP]
linarith [log_lt_sub_one_of_pos hxy' hxy'']
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
h : 0 < y - x
hxy' : 0 < x / y
hxy'' : x / y ≠ 1
⊢ -log (x / y) = -(log x - log y)
[PROOFSTEP]
rw [log_div hx.ne' hy.ne']
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
h : 0 < y - x
hxy' : 0 < x / y
hxy'' : x / y ≠ 1
⊢ -(log x - log y) = log y - log x
[PROOFSTEP]
ring
[GOAL]
s : ℝ
hs : -1 ≤ s
hs' : s ≠ 0
p : ℝ
hp : 1 < p
⊢ 1 + p * s < (1 + s) ^ p
[PROOFSTEP]
rcases eq_or_lt_of_le hs with (rfl | hs)
[GOAL]
case inl
p : ℝ
hp : 1 < p
hs : -1 ≤ -1
hs' : -1 ≠ 0
⊢ 1 + p * -1 < (1 + -1) ^ p
[PROOFSTEP]
have : p ≠ 0 := by positivity
[GOAL]
p : ℝ
hp : 1 < p
hs : -1 ≤ -1
hs' : -1 ≠ 0
⊢ p ≠ 0
[PROOFSTEP]
positivity
[GOAL]
case inl
p : ℝ
hp : 1 < p
hs : -1 ≤ -1
hs' : -1 ≠ 0
this : p ≠ 0
⊢ 1 + p * -1 < (1 + -1) ^ p
[PROOFSTEP]
simpa [zero_rpow this]
[GOAL]
case inr
s : ℝ
hs✝ : -1 ≤ s
hs' : s ≠ 0
p : ℝ
hp : 1 < p
hs : -1 < s
⊢ 1 + p * s < (1 + s) ^ p
[PROOFSTEP]
have hs1 : 0 < 1 + s := by linarith
[GOAL]
s : ℝ
hs✝ : -1 ≤ s
hs' : s ≠ 0
p : ℝ
hp : 1 < p
hs : -1 < s
⊢ 0 < 1 + s
[PROOFSTEP]
linarith
[GOAL]
case inr
s : ℝ
hs✝ : -1 ≤ s
hs' : s ≠ 0
p : ℝ
hp : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
⊢ 1 + p * s < (1 + s) ^ p
[PROOFSTEP]
cases' le_or_lt (1 + p * s) 0 with hs2 hs2
[GOAL]
case inr.inl
s : ℝ
hs✝ : -1 ≤ s
hs' : s ≠ 0
p : ℝ
hp : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 1 + p * s ≤ 0
⊢ 1 + p * s < (1 + s) ^ p
[PROOFSTEP]
exact hs2.trans_lt (rpow_pos_of_pos hs1 _)
[GOAL]
case inr.inr
s : ℝ
hs✝ : -1 ≤ s
hs' : s ≠ 0
p : ℝ
hp : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
⊢ 1 + p * s < (1 + s) ^ p
[PROOFSTEP]
rw [rpow_def_of_pos hs1, ← exp_log hs2]
[GOAL]
case inr.inr
s : ℝ
hs✝ : -1 ≤ s
hs' : s ≠ 0
p : ℝ
hp : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
⊢ exp (log (1 + p * s)) < exp (log (1 + s) * p)
[PROOFSTEP]
apply exp_strictMono
[GOAL]
case inr.inr.a
s : ℝ
hs✝ : -1 ≤ s
hs' : s ≠ 0
p : ℝ
hp : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
⊢ log (1 + p * s) < log (1 + s) * p
[PROOFSTEP]
have hp : 0 < p := by positivity
[GOAL]
s : ℝ
hs✝ : -1 ≤ s
hs' : s ≠ 0
p : ℝ
hp : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
⊢ 0 < p
[PROOFSTEP]
positivity
[GOAL]
case inr.inr.a
s : ℝ
hs✝ : -1 ≤ s
hs' : s ≠ 0
p : ℝ
hp✝ : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
hp : 0 < p
⊢ log (1 + p * s) < log (1 + s) * p
[PROOFSTEP]
have hs3 : 1 + s ≠ 1 := by contrapose! hs'; linarith
[GOAL]
s : ℝ
hs✝ : -1 ≤ s
hs' : s ≠ 0
p : ℝ
hp✝ : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
hp : 0 < p
⊢ 1 + s ≠ 1
[PROOFSTEP]
contrapose! hs'
[GOAL]
s : ℝ
hs✝ : -1 ≤ s
p : ℝ
hp✝ : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
hp : 0 < p
hs' : 1 + s = 1
⊢ s = 0
[PROOFSTEP]
linarith
[GOAL]
case inr.inr.a
s : ℝ
hs✝ : -1 ≤ s
hs' : s ≠ 0
p : ℝ
hp✝ : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
hp : 0 < p
hs3 : 1 + s ≠ 1
⊢ log (1 + p * s) < log (1 + s) * p
[PROOFSTEP]
have hs4 : 1 + p * s ≠ 1 := by contrapose! hs'; nlinarith
[GOAL]
s : ℝ
hs✝ : -1 ≤ s
hs' : s ≠ 0
p : ℝ
hp✝ : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
hp : 0 < p
hs3 : 1 + s ≠ 1
⊢ 1 + p * s ≠ 1
[PROOFSTEP]
contrapose! hs'
[GOAL]
s : ℝ
hs✝ : -1 ≤ s
p : ℝ
hp✝ : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
hp : 0 < p
hs3 : 1 + s ≠ 1
hs' : 1 + p * s = 1
⊢ s = 0
[PROOFSTEP]
nlinarith
[GOAL]
case inr.inr.a
s : ℝ
hs✝ : -1 ≤ s
hs' : s ≠ 0
p : ℝ
hp✝ : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
hp : 0 < p
hs3 : 1 + s ≠ 1
hs4 : 1 + p * s ≠ 1
⊢ log (1 + p * s) < log (1 + s) * p
[PROOFSTEP]
cases' lt_or_gt_of_ne hs' with hs' hs'
[GOAL]
case inr.inr.a.inl
s : ℝ
hs✝ : -1 ≤ s
hs'✝ : s ≠ 0
p : ℝ
hp✝ : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
hp : 0 < p
hs3 : 1 + s ≠ 1
hs4 : 1 + p * s ≠ 1
hs' : s < 0
⊢ log (1 + p * s) < log (1 + s) * p
[PROOFSTEP]
rw [← div_lt_iff hp, ← div_lt_div_right_of_neg hs']
-- Porting note: previously we could write `zero_lt_one` inline,
-- but now Lean doesn't guess we are talking about `1` fast enough.
[GOAL]
case inr.inr.a.inl
s : ℝ
hs✝ : -1 ≤ s
hs'✝ : s ≠ 0
p : ℝ
hp✝ : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
hp : 0 < p
hs3 : 1 + s ≠ 1
hs4 : 1 + p * s ≠ 1
hs' : s < 0
⊢ log (1 + s) / s < log (1 + p * s) / p / s
[PROOFSTEP]
haveI : (1 : ℝ) ∈ Ioi 0 := zero_lt_one
[GOAL]
case inr.inr.a.inl
s : ℝ
hs✝ : -1 ≤ s
hs'✝ : s ≠ 0
p : ℝ
hp✝ : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
hp : 0 < p
hs3 : 1 + s ≠ 1
hs4 : 1 + p * s ≠ 1
hs' : s < 0
this : 1 ∈ Ioi 0
⊢ log (1 + s) / s < log (1 + p * s) / p / s
[PROOFSTEP]
convert strictConcaveOn_log_Ioi.secant_strict_mono this hs2 hs1 hs4 hs3 _ using 1
[GOAL]
case h.e'_3
s : ℝ
hs✝ : -1 ≤ s
hs'✝ : s ≠ 0
p : ℝ
hp✝ : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
hp : 0 < p
hs3 : 1 + s ≠ 1
hs4 : 1 + p * s ≠ 1
hs' : s < 0
this : 1 ∈ Ioi 0
⊢ log (1 + s) / s = (log (1 + s) - log 1) / (1 + s - 1)
[PROOFSTEP]
field_simp [log_one]
[GOAL]
case h.e'_4
s : ℝ
hs✝ : -1 ≤ s
hs'✝ : s ≠ 0
p : ℝ
hp✝ : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
hp : 0 < p
hs3 : 1 + s ≠ 1
hs4 : 1 + p * s ≠ 1
hs' : s < 0
this : 1 ∈ Ioi 0
⊢ log (1 + p * s) / p / s = (log (1 + p * s) - log 1) / (1 + p * s - 1)
[PROOFSTEP]
field_simp [log_one]
[GOAL]
case inr.inr.a.inl
s : ℝ
hs✝ : -1 ≤ s
hs'✝ : s ≠ 0
p : ℝ
hp✝ : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
hp : 0 < p
hs3 : 1 + s ≠ 1
hs4 : 1 + p * s ≠ 1
hs' : s < 0
this : 1 ∈ Ioi 0
⊢ 1 + p * s < 1 + s
[PROOFSTEP]
nlinarith
[GOAL]
case inr.inr.a.inr
s : ℝ
hs✝ : -1 ≤ s
hs'✝ : s ≠ 0
p : ℝ
hp✝ : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
hp : 0 < p
hs3 : 1 + s ≠ 1
hs4 : 1 + p * s ≠ 1
hs' : s > 0
⊢ log (1 + p * s) < log (1 + s) * p
[PROOFSTEP]
rw [← div_lt_iff hp, ← div_lt_div_right hs']
-- Porting note: previously we could write `zero_lt_one` inline,
-- but now Lean doesn't guess we are talking about `1` fast enough.
[GOAL]
case inr.inr.a.inr
s : ℝ
hs✝ : -1 ≤ s
hs'✝ : s ≠ 0
p : ℝ
hp✝ : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
hp : 0 < p
hs3 : 1 + s ≠ 1
hs4 : 1 + p * s ≠ 1
hs' : s > 0
⊢ log (1 + p * s) / p / s < log (1 + s) / s
[PROOFSTEP]
haveI : (1 : ℝ) ∈ Ioi 0 := zero_lt_one
[GOAL]
case inr.inr.a.inr
s : ℝ
hs✝ : -1 ≤ s
hs'✝ : s ≠ 0
p : ℝ
hp✝ : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
hp : 0 < p
hs3 : 1 + s ≠ 1
hs4 : 1 + p * s ≠ 1
hs' : s > 0
this : 1 ∈ Ioi 0
⊢ log (1 + p * s) / p / s < log (1 + s) / s
[PROOFSTEP]
convert strictConcaveOn_log_Ioi.secant_strict_mono this hs1 hs2 hs3 hs4 _ using 1
[GOAL]
case h.e'_3
s : ℝ
hs✝ : -1 ≤ s
hs'✝ : s ≠ 0
p : ℝ
hp✝ : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
hp : 0 < p
hs3 : 1 + s ≠ 1
hs4 : 1 + p * s ≠ 1
hs' : s > 0
this : 1 ∈ Ioi 0
⊢ log (1 + p * s) / p / s = (log (1 + p * s) - log 1) / (1 + p * s - 1)
[PROOFSTEP]
field_simp [log_one, hp.ne']
[GOAL]
case h.e'_4
s : ℝ
hs✝ : -1 ≤ s
hs'✝ : s ≠ 0
p : ℝ
hp✝ : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
hp : 0 < p
hs3 : 1 + s ≠ 1
hs4 : 1 + p * s ≠ 1
hs' : s > 0
this : 1 ∈ Ioi 0
⊢ log (1 + s) / s = (log (1 + s) - log 1) / (1 + s - 1)
[PROOFSTEP]
field_simp [log_one]
[GOAL]
case inr.inr.a.inr
s : ℝ
hs✝ : -1 ≤ s
hs'✝ : s ≠ 0
p : ℝ
hp✝ : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
hp : 0 < p
hs3 : 1 + s ≠ 1
hs4 : 1 + p * s ≠ 1
hs' : s > 0
this : 1 ∈ Ioi 0
⊢ 1 + s < 1 + p * s
[PROOFSTEP]
nlinarith
[GOAL]
s : ℝ
hs : -1 ≤ s
p : ℝ
hp : 1 ≤ p
⊢ 1 + p * s ≤ (1 + s) ^ p
[PROOFSTEP]
rcases eq_or_lt_of_le hp with (rfl | hp)
[GOAL]
case inl
s : ℝ
hs : -1 ≤ s
hp : 1 ≤ 1
⊢ 1 + 1 * s ≤ (1 + s) ^ 1
[PROOFSTEP]
simp
[GOAL]
case inr
s : ℝ
hs : -1 ≤ s
p : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
⊢ 1 + p * s ≤ (1 + s) ^ p
[PROOFSTEP]
by_cases hs' : s = 0
[GOAL]
case pos
s : ℝ
hs : -1 ≤ s
p : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
hs' : s = 0
⊢ 1 + p * s ≤ (1 + s) ^ p
[PROOFSTEP]
simp [hs']
[GOAL]
case neg
s : ℝ
hs : -1 ≤ s
p : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
hs' : ¬s = 0
⊢ 1 + p * s ≤ (1 + s) ^ p
[PROOFSTEP]
exact (one_add_mul_self_lt_rpow_one_add hs hs' hp).le
[GOAL]
p : ℝ
hp : 1 < p
⊢ StrictConvexOn ℝ (Ici 0) fun x => x ^ p
[PROOFSTEP]
apply strictConvexOn_of_slope_strict_mono_adjacent (convex_Ici (0 : ℝ))
[GOAL]
p : ℝ
hp : 1 < p
⊢ ∀ {x y z : ℝ}, x ∈ Ici 0 → z ∈ Ici 0 → x < y → y < z → (y ^ p - x ^ p) / (y - x) < (z ^ p - y ^ p) / (z - y)
[PROOFSTEP]
rintro x y z (hx : 0 ≤ x) (hz : 0 ≤ z) hxy hyz
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
⊢ (y ^ p - x ^ p) / (y - x) < (z ^ p - y ^ p) / (z - y)
[PROOFSTEP]
have hy : 0 < y := by linarith
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
⊢ 0 < y
[PROOFSTEP]
linarith
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
⊢ (y ^ p - x ^ p) / (y - x) < (z ^ p - y ^ p) / (z - y)
[PROOFSTEP]
have hy' : 0 < y ^ p := rpow_pos_of_pos hy _
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
⊢ (y ^ p - x ^ p) / (y - x) < (z ^ p - y ^ p) / (z - y)
[PROOFSTEP]
have H1 : y ^ (p - 1 + 1) = y ^ (p - 1) * y := rpow_add_one hy.ne' _
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ (p - 1 + 1) = y ^ (p - 1) * y
⊢ (y ^ p - x ^ p) / (y - x) < (z ^ p - y ^ p) / (z - y)
[PROOFSTEP]
ring_nf at H1
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
⊢ (y ^ p - x ^ p) / (y - x) < (z ^ p - y ^ p) / (z - y)
[PROOFSTEP]
trans p * y ^ (p - 1)
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
⊢ (y ^ p - x ^ p) / (y - x) < p * y ^ (p - 1)
[PROOFSTEP]
have h3 : 0 < y - x := by linarith only [hxy]
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
⊢ 0 < y - x
[PROOFSTEP]
linarith only [hxy]
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
h3 : 0 < y - x
⊢ (y ^ p - x ^ p) / (y - x) < p * y ^ (p - 1)
[PROOFSTEP]
have hyx'' : x / y < 1 := by rwa [div_lt_one hy]
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
h3 : 0 < y - x
⊢ x / y < 1
[PROOFSTEP]
rwa [div_lt_one hy]
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
h3 : 0 < y - x
hyx'' : x / y < 1
⊢ (y ^ p - x ^ p) / (y - x) < p * y ^ (p - 1)
[PROOFSTEP]
have hyx''' : x / y - 1 < 0 := by linarith only [hyx'']
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
h3 : 0 < y - x
hyx'' : x / y < 1
⊢ x / y - 1 < 0
[PROOFSTEP]
linarith only [hyx'']
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
h3 : 0 < y - x
hyx'' : x / y < 1
hyx''' : x / y - 1 < 0
⊢ (y ^ p - x ^ p) / (y - x) < p * y ^ (p - 1)
[PROOFSTEP]
have hyx'''' : 0 ≤ x / y := by positivity
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
h3 : 0 < y - x
hyx'' : x / y < 1
hyx''' : x / y - 1 < 0
⊢ 0 ≤ x / y
[PROOFSTEP]
positivity
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
h3 : 0 < y - x
hyx'' : x / y < 1
hyx''' : x / y - 1 < 0
hyx'''' : 0 ≤ x / y
⊢ (y ^ p - x ^ p) / (y - x) < p * y ^ (p - 1)
[PROOFSTEP]
have hyx''''' : -1 ≤ x / y - 1 := by linarith only [hyx'''']
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
h3 : 0 < y - x
hyx'' : x / y < 1
hyx''' : x / y - 1 < 0
hyx'''' : 0 ≤ x / y
⊢ -1 ≤ x / y - 1
[PROOFSTEP]
linarith only [hyx'''']
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
h3 : 0 < y - x
hyx'' : x / y < 1
hyx''' : x / y - 1 < 0
hyx'''' : 0 ≤ x / y
hyx''''' : -1 ≤ x / y - 1
⊢ (y ^ p - x ^ p) / (y - x) < p * y ^ (p - 1)
[PROOFSTEP]
have : 1 - (1 + (x / y - 1)) ^ p < -p * (x / y - 1) := by
linarith [one_add_mul_self_lt_rpow_one_add hyx''''' hyx'''.ne hp]
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
h3 : 0 < y - x
hyx'' : x / y < 1
hyx''' : x / y - 1 < 0
hyx'''' : 0 ≤ x / y
hyx''''' : -1 ≤ x / y - 1
⊢ 1 - (1 + (x / y - 1)) ^ p < -p * (x / y - 1)
[PROOFSTEP]
linarith [one_add_mul_self_lt_rpow_one_add hyx''''' hyx'''.ne hp]
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
h3 : 0 < y - x
hyx'' : x / y < 1
hyx''' : x / y - 1 < 0
hyx'''' : 0 ≤ x / y
hyx''''' : -1 ≤ x / y - 1
this : 1 - (1 + (x / y - 1)) ^ p < -p * (x / y - 1)
⊢ (y ^ p - x ^ p) / (y - x) < p * y ^ (p - 1)
[PROOFSTEP]
rw [div_lt_iff h3, ← div_lt_div_right hy']
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
h3 : 0 < y - x
hyx'' : x / y < 1
hyx''' : x / y - 1 < 0
hyx'''' : 0 ≤ x / y
hyx''''' : -1 ≤ x / y - 1
this : 1 - (1 + (x / y - 1)) ^ p < -p * (x / y - 1)
⊢ (y ^ p - x ^ p) / y ^ p < p * y ^ (p - 1) * (y - x) / y ^ p
[PROOFSTEP]
convert this using 1
[GOAL]
case h.e'_3
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
h3 : 0 < y - x
hyx'' : x / y < 1
hyx''' : x / y - 1 < 0
hyx'''' : 0 ≤ x / y
hyx''''' : -1 ≤ x / y - 1
this : 1 - (1 + (x / y - 1)) ^ p < -p * (x / y - 1)
⊢ (y ^ p - x ^ p) / y ^ p = 1 - (1 + (x / y - 1)) ^ p
[PROOFSTEP]
have H : (x / y) ^ p = x ^ p / y ^ p := div_rpow hx hy.le _
[GOAL]
case h.e'_3
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
h3 : 0 < y - x
hyx'' : x / y < 1
hyx''' : x / y - 1 < 0
hyx'''' : 0 ≤ x / y
hyx''''' : -1 ≤ x / y - 1
this : 1 - (1 + (x / y - 1)) ^ p < -p * (x / y - 1)
H : (x / y) ^ p = x ^ p / y ^ p
⊢ (y ^ p - x ^ p) / y ^ p = 1 - (1 + (x / y - 1)) ^ p
[PROOFSTEP]
ring_nf at H ⊢
[GOAL]
case h.e'_3
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
h3 : 0 < y - x
hyx'' : x / y < 1
hyx''' : x / y - 1 < 0
hyx'''' : 0 ≤ x / y
hyx''''' : -1 ≤ x / y - 1
this : 1 - (1 + (x / y - 1)) ^ p < -p * (x / y - 1)
H : (x * y⁻¹) ^ p = x ^ p * (y ^ p)⁻¹
⊢ -(x ^ p * (y ^ p)⁻¹) + y ^ p * (y ^ p)⁻¹ = 1 - (x * y⁻¹) ^ p
[PROOFSTEP]
field_simp [hy.ne', hy'.ne'] at H ⊢
[GOAL]
case h.e'_3
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
h3 : 0 < y - x
hyx'' : x / y < 1
hyx''' : x / y - 1 < 0
hyx'''' : 0 ≤ x / y
hyx''''' : -1 ≤ x / y - 1
this : 1 - (1 + (x / y - 1)) ^ p < -p * (x / y - 1)
H : (x / y) ^ p * y ^ p = x ^ p
⊢ -x ^ p + y ^ p = (1 - (x / y) ^ p) * y ^ p
[PROOFSTEP]
linear_combination H
[GOAL]
case h.e'_4
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
h3 : 0 < y - x
hyx'' : x / y < 1
hyx''' : x / y - 1 < 0
hyx'''' : 0 ≤ x / y
hyx''''' : -1 ≤ x / y - 1
this : 1 - (1 + (x / y - 1)) ^ p < -p * (x / y - 1)
⊢ p * y ^ (p - 1) * (y - x) / y ^ p = -p * (x / y - 1)
[PROOFSTEP]
ring_nf at H1 ⊢
[GOAL]
case h.e'_4
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
h3 : 0 < y - x
hyx'' : x / y < 1
hyx''' : x / y - 1 < 0
hyx'''' : 0 ≤ x / y
hyx''''' : -1 ≤ x / y - 1
this : 1 - (1 + (x / y - 1)) ^ p < -p * (x / y - 1)
⊢ p * y ^ (-1 + p) * y * (y ^ p)⁻¹ - p * y ^ (-1 + p) * x * (y ^ p)⁻¹ = p - p * x * y⁻¹
[PROOFSTEP]
field_simp [hy.ne', hy'.ne']
[GOAL]
case h.e'_4
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
h3 : 0 < y - x
hyx'' : x / y < 1
hyx''' : x / y - 1 < 0
hyx'''' : 0 ≤ x / y
hyx''''' : -1 ≤ x / y - 1
this : 1 - (1 + (x / y - 1)) ^ p < -p * (x / y - 1)
⊢ (p * y ^ (-1 + p) * y - p * y ^ (-1 + p) * x) * y = (p * y - p * x) * y ^ p
[PROOFSTEP]
linear_combination p * (-y + x) * H1
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
⊢ p * y ^ (p - 1) < (z ^ p - y ^ p) / (z - y)
[PROOFSTEP]
have hyz' : 0 < z - y := by linarith only [hyz]
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
⊢ 0 < z - y
[PROOFSTEP]
linarith only [hyz]
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
hyz' : 0 < z - y
⊢ p * y ^ (p - 1) < (z ^ p - y ^ p) / (z - y)
[PROOFSTEP]
have hyz'' : 1 < z / y := by rwa [one_lt_div hy]
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
hyz' : 0 < z - y
⊢ 1 < z / y
[PROOFSTEP]
rwa [one_lt_div hy]
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
hyz' : 0 < z - y
hyz'' : 1 < z / y
⊢ p * y ^ (p - 1) < (z ^ p - y ^ p) / (z - y)
[PROOFSTEP]
have hyz''' : 0 < z / y - 1 := by linarith only [hyz'']
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
hyz' : 0 < z - y
hyz'' : 1 < z / y
⊢ 0 < z / y - 1
[PROOFSTEP]
linarith only [hyz'']
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
hyz' : 0 < z - y
hyz'' : 1 < z / y
hyz''' : 0 < z / y - 1
⊢ p * y ^ (p - 1) < (z ^ p - y ^ p) / (z - y)
[PROOFSTEP]
have hyz'''' : -1 ≤ z / y - 1 := by linarith only [hyz'']
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
hyz' : 0 < z - y
hyz'' : 1 < z / y
hyz''' : 0 < z / y - 1
⊢ -1 ≤ z / y - 1
[PROOFSTEP]
linarith only [hyz'']
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
hyz' : 0 < z - y
hyz'' : 1 < z / y
hyz''' : 0 < z / y - 1
hyz'''' : -1 ≤ z / y - 1
⊢ p * y ^ (p - 1) < (z ^ p - y ^ p) / (z - y)
[PROOFSTEP]
have : p * (z / y - 1) < (1 + (z / y - 1)) ^ p - 1 := by
linarith [one_add_mul_self_lt_rpow_one_add hyz'''' hyz'''.ne' hp]
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
hyz' : 0 < z - y
hyz'' : 1 < z / y
hyz''' : 0 < z / y - 1
hyz'''' : -1 ≤ z / y - 1
⊢ p * (z / y - 1) < (1 + (z / y - 1)) ^ p - 1
[PROOFSTEP]
linarith [one_add_mul_self_lt_rpow_one_add hyz'''' hyz'''.ne' hp]
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
hyz' : 0 < z - y
hyz'' : 1 < z / y
hyz''' : 0 < z / y - 1
hyz'''' : -1 ≤ z / y - 1
this : p * (z / y - 1) < (1 + (z / y - 1)) ^ p - 1
⊢ p * y ^ (p - 1) < (z ^ p - y ^ p) / (z - y)
[PROOFSTEP]
rw [lt_div_iff hyz', ← div_lt_div_right hy']
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
hyz' : 0 < z - y
hyz'' : 1 < z / y
hyz''' : 0 < z / y - 1
hyz'''' : -1 ≤ z / y - 1
this : p * (z / y - 1) < (1 + (z / y - 1)) ^ p - 1
⊢ p * y ^ (p - 1) * (z - y) / y ^ p < (z ^ p - y ^ p) / y ^ p
[PROOFSTEP]
convert this using 1
[GOAL]
case h.e'_3
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
hyz' : 0 < z - y
hyz'' : 1 < z / y
hyz''' : 0 < z / y - 1
hyz'''' : -1 ≤ z / y - 1
this : p * (z / y - 1) < (1 + (z / y - 1)) ^ p - 1
⊢ p * y ^ (p - 1) * (z - y) / y ^ p = p * (z / y - 1)
[PROOFSTEP]
ring_nf at H1 ⊢
[GOAL]
case h.e'_3
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
hyz' : 0 < z - y
hyz'' : 1 < z / y
hyz''' : 0 < z / y - 1
hyz'''' : -1 ≤ z / y - 1
this : p * (z / y - 1) < (1 + (z / y - 1)) ^ p - 1
⊢ -(p * y ^ (-1 + p) * y * (y ^ p)⁻¹) + p * y ^ (-1 + p) * z * (y ^ p)⁻¹ = -p + p * z * y⁻¹
[PROOFSTEP]
field_simp [hy.ne', hy'.ne'] at H1 ⊢
[GOAL]
case h.e'_3
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
hyz' : 0 < z - y
hyz'' : 1 < z / y
hyz''' : 0 < z / y - 1
hyz'''' : -1 ≤ z / y - 1
this : p * (z / y - 1) < (1 + (z / y - 1)) ^ p - 1
⊢ (-(p * y ^ (-1 + p) * y * y ^ p) + p * y ^ (-1 + p) * z * y ^ p) * y = (-(p * y) + p * z) * (y ^ p * y ^ p)
[PROOFSTEP]
linear_combination p * (y - z) * y ^ p * H1
[GOAL]
case h.e'_4
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
hyz' : 0 < z - y
hyz'' : 1 < z / y
hyz''' : 0 < z / y - 1
hyz'''' : -1 ≤ z / y - 1
this : p * (z / y - 1) < (1 + (z / y - 1)) ^ p - 1
⊢ (z ^ p - y ^ p) / y ^ p = (1 + (z / y - 1)) ^ p - 1
[PROOFSTEP]
have H : (z / y) ^ p = z ^ p / y ^ p := div_rpow hz hy.le _
[GOAL]
case h.e'_4
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
hyz' : 0 < z - y
hyz'' : 1 < z / y
hyz''' : 0 < z / y - 1
hyz'''' : -1 ≤ z / y - 1
this : p * (z / y - 1) < (1 + (z / y - 1)) ^ p - 1
H : (z / y) ^ p = z ^ p / y ^ p
⊢ (z ^ p - y ^ p) / y ^ p = (1 + (z / y - 1)) ^ p - 1
[PROOFSTEP]
ring_nf at H ⊢
[GOAL]
case h.e'_4
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
hyz' : 0 < z - y
hyz'' : 1 < z / y
hyz''' : 0 < z / y - 1
hyz'''' : -1 ≤ z / y - 1
this : p * (z / y - 1) < (1 + (z / y - 1)) ^ p - 1
H : (z * y⁻¹) ^ p = z ^ p * (y ^ p)⁻¹
⊢ z ^ p * (y ^ p)⁻¹ - y ^ p * (y ^ p)⁻¹ = -1 + (z * y⁻¹) ^ p
[PROOFSTEP]
field_simp [hy.ne', hy'.ne'] at H ⊢
[GOAL]
case h.e'_4
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
hyz' : 0 < z - y
hyz'' : 1 < z / y
hyz''' : 0 < z / y - 1
hyz'''' : -1 ≤ z / y - 1
this : p * (z / y - 1) < (1 + (z / y - 1)) ^ p - 1
H : (z / y) ^ p * y ^ p = z ^ p
⊢ z ^ p - y ^ p = (-1 + (z / y) ^ p) * y ^ p
[PROOFSTEP]
linear_combination -H
[GOAL]
p : ℝ
hp : 1 ≤ p
⊢ ConvexOn ℝ (Ici 0) fun x => x ^ p
[PROOFSTEP]
rcases eq_or_lt_of_le hp with (rfl | hp)
[GOAL]
case inl
hp : 1 ≤ 1
⊢ ConvexOn ℝ (Ici 0) fun x => x ^ 1
[PROOFSTEP]
simpa using convexOn_id (convex_Ici _)
[GOAL]
case inr
p : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
⊢ ConvexOn ℝ (Ici 0) fun x => x ^ p
[PROOFSTEP]
exact (strictConvexOn_rpow hp).convexOn
[GOAL]
⊢ StrictConcaveOn ℝ (Iio 0) log
[PROOFSTEP]
refine' ⟨convex_Iio _, _⟩
[GOAL]
⊢ ∀ ⦃x : ℝ⦄,
x ∈ Iio 0 →
∀ ⦃y : ℝ⦄,
y ∈ Iio 0 → x ≠ y → ∀ ⦃a b : ℝ⦄, 0 < a → 0 < b → a + b = 1 → a • log x + b • log y < log (a • x + b • y)
[PROOFSTEP]
rintro x (hx : x < 0) y (hy : y < 0) hxy a b ha hb hab
[GOAL]
x : ℝ
hx : x < 0
y : ℝ
hy : y < 0
hxy : x ≠ y
a b : ℝ
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ a • log x + b • log y < log (a • x + b • y)
[PROOFSTEP]
have hx' : 0 < -x := by linarith
[GOAL]
x : ℝ
hx : x < 0
y : ℝ
hy : y < 0
hxy : x ≠ y
a b : ℝ
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ 0 < -x
[PROOFSTEP]
linarith
[GOAL]
x : ℝ
hx : x < 0
y : ℝ
hy : y < 0
hxy : x ≠ y
a b : ℝ
ha : 0 < a
hb : 0 < b
hab : a + b = 1
hx' : 0 < -x
⊢ a • log x + b • log y < log (a • x + b • y)
[PROOFSTEP]
have hy' : 0 < -y := by linarith
[GOAL]
x : ℝ
hx : x < 0
y : ℝ
hy : y < 0
hxy : x ≠ y
a b : ℝ
ha : 0 < a
hb : 0 < b
hab : a + b = 1
hx' : 0 < -x
⊢ 0 < -y
[PROOFSTEP]
linarith
[GOAL]
x : ℝ
hx : x < 0
y : ℝ
hy : y < 0
hxy : x ≠ y
a b : ℝ
ha : 0 < a
hb : 0 < b
hab : a + b = 1
hx' : 0 < -x
hy' : 0 < -y
⊢ a • log x + b • log y < log (a • x + b • y)
[PROOFSTEP]
have hxy' : -x ≠ -y := by contrapose! hxy; linarith
[GOAL]
x : ℝ
hx : x < 0
y : ℝ
hy : y < 0
hxy : x ≠ y
a b : ℝ
ha : 0 < a
hb : 0 < b
hab : a + b = 1
hx' : 0 < -x
hy' : 0 < -y
⊢ -x ≠ -y
[PROOFSTEP]
contrapose! hxy
[GOAL]
x : ℝ
hx : x < 0
y : ℝ
hy : y < 0
a b : ℝ
ha : 0 < a
hb : 0 < b
hab : a + b = 1
hx' : 0 < -x
hy' : 0 < -y
hxy : -x = -y
⊢ x = y
[PROOFSTEP]
linarith
[GOAL]
x : ℝ
hx : x < 0
y : ℝ
hy : y < 0
hxy : x ≠ y
a b : ℝ
ha : 0 < a
hb : 0 < b
hab : a + b = 1
hx' : 0 < -x
hy' : 0 < -y
hxy' : -x ≠ -y
⊢ a • log x + b • log y < log (a • x + b • y)
[PROOFSTEP]
calc
a • log x + b • log y = a • log (-x) + b • log (-y) := by simp_rw [log_neg_eq_log]
_ < log (a • -x + b • -y) := (strictConcaveOn_log_Ioi.2 hx' hy' hxy' ha hb hab)
_ = log (-(a • x + b • y)) := by congr 1; simp only [Algebra.id.smul_eq_mul]; ring
_ = _ := by rw [log_neg_eq_log]
[GOAL]
x : ℝ
hx : x < 0
y : ℝ
hy : y < 0
hxy : x ≠ y
a b : ℝ
ha : 0 < a
hb : 0 < b
hab : a + b = 1
hx' : 0 < -x
hy' : 0 < -y
hxy' : -x ≠ -y
⊢ a • log x + b • log y = a • log (-x) + b • log (-y)
[PROOFSTEP]
simp_rw [log_neg_eq_log]
[GOAL]
x : ℝ
hx : x < 0
y : ℝ
hy : y < 0
hxy : x ≠ y
a b : ℝ
ha : 0 < a
hb : 0 < b
hab : a + b = 1
hx' : 0 < -x
hy' : 0 < -y
hxy' : -x ≠ -y
⊢ log (a • -x + b • -y) = log (-(a • x + b • y))
[PROOFSTEP]
congr 1
[GOAL]
case e_x
x : ℝ
hx : x < 0
y : ℝ
hy : y < 0
hxy : x ≠ y
a b : ℝ
ha : 0 < a
hb : 0 < b
hab : a + b = 1
hx' : 0 < -x
hy' : 0 < -y
hxy' : -x ≠ -y
⊢ a • -x + b • -y = -(a • x + b • y)
[PROOFSTEP]
simp only [Algebra.id.smul_eq_mul]
[GOAL]
case e_x
x : ℝ
hx : x < 0
y : ℝ
hy : y < 0
hxy : x ≠ y
a b : ℝ
ha : 0 < a
hb : 0 < b
hab : a + b = 1
hx' : 0 < -x
hy' : 0 < -y
hxy' : -x ≠ -y
⊢ a * -x + b * -y = -(a * x + b * y)
[PROOFSTEP]
ring
[GOAL]
x : ℝ
hx : x < 0
y : ℝ
hy : y < 0
hxy : x ≠ y
a b : ℝ
ha : 0 < a
hb : 0 < b
hab : a + b = 1
hx' : 0 < -x
hy' : 0 < -y
hxy' : -x ≠ -y
⊢ log (-(a • x + b • y)) = log (a • x + b • y)
[PROOFSTEP]
rw [log_neg_eq_log]
|
/-
Copyright (c) 2022 Andrew Yang. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Andrew Yang
! This file was ported from Lean 3 source module algebra.gcd_monoid.integrally_closed
! leanprover-community/mathlib commit 2032a878972d5672e7c27c957e7a6e297b044973
! Please do not edit these lines, except to modify the commit id
! if you have ported upstream changes.
-/
import Mathbin.Algebra.GcdMonoid.Basic
import Mathbin.RingTheory.IntegrallyClosed
import Mathbin.RingTheory.Polynomial.Eisenstein.Basic
/-!
# GCD domains are integrally closed
-/
open BigOperators Polynomial
variable {R A : Type _} [CommRing R] [IsDomain R] [GCDMonoid R] [CommRing A] [Algebra R A]
theorem IsLocalization.surj_of_gcd_domain (M : Submonoid R) [IsLocalization M A] (z : A) :
∃ a b : R, IsUnit (gcd a b) ∧ z * algebraMap R A b = algebraMap R A a :=
by
obtain ⟨x, ⟨y, hy⟩, rfl⟩ := IsLocalization.mk'_surjective M z
obtain ⟨x', y', hx', hy', hu⟩ := extract_gcd x y
use x', y', hu
rw [mul_comm, IsLocalization.mul_mk'_eq_mk'_of_mul]
convert IsLocalization.mk'_mul_cancel_left _ _ using 2
· rw [Subtype.coe_mk, hy', ← mul_comm y', mul_assoc]
conv_lhs => rw [hx']
· infer_instance
#align is_localization.surj_of_gcd_domain IsLocalization.surj_of_gcd_domain
instance (priority := 100) GCDMonoid.toIsIntegrallyClosed : IsIntegrallyClosed R :=
⟨fun X ⟨p, hp₁, hp₂⟩ =>
by
obtain ⟨x, y, hg, he⟩ := IsLocalization.surj_of_gcd_domain (nonZeroDivisors R) X
have :=
Polynomial.dvd_pow_natDegree_of_eval₂_eq_zero (IsFractionRing.injective R <| FractionRing R)
hp₁ y x _ hp₂ (by rw [mul_comm, he])
have : IsUnit y := by
rw [isUnit_iff_dvd_one, ← one_pow]
exact
(dvd_gcd this <| dvd_refl y).trans
(gcd_pow_left_dvd_pow_gcd.trans <| pow_dvd_pow_of_dvd (isUnit_iff_dvd_one.1 hg) _)
use x * (this.unit⁻¹ : _)
erw [map_mul, ← Units.coe_map_inv, eq_comm, Units.eq_mul_inv_iff_mul_eq]
exact he⟩
#align gcd_monoid.to_is_integrally_closed GCDMonoid.toIsIntegrallyClosed
|
import Aoc
import Data.List
import Data.List1
import Data.Strings
import Data.SortedMap
import Debug.Trace
data Production = Terminal String | NTs (List (List Int))
Show Production where
show (Terminal s) = show s
show (NTs s) = show s
Rules : Type
Rules = SortedMap Int Production
toRules : List (Int, Production) -> Rules
toRules = fromList
parseRule : String -> Maybe (Int, Production)
parseRule s = do
(sn:::[rest]) <- pure (split (==':') s) | _ => Nothing
n <- parsePositive {a=Int} sn
case split (=='"') rest of
(" ":::[t,""]) => Just (n, Terminal t)
_ =>
let parseChain = traverse parsePositive . forget . split (==' ') . trim
in case traverse parseChain . forget . split (=='|') . trim $ rest of
Just nts => Just (n, NTs nts)
Nothing => Nothing
munch : Eq a => List a -> List a -> Maybe (List a)
munch [] ys = Just ys
munch (x::xs) [] = Nothing
munch (x::xs) (y::ys) = if x == y then munch xs ys else Nothing
mutual
matches : Rules -> Int -> List Char -> List (List Char)
matches rs k cs =
case lookup k rs of
Nothing => []
Just (Terminal t) => toList $ munch (unpack t) cs
Just (NTs alts) => do
alt <- alts
matchesSeq rs alt cs
matchesSeq : Rules -> List Int -> List Char -> List (List Char)
matchesSeq rs [] cs = [cs]
matchesSeq rs (k::ks) cs = do
cs' <- matches rs k cs
matchesSeq rs ks cs'
matchesFully : Rules -> Int -> String -> Bool
matchesFully rs k s = any (==[]) $ matches rs k (unpack s)
main : IO ()
main = do
(ls1:::[ls2]) <- readParagraphs | _ => putStrLn "paragraph parse error"
Just rules <- pure $ toRules <$> traverse parseRule ls1 | _ => putStrLn "rule parse error"
putStr "* "; printLn $ count (matchesFully rules 0) ls2
let rules' = insert 8 (NTs [[42,8],[42]]) $ insert 11 (NTs [[42,31],[42,11,31]]) $ rules
putStr "** "; printLn $ count (matchesFully rules' 0) ls2
|
section "Setup of Environment for CAVA Model Checker"
theory CAVA_Base
imports
Collections.CollectionsV1 (*-- {* Compatibility with ICF 1.0 *}*)
Collections.Refine_Dflt
Statistics (*-- {* Collecting statistics by instrumenting the formalization *}*)
CAVA_Code_Target (*-- {* Code Generator Setup *}*)
begin
hide_const (open) CollectionsV1.ahs_rel
(*
(* Select-function that selects element from set *)
(* TODO: Move! Is select properly integrated into autoref? *)
definition select where
"select S \<equiv> if S={} then RETURN None else RES {Some s | s. s\<in>S}"
lemma select_correct:
"select X \<le> SPEC (\<lambda>r. case r of None \<Rightarrow> X={} | Some x \<Rightarrow> x\<in>X)"
unfolding select_def
apply (refine_rcg refine_vcg)
by auto
*)
text \<open>Cleaning up the namespace a bit\<close>
hide_type (open) Word.word
no_notation test_bit (infixl "!!" 100)
text \<open>Some custom setup in cava, that does not match HOL defaults:\<close>
declare Let_def[simp add]
end
|
Subsets and Splits