ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Set.integer_eq
File: Mathlib/RingTheory/DedekindDomain/SInteger.lean

Proof steps:
state_before: R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
S : Set (HeightOneSpectrum R)
K : Type v
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
⊢ ↑(S.integer K).toSubring = ↑(⨅ v, ⨅ (_ : v ∉ S), v.valuation.valuationSubring.toSubring)
state_after: case h
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
S : Set (HeightOneSpectrum R)
K : Type v
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
x✝ : K
⊢ x✝ ∈ ↑(S.integer K).toSubring ↔ x✝ ∈ ↑(⨅ v, ⨅ (_ : v ∉ S), v.valuation.valuationSubring.toSubring)
tactic: ext
state_before: case h
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
S : Set (HeightOneSpectrum R)
K : Type v
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
x✝ : K
⊢ x✝ ∈ ↑(S.integer K).toSubring ↔ x✝ ∈ ↑(⨅ v, ⨅ (_ : v ∉ S), v.valuation.valuationSubring.toSubring)
state_after: no goals
tactic: simp
Theorem: ChainComplex.toSingle₀Equiv_symm_apply_f_zero
File: Mathlib/Algebra/Homology/Single.lean

Proof steps:
state_before: V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : ChainComplex V ℕ
X : V
f : C.X 0 ⟶ X
hf : C.d 1 0 ≫ f = 0
⊢ ((C.toSingle₀Equiv X).symm ⟨f, hf⟩).f 0 = f
state_after: no goals
tactic: simp [toSingle₀Equiv]
Theorem: MvPolynomial.eval₂Hom_comp_bind₂
File: Mathlib/Algebra/MvPolynomial/Monad.lean

Proof steps:
state_before: σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
T : Type u_5
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S
inst✝ : CommSemiring T
f✝ : σ → MvPolynomial τ R
f : S →+* T
g : σ → T
h : R →+* MvPolynomial σ S
⊢ (eval₂Hom f g).comp (bind₂ h) = eval₂Hom ((eval₂Hom f g).comp h) g
state_after: no goals
tactic: ext : 2 <;> simp
Theorem: PadicInt.norm_lt_one_iff_dvd
File: Mathlib/NumberTheory/Padics/PadicIntegers.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
⊢ ‖x‖ < 1 ↔ ↑p ∣ x
state_after: p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
this : ‖x‖ ≤ ↑p ^ (-↑1) ↔ x ∈ Ideal.span {↑p ^ 1}
⊢ ‖x‖ < 1 ↔ ↑p ∣ x
tactic: have := norm_le_pow_iff_mem_span_pow x 1
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
this : ‖x‖ ≤ ↑p ^ (-↑1) ↔ x ∈ Ideal.span {↑p ^ 1}
⊢ ‖x‖ < 1 ↔ ↑p ∣ x
state_after: p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
this : ‖x‖ ≤ ↑p ^ (-↑1) ↔ ↑p ∣ x
⊢ ‖x‖ < 1 ↔ ↑p ∣ x
tactic: rw [Ideal.mem_span_singleton, pow_one] at this
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
this : ‖x‖ ≤ ↑p ^ (-↑1) ↔ ↑p ∣ x
⊢ ‖x‖ < 1 ↔ ↑p ∣ x
state_after: p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
this : ‖x‖ ≤ ↑p ^ (-↑1) ↔ ↑p ∣ x
⊢ ‖x‖ < 1 ↔ ‖x‖ < ↑p ^ (-↑1 + 1)
tactic: rw [← this, norm_le_pow_iff_norm_lt_pow_add_one]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
this : ‖x‖ ≤ ↑p ^ (-↑1) ↔ ↑p ∣ x
⊢ ‖x‖ < 1 ↔ ‖x‖ < ↑p ^ (-↑1 + 1)
state_after: no goals
tactic: simp only [zpow_zero, Int.ofNat_zero, Int.ofNat_succ, add_left_neg, zero_add]
Theorem: Real.tan_pi_div_two_sub
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

Proof steps:
state_before: x : ℝ
⊢ tan (π / 2 - x) = (tan x)⁻¹
state_after: no goals
tactic: rw [tan_eq_sin_div_cos, tan_eq_sin_div_cos, inv_div, sin_pi_div_two_sub, cos_pi_div_two_sub]
Theorem: NNReal.ball_zero_eq_Ico
File: Mathlib/Topology/MetricSpace/Pseudo/Constructions.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : PseudoMetricSpace α
c : ℝ
⊢ ball 0 c = Ico 0 c.toNNReal
state_after: case pos
α : Type u_1
β : Type u_2
inst✝ : PseudoMetricSpace α
c : ℝ
c_pos : 0 < c
⊢ ball 0 c = Ico 0 c.toNNReal

case neg
α : Type u_1
β : Type u_2
inst✝ : PseudoMetricSpace α
c : ℝ
c_pos : ¬0 < c
⊢ ball 0 c = Ico 0 c.toNNReal
tactic: by_cases c_pos : 0 < c
state_before: case neg
α : Type u_1
β : Type u_2
inst✝ : PseudoMetricSpace α
c : ℝ
c_pos : ¬0 < c
⊢ ball 0 c = Ico 0 c.toNNReal
state_after: no goals
tactic: simp [not_lt.mp c_pos]
Theorem: CategoryTheory.StrongOplaxNatTrans.whiskerLeft_naturality_id
File: Mathlib/CategoryTheory/Bicategory/NaturalTransformation/Strong.lean

Proof steps:
state_before: B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G H : OplaxFunctor B C
η : StrongOplaxNatTrans F G
θ : StrongOplaxNatTrans G H
a b c : B
a' : C
f : a' ⟶ G.obj a
⊢ f ◁ (θ.naturality (𝟙 a)).hom ≫ f ◁ θ.app a ◁ H.mapId a =
    f ◁ G.mapId a ▷ θ.app a ≫ f ◁ (λ_ (θ.app a)).hom ≫ f ◁ (ρ_ (θ.app a)).inv
state_after: no goals
tactic: apply θ.toOplax.whiskerLeft_naturality_id
Theorem: Set.encard_eq_encard_iff_encard_diff_eq_encard_diff
File: Mathlib/Data/Set/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s t : Set α
h : (s ∩ t).Finite
⊢ s.encard = t.encard ↔ (s \ t).encard = (t \ s).encard
state_after: no goals
tactic: rw [← encard_diff_add_encard_inter s t, ← encard_diff_add_encard_inter t s, inter_comm t s,
    WithTop.add_right_cancel_iff h.encard_lt_top.ne]
Theorem: Cycle.Nodup.nontrivial_iff
File: Mathlib/Data/List/Cycle.lean

Proof steps:
state_before: α : Type u_1
s : Cycle α
h : s.Nodup
⊢ s.Nontrivial ↔ ¬s.Subsingleton
state_after: α : Type u_1
s : Cycle α
h : s.Nodup
⊢ s.Nontrivial ↔ ¬s.length ≤ 1
tactic: rw [length_subsingleton_iff]
state_before: α : Type u_1
s : Cycle α
h : s.Nodup
⊢ s.Nontrivial ↔ ¬s.length ≤ 1
state_after: case h
α : Type u_1
a✝ : List α
h : Nodup (Quotient.mk'' a✝)
⊢ Nontrivial (Quotient.mk'' a✝) ↔ ¬length (Quotient.mk'' a✝) ≤ 1
tactic: induction s using Quotient.inductionOn'
state_before: case h
α : Type u_1
a✝ : List α
h : Nodup (Quotient.mk'' a✝)
⊢ Nontrivial (Quotient.mk'' a✝) ↔ ¬length (Quotient.mk'' a✝) ≤ 1
state_after: case h
α : Type u_1
a✝ : List α
h : a✝.Nodup
⊢ Nontrivial (Quotient.mk'' a✝) ↔ ¬length (Quotient.mk'' a✝) ≤ 1
tactic: simp only [mk''_eq_coe, nodup_coe_iff] at h
state_before: case h
α : Type u_1
a✝ : List α
h : a✝.Nodup
⊢ Nontrivial (Quotient.mk'' a✝) ↔ ¬length (Quotient.mk'' a✝) ≤ 1
state_after: no goals
tactic: simp [h, Nat.succ_le_iff]
Theorem: List.head!_mem_head?
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝ : Inhabited α
h : [] ≠ []
⊢ [].head! ∈ [].head?
state_after: no goals
tactic: contradiction
Theorem: LinearMap.IsRefl.ker_eq_bot_iff_ker_flip_eq_bot
File: Mathlib/LinearAlgebra/SesquilinearForm.lean

Proof steps:
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
Mₗ₁ : Type u_9
Mₗ₁' : Type u_10
Mₗ₂ : Type u_11
Mₗ₂' : Type u_12
K : Type u_13
K₁ : Type u_14
K₂ : Type u_15
V : Type u_16
V₁ : Type u_17
V₂ : Type u_18
n : Type u_19
inst✝⁵ : CommSemiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : CommSemiring R₁
inst✝¹ : AddCommMonoid M₁
inst✝ : Module R₁ M₁
I₁ I₂ : R₁ →+* R
B : M₁ →ₛₗ[I₁] M₁ →ₛₗ[I₂] M
H✝ H : B.IsRefl
⊢ ker B = ⊥ ↔ ker B.flip = ⊥
state_after: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
Mₗ₁ : Type u_9
Mₗ₁' : Type u_10
Mₗ₂ : Type u_11
Mₗ₂' : Type u_12
K : Type u_13
K₁ : Type u_14
K₂ : Type u_15
V : Type u_16
V₁ : Type u_17
V₂ : Type u_18
n : Type u_19
inst✝⁵ : CommSemiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : CommSemiring R₁
inst✝¹ : AddCommMonoid M₁
inst✝ : Module R₁ M₁
I₁ I₂ : R₁ →+* R
B : M₁ →ₛₗ[I₁] M₁ →ₛₗ[I₂] M
H✝ H : B.IsRefl
h : ker B.flip = ⊥
⊢ ker B = ⊥
tactic: refine ⟨ker_flip_eq_bot H, fun h ↦ ?_⟩
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
Mₗ₁ : Type u_9
Mₗ₁' : Type u_10
Mₗ₂ : Type u_11
Mₗ₂' : Type u_12
K : Type u_13
K₁ : Type u_14
K₂ : Type u_15
V : Type u_16
V₁ : Type u_17
V₂ : Type u_18
n : Type u_19
inst✝⁵ : CommSemiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : CommSemiring R₁
inst✝¹ : AddCommMonoid M₁
inst✝ : Module R₁ M₁
I₁ I₂ : R₁ →+* R
B : M₁ →ₛₗ[I₁] M₁ →ₛₗ[I₂] M
H✝ H : B.IsRefl
h : ker B.flip = ⊥
⊢ ker B = ⊥
state_after: no goals
tactic: exact (congr_arg _ B.flip_flip.symm).trans (ker_flip_eq_bot (flip_isRefl_iff.mpr H) h)
Theorem: Nat.log_mul_base
File: Mathlib/Data/Nat/Log.lean

Proof steps:
state_before: b n : ℕ
hb : 1 < b
hn : n ≠ 0
⊢ log b (n * b) = log b n + 1
state_after: case h₁
b n : ℕ
hb : 1 < b
hn : n ≠ 0
⊢ b ^ log b n * b ≤ n * b

case h₂
b n : ℕ
hb : 1 < b
hn : n ≠ 0
⊢ n * b < b ^ (log b n + 1) * b
tactic: apply log_eq_of_pow_le_of_lt_pow <;> rw [pow_succ', Nat.mul_comm b]
state_before: case h₁
b n : ℕ
hb : 1 < b
hn : n ≠ 0
⊢ b ^ log b n * b ≤ n * b

case h₂
b n : ℕ
hb : 1 < b
hn : n ≠ 0
⊢ n * b < b ^ (log b n + 1) * b
state_after: no goals
tactic: exacts [Nat.mul_le_mul_right _ (pow_log_le_self _ hn),
    (Nat.mul_lt_mul_right (Nat.zero_lt_one.trans hb)).2 (lt_pow_succ_log_self hb _)]
Theorem: Complex.ofReal_inv
File: Mathlib/Data/Complex/Basic.lean

Proof steps:
state_before: r : ℝ
⊢ (↑r⁻¹).re = (↑r)⁻¹.re ∧ (↑r⁻¹).im = (↑r)⁻¹.im
state_after: no goals
tactic: simp [ofReal']
Theorem: Filter.HasBasis.nhds
File: Mathlib/Topology/Filter.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
X : Type u_4
Y : Type u_5
l : Filter α
p : ι → Prop
s : ι → Set α
h : l.HasBasis p s
⊢ (𝓝 l).HasBasis p fun i => Iic (𝓟 (s i))
state_after: ι : Sort u_1
α : Type u_2
β : Type u_3
X : Type u_4
Y : Type u_5
l : Filter α
p : ι → Prop
s : ι → Set α
h : l.HasBasis p s
⊢ (l.lift' (Iic ∘ 𝓟)).HasBasis p fun i => Iic (𝓟 (s i))
tactic: rw [nhds_eq]
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
X : Type u_4
Y : Type u_5
l : Filter α
p : ι → Prop
s : ι → Set α
h : l.HasBasis p s
⊢ (l.lift' (Iic ∘ 𝓟)).HasBasis p fun i => Iic (𝓟 (s i))
state_after: no goals
tactic: exact h.lift' monotone_principal.Iic
Theorem: Matroid.basis'_iff_basis_closure
File: Mathlib/Data/Matroid/Closure.lean

Proof steps:
state_before: ι✝ : Type u_1
α : Type u_2
M : Matroid α
F X Y : Set α
e : α
ι : Sort u_3
I J B : Set α
f x y : α
⊢ M.Basis' I X ↔ M.Basis I (M.closure X) ∧ I ⊆ X
state_after: ι✝ : Type u_1
α : Type u_2
M : Matroid α
F X Y : Set α
e : α
ι : Sort u_3
I J B : Set α
f x y : α
⊢ M.Basis I (X ∩ M.E) ↔ M.Basis I (M.closure (X ∩ M.E)) ∧ I ⊆ X
tactic: rw [← closure_inter_ground, basis'_iff_basis_inter_ground]
state_before: ι✝ : Type u_1
α : Type u_2
M : Matroid α
F X Y : Set α
e : α
ι : Sort u_3
I J B : Set α
f x y : α
⊢ M.Basis I (X ∩ M.E) ↔ M.Basis I (M.closure (X ∩ M.E)) ∧ I ⊆ X
state_after: no goals
tactic: exact ⟨fun h ↦ ⟨h.basis_closure_right, h.subset.trans inter_subset_left⟩,
    fun h ↦ h.1.basis_subset (subset_inter h.2 h.1.indep.subset_ground) (M.subset_closure _)⟩
Theorem: aemeasurable_uIoc_iff
File: Mathlib/MeasureTheory/Measure/AEMeasurable.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
R : Type u_6
m0 : MeasurableSpace α
inst✝³ : MeasurableSpace β
inst✝² : MeasurableSpace γ
inst✝¹ : MeasurableSpace δ
f✝ g : α → β
μ ν : Measure α
inst✝ : LinearOrder α
f : α → β
a b : α
⊢ AEMeasurable f (μ.restrict (Ι a b)) ↔ AEMeasurable f (μ.restrict (Ioc a b)) ∧ AEMeasurable f (μ.restrict (Ioc b a))
state_after: no goals
tactic: rw [uIoc_eq_union, aemeasurable_union_iff]
Theorem: ProbabilityTheory.Kernel.bind_add
File: Mathlib/Probability/Kernel/Invariance.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
μ ν : Measure α
κ : Kernel α β
⊢ (μ + ν).bind ⇑κ = μ.bind ⇑κ + ν.bind ⇑κ
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
μ ν : Measure α
κ : Kernel α β
s : Set β
hs : MeasurableSet s
⊢ ((μ + ν).bind ⇑κ) s = (μ.bind ⇑κ + ν.bind ⇑κ) s
tactic: ext1 s hs
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
μ ν : Measure α
κ : Kernel α β
s : Set β
hs : MeasurableSet s
⊢ ((μ + ν).bind ⇑κ) s = (μ.bind ⇑κ + ν.bind ⇑κ) s
state_after: no goals
tactic: rw [Measure.bind_apply hs (Kernel.measurable _), lintegral_add_measure, Measure.coe_add,
    Pi.add_apply, Measure.bind_apply hs (Kernel.measurable _),
    Measure.bind_apply hs (Kernel.measurable _)]
Theorem: Subfield.cardinal_mk_closure_le_max
File: Mathlib/SetTheory/Cardinal/Subfield.lean

Proof steps:
state_before: α : Type u
s : Set α
inst✝ : DivisionRing α
⊢ #(WType (Subfield.Operands s)) ≤ max #↑s ℵ₀
state_after: case h.e'_4
α : Type u
s : Set α
inst✝ : DivisionRing α
⊢ max #↑s ℵ₀ = max (lift.{0, u} #(Fin 6 ⊕ ↑s)) ℵ₀

case convert_3
α : Type u
s : Set α
inst✝ : DivisionRing α
⊢ ∀ (a : Fin 6 ⊕ ↑s), Finite (Subfield.Operands s a)
tactic: convert WType.cardinal_mk_le_max_aleph0_of_finite' using 1
state_before: case convert_3
α : Type u
s : Set α
inst✝ : DivisionRing α
⊢ ∀ (a : Fin 6 ⊕ ↑s), Finite (Subfield.Operands s a)
state_after: case convert_3.inl
α : Type u
s : Set α
inst✝ : DivisionRing α
n : Fin 6
⊢ Finite (Subfield.Operands s (Sum.inl n))

case convert_3.inr
α : Type u
s : Set α
inst✝ : DivisionRing α
val✝ : ↑s
⊢ Finite (Subfield.Operands s (Sum.inr val✝))
tactic: rintro (n|_)
state_before: case convert_3.inr
α : Type u
s : Set α
inst✝ : DivisionRing α
val✝ : ↑s
⊢ Finite (Subfield.Operands s (Sum.inr val✝))
state_after: no goals
tactic: infer_instance
Theorem: MvPolynomial.isHomogeneous_monomial
File: Mathlib/RingTheory/MvPolynomial/Homogeneous.lean

Proof steps:
state_before: σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝¹ inst✝ : CommSemiring R
d : σ →₀ ℕ
r : R
n : ℕ
hn : d.degree = n
⊢ ((monomial d) r).IsHomogeneous n
state_after: σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝¹ inst✝ : CommSemiring R
d : σ →₀ ℕ
r : R
n : ℕ
hn : (weight 1) d = n
⊢ ((monomial d) r).IsHomogeneous n
tactic: rw [degree_eq_weight_one] at hn
state_before: σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝¹ inst✝ : CommSemiring R
d : σ →₀ ℕ
r : R
n : ℕ
hn : (weight 1) d = n
⊢ ((monomial d) r).IsHomogeneous n
state_after: no goals
tactic: exact isWeightedHomogeneous_monomial 1 d r hn
Theorem: SimpleGraph.Subgraph.isPerfectMatching_iff_forall_degree
File: Mathlib/Combinatorics/SimpleGraph/Matching.lean

Proof steps:
state_before: V : Type u_1
G G' : SimpleGraph V
M M' : G.Subgraph
v w : V
inst✝ : (v : V) → Fintype ↑(M.neighborSet v)
⊢ M.IsPerfectMatching ↔ ∀ (v : V), M.degree v = 1
state_after: no goals
tactic: simp [degree_eq_one_iff_unique_adj, isPerfectMatching_iff]
Theorem: Equiv.Perm.sign_surjective
File: Mathlib/GroupTheory/Perm/Sign.lean

Proof steps:
state_before: α : Type u
inst✝² : DecidableEq α
β : Type v
inst✝¹ : Fintype α
inst✝ : Nontrivial α
a : ℤˣ
h : a = 1
⊢ sign 1 = a
state_after: no goals
tactic: simp [h]
state_before: α : Type u
inst✝² : DecidableEq α
β : Type v
inst✝¹ : Fintype α
inst✝ : Nontrivial α
a : ℤˣ
h : a = -1
x y : α
hxy : x ≠ y
⊢ sign (swap x y) = a
state_after: no goals
tactic: rw [sign_swap hxy, h]
Theorem: Complex.arg_eq_nhds_of_re_neg_of_im_pos
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

Proof steps:
state_before: a x z : ℂ
hx_re : x.re < 0
hx_im : 0 < x.im
⊢ arg =ᶠ[𝓝 x] fun x => Real.arcsin ((-x).im / abs x) + π
state_after: a x z : ℂ
hx_re : x.re < 0
hx_im : 0 < x.im
⊢ ∀ᶠ (y : ℂ) in 𝓝 x, y.re < 0 ∧ 0 < y.im
tactic: suffices h_forall_nhds : ∀ᶠ y : ℂ in 𝓝 x, y.re < 0 ∧ 0 < y.im from
    h_forall_nhds.mono fun y hy => arg_of_re_neg_of_im_nonneg hy.1 hy.2.le
state_before: a x z : ℂ
hx_re : x.re < 0
hx_im : 0 < x.im
⊢ ∀ᶠ (y : ℂ) in 𝓝 x, y.re < 0 ∧ 0 < y.im
state_after: a x z : ℂ
hx_re : x.re < 0
hx_im : 0 < x.im
⊢ IsOpen fun y => y.re < 0 ∧ 0 < y.im
tactic: refine IsOpen.eventually_mem ?_ (⟨hx_re, hx_im⟩ : x.re < 0 ∧ 0 < x.im)
state_before: a x z : ℂ
hx_re : x.re < 0
hx_im : 0 < x.im
⊢ IsOpen fun y => y.re < 0 ∧ 0 < y.im
state_after: no goals
tactic: exact
    IsOpen.and (isOpen_lt continuous_re continuous_zero) (isOpen_lt continuous_zero continuous_im)
Theorem: Matrix.vecMulVec_eq
File: Mathlib/Data/Matrix/RowCol.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
inst✝² : Mul α
inst✝¹ : AddCommMonoid α
inst✝ : Unique ι
w : m → α
v : n → α
⊢ vecMulVec w v = col ι w * row ι v
state_after: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
inst✝² : Mul α
inst✝¹ : AddCommMonoid α
inst✝ : Unique ι
w : m → α
v : n → α
i✝ : m
j✝ : n
⊢ vecMulVec w v i✝ j✝ = (col ι w * row ι v) i✝ j✝
tactic: ext
state_before: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
inst✝² : Mul α
inst✝¹ : AddCommMonoid α
inst✝ : Unique ι
w : m → α
v : n → α
i✝ : m
j✝ : n
⊢ vecMulVec w v i✝ j✝ = (col ι w * row ι v) i✝ j✝
state_after: no goals
tactic: simp [vecMulVec, mul_apply]
Theorem: Relation.ReflTransGen.trans
File: Mathlib/Logic/Relation.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
hab : ReflTransGen r a b
hbc : ReflTransGen r b c
⊢ ReflTransGen r a c
state_after: no goals
tactic: induction hbc with
  | refl => assumption
  | tail _ hcd hac => exact hac.tail hcd
Theorem: UniqueMul.of_mulHom_image
File: Mathlib/Algebra/Group/UniqueProds.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
inst✝² : Mul G
inst✝¹ : Mul H
A B : Finset G
a0 b0 : G
inst✝ : DecidableEq H
f : G →ₙ* H
hf : ∀ ⦃a b c d : G⦄, a * b = c * d → f a = f c ∧ f b = f d → a = c ∧ b = d
h : UniqueMul (Finset.image (⇑f) A) (Finset.image (⇑f) B) (f a0) (f b0)
a b : G
ha : a ∈ A
hb : b ∈ B
ab : a * b = a0 * b0
⊢ f a * f b = f a0 * f b0
state_after: no goals
tactic: simp_rw [← map_mul, ab]
Theorem: top_himp
File: Mathlib/Order/Heyting/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : GeneralizedHeytingAlgebra α
a b✝ c d b : α
⊢ b ≤ ⊤ ⇨ a ↔ b ≤ a
state_after: no goals
tactic: rw [le_himp_iff, inf_top_eq]
Theorem: linearIndependent_insert
File: Mathlib/LinearAlgebra/LinearIndependent.lean

Proof steps:
state_before: ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v : ι → V
s t : Set V
x y z : V
hxs : x ∉ s
⊢ (LinearIndependent K fun (x : ↑s) => id ↑x) ∧ id x ∉ span K (id '' s) ↔
    (LinearIndependent K fun (b : ↑s) => ↑b) ∧ x ∉ span K s
state_after: no goals
tactic: simp
Theorem: Set.image2_eq_iUnion
File: Mathlib/Data/Set/Lattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
f : α → β → γ
s✝ : Set α
t✝ : Set β
s : Set α
t : Set β
⊢ image2 f s t = ⋃ i ∈ s, ⋃ j ∈ t, {f i j}
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
f : α → β → γ
s✝ : Set α
t✝ : Set β
s : Set α
t : Set β
x✝ : γ
⊢ x✝ ∈ image2 f s t ↔ x✝ ∈ ⋃ i ∈ s, ⋃ j ∈ t, {f i j}
tactic: ext
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
f : α → β → γ
s✝ : Set α
t✝ : Set β
s : Set α
t : Set β
x✝ : γ
⊢ x✝ ∈ image2 f s t ↔ x✝ ∈ ⋃ i ∈ s, ⋃ j ∈ t, {f i j}
state_after: no goals
tactic: simp [eq_comm]
Theorem: CategoryTheory.Limits.Types.Quot.desc_colimitCocone
File: Mathlib/CategoryTheory/Limits/Types.lean

Proof steps:
state_before: J : Type v
inst✝¹ : Category.{w, v} J
F : J ⥤ Type u
inst✝ : Small.{u, max u v} (Quot F)
⊢ desc (colimitCocone F) = ⇑(equivShrink (Quot F))
state_after: case h.mk.mk
J : Type v
inst✝¹ : Category.{w, v} J
F : J ⥤ Type u
inst✝ : Small.{u, max u v} (Quot F)
x✝ : Quot F
j : J
x : F.obj j
⊢ desc (colimitCocone F) (Quot.mk (Rel F) ⟨j, x⟩) = (equivShrink (Quot F)) (Quot.mk (Rel F) ⟨j, x⟩)
tactic: ext ⟨j, x⟩
state_before: case h.mk.mk
J : Type v
inst✝¹ : Category.{w, v} J
F : J ⥤ Type u
inst✝ : Small.{u, max u v} (Quot F)
x✝ : Quot F
j : J
x : F.obj j
⊢ desc (colimitCocone F) (Quot.mk (Rel F) ⟨j, x⟩) = (equivShrink (Quot F)) (Quot.mk (Rel F) ⟨j, x⟩)
state_after: no goals
tactic: rfl
Theorem: dist_mono_right_pi
File: Mathlib/Analysis/Normed/Order/UpperLower.lean

Proof steps:
state_before: α : Type u_1
ι : Type u_2
inst✝ : Fintype ι
s t : Set (ι → ℝ)
a₁ a₂ b₁ b₂ x y : ι → ℝ
δ : ℝ
⊢ MonotoneOn (dist x) (Ici x)
state_after: no goals
tactic: simpa only [dist_comm _ x] using dist_mono_left_pi (y := x)
Theorem: tsub_one_mul
File: Mathlib/Algebra/Order/Ring/Canonical.lean

Proof steps:
state_before: α : Type u
β : Type u_1
inst✝⁴ : CanonicallyOrderedCommSemiring α
a✝ b✝ c : α
inst✝³ : Sub α
inst✝² : OrderedSub α
inst✝¹ : IsTotal α fun x x_1 => x ≤ x_1
inst✝ : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
a b : α
⊢ (a - 1) * b = a * b - b
state_after: no goals
tactic: rw [tsub_mul, one_mul]
Theorem: WittVector.wittZero_eq_zero
File: Mathlib/RingTheory/WittVector/Defs.lean

Proof steps:
state_before: p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
n : ℕ
⊢ wittZero p n = 0
state_after: case a
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
n : ℕ
⊢ (map (Int.castRingHom ℚ)) (wittZero p n) = (map (Int.castRingHom ℚ)) 0
tactic: apply MvPolynomial.map_injective (Int.castRingHom ℚ) Int.cast_injective
state_before: case a
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
n : ℕ
⊢ (map (Int.castRingHom ℚ)) (wittZero p n) = (map (Int.castRingHom ℚ)) 0
state_after: no goals
tactic: simp only [wittZero, wittStructureRat, bind₁, aeval_zero', constantCoeff_xInTermsOfW, map_zero,
    map_wittStructureInt]
Theorem: LinearMap.mulRight_eq_zero_iff
File: Mathlib/Algebra/Algebra/Bilinear.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
a : A
⊢ mulRight R a = 0 ↔ a = 0
state_after: case mp
R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
a : A
h : mulRight R a = 0
⊢ a = 0

case mpr
R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
a : A
h : a = 0
⊢ mulRight R a = 0
tactic: constructor <;> intro h