ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- _private.Mathlib.NumberTheory.NumberField.House.0.NumberField.house.asiegel_remark
private theorem asiegel_remark : ‖asiegel K a‖ ≤ c₂ K * A 
Arguments: (K : Type u_1) [Field K] [NumberField K] [DecidableEq (K →+* ℂ)] {α : Type u_2} {β : Type u_3} [Fintype α] [Fintype β] (a : Matrix α β (NumberField.RingOfIntegers K)) {A : ℝ} (habs : ∀ (k : α) (l : β), NumberField.house ((algebraMap (NumberField.RingOfIntegers K) K) (a k l)) ≤ A) (Apos : 0 ≤ A)
Goal: ‖NumberField.house.asiegel K a‖ ≤ NumberField.house.c₂ K * A
-- _private.Mathlib.NumberTheory.NumberField.House.0.NumberField.house.house_le_bound
private theorem house_le_bound : ∀ l, house (ξ K x l).1 ≤ (c₁ K) *
    ((c₁ K * q * A)^((p : ℝ) / (q - p))) 
Arguments: (K : Type u_1) [Field K] [NumberField K] [DecidableEq (K →+* ℂ)] {α : Type u_2} {β : Type u_3} [Fintype α] [Fintype β] (a : Matrix α β (NumberField.RingOfIntegers K)) {p q : ℕ} (hpq : p < q) (x : β × (K →+* ℂ) → ℤ) (hxbound : ‖x‖ ≤ (↑q * ↑(FiniteDimensional.finrank ℚ K) * ‖NumberField.house.asiegel K a‖) ^ (↑p / (↑q - ↑p))) {A : ℝ} (habs : ∀ (k : α) (l : β), NumberField.house ((algebraMap (NumberField.RingOfIntegers K) K) (a k l)) ≤ A) (Apos : 0 ≤ A) (l : β)
Goal: NumberField.house ↑(NumberField.house.ξ K x l) ≤
  NumberField.house.c₁ K * (NumberField.house.c₁ K * ↑q * A) ^ (↑p / (↑q - ↑p))
-- NumberField.house.exists_ne_zero_int_vec_house_le
theorem exists_ne_zero_int_vec_house_le :
    ∃ (ξ : β → 𝓞 K), ξ ≠ 0 ∧ a *ᵥ ξ = 0 ∧
    ∀ l, house (ξ l).1 ≤ c₁ K * ((c₁ K * q * A) ^ ((p : ℝ) / (q - p))) 
Arguments: (K : Type u_1) [Field K] [NumberField K] [DecidableEq (K →+* ℂ)] {α : Type u_2} {β : Type u_3} [Fintype α] [Fintype β] (a : Matrix α β (NumberField.RingOfIntegers K)) (ha : a ≠ 0) {p q : ℕ} (cardα : Fintype.card α = p) (cardβ : Fintype.card β = q) (h0p : 0 < p) (hpq : p < q) {A : ℝ} (habs : ∀ (k : α) (l : β), NumberField.house ((algebraMap (NumberField.RingOfIntegers K) K) (a k l)) ≤ A)
Goal: ∃ ξ,
  ξ ≠ 0 ∧
    a.mulVec ξ = 0 ∧
      ∀ (l : β),
        NumberField.house ↑(ξ l) ≤ NumberField.house.c₁ K * (NumberField.house.c₁ K * ↑q * A) ^ (↑p / (↑q - ↑p))
-- IsPoly.neg
theorem IsPoly.neg {f : (α → ℕ) → ℤ} : IsPoly f → IsPoly (-f) 
Arguments: {α : Type u_1} {f : (α → ℕ) → ℤ}
Goal: IsPoly f → IsPoly (-f)
-- IsPoly.add
theorem IsPoly.add {f g : (α → ℕ) → ℤ} (hf : IsPoly f) (hg : IsPoly g) : IsPoly (f + g) 
Arguments: {α : Type u_1} {f g : (α → ℕ) → ℤ} (hf : IsPoly f) (hg : IsPoly g)
Goal: IsPoly (f + g)
-- Poly.isPoly
protected theorem isPoly (f : Poly α) : IsPoly f 
Arguments: {α : Type u_1} (f : Poly α)
Goal: IsPoly ⇑f
-- Poly.ext
@[ext]
theorem ext {f g : Poly α} : (∀ x, f x = g x) → f = g 
Arguments: {α : Type u_1} {f g : Poly α}
Goal: (∀ (x : α → ℕ), f x = g x) → f = g
-- Poly.proj_apply
@[simp]
theorem proj_apply (i : α) (x) : proj i x = x i 
Arguments: {α : Type u_1} (i : α) (x : α → ℕ)
Goal: (Poly.proj i) x = ↑(x i)
-- Poly.const_apply
@[simp]
theorem const_apply (n) (x : α → ℕ) : const n x = n 
Arguments: {α : Type u_1} (n : ℤ) (x : α → ℕ)
Goal: (Poly.const n) x = n
-- Poly.coe_zero
@[simp]
theorem coe_zero : ⇑(0 : Poly α) = const 0 
Arguments: {α : Type u_1}
Goal: ⇑0 = ⇑(Poly.const 0)
-- Poly.coe_one
@[simp]
theorem coe_one : ⇑(1 : Poly α) = const 1 
Arguments: {α : Type u_1}
Goal: ⇑1 = ⇑(Poly.const 1)
-- Poly.coe_neg
@[simp]
theorem coe_neg (f : Poly α) : ⇑(-f) = -f 
Arguments: {α : Type u_1} (f : Poly α)
Goal: ⇑(-f) = -⇑f
-- Poly.coe_add
@[simp]
theorem coe_add (f g : Poly α) : ⇑(f + g) = f + g 
Arguments: {α : Type u_1} (f g : Poly α)
Goal: ⇑(f + g) = ⇑f + ⇑g
-- Poly.coe_sub
@[simp]
theorem coe_sub (f g : Poly α) : ⇑(f - g) = f - g 
Arguments: {α : Type u_1} (f g : Poly α)
Goal: ⇑(f - g) = ⇑f - ⇑g
-- Poly.coe_mul
@[simp]
theorem coe_mul (f g : Poly α) : ⇑(f * g) = f * g 
Arguments: {α : Type u_1} (f g : Poly α)
Goal: ⇑(f * g) = ⇑f * ⇑g
-- Poly.zero_apply
@[simp]
theorem zero_apply (x) : (0 : Poly α) x = 0 
Arguments: {α : Type u_1} (x : α → ℕ)
Goal: 0 x = 0
-- Poly.one_apply
@[simp]
theorem one_apply (x) : (1 : Poly α) x = 1 
Arguments: {α : Type u_1} (x : α → ℕ)
Goal: 1 x = 1
-- Poly.neg_apply
@[simp]
theorem neg_apply (f : Poly α) (x) : (-f) x = -f x 
Arguments: {α : Type u_1} (f : Poly α) (x : α → ℕ)
Goal: (-f) x = -f x
-- Poly.add_apply
@[simp]
theorem add_apply (f g : Poly α) (x : α → ℕ) : (f + g) x = f x + g x 
Arguments: {α : Type u_1} (f g : Poly α) (x : α → ℕ)
Goal: (f + g) x = f x + g x
-- Poly.sub_apply
@[simp]
theorem sub_apply (f g : Poly α) (x : α → ℕ) : (f - g) x = f x - g x 
Arguments: {α : Type u_1} (f g : Poly α) (x : α → ℕ)
Goal: (f - g) x = f x - g x
-- Poly.mul_apply
@[simp]
theorem mul_apply (f g : Poly α) (x : α → ℕ) : (f * g) x = f x * g x 
Arguments: {α : Type u_1} (f g : Poly α) (x : α → ℕ)
Goal: (f * g) x = f x * g x
-- Poly.induction
theorem induction {C : Poly α → Prop} (H1 : ∀ i, C (proj i)) (H2 : ∀ n, C (const n))
    (H3 : ∀ f g, C f → C g → C (f - g)) (H4 : ∀ f g, C f → C g → C (f * g)) (f : Poly α) : C f 
Arguments: {α : Type u_1} {C : Poly α → Prop} (H1 : ∀ (i : α), C (Poly.proj i)) (H2 : ∀ (n : ℤ), C (Poly.const n)) (H3 : ∀ (f g : Poly α), C f → C g → C (f - g)) (H4 : ∀ (f g : Poly α), C f → C g → C (f * g)) (f : Poly α)
Goal: C f
-- Poly.sumsq_nonneg
theorem sumsq_nonneg (x : α → ℕ) : ∀ l, 0 ≤ sumsq l x
  
Arguments: {α : Type u_1} (x : α → ℕ) (l : List (Poly α))
Goal: 0 ≤ (Poly.sumsq l) x
-- Poly.sumsq_eq_zero
theorem sumsq_eq_zero (x) : ∀ l, sumsq l x = 0 ↔ l.Forall fun a : Poly α => a x = 0
  
Arguments: {α : Type u_1} (x : α → ℕ) (l : List (Poly α))
Goal: (Poly.sumsq l) x = 0 ↔ List.Forall (fun a => a x = 0) l
-- Poly.map_apply
@[simp]
theorem map_apply {α β} (f : α → β) (g : Poly α) (v) : map f g v = g (v ∘ f) 
Arguments: {α : Type u_4} {β : Type u_5} (f : α → β) (g : Poly α) (v : β → ℕ)
Goal: (Poly.map f g) v = g (v ∘ f)
-- Dioph.ext
theorem ext (d : Dioph S) (H : ∀ v, v ∈ S ↔ v ∈ S') : Dioph S' 
Arguments: {α : Type u} {S S' : Set (α → ℕ)} (d : Dioph S) (H : ∀ (v : α → ℕ), v ∈ S ↔ v ∈ S')
Goal: Dioph S'
-- Dioph.of_no_dummies
theorem of_no_dummies (S : Set (α → ℕ)) (p : Poly α) (h : ∀ v, S v ↔ p v = 0) : Dioph S 
Arguments: {α : Type u} (S : Set (α → ℕ)) (p : Poly α) (h : ∀ (v : α → ℕ), S v ↔ p v = 0)
Goal: Dioph S
-- Dioph.inject_dummies_lem
theorem inject_dummies_lem (f : β → γ) (g : γ → Option β) (inv : ∀ x, g (f x) = some x)
    (p : Poly (α ⊕ β)) (v : α → ℕ) :
    (∃ t, p (v ⊗ t) = 0) ↔ ∃ t, p.map (inl ⊗ inr ∘ f) (v ⊗ t) = 0 
Arguments: {α β γ : Type u} (f : β → γ) (g : γ → Option β) (inv : ∀ (x : β), g (f x) = some x) (p : Poly (α ⊕ β)) (v : α → ℕ)
Goal: (∃ t, p (v ⊗ t) = 0) ↔ ∃ t, (Poly.map (Sum.inl ⊗ Sum.inr ∘ f) p) (v ⊗ t) = 0
-- Dioph.inject_dummies
theorem inject_dummies (f : β → γ) (g : γ → Option β) (inv : ∀ x, g (f x) = some x)
    (p : Poly (α ⊕ β)) (h : ∀ v, S v ↔ ∃ t, p (v ⊗ t) = 0) :
    ∃ q : Poly (α ⊕ γ), ∀ v, S v ↔ ∃ t, q (v ⊗ t) = 0 
Arguments: {α β γ : Type u} {S : Set (α → ℕ)} (f : β → γ) (g : γ → Option β) (inv : ∀ (x : β), g (f x) = some x) (p : Poly (α ⊕ β)) (h : ∀ (v : α → ℕ), S v ↔ ∃ t, p (v ⊗ t) = 0)
Goal: ∃ q, ∀ (v : α → ℕ), S v ↔ ∃ t, q (v ⊗ t) = 0
-- Dioph.reindex_dioph
theorem reindex_dioph (f : α → β) : Dioph S → Dioph {v | v ∘ f ∈ S}
  
Arguments: {α : Type u} (β : Type u) {S : Set (α → ℕ)} (f : α → β)
Goal: Dioph S → Dioph {v | v ∘ f ∈ S}
-- Dioph.DiophList.forall
theorem DiophList.forall (l : List (Set <| α → ℕ)) (d : l.Forall Dioph) :
    Dioph {v | l.Forall fun S : Set (α → ℕ) => v ∈ S} 
Arguments: {α : Type u} (l : List (Set (α → ℕ))) (d : List.Forall Dioph l)
Goal: Dioph {v | List.Forall (fun S => v ∈ S) l}
-- Dioph.inter
theorem inter (d : Dioph S) (d' : Dioph S') : Dioph (S ∩ S') 
Arguments: {α : Type u} {S S' : Set (α → ℕ)} (d : Dioph S) (d' : Dioph S')
Goal: Dioph (S ∩ S')
-- Dioph.union
theorem union : ∀ (_ : Dioph S) (_ : Dioph S'), Dioph (S ∪ S')
  
Arguments: {α : Type u} {S S' : Set (α → ℕ)}
Goal: Dioph S → Dioph S' → Dioph (S ∪ S')
-- Dioph.reindex_diophFn
theorem reindex_diophFn {f : (α → ℕ) → ℕ} (g : α → β) (d : DiophFn f) :
    DiophFn fun v => f (v ∘ g) 
Arguments: {α β : Type u} {f : (α → ℕ) → ℕ} (g : α → β) (d : Dioph.DiophFn f)
Goal: Dioph.DiophFn fun v => f (v ∘ g)
-- Dioph.ex_dioph
theorem ex_dioph {S : Set (α ⊕ β → ℕ)} : Dioph S → Dioph {v | ∃ x, v ⊗ x ∈ S}
  
Arguments: {α β : Type u} {S : Set (α ⊕ β → ℕ)}
Goal: Dioph S → Dioph {v | ∃ x, v ⊗ x ∈ S}
-- Dioph.ex1_dioph
theorem ex1_dioph {S : Set (Option α → ℕ)} : Dioph S → Dioph {v | ∃ x, x ::ₒ v ∈ S}
  
Arguments: {α : Type u} {S : Set (Option α → ℕ)}
Goal: Dioph S → Dioph {v | ∃ x, x ::ₒ v ∈ S}
-- Dioph.dom_dioph
theorem dom_dioph {f : (α → ℕ) →. ℕ} (d : DiophPFun f) : Dioph f.Dom 
Arguments: {α : Type u} {f : (α → ℕ) →. ℕ} (d : Dioph.DiophPFun f)
Goal: Dioph f.Dom
-- Dioph.diophFn_iff_pFun
theorem diophFn_iff_pFun (f : (α → ℕ) → ℕ) : DiophFn f = @DiophPFun α f 
Arguments: {α : Type u} (f : (α → ℕ) → ℕ)
Goal: Dioph.DiophFn f = Dioph.DiophPFun ↑f
-- Dioph.abs_poly_dioph
theorem abs_poly_dioph (p : Poly α) : DiophFn fun v => (p v).natAbs 
Arguments: {α : Type u} (p : Poly α)
Goal: Dioph.DiophFn fun v => (p v).natAbs
-- Dioph.proj_dioph
theorem proj_dioph (i : α) : DiophFn fun v => v i 
Arguments: {α : Type u} (i : α)
Goal: Dioph.DiophFn fun v => v i
-- Dioph.diophPFun_comp1
theorem diophPFun_comp1 {S : Set (Option α → ℕ)} (d : Dioph S) {f} (df : DiophPFun f) :
    Dioph {v : α → ℕ | ∃ h : f.Dom v, f.fn v h ::ₒ v ∈ S} 
Arguments: {α : Type u} {S : Set (Option α → ℕ)} (d : Dioph S) {f : (α → ℕ) →. ℕ} (df : Dioph.DiophPFun f)
Goal: Dioph {v | ∃ (h : f.Dom v), f.fn v h ::ₒ v ∈ S}
-- Dioph.diophFn_comp1
theorem diophFn_comp1 {S : Set (Option α → ℕ)} (d : Dioph S) {f : (α → ℕ) → ℕ} (df : DiophFn f) :
    Dioph {v | f v ::ₒ v ∈ S} 
Arguments: {α : Type u} {S : Set (Option α → ℕ)} (d : Dioph S) {f : (α → ℕ) → ℕ} (df : Dioph.DiophFn f)
Goal: Dioph {v | f v ::ₒ v ∈ S}
-- Dioph.diophFn_vec_comp1
theorem diophFn_vec_comp1 {S : Set (Vector3 ℕ (succ n))} (d : Dioph S) {f : Vector3 ℕ n → ℕ}
    (df : DiophFn f) : Dioph {v : Vector3 ℕ n | (f v::v) ∈ S} 
Arguments: {n : ℕ} {S : Set (Vector3 ℕ n.succ)} (d : Dioph S) {f : Vector3 ℕ n → ℕ} (df : Dioph.DiophFn f)
Goal: Dioph {v | Vector3.cons (f v) v ∈ S}
-- Dioph.vec_ex1_dioph
theorem vec_ex1_dioph (n) {S : Set (Vector3 ℕ (succ n))} (d : Dioph S) :
    Dioph {v : Fin2 n → ℕ | ∃ x, (x::v) ∈ S} 
Arguments: (n : ℕ) {S : Set (Vector3 ℕ n.succ)} (d : Dioph S)
Goal: Dioph {v | ∃ x, Vector3.cons x v ∈ S}
-- Dioph.diophFn_vec
theorem diophFn_vec (f : Vector3 ℕ n → ℕ) : DiophFn f ↔ Dioph {v | f (v ∘ fs) = v fz} 
Arguments: {n : ℕ} (f : Vector3 ℕ n → ℕ)
Goal: Dioph.DiophFn f ↔ Dioph {v | f (v ∘ Fin2.fs) = v Fin2.fz}
-- Dioph.diophPFun_vec
theorem diophPFun_vec (f : Vector3 ℕ n →. ℕ) : DiophPFun f ↔ Dioph {v | f.graph (v ∘ fs, v fz)} 
Arguments: {n : ℕ} (f : Vector3 ℕ n →. ℕ)
Goal: Dioph.DiophPFun f ↔ Dioph {v | f.graph (v ∘ Fin2.fs, v Fin2.fz)}
-- Dioph.diophFn_compn
theorem diophFn_compn :
    ∀ {n} {S : Set (α ⊕ (Fin2 n) → ℕ)} (_ : Dioph S) {f : Vector3 ((α → ℕ) → ℕ) n}
      (_ : VectorAllP DiophFn f), Dioph {v : α → ℕ | (v ⊗ fun i => f i v) ∈ S}
  
Arguments: {α : Type} {n : ℕ} {S : Set (α ⊕ Fin2 n → ℕ)}
Goal: Dioph S → ∀ {f : Vector3 ((α → ℕ) → ℕ) n}, VectorAllP Dioph.DiophFn f → Dioph {v | (v ⊗ fun i => f i v) ∈ S}
-- Dioph.dioph_comp
theorem dioph_comp {S : Set (Vector3 ℕ n)} (d : Dioph S) (f : Vector3 ((α → ℕ) → ℕ) n)
    (df : VectorAllP DiophFn f) : Dioph {v | (fun i => f i v) ∈ S} 
Arguments: {α : Type} {n : ℕ} {S : Set (Vector3 ℕ n)} (d : Dioph S) (f : Vector3 ((α → ℕ) → ℕ) n) (df : VectorAllP Dioph.DiophFn f)
Goal: Dioph {v | (fun i => f i v) ∈ S}
-- Dioph.diophFn_comp
theorem diophFn_comp {f : Vector3 ℕ n → ℕ} (df : DiophFn f) (g : Vector3 ((α → ℕ) → ℕ) n)
    (dg : VectorAllP DiophFn g) : DiophFn fun v => f fun i => g i v 
Arguments: {α : Type} {n : ℕ} {f : Vector3 ℕ n → ℕ} (df : Dioph.DiophFn f) (g : Vector3 ((α → ℕ) → ℕ) n) (dg : VectorAllP Dioph.DiophFn g)
Goal: Dioph.DiophFn fun v => f fun i => g i v
-- Dioph.proj_dioph_of_nat
theorem proj_dioph_of_nat {n : ℕ} (m : ℕ) [IsLT m n] : DiophFn fun v : Vector3 ℕ n => v &m 
Arguments: {n : ℕ} (m : ℕ) [Fin2.IsLT m n]
Goal: Dioph.DiophFn fun v => v (Fin2.ofNat' m)
-- Dioph.const_dioph
theorem const_dioph (n : ℕ) : DiophFn (const (α → ℕ) n) 
Arguments: {α : Type} (n : ℕ)
Goal: Dioph.DiophFn (Function.const (α → ℕ) n)
-- Dioph.dioph_comp2
theorem dioph_comp2 {S : ℕ → ℕ → Prop} (d : Dioph fun v : Vector3 ℕ 2 => S (v &0) (v &1)) :
    Dioph fun v => S (f v) (g v) 
Arguments: {α : Type} {f g : (α → ℕ) → ℕ} (df : Dioph.DiophFn f) (dg : Dioph.DiophFn g) {S : ℕ → ℕ → Prop} (d : Dioph fun v => S (v (Fin2.ofNat' 0)) (v (Fin2.ofNat' 1)))
Goal: Dioph fun v => S (f v) (g v)
-- Dioph.diophFn_comp2
theorem diophFn_comp2 {h : ℕ → ℕ → ℕ} (d : DiophFn fun v : Vector3 ℕ 2 => h (v &0) (v &1)) :
    DiophFn fun v => h (f v) (g v) 
Arguments: {α : Type} {f g : (α → ℕ) → ℕ} (df : Dioph.DiophFn f) (dg : Dioph.DiophFn g) {h : ℕ → ℕ → ℕ} (d : Dioph.DiophFn fun v => h (v (Fin2.ofNat' 0)) (v (Fin2.ofNat' 1)))
Goal: Dioph.DiophFn fun v => h (f v) (g v)
-- Dioph.eq_dioph
theorem eq_dioph : Dioph fun v => f v = g v 
Arguments: {α : Type} {f g : (α → ℕ) → ℕ} (df : Dioph.DiophFn f) (dg : Dioph.DiophFn g)
Goal: Dioph fun v => f v = g v
-- Dioph.add_dioph
theorem add_dioph : DiophFn fun v => f v + g v 
Arguments: {α : Type} {f g : (α → ℕ) → ℕ} (df : Dioph.DiophFn f) (dg : Dioph.DiophFn g)
Goal: Dioph.DiophFn fun v => f v + g v
-- Dioph.mul_dioph
theorem mul_dioph : DiophFn fun v => f v * g v 
Arguments: {α : Type} {f g : (α → ℕ) → ℕ} (df : Dioph.DiophFn f) (dg : Dioph.DiophFn g)
Goal: Dioph.DiophFn fun v => f v * g v
-- Dioph.le_dioph
theorem le_dioph : Dioph {v | f v ≤ g v} 
Arguments: {α : Type} {f g : (α → ℕ) → ℕ} (df : Dioph.DiophFn f) (dg : Dioph.DiophFn g)
Goal: Dioph {v | f v ≤ g v}
-- Dioph.lt_dioph
theorem lt_dioph : Dioph {v | f v < g v} 
Arguments: {α : Type} {f g : (α → ℕ) → ℕ} (df : Dioph.DiophFn f) (dg : Dioph.DiophFn g)
Goal: Dioph {v | f v < g v}
-- Dioph.ne_dioph
theorem ne_dioph : Dioph {v | f v ≠ g v} 
Arguments: {α : Type} {f g : (α → ℕ) → ℕ} (df : Dioph.DiophFn f) (dg : Dioph.DiophFn g)
Goal: Dioph {v | f v ≠ g v}
-- Dioph.sub_dioph
theorem sub_dioph : DiophFn fun v => f v - g v 
Arguments: {α : Type} {f g : (α → ℕ) → ℕ} (df : Dioph.DiophFn f) (dg : Dioph.DiophFn g)
Goal: Dioph.DiophFn fun v => f v - g v
-- Dioph.dvd_dioph
theorem dvd_dioph : Dioph fun v => f v ∣ g v 
Arguments: {α : Type} {f g : (α → ℕ) → ℕ} (df : Dioph.DiophFn f) (dg : Dioph.DiophFn g)
Goal: Dioph fun v => f v ∣ g v
-- Dioph.mod_dioph
theorem mod_dioph : DiophFn fun v => f v % g v 
Arguments: {α : Type} {f g : (α → ℕ) → ℕ} (df : Dioph.DiophFn f) (dg : Dioph.DiophFn g)
Goal: Dioph.DiophFn fun v => f v % g v
-- Dioph.modEq_dioph
theorem modEq_dioph {h : (α → ℕ) → ℕ} (dh : DiophFn h) : Dioph fun v => f v ≡ g v [MOD h v] 
Arguments: {α : Type} {f g : (α → ℕ) → ℕ} (df : Dioph.DiophFn f) (dg : Dioph.DiophFn g) {h : (α → ℕ) → ℕ} (dh : Dioph.DiophFn h)
Goal: Dioph fun v => f v ≡ g v [MOD h v]
-- Dioph.div_dioph
theorem div_dioph : DiophFn fun v => f v / g v 
Arguments: {α : Type} {f g : (α → ℕ) → ℕ} (df : Dioph.DiophFn f) (dg : Dioph.DiophFn g)
Goal: Dioph.DiophFn fun v => f v / g v
-- Dioph.pell_dioph
theorem pell_dioph :
    Dioph fun v : Vector3 ℕ 4 => ∃ h : 1 < v &0, xn h (v &1) = v &2 ∧ yn h (v &1) = v &3 
Goal: Dioph fun v =>
  ∃ (h : 1 < v (Fin2.ofNat' 0)),
    Pell.xn h (v (Fin2.ofNat' 1)) = v (Fin2.ofNat' 2) ∧ Pell.yn h (v (Fin2.ofNat' 1)) = v (Fin2.ofNat' 3)
-- Dioph.xn_dioph
theorem xn_dioph : DiophPFun fun v : Vector3 ℕ 2 => ⟨1 < v &0, fun h => xn h (v &1)⟩ 
Goal: Dioph.DiophPFun fun v => { Dom := 1 < v (Fin2.ofNat' 0), get := fun h => Pell.xn h (v (Fin2.ofNat' 1)) }
-- Dioph.pow_dioph
theorem pow_dioph : DiophFn fun v => f v ^ g v 
Arguments: {α : Type} {f g : (α → ℕ) → ℕ} (df : Dioph.DiophFn f) (dg : Dioph.DiophFn g)
Goal: Dioph.DiophFn fun v => f v ^ g v
-- sq_ne_two_fin_zmod_four
theorem sq_ne_two_fin_zmod_four (z : ZMod 4) : z * z ≠ 2 
Arguments: (z : ZMod 4)
Goal: z * z ≠ 2
-- Int.sq_ne_two_mod_four
theorem Int.sq_ne_two_mod_four (z : ℤ) : z * z % 4 ≠ 2 
Arguments: (z : ℤ)
Goal: z * z % 4 ≠ 2
-- pythagoreanTriple_comm
theorem pythagoreanTriple_comm {x y z : ℤ} : PythagoreanTriple x y z ↔ PythagoreanTriple y x z 
Arguments: {x y z : ℤ}
Goal: PythagoreanTriple x y z ↔ PythagoreanTriple y x z
-- PythagoreanTriple.zero
theorem PythagoreanTriple.zero : PythagoreanTriple 0 0 0 
Goal: PythagoreanTriple 0 0 0
-- PythagoreanTriple.eq
theorem eq : x * x + y * y = z * z 
Arguments: {x y z : ℤ} (h : PythagoreanTriple x y z)
Goal: x * x + y * y = z * z
-- PythagoreanTriple.symm
@[symm]
theorem symm : PythagoreanTriple y x z 
Arguments: {x y z : ℤ} (h : PythagoreanTriple x y z)
Goal: PythagoreanTriple y x z
-- PythagoreanTriple.mul
theorem mul (k : ℤ) : PythagoreanTriple (k * x) (k * y) (k * z) 
Arguments: {x y z : ℤ} (h : PythagoreanTriple x y z) (k : ℤ)
Goal: PythagoreanTriple (k * x) (k * y) (k * z)
-- PythagoreanTriple.mul_iff
theorem mul_iff (k : ℤ) (hk : k ≠ 0) :
    PythagoreanTriple (k * x) (k * y) (k * z) ↔ PythagoreanTriple x y z 
Arguments: {x y z : ℤ} (k : ℤ) (hk : k ≠ 0)
Goal: PythagoreanTriple (k * x) (k * y) (k * z) ↔ PythagoreanTriple x y z
-- PythagoreanTriple.mul_isClassified
theorem mul_isClassified (k : ℤ) (hc : h.IsClassified) : (h.mul k).IsClassified 
Arguments: {x y z : ℤ} (h : PythagoreanTriple x y z) (k : ℤ) (hc : h.IsClassified)
Goal: ⋯.IsClassified
-- PythagoreanTriple.even_odd_of_coprime
theorem even_odd_of_coprime (hc : Int.gcd x y = 1) :
    x % 2 = 0 ∧ y % 2 = 1 ∨ x % 2 = 1 ∧ y % 2 = 0 
Arguments: {x y z : ℤ} (h : PythagoreanTriple x y z) (hc : x.gcd y = 1)
Goal: x % 2 = 0 ∧ y % 2 = 1 ∨ x % 2 = 1 ∧ y % 2 = 0
-- PythagoreanTriple.gcd_dvd
theorem gcd_dvd : (Int.gcd x y : ℤ) ∣ z 
Arguments: {x y z : ℤ} (h : PythagoreanTriple x y z)
Goal: ↑(x.gcd y) ∣ z
-- PythagoreanTriple.normalize
theorem normalize : PythagoreanTriple (x / Int.gcd x y) (y / Int.gcd x y) (z / Int.gcd x y) 
Arguments: {x y z : ℤ} (h : PythagoreanTriple x y z)
Goal: PythagoreanTriple (x / ↑(x.gcd y)) (y / ↑(x.gcd y)) (z / ↑(x.gcd y))
-- PythagoreanTriple.isClassified_of_isPrimitiveClassified
theorem isClassified_of_isPrimitiveClassified (hp : h.IsPrimitiveClassified) : h.IsClassified 
Arguments: {x y z : ℤ} (h : PythagoreanTriple x y z) (hp : h.IsPrimitiveClassified)
Goal: h.IsClassified
-- PythagoreanTriple.isClassified_of_normalize_isPrimitiveClassified
theorem isClassified_of_normalize_isPrimitiveClassified (hc : h.normalize.IsPrimitiveClassified) :
    h.IsClassified 
Arguments: {x y z : ℤ} (h : PythagoreanTriple x y z) (hc : ⋯.IsPrimitiveClassified)
Goal: h.IsClassified
-- PythagoreanTriple.ne_zero_of_coprime
theorem ne_zero_of_coprime (hc : Int.gcd x y = 1) : z ≠ 0 
Arguments: {x y z : ℤ} (h : PythagoreanTriple x y z) (hc : x.gcd y = 1)
Goal: z ≠ 0
-- PythagoreanTriple.isPrimitiveClassified_of_coprime_of_zero_left
theorem isPrimitiveClassified_of_coprime_of_zero_left (hc : Int.gcd x y = 1) (hx : x = 0) :
    h.IsPrimitiveClassified 
Arguments: {x y z : ℤ} (h : PythagoreanTriple x y z) (hc : x.gcd y = 1) (hx : x = 0)
Goal: h.IsPrimitiveClassified
-- PythagoreanTriple.coprime_of_coprime
theorem coprime_of_coprime (hc : Int.gcd x y = 1) : Int.gcd y z = 1 
Arguments: {x y z : ℤ} (h : PythagoreanTriple x y z) (hc : x.gcd y = 1)
Goal: y.gcd z = 1
-- circleEquivGen_apply
@[simp]
theorem circleEquivGen_apply (hk : ∀ x : K, 1 + x ^ 2 ≠ 0) (x : K) :
    (circleEquivGen hk x : K × K) = ⟨2 * x / (1 + x ^ 2), (1 - x ^ 2) / (1 + x ^ 2)⟩ 
Arguments: {K : Type u_1} [Field K] (hk : ∀ (x : K), 1 + x ^ 2 ≠ 0) (x : K)
Goal: ↑((circleEquivGen hk) x) = (2 * x / (1 + x ^ 2), (1 - x ^ 2) / (1 + x ^ 2))
-- circleEquivGen_symm_apply
@[simp]
theorem circleEquivGen_symm_apply (hk : ∀ x : K, 1 + x ^ 2 ≠ 0)
    (v : { p : K × K // p.1 ^ 2 + p.2 ^ 2 = 1 ∧ p.2 ≠ -1 }) :
    (circleEquivGen hk).symm v = (v : K × K).1 / ((v : K × K).2 + 1) 
Arguments: {K : Type u_1} [Field K] (hk : ∀ (x : K), 1 + x ^ 2 ≠ 0) (v : { p // p.1 ^ 2 + p.2 ^ 2 = 1 ∧ p.2 ≠ -1 })
Goal: (circleEquivGen hk).symm v = (↑v).1 / ((↑v).2 + 1)
-- _private.Mathlib.NumberTheory.PythagoreanTriples.0.coprime_sq_sub_sq_add_of_even_odd
private theorem coprime_sq_sub_sq_add_of_even_odd {m n : ℤ} (h : Int.gcd m n = 1) (hm : m % 2 = 0)
    (hn : n % 2 = 1) : Int.gcd (m ^ 2 - n ^ 2) (m ^ 2 + n ^ 2) = 1 
Arguments: {m n : ℤ} (h : m.gcd n = 1) (hm : m % 2 = 0) (hn : n % 2 = 1)
Goal: (m ^ 2 - n ^ 2).gcd (m ^ 2 + n ^ 2) = 1
-- _private.Mathlib.NumberTheory.PythagoreanTriples.0.coprime_sq_sub_sq_add_of_odd_even
private theorem coprime_sq_sub_sq_add_of_odd_even {m n : ℤ} (h : Int.gcd m n = 1) (hm : m % 2 = 1)
    (hn : n % 2 = 0) : Int.gcd (m ^ 2 - n ^ 2) (m ^ 2 + n ^ 2) = 1 
Arguments: {m n : ℤ} (h : m.gcd n = 1) (hm : m % 2 = 1) (hn : n % 2 = 0)
Goal: (m ^ 2 - n ^ 2).gcd (m ^ 2 + n ^ 2) = 1
-- _private.Mathlib.NumberTheory.PythagoreanTriples.0.coprime_sq_sub_mul_of_even_odd
private theorem coprime_sq_sub_mul_of_even_odd {m n : ℤ} (h : Int.gcd m n = 1) (hm : m % 2 = 0)
    (hn : n % 2 = 1) : Int.gcd (m ^ 2 - n ^ 2) (2 * m * n) = 1 
Arguments: {m n : ℤ} (h : m.gcd n = 1) (hm : m % 2 = 0) (hn : n % 2 = 1)
Goal: (m ^ 2 - n ^ 2).gcd (2 * m * n) = 1
-- _private.Mathlib.NumberTheory.PythagoreanTriples.0.coprime_sq_sub_mul_of_odd_even
private theorem coprime_sq_sub_mul_of_odd_even {m n : ℤ} (h : Int.gcd m n = 1) (hm : m % 2 = 1)
    (hn : n % 2 = 0) : Int.gcd (m ^ 2 - n ^ 2) (2 * m * n) = 1 
Arguments: {m n : ℤ} (h : m.gcd n = 1) (hm : m % 2 = 1) (hn : n % 2 = 0)
Goal: (m ^ 2 - n ^ 2).gcd (2 * m * n) = 1
-- _private.Mathlib.NumberTheory.PythagoreanTriples.0.coprime_sq_sub_mul
private theorem coprime_sq_sub_mul {m n : ℤ} (h : Int.gcd m n = 1)
    (hmn : m % 2 = 0 ∧ n % 2 = 1 ∨ m % 2 = 1 ∧ n % 2 = 0) :
    Int.gcd (m ^ 2 - n ^ 2) (2 * m * n) = 1 
Arguments: {m n : ℤ} (h : m.gcd n = 1) (hmn : m % 2 = 0 ∧ n % 2 = 1 ∨ m % 2 = 1 ∧ n % 2 = 0)
Goal: (m ^ 2 - n ^ 2).gcd (2 * m * n) = 1
-- _private.Mathlib.NumberTheory.PythagoreanTriples.0.coprime_sq_sub_sq_sum_of_odd_odd
private theorem coprime_sq_sub_sq_sum_of_odd_odd {m n : ℤ} (h : Int.gcd m n = 1) (hm : m % 2 = 1)
    (hn : n % 2 = 1) :
    2 ∣ m ^ 2 + n ^ 2 ∧
      2 ∣ m ^ 2 - n ^ 2 ∧
        (m ^ 2 - n ^ 2) / 2 % 2 = 0 ∧ Int.gcd ((m ^ 2 - n ^ 2) / 2) ((m ^ 2 + n ^ 2) / 2) = 1 
Arguments: {m n : ℤ} (h : m.gcd n = 1) (hm : m % 2 = 1) (hn : n % 2 = 1)
Goal: 2 ∣ m ^ 2 + n ^ 2 ∧
  2 ∣ m ^ 2 - n ^ 2 ∧ (m ^ 2 - n ^ 2) / 2 % 2 = 0 ∧ ((m ^ 2 - n ^ 2) / 2).gcd ((m ^ 2 + n ^ 2) / 2) = 1
-- PythagoreanTriple.isPrimitiveClassified_aux
theorem isPrimitiveClassified_aux (hc : x.gcd y = 1) (hzpos : 0 < z) {m n : ℤ}
    (hm2n2 : 0 < m ^ 2 + n ^ 2) (hv2 : (x : ℚ) / z = 2 * m * n / ((m : ℚ) ^ 2 + (n : ℚ) ^ 2))
    (hw2 : (y : ℚ) / z = ((m : ℚ) ^ 2 - (n : ℚ) ^ 2) / ((m : ℚ) ^ 2 + (n : ℚ) ^ 2))
    (H : Int.gcd (m ^ 2 - n ^ 2) (m ^ 2 + n ^ 2) = 1) (co : Int.gcd m n = 1)
    (pp : m % 2 = 0 ∧ n % 2 = 1 ∨ m % 2 = 1 ∧ n % 2 = 0) : h.IsPrimitiveClassified 
Arguments: {x y z : ℤ} (h : PythagoreanTriple x y z) (hc : x.gcd y = 1) (hzpos : 0 < z) {m n : ℤ} (hm2n2 : 0 < m ^ 2 + n ^ 2) (hv2 : ↑x / ↑z = 2 * ↑m * ↑n / (↑m ^ 2 + ↑n ^ 2)) (hw2 : ↑y / ↑z = (↑m ^ 2 - ↑n ^ 2) / (↑m ^ 2 + ↑n ^ 2)) (H : (m ^ 2 - n ^ 2).gcd (m ^ 2 + n ^ 2) = 1) (co : m.gcd n = 1) (pp : m % 2 = 0 ∧ n % 2 = 1 ∨ m % 2 = 1 ∧ n % 2 = 0)
Goal: h.IsPrimitiveClassified
-- PythagoreanTriple.isPrimitiveClassified_of_coprime_of_odd_of_pos
theorem isPrimitiveClassified_of_coprime_of_odd_of_pos (hc : Int.gcd x y = 1) (hyo : y % 2 = 1)
    (hzpos : 0 < z) : h.IsPrimitiveClassified 
Arguments: {x y z : ℤ} (h : PythagoreanTriple x y z) (hc : x.gcd y = 1) (hyo : y % 2 = 1) (hzpos : 0 < z)
Goal: h.IsPrimitiveClassified
-- PythagoreanTriple.isPrimitiveClassified_of_coprime_of_pos
theorem isPrimitiveClassified_of_coprime_of_pos (hc : Int.gcd x y = 1) (hzpos : 0 < z) :
    h.IsPrimitiveClassified 
Arguments: {x y z : ℤ} (h : PythagoreanTriple x y z) (hc : x.gcd y = 1) (hzpos : 0 < z)
Goal: h.IsPrimitiveClassified
-- PythagoreanTriple.isPrimitiveClassified_of_coprime
theorem isPrimitiveClassified_of_coprime (hc : Int.gcd x y = 1) : h.IsPrimitiveClassified 
Arguments: {x y z : ℤ} (h : PythagoreanTriple x y z) (hc : x.gcd y = 1)
Goal: h.IsPrimitiveClassified
-- PythagoreanTriple.classified
theorem classified : h.IsClassified 
Arguments: {x y z : ℤ} (h : PythagoreanTriple x y z)
Goal: h.IsClassified