ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: mapClusterPt_of_comp
File: Mathlib/Topology/Basic.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p✝ p₁ p₂ : X → Prop
inst✝¹ : TopologicalSpace X
F : Filter α
φ : β → α
p : Filter β
u : α → X
inst✝ : p.NeBot
h : Tendsto φ p F
H : Tendsto (u ∘ φ) p (𝓝 x)
⊢ MapClusterPt x F u
state_after: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p✝ p₁ p₂ : X → Prop
inst✝¹ : TopologicalSpace X
F : Filter α
φ : β → α
p : Filter β
u : α → X
inst✝ : p.NeBot
h : Tendsto φ p F
H : Tendsto (u ∘ φ) p (𝓝 x)
this : map (u ∘ φ) p ≤ map u F
⊢ MapClusterPt x F u
tactic: have :=
    calc
      map (u ∘ φ) p = map u (map φ p) := map_map
      _ ≤ map u F := map_mono h
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p✝ p₁ p₂ : X → Prop
inst✝¹ : TopologicalSpace X
F : Filter α
φ : β → α
p : Filter β
u : α → X
inst✝ : p.NeBot
h : Tendsto φ p F
H : Tendsto (u ∘ φ) p (𝓝 x)
this : map (u ∘ φ) p ≤ map u F
⊢ MapClusterPt x F u
state_after: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p✝ p₁ p₂ : X → Prop
inst✝¹ : TopologicalSpace X
F : Filter α
φ : β → α
p : Filter β
u : α → X
inst✝ : p.NeBot
h : Tendsto φ p F
H : Tendsto (u ∘ φ) p (𝓝 x)
this✝ : map (u ∘ φ) p ≤ map u F
this : map (u ∘ φ) p ≤ 𝓝 x ⊓ map u F
⊢ MapClusterPt x F u
tactic: have : map (u ∘ φ) p ≤ 𝓝 x ⊓ map u F := le_inf H this
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p✝ p₁ p₂ : X → Prop
inst✝¹ : TopologicalSpace X
F : Filter α
φ : β → α
p : Filter β
u : α → X
inst✝ : p.NeBot
h : Tendsto φ p F
H : Tendsto (u ∘ φ) p (𝓝 x)
this✝ : map (u ∘ φ) p ≤ map u F
this : map (u ∘ φ) p ≤ 𝓝 x ⊓ map u F
⊢ MapClusterPt x F u
state_after: no goals
tactic: exact neBot_of_le this
Theorem: Complex.cos_eq_zero_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Complex.lean

Proof steps:
state_before: θ : ℂ
⊢ cos θ = 0 ↔ ∃ k, θ = (2 * ↑k + 1) * ↑π / 2
state_after: θ : ℂ
h : (cexp (θ * I) + cexp (-θ * I)) / 2 = 0 ↔ cexp (2 * θ * I) = -1
⊢ cos θ = 0 ↔ ∃ k, θ = (2 * ↑k + 1) * ↑π / 2
tactic: have h : (exp (θ * I) + exp (-θ * I)) / 2 = 0 ↔ exp (2 * θ * I) = -1 := by
    rw [@div_eq_iff _ _ (exp (θ * I) + exp (-θ * I)) 2 0 two_ne_zero, zero_mul,
      add_eq_zero_iff_eq_neg, neg_eq_neg_one_mul, ← div_eq_iff (exp_ne_zero _), ← exp_sub]
    ring_nf
state_before: θ : ℂ
h : (cexp (θ * I) + cexp (-θ * I)) / 2 = 0 ↔ cexp (2 * θ * I) = -1
⊢ cos θ = 0 ↔ ∃ k, θ = (2 * ↑k + 1) * ↑π / 2
state_after: θ : ℂ
h : (cexp (θ * I) + cexp (-θ * I)) / 2 = 0 ↔ cexp (2 * θ * I) = -1
⊢ (∃ n, 2 * I * θ = ↑π * I + ↑n * (2 * ↑π * I)) ↔ ∃ k, θ = (2 * ↑k + 1) * ↑π / 2
tactic: rw [cos, h, ← exp_pi_mul_I, exp_eq_exp_iff_exists_int, mul_right_comm]
state_before: θ : ℂ
h : (cexp (θ * I) + cexp (-θ * I)) / 2 = 0 ↔ cexp (2 * θ * I) = -1
⊢ (∃ n, 2 * I * θ = ↑π * I + ↑n * (2 * ↑π * I)) ↔ ∃ k, θ = (2 * ↑k + 1) * ↑π / 2
state_after: θ : ℂ
h : (cexp (θ * I) + cexp (-θ * I)) / 2 = 0 ↔ cexp (2 * θ * I) = -1
x : ℤ
⊢ 2 * I * θ = ↑π * I + ↑x * (2 * ↑π * I) ↔ θ = (2 * ↑x + 1) * ↑π / 2
tactic: refine exists_congr fun x => ?_
state_before: θ : ℂ
h : (cexp (θ * I) + cexp (-θ * I)) / 2 = 0 ↔ cexp (2 * θ * I) = -1
x : ℤ
⊢ 2 * I * θ = ↑π * I + ↑x * (2 * ↑π * I) ↔ θ = (2 * ↑x + 1) * ↑π / 2
state_after: θ : ℂ
h : (cexp (θ * I) + cexp (-θ * I)) / 2 = 0 ↔ cexp (2 * θ * I) = -1
x : ℤ
⊢ ↑π * I + ↑x * (2 * ↑π * I) = 2 * I * ((2 * ↑x + 1) * ↑π / 2)
tactic: refine (iff_of_eq <| congr_arg _ ?_).trans (mul_right_inj' <| mul_ne_zero two_ne_zero I_ne_zero)
state_before: θ : ℂ
h : (cexp (θ * I) + cexp (-θ * I)) / 2 = 0 ↔ cexp (2 * θ * I) = -1
x : ℤ
⊢ ↑π * I + ↑x * (2 * ↑π * I) = 2 * I * ((2 * ↑x + 1) * ↑π / 2)
state_after: θ : ℂ
h : (cexp (θ * I) + cexp (-θ * I)) / 2 = 0 ↔ cexp (2 * θ * I) = -1
x : ℤ
⊢ (↑π * I + ↑x * (2 * ↑π * I)) * 2 = 2 * I * ((2 * ↑x + 1) * ↑π)
tactic: field_simp
state_before: θ : ℂ
h : (cexp (θ * I) + cexp (-θ * I)) / 2 = 0 ↔ cexp (2 * θ * I) = -1
x : ℤ
⊢ (↑π * I + ↑x * (2 * ↑π * I)) * 2 = 2 * I * ((2 * ↑x + 1) * ↑π)
state_after: no goals
tactic: ring
Theorem: Geometry.SimplicialComplex.mem_space_iff
File: Mathlib/Analysis/Convex/SimplicialComplex/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
ι : Type u_3
inst✝² : OrderedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
K : SimplicialComplex 𝕜 E
s t : Finset E
x : E
⊢ x ∈ K.space ↔ ∃ s ∈ K.faces, x ∈ (convexHull 𝕜) ↑s
state_after: no goals
tactic: simp [space]
Theorem: IsLocalization.AtPrime.discreteValuationRing_of_dedekind_domain
File: Mathlib/RingTheory/DedekindDomain/Dvr.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : IsDomain A
inst✝⁵ : Field K
inst✝⁴ : IsDedekindDomain A
P : Ideal A
hP : P ≠ ⊥
pP : P.IsPrime
Aₘ : Type u_4
inst✝³ : CommRing Aₘ
inst✝² : IsDomain Aₘ
inst✝¹ : Algebra A Aₘ
inst✝ : IsLocalization.AtPrime Aₘ P
⊢ DiscreteValuationRing Aₘ
state_after: no goals
tactic: classical
  letI : IsNoetherianRing Aₘ :=
    IsLocalization.isNoetherianRing P.primeCompl _ IsDedekindRing.toIsNoetherian
  letI : LocalRing Aₘ := IsLocalization.AtPrime.localRing Aₘ P
  have hnf := IsLocalization.AtPrime.not_isField A hP Aₘ
  exact
    ((DiscreteValuationRing.TFAE Aₘ hnf).out 0 2).mpr
      (IsLocalization.AtPrime.isDedekindDomain A P _)
Theorem: measurableSet_of_differentiableWithinAt_Ici
File: Mathlib/Analysis/Calculus/FDeriv/Measurable.lean

Proof steps:
state_before: F : Type u_1
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
f : ℝ → F
K : Set F
inst✝ : CompleteSpace F
⊢ MeasurableSet {x | DifferentiableWithinAt ℝ f (Ici x) x}
state_after: F : Type u_1
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
f : ℝ → F
K : Set F
inst✝ : CompleteSpace F
this : IsComplete univ
⊢ MeasurableSet {x | DifferentiableWithinAt ℝ f (Ici x) x}
tactic: have : IsComplete (univ : Set F) := complete_univ
state_before: F : Type u_1
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
f : ℝ → F
K : Set F
inst✝ : CompleteSpace F
this : IsComplete univ
⊢ MeasurableSet {x | DifferentiableWithinAt ℝ f (Ici x) x}
state_after: case h.e'_3.h.e'_2.h.a
F : Type u_1
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
f : ℝ → F
K : Set F
inst✝ : CompleteSpace F
this : IsComplete univ
x✝ : ℝ
⊢ DifferentiableWithinAt ℝ f (Ici x✝) x✝ ↔ DifferentiableWithinAt ℝ f (Ici x✝) x✝ ∧ derivWithin f (Ici x✝) x✝ ∈ univ
tactic: convert measurableSet_of_differentiableWithinAt_Ici_of_isComplete f this
state_before: case h.e'_3.h.e'_2.h.a
F : Type u_1
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
f : ℝ → F
K : Set F
inst✝ : CompleteSpace F
this : IsComplete univ
x✝ : ℝ
⊢ DifferentiableWithinAt ℝ f (Ici x✝) x✝ ↔ DifferentiableWithinAt ℝ f (Ici x✝) x✝ ∧ derivWithin f (Ici x✝) x✝ ∈ univ
state_after: no goals
tactic: simp
Theorem: List.pmap_prev_eq_rotate_length_sub_one
File: Mathlib/Data/List/Cycle.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
l : List α
x : α
h : l.Nodup
⊢ pmap l.prev l ⋯ = l.rotate (l.length - 1)
state_after: case hl
α : Type u_1
inst✝ : DecidableEq α
l : List α
x : α
h : l.Nodup
⊢ (pmap l.prev l ⋯).length = (l.rotate (l.length - 1)).length

case h
α : Type u_1
inst✝ : DecidableEq α
l : List α
x : α
h : l.Nodup
⊢ ∀ (n : ℕ) (h₁ : n < (pmap l.prev l ⋯).length) (h₂ : n < (l.rotate (l.length - 1)).length),
    (pmap l.prev l ⋯).nthLe n h₁ = (l.rotate (l.length - 1)).nthLe n h₂
tactic: apply List.ext_nthLe
Theorem: ModularGroup.bottom_row_coprime
File: Mathlib/NumberTheory/Modular.lean

Proof steps:
state_before: g✝ : SL(2, ℤ)
z : ℍ
R : Type u_1
inst✝ : CommRing R
g : SL(2, R)
⊢ IsCoprime (↑g 1 0) (↑g 1 1)
state_after: case h
g✝ : SL(2, ℤ)
z : ℍ
R : Type u_1
inst✝ : CommRing R
g : SL(2, R)
⊢ -↑g 0 1 * ↑g 1 0 + ↑g 0 0 * ↑g 1 1 = 1
tactic: use -(↑g : Matrix (Fin 2) (Fin 2) R) 0 1, (↑g : Matrix (Fin 2) (Fin 2) R) 0 0
state_before: case h
g✝ : SL(2, ℤ)
z : ℍ
R : Type u_1
inst✝ : CommRing R
g : SL(2, R)
⊢ -↑g 0 1 * ↑g 1 0 + ↑g 0 0 * ↑g 1 1 = 1
state_after: case h
g✝ : SL(2, ℤ)
z : ℍ
R : Type u_1
inst✝ : CommRing R
g : SL(2, R)
⊢ (↑g).det = 1
tactic: rw [add_comm, neg_mul, ← sub_eq_add_neg, ← det_fin_two]
state_before: case h
g✝ : SL(2, ℤ)
z : ℍ
R : Type u_1
inst✝ : CommRing R
g : SL(2, R)
⊢ (↑g).det = 1
state_after: no goals
tactic: exact g.det_coe
Theorem: measurable_piCongrLeft
File: Mathlib/MeasureTheory/MeasurableSpace/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
π : δ → Type u_6
inst✝² : MeasurableSpace α
inst✝¹ : (a : δ) → MeasurableSpace (π a)
inst✝ : MeasurableSpace γ
f : δ' ≃ δ
⊢ Measurable ⇑(piCongrLeft π f)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
π : δ → Type u_6
inst✝² : MeasurableSpace α
inst✝¹ : (a : δ) → MeasurableSpace (π a)
inst✝ : MeasurableSpace γ
f : δ' ≃ δ
⊢ ∀ (a : δ), Measurable fun x => (piCongrLeft π f) x a
tactic: rw [measurable_pi_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
π : δ → Type u_6
inst✝² : MeasurableSpace α
inst✝¹ : (a : δ) → MeasurableSpace (π a)
inst✝ : MeasurableSpace γ
f : δ' ≃ δ
⊢ ∀ (a : δ), Measurable fun x => (piCongrLeft π f) x a
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
π : δ → Type u_6
inst✝² : MeasurableSpace α
inst✝¹ : (a : δ) → MeasurableSpace (π a)
inst✝ : MeasurableSpace γ
f : δ' ≃ δ
i : δ
⊢ Measurable fun x => (piCongrLeft π f) x i
tactic: intro i
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
π : δ → Type u_6
inst✝² : MeasurableSpace α
inst✝¹ : (a : δ) → MeasurableSpace (π a)
inst✝ : MeasurableSpace γ
f : δ' ≃ δ
i : δ
⊢ Measurable fun x => (piCongrLeft π f) x i
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
π : δ → Type u_6
inst✝² : MeasurableSpace α
inst✝¹ : (a : δ) → MeasurableSpace (π a)
inst✝ : MeasurableSpace γ
f : δ' ≃ δ
i : δ
⊢ Measurable fun x => cast ⋯ (x (f.symm i))
tactic: simp_rw [piCongrLeft_apply_eq_cast]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
π : δ → Type u_6
inst✝² : MeasurableSpace α
inst✝¹ : (a : δ) → MeasurableSpace (π a)
inst✝ : MeasurableSpace γ
f : δ' ≃ δ
i : δ
⊢ Measurable fun x => cast ⋯ (x (f.symm i))
state_after: no goals
tactic: exact Measurable.eq_mp π (f.apply_symm_apply i) <| measurable_pi_apply <| f.symm i
Theorem: Complex.log_exp
File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

Proof steps:
state_before: x : ℂ
hx₁ : -π < x.im
hx₂ : x.im ≤ π
⊢ log (cexp x) = x
state_after: no goals
tactic: rw [log, abs_exp, Real.log_exp, exp_eq_exp_re_mul_sin_add_cos, ← ofReal_exp,
    arg_mul_cos_add_sin_mul_I (Real.exp_pos _) ⟨hx₁, hx₂⟩, re_add_im]
Theorem: SimpleGraph.Walk.copy_cons
File: Mathlib/Combinatorics/SimpleGraph/Walk.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w u' w' : V
h : G.Adj u v
p : G.Walk v w
hu : u = u'
hw : w = w'
⊢ (cons h p).copy hu hw = cons ⋯ (p.copy ⋯ hw)
state_after: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v u' w' : V
h : G.Adj u' v
p : G.Walk v w'
⊢ (cons h p).copy ⋯ ⋯ = cons ⋯ (p.copy ⋯ ⋯)
tactic: subst_vars
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v u' w' : V
h : G.Adj u' v
p : G.Walk v w'
⊢ (cons h p).copy ⋯ ⋯ = cons ⋯ (p.copy ⋯ ⋯)
state_after: no goals
tactic: rfl
Theorem: tendsto_cofinite_cocompact_of_discrete
File: Mathlib/Topology/DiscreteSubset.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
f : X → Y
inst✝ : DiscreteTopology X
hf : Tendsto f (cocompact X) (cocompact Y)
⊢ Tendsto f cofinite (cocompact Y)
state_after: case h.e'_4
X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
f : X → Y
inst✝ : DiscreteTopology X
hf : Tendsto f (cocompact X) (cocompact Y)
⊢ cofinite = cocompact X
tactic: convert hf
state_before: case h.e'_4
X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
f : X → Y
inst✝ : DiscreteTopology X
hf : Tendsto f (cocompact X) (cocompact Y)
⊢ cofinite = cocompact X
state_after: no goals
tactic: rw [cocompact_eq_cofinite X]
Theorem: multiplicity.dvd_iff_multiplicity_pos
File: Mathlib/RingTheory/Multiplicity.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : Monoid α
inst✝² : Monoid β
inst✝¹ : DecidableRel fun x x_1 => x ∣ x_1
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
hdvd : a ∣ b
heq : 0 = multiplicity a b
⊢ multiplicity a b < 1
state_after: no goals
tactic: simpa only [heq, Nat.cast_zero] using PartENat.coe_lt_coe.mpr zero_lt_one
state_before: α : Type u_1
β : Type u_2
inst✝³ : Monoid α
inst✝² : Monoid β
inst✝¹ : DecidableRel fun x x_1 => x ∣ x_1
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
hdvd : a ∣ b
heq : 0 = multiplicity a b
⊢ a ^ 1 ∣ b
state_after: no goals
tactic: rwa [pow_one a]
Theorem: CategoryTheory.ShortComplex.HomotopyEquiv.refl_homotopyHomInvId
File: Mathlib/Algebra/Homology/ShortComplex/Preadditive.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.237910, u_1} C
inst✝ : Preadditive C
S₁ S₂ S₃ : ShortComplex C
φ₁ φ₂ φ₃ φ₄ : S₁ ⟶ S₂
S : ShortComplex C
⊢ 𝟙 S ≫ 𝟙 S = 𝟙 S
state_after: no goals
tactic: simp
state_before: C : Type u_1
inst✝¹ : Category.{?u.237910, u_1} C
inst✝ : Preadditive C
S₁ S₂ S₃ : ShortComplex C
φ₁ φ₂ φ₃ φ₄ : S₁ ⟶ S₂
S : ShortComplex C
⊢ 𝟙 S ≫ 𝟙 S = 𝟙 S
state_after: no goals
tactic: simp
Theorem: quasiIsoAt_iff
File: Mathlib/Algebra/Homology/QuasiIso.lean

Proof steps:
state_before: ι : Type u_1
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
c : ComplexShape ι
K L M K' L' : HomologicalComplex C c
f : K ⟶ L
i : ι
inst✝¹ : K.HasHomology i
inst✝ : L.HasHomology i
⊢ QuasiIsoAt f i ↔ ShortComplex.QuasiIso ((shortComplexFunctor C c i).map f)
state_after: case mp
ι : Type u_1
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
c : ComplexShape ι
K L M K' L' : HomologicalComplex C c
f : K ⟶ L
i : ι
inst✝¹ : K.HasHomology i
inst✝ : L.HasHomology i
⊢ QuasiIsoAt f i → ShortComplex.QuasiIso ((shortComplexFunctor C c i).map f)

case mpr
ι : Type u_1
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
c : ComplexShape ι
K L M K' L' : HomologicalComplex C c
f : K ⟶ L
i : ι
inst✝¹ : K.HasHomology i
inst✝ : L.HasHomology i
⊢ ShortComplex.QuasiIso ((shortComplexFunctor C c i).map f) → QuasiIsoAt f i
tactic: constructor
Theorem: norm_jacobiTheta₂_term_le
File: Mathlib/NumberTheory/ModularForms/JacobiTheta/TwoVariable.lean

Proof steps:
state_before: S T : ℝ
hT : 0 < T
z τ : ℂ
hz : |z.im| ≤ S
hτ : T ≤ τ.im
n : ℤ
⊢ ‖jacobiTheta₂_term n z τ‖ ≤ rexp (-π * (T * ↑n ^ 2 - 2 * S * ↑|n|))
state_after: S T : ℝ
hT : 0 < T
z τ : ℂ
hz : |z.im| ≤ S
hτ : T ≤ τ.im
n : ℤ
⊢ ↑n ^ 2 * T + -(2 * S * ↑|n|) ≤ ↑n ^ 2 * τ.im + 2 * ↑n * z.im
tactic: simp_rw [norm_jacobiTheta₂_term, Real.exp_le_exp, sub_eq_add_neg, neg_mul, ← neg_add,
    neg_le_neg_iff, mul_comm (2 : ℝ), mul_assoc π, ← mul_add, mul_le_mul_left pi_pos,
    mul_comm T, mul_comm S]
state_before: S T : ℝ
hT : 0 < T
z τ : ℂ
hz : |z.im| ≤ S
hτ : T ≤ τ.im
n : ℤ
⊢ ↑n ^ 2 * T + -(2 * S * ↑|n|) ≤ ↑n ^ 2 * τ.im + 2 * ↑n * z.im
state_after: S T : ℝ
hT : 0 < T
z τ : ℂ
hz : |z.im| ≤ S
hτ : T ≤ τ.im
n : ℤ
⊢ -(2 * S * ↑|n|) ≤ 2 * ↑n * z.im
tactic: refine add_le_add (mul_le_mul le_rfl hτ hT.le (sq_nonneg _)) ?_
state_before: S T : ℝ
hT : 0 < T
z τ : ℂ
hz : |z.im| ≤ S
hτ : T ≤ τ.im
n : ℤ
⊢ -(2 * S * ↑|n|) ≤ 2 * ↑n * z.im
state_after: S T : ℝ
hT : 0 < T
z τ : ℂ
hz : |z.im| ≤ S
hτ : T ≤ τ.im
n : ℤ
⊢ ↑|n| * -S ≤ ↑n * z.im
tactic: rw [← mul_neg, mul_assoc, mul_assoc, mul_le_mul_left two_pos, mul_comm, neg_mul, ← mul_neg]
state_before: S T : ℝ
hT : 0 < T
z τ : ℂ
hz : |z.im| ≤ S
hτ : T ≤ τ.im
n : ℤ
⊢ ↑|n| * -S ≤ ↑n * z.im
state_after: S T : ℝ
hT : 0 < T
z τ : ℂ
hz : |z.im| ≤ S
hτ : T ≤ τ.im
n : ℤ
⊢ ↑|n| * -S ≤ -|↑n * z.im|
tactic: refine le_trans ?_ (neg_abs_le _)
state_before: S T : ℝ
hT : 0 < T
z τ : ℂ
hz : |z.im| ≤ S
hτ : T ≤ τ.im
n : ℤ
⊢ ↑|n| * -S ≤ -|↑n * z.im|
state_after: S T : ℝ
hT : 0 < T
z τ : ℂ
hz : |z.im| ≤ S
hτ : T ≤ τ.im
n : ℤ
⊢ |↑n| * |z.im| ≤ |↑n| * S
tactic: rw [mul_neg, neg_le_neg_iff, abs_mul, Int.cast_abs]
state_before: S T : ℝ
hT : 0 < T
z τ : ℂ
hz : |z.im| ≤ S
hτ : T ≤ τ.im
n : ℤ
⊢ |↑n| * |z.im| ≤ |↑n| * S
state_after: no goals
tactic: exact mul_le_mul_of_nonneg_left hz (abs_nonneg _)
Theorem: Rel.preimage_eq_codom_of_domain_subset
File: Mathlib/Data/Rel.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : Rel α β
s : Set α
h : r.dom ⊆ s
⊢ r.image s = r.codom
state_after: no goals
tactic: apply r.inv.image_eq_dom_of_codomain_subset (by rwa [← codom_inv] at h)
Theorem: vsub_sub_vsub_cancel_left
File: Mathlib/Algebra/AddTorsor.lean

Proof steps:
state_before: G : Type u_1
P : Type u_2
inst✝¹ : AddCommGroup G
inst✝ : AddTorsor G P
p₁ p₂ p₃ : P
⊢ p₃ -ᵥ p₂ - (p₃ -ᵥ p₁) = p₁ -ᵥ p₂
state_after: no goals
tactic: rw [sub_eq_add_neg, neg_vsub_eq_vsub_rev, add_comm, vsub_add_vsub_cancel]
Theorem: Ideal.pow_mem_of_mem
File: Mathlib/RingTheory/Ideal/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
a b : α
inst✝ : CommSemiring α
I : Ideal α
ha : a ∈ I
n : ℕ
hn : 0 < n
⊢ ¬0 < Nat.zero
state_after: no goals
tactic: decide
Theorem: Option.mem_toFinset
File: Mathlib/Data/Finset/Option.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
a : α
o : Option α
⊢ a ∈ o.toFinset ↔ a ∈ o
state_after: no goals
tactic: cases o <;> simp [eq_comm]
Theorem: Fin.mul_zero'
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n m : ℕ
inst✝ : NeZero n
k : Fin n
⊢ k * 0 = 0
state_after: no goals
tactic: simp [Fin.ext_iff, mul_def]
Theorem: Polynomial.natDegree_multiset_sum_le
File: Mathlib/Algebra/Polynomial/BigOperators.lean

Proof steps:
state_before: R : Type u
ι : Type w
s : Finset ι
S : Type u_1
inst✝ : Semiring S
l : Multiset S[X]
⊢ ∀ (a : List S[X]), (Multiset.sum ⟦a⟧).natDegree ≤ foldr max ⋯ 0 (Multiset.map natDegree ⟦a⟧)
state_after: no goals
tactic: simpa using natDegree_list_sum_le
Theorem: CategoryTheory.Iso.symm_self_conj
File: Mathlib/CategoryTheory/Conj.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
α : X ≅ Y
f : End X
⊢ α.symm.conj (α.conj f) = f
state_after: no goals
tactic: rw [← trans_conj, α.self_symm_id, refl_conj]
Theorem: Real.Angle.cos_nonneg_iff_abs_toReal_le_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

Proof steps:
state_before: θ : Angle
⊢ 0 ≤ θ.cos ↔ |θ.toReal| ≤ π / 2
state_after: θ : Angle
⊢ 0 ≤ (↑θ.toReal).cos ↔ |θ.toReal| ≤ π / 2
tactic: nth_rw 1 [← coe_toReal θ]
state_before: θ : Angle
⊢ 0 ≤ (↑θ.toReal).cos ↔ |θ.toReal| ≤ π / 2
state_after: θ : Angle
⊢ 0 ≤ Real.cos θ.toReal ↔ -(π / 2) ≤ θ.toReal ∧ θ.toReal ≤ π / 2
tactic: rw [abs_le, cos_coe]
state_before: θ : Angle
⊢ 0 ≤ Real.cos θ.toReal ↔ -(π / 2) ≤ θ.toReal ∧ θ.toReal ≤ π / 2
state_after: θ : Angle
h : 0 ≤ Real.cos θ.toReal
⊢ -(π / 2) ≤ θ.toReal ∧ θ.toReal ≤ π / 2
tactic: refine ⟨fun h => ?_, cos_nonneg_of_mem_Icc⟩
state_before: θ : Angle
h : 0 ≤ Real.cos θ.toReal
⊢ -(π / 2) ≤ θ.toReal ∧ θ.toReal ≤ π / 2
state_after: θ : Angle
h : 0 ≤ Real.cos θ.toReal
hn : ¬(-(π / 2) ≤ θ.toReal ∧ θ.toReal ≤ π / 2)
⊢ False
tactic: by_contra hn
state_before: θ : Angle
h : 0 ≤ Real.cos θ.toReal
hn : ¬(-(π / 2) ≤ θ.toReal ∧ θ.toReal ≤ π / 2)
⊢ False
state_after: θ : Angle
h : 0 ≤ Real.cos θ.toReal
hn : θ.toReal < -(π / 2) ∨ π / 2 < θ.toReal
⊢ False
tactic: rw [not_and_or, not_le, not_le] at hn
state_before: θ : Angle
h : 0 ≤ Real.cos θ.toReal
hn : θ.toReal < -(π / 2) ∨ π / 2 < θ.toReal
⊢ False
state_after: θ : Angle
h : 0 ≤ Real.cos θ.toReal
hn : θ.toReal < -(π / 2) ∨ π / 2 < θ.toReal
⊢ Real.cos θ.toReal < 0
tactic: refine (not_lt.2 h) ?_
state_before: θ : Angle
h : 0 ≤ Real.cos θ.toReal
hn : θ.toReal < -(π / 2) ∨ π / 2 < θ.toReal
⊢ Real.cos θ.toReal < 0
state_after: case inl
θ : Angle
h : 0 ≤ Real.cos θ.toReal
hn : θ.toReal < -(π / 2)
⊢ Real.cos θ.toReal < 0

case inr
θ : Angle
h : 0 ≤ Real.cos θ.toReal
hn : π / 2 < θ.toReal
⊢ Real.cos θ.toReal < 0
tactic: rcases hn with (hn | hn)
Theorem: FirstOrder.Language.Term.listDecode_encode_list
File: Mathlib/ModelTheory/Encoding.lean

Proof steps:
state_before: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l : List (L.Term α)
⊢ ∀ (t : L.Term α) (l : List (α ⊕ (i : ℕ) × L.Functions i)), listDecode (t.listEncode ++ l) = t :: listDecode l
state_after: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l : List (L.Term α)
t : L.Term α
⊢ ∀ (l : List (α ⊕ (i : ℕ) × L.Functions i)), listDecode (t.listEncode ++ l) = t :: listDecode l
tactic: intro t
state_before: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l : List (L.Term α)
t : L.Term α
⊢ ∀ (l : List (α ⊕ (i : ℕ) × L.Functions i)), listDecode (t.listEncode ++ l) = t :: listDecode l
state_after: case var
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List (L.Term α)
a : α
l : List (α ⊕ (i : ℕ) × L.Functions i)
⊢ listDecode ((var a).listEncode ++ l) = var a :: listDecode l

case func
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List (L.Term α)
n : ℕ
f : L.Functions n
ts : Fin n → L.Term α
ih : ∀ (a : Fin n) (l : List (α ⊕ (i : ℕ) × L.Functions i)), listDecode ((ts a).listEncode ++ l) = ts a :: listDecode l
l : List (α ⊕ (i : ℕ) × L.Functions i)
⊢ listDecode ((func f ts).listEncode ++ l) = func f ts :: listDecode l
tactic: induction' t with a n f ts ih <;> intro l
Theorem: Submonoid.closure_singleton_le_iff_mem
File: Mathlib/Algebra/Group/Submonoid/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
A : Type u_3
inst✝¹ : MulOneClass M
s : Set M
inst✝ : AddZeroClass A
t : Set A
S : Submonoid M
m : M
p : Submonoid M
⊢ closure {m} ≤ p ↔ m ∈ p
state_after: no goals
tactic: rw [closure_le, singleton_subset_iff, SetLike.mem_coe]
Theorem: AddSubgroup.addCommute_of_normal_of_disjoint
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N : Type u_5
inst✝ : Group N
H₁ H₂ : Subgroup G
hH₁ : H₁.Normal
hH₂ : H₂.Normal
hdis : Disjoint H₁ H₂
x y : G
hx : x ∈ H₁
hy : y ∈ H₂
⊢ x * y * x⁻¹ * y⁻¹ = 1
state_after: case a
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N : Type u_5
inst✝ : Group N
H₁ H₂ : Subgroup G
hH₁ : H₁.Normal
hH₂ : H₂.Normal
hdis : Disjoint H₁ H₂
x y : G
hx : x ∈ H₁
hy : y ∈ H₂
⊢ x * y * x⁻¹ * y⁻¹ ∈ H₁ ⊓ H₂
tactic: apply hdis.le_bot
state_before: case a
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N : Type u_5
inst✝ : Group N
H₁ H₂ : Subgroup G
hH₁ : H₁.Normal
hH₂ : H₂.Normal
hdis : Disjoint H₁ H₂
x y : G
hx : x ∈ H₁
hy : y ∈ H₂
⊢ x * y * x⁻¹ * y⁻¹ ∈ H₁ ⊓ H₂
state_after: case a.left
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N : Type u_5
inst✝ : Group N
H₁ H₂ : Subgroup G
hH₁ : H₁.Normal
hH₂ : H₂.Normal
hdis : Disjoint H₁ H₂
x y : G
hx : x ∈ H₁
hy : y ∈ H₂
⊢ x * y * x⁻¹ * y⁻¹ ∈ ↑H₁.toSubmonoid

case a.right
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N : Type u_5
inst✝ : Group N
H₁ H₂ : Subgroup G
hH₁ : H₁.Normal
hH₂ : H₂.Normal
hdis : Disjoint H₁ H₂
x y : G
hx : x ∈ H₁
hy : y ∈ H₂
⊢ x * y * x⁻¹ * y⁻¹ ∈ ↑H₂.toSubmonoid
tactic: constructor