1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: hasFDerivAt_of_subsingleton
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

tactic: rw [← hasFDerivWithinAt_univ, subsingleton_univ.eq_singleton_of_mem (mem_univ x)]
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x✝ : E
s t : Set E
L L₁ L₂ : Filter E
h : Subsingleton E
f : E → F
x : E
⊢ HasFDerivAt f 0 x
state_after: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x✝ : E
s t : Set E
L L₁ L₂ : Filter E
h : Subsingleton E
f : E → F
x : E
⊢ HasFDerivWithinAt f 0 {x} x

tactic: exact hasFDerivWithinAt_singleton f x
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x✝ : E
s t : Set E
L L₁ L₂ : Filter E
h : Subsingleton E
f : E → F
x : E
⊢ HasFDerivWithinAt f 0 {x} x
state_after: no goals
Theorem: Batteries.UnionFind.rank'_lt_rankMax
File: .lake/packages/batteries/Batteries/Data/UnionFind/Basic.lean

tactic: simp [rankMax, Array.foldr_eq_foldr_data]
state_before: self : UnionFind
i : Fin self.size
⊢ (self.arr.get i).rank < self.rankMax
state_after: self : UnionFind
i : Fin self.size
⊢ self.arr[↑i].rank < List.foldr (fun x => max x.rank) 0 self.arr.data + 1

tactic: exact Nat.lt_succ.2 <| go (self.arr.data.get_mem i.1 i.2)
state_before: self : UnionFind
i : Fin self.size
⊢ self.arr[↑i].rank < List.foldr (fun x => max x.rank) 0 self.arr.data + 1
state_after: no goals

tactic: dsimp
state_before: self : UnionFind
i : Fin self.size
a : UFNode
l : List UFNode
⊢ a.rank ≤ List.foldr (fun x => max x.rank) 0 (a :: l)
state_after: self : UnionFind
i : Fin self.size
a : UFNode
l : List UFNode
⊢ a.rank ≤ max a.rank (List.foldr (fun x => max x.rank) 0 l)

tactic: apply Nat.le_max_left
state_before: self : UnionFind
i : Fin self.size
a : UFNode
l : List UFNode
⊢ a.rank ≤ max a.rank (List.foldr (fun x => max x.rank) 0 l)
state_after: no goals

tactic: dsimp
state_before: self : UnionFind
i : Fin self.size
a : UFNode
l : List UFNode
a✝ : UFNode
h : List.Mem a✝ l
⊢ a✝.rank ≤ List.foldr (fun x => max x.rank) 0 (a :: l)
state_after: self : UnionFind
i : Fin self.size
a : UFNode
l : List UFNode
a✝ : UFNode
h : List.Mem a✝ l
⊢ a✝.rank ≤ max a.rank (List.foldr (fun x => max x.rank) 0 l)

tactic: exact Nat.le_trans (go h) (Nat.le_max_right ..)
state_before: self : UnionFind
i : Fin self.size
a : UFNode
l : List UFNode
a✝ : UFNode
h : List.Mem a✝ l
⊢ a✝.rank ≤ max a.rank (List.foldr (fun x => max x.rank) 0 l)
state_after: no goals
Theorem: SimpleGraph.locallyLinear_bot
File: Mathlib/Combinatorics/SimpleGraph/Triangle/Basic.lean

tactic: simp [LocallyLinear]
state_before: α : Type u_1
β : Type u_2
𝕜 : Type u_3
inst✝ : LinearOrderedField 𝕜
G H : SimpleGraph α
ε δ : 𝕜
n : ℕ
s : Finset α
⊢ ⊥.LocallyLinear
state_after: no goals
Theorem: List.join_join
File: Mathlib/Data/List/Join.lean

tactic: induction l <;> simp [*]
state_before: α : Type u_1
β : Type u_2
l : List (List (List α))
⊢ l.join.join = (map join l).join
state_after: no goals
Theorem: MeasureTheory.DominatedFinMeasAdditive.eq_zero
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

tactic: simp only [Measure.coe_zero, Pi.zero_apply]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace ℝ F
inst✝⁴ : NormedAddCommGroup F'
inst✝³ : NormedSpace ℝ F'
inst✝² : NormedAddCommGroup G
m✝ : MeasurableSpace α
μ : Measure α
β✝ : Type u_7
inst✝¹ : SeminormedAddCommGroup β✝
T✝ T' : Set α → β✝
C✝ C' : ℝ
β : Type u_8
inst✝ : NormedAddCommGroup β
T : Set α → β
C : ℝ
m : MeasurableSpace α
hT : DominatedFinMeasAdditive 0 T C
s : Set α
hs : MeasurableSet s
⊢ 0 s = 0
state_after: no goals
Theorem: SkyscraperPresheafFunctor.map'_id
File: Mathlib/Topology/Sheaves/Skyscraper.lean

tactic: ext U
state_before: X : TopCat
p₀ : ↑X
inst✝² : (U : Opens ↑X) → Decidable (p₀ ∈ U)
C : Type v
inst✝¹ : Category.{w, v} C
inst✝ : HasTerminal C
A a : C
⊢ map' p₀ (𝟙 a) = 𝟙 (skyscraperPresheaf p₀ a)
state_after: case w
X : TopCat
p₀ : ↑X
inst✝² : (U : Opens ↑X) → Decidable (p₀ ∈ U)
C : Type v
inst✝¹ : Category.{w, v} C
inst✝ : HasTerminal C
A a : C
U : Opens ↑X
⊢ (map' p₀ (𝟙 a)).app { unop := U } = (𝟙 (skyscraperPresheaf p₀ a)).app { unop := U }

tactic: simp only [SkyscraperPresheafFunctor.map'_app, NatTrans.id_app]
state_before: case w
X : TopCat
p₀ : ↑X
inst✝² : (U : Opens ↑X) → Decidable (p₀ ∈ U)
C : Type v
inst✝¹ : Category.{w, v} C
inst✝ : HasTerminal C
A a : C
U : Opens ↑X
⊢ (map' p₀ (𝟙 a)).app { unop := U } = (𝟙 (skyscraperPresheaf p₀ a)).app { unop := U }
state_after: case w
X : TopCat
p₀ : ↑X
inst✝² : (U : Opens ↑X) → Decidable (p₀ ∈ U)
C : Type v
inst✝¹ : Category.{w, v} C
inst✝ : HasTerminal C
A a : C
U : Opens ↑X
⊢ (if h : p₀ ∈ U then eqToHom ⋯ ≫ 𝟙 a ≫ eqToHom ⋯
    else (⋯ ▸ terminalIsTerminal).from ((skyscraperPresheaf p₀ a).obj { unop := U })) =
    (𝟙 (skyscraperPresheaf p₀ a)).app { unop := U }

tactic: split_ifs <;> aesop_cat
state_before: case w
X : TopCat
p₀ : ↑X
inst✝² : (U : Opens ↑X) → Decidable (p₀ ∈ U)
C : Type v
inst✝¹ : Category.{w, v} C
inst✝ : HasTerminal C
A a : C
U : Opens ↑X
⊢ (if h : p₀ ∈ U then eqToHom ⋯ ≫ 𝟙 a ≫ eqToHom ⋯
    else (⋯ ▸ terminalIsTerminal).from ((skyscraperPresheaf p₀ a).obj { unop := U })) =
    (𝟙 (skyscraperPresheaf p₀ a)).app { unop := U }
state_after: no goals
Theorem: AddSubmonoid.mem_iSup_iff_exists_dfinsupp'
File: Mathlib/Data/DFinsupp/Basic.lean

tactic: rw [AddSubmonoid.mem_iSup_iff_exists_dfinsupp]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : AddCommMonoid γ
S : ι → AddSubmonoid γ
inst✝ : (i : ι) → (x : ↥(S i)) → Decidable (x ≠ 0)
x : γ
⊢ x ∈ iSup S ↔ ∃ f, (f.sum fun i xi => ↑xi) = x
state_after: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : AddCommMonoid γ
S : ι → AddSubmonoid γ
inst✝ : (i : ι) → (x : ↥(S i)) → Decidable (x ≠ 0)
x : γ
⊢ (∃ f, (sumAddHom fun i => (S i).subtype) f = x) ↔ ∃ f, (f.sum fun i xi => ↑xi) = x

tactic: simp_rw [sumAddHom_apply]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : AddCommMonoid γ
S : ι → AddSubmonoid γ
inst✝ : (i : ι) → (x : ↥(S i)) → Decidable (x ≠ 0)
x : γ
⊢ (∃ f, (sumAddHom fun i => (S i).subtype) f = x) ↔ ∃ f, (f.sum fun i xi => ↑xi) = x
state_after: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : AddCommMonoid γ
S : ι → AddSubmonoid γ
inst✝ : (i : ι) → (x : ↥(S i)) → Decidable (x ≠ 0)
x : γ
⊢ (∃ f, (f.sum fun x => ⇑(S x).subtype) = x) ↔ ∃ f, (f.sum fun i xi => ↑xi) = x

tactic: rfl
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : AddCommMonoid γ
S : ι → AddSubmonoid γ
inst✝ : (i : ι) → (x : ↥(S i)) → Decidable (x ≠ 0)
x : γ
⊢ (∃ f, (f.sum fun x => ⇑(S x).subtype) = x) ↔ ∃ f, (f.sum fun i xi => ↑xi) = x
state_after: no goals
Theorem: Complex.abs_eq_one_iff
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: refine ⟨fun hz => ⟨arg z, ?_⟩, ?_⟩
state_before: a x z✝ z : ℂ
⊢ abs z = 1 ↔ ∃ θ, cexp (↑θ * I) = z
state_after: case refine_1
a x z✝ z : ℂ
hz : abs z = 1
⊢ cexp (↑z.arg * I) = z

case refine_2
a x z✝ z : ℂ
⊢ (∃ θ, cexp (↑θ * I) = z) → abs z = 1

tactic: calc
  exp (arg z * I) = abs z * exp (arg z * I) := by rw [hz, ofReal_one, one_mul]
  _ = z := abs_mul_exp_arg_mul_I z
state_before: case refine_1
a x z✝ z : ℂ
hz : abs z = 1
⊢ cexp (↑z.arg * I) = z
state_after: no goals

tactic: rw [hz, ofReal_one, one_mul]
state_before: a x z✝ z : ℂ
hz : abs z = 1
⊢ cexp (↑z.arg * I) = ↑(abs z) * cexp (↑z.arg * I)
state_after: no goals

tactic: rintro ⟨θ, rfl⟩
state_before: case refine_2
a x z✝ z : ℂ
⊢ (∃ θ, cexp (↑θ * I) = z) → abs z = 1
state_after: case refine_2.intro
a x z : ℂ
θ : ℝ
⊢ abs (cexp (↑θ * I)) = 1

tactic: exact Complex.abs_exp_ofReal_mul_I θ
state_before: case refine_2.intro
a x z : ℂ
θ : ℝ
⊢ abs (cexp (↑θ * I)) = 1
state_after: no goals
Theorem: List.splitWrtComposition_join
File: Mathlib/Combinatorics/Enumerative/Composition.lean

tactic: simp only [eq_self_iff_true, and_self_iff, eq_iff_join_eq, join_splitWrtComposition,
  map_length_splitWrtComposition, h]
state_before: n : ℕ
α : Type u_1
L : List (List α)
c : Composition L.join.length
h : map length L = c.blocks
⊢ L.join.splitWrtComposition c = L
state_after: no goals
Theorem: HahnSeries.ofPowerSeries_apply_coeff
File: Mathlib/RingTheory/HahnSeries/PowerSeries.lean

tactic: simp [ofPowerSeries_apply]
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : Semiring R
inst✝ : StrictOrderedSemiring Γ
x : PowerSeries R
n : ℕ
⊢ ((ofPowerSeries Γ R) x).coeff ↑n = (PowerSeries.coeff R n) x
state_after: no goals
Theorem: Polynomial.C_mul'
File: Mathlib/Algebra/Polynomial/Coeff.lean

tactic: ext
state_before: R : Type u
S : Type v
a✝ b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
a : R
f : R[X]
⊢ C a * f = a • f
state_after: case a
R : Type u
S : Type v
a✝ b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
a : R
f : R[X]
n✝ : ℕ
⊢ (C a * f).coeff n✝ = (a • f).coeff n✝

tactic: rw [coeff_C_mul, coeff_smul, smul_eq_mul]
state_before: case a
R : Type u
S : Type v
a✝ b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
a : R
f : R[X]
n✝ : ℕ
⊢ (C a * f).coeff n✝ = (a • f).coeff n✝
state_after: no goals
Theorem: FractionalIdeal.coe_dual_one
File: Mathlib/RingTheory/DedekindDomain/Different.lean

tactic: rw [← coe_one, coe_dual]
state_before: A : Type u_1
K : Type u_2
L : Type u
B : Type u_3
inst✝¹⁹ : CommRing A
inst✝¹⁸ : Field K
inst✝¹⁷ : CommRing B
inst✝¹⁶ : Field L
inst✝¹⁵ : Algebra A K
inst✝¹⁴ : Algebra B L
inst✝¹³ : Algebra A B
inst✝¹² : Algebra K L
inst✝¹¹ : Algebra A L
inst✝¹⁰ : IsScalarTower A K L
inst✝⁹ : IsScalarTower A B L
inst✝⁸ : IsDomain A
inst✝⁷ : IsDomain B
inst✝⁶ : IsFractionRing A K
inst✝⁵ : IsIntegralClosure B A L
inst✝⁴ : IsFractionRing B L
inst✝³ : FiniteDimensional K L
inst✝² : IsSeparable K L
inst✝¹ : IsIntegrallyClosed A
inst✝ : IsDedekindDomain B
I J : FractionalIdeal B⁰ L
hI : I ≠ 0
hJ : J ≠ 0
⊢ ↑(dual A K 1) = 1ᵛ
state_after: case hI
A : Type u_1
K : Type u_2
L : Type u
B : Type u_3
inst✝¹⁹ : CommRing A
inst✝¹⁸ : Field K
inst✝¹⁷ : CommRing B
inst✝¹⁶ : Field L
inst✝¹⁵ : Algebra A K
inst✝¹⁴ : Algebra B L
inst✝¹³ : Algebra A B
inst✝¹² : Algebra K L
inst✝¹¹ : Algebra A L
inst✝¹⁰ : IsScalarTower A K L
inst✝⁹ : IsScalarTower A B L
inst✝⁸ : IsDomain A
inst✝⁷ : IsDomain B
inst✝⁶ : IsFractionRing A K
inst✝⁵ : IsIntegralClosure B A L
inst✝⁴ : IsFractionRing B L
inst✝³ : FiniteDimensional K L
inst✝² : IsSeparable K L
inst✝¹ : IsIntegrallyClosed A
inst✝ : IsDedekindDomain B
I J : FractionalIdeal B⁰ L
hI : I ≠ 0
hJ : J ≠ 0
⊢ 1 ≠ 0

tactic: exact one_ne_zero
state_before: case hI
A : Type u_1
K : Type u_2
L : Type u
B : Type u_3
inst✝¹⁹ : CommRing A
inst✝¹⁸ : Field K
inst✝¹⁷ : CommRing B
inst✝¹⁶ : Field L
inst✝¹⁵ : Algebra A K
inst✝¹⁴ : Algebra B L
inst✝¹³ : Algebra A B
inst✝¹² : Algebra K L
inst✝¹¹ : Algebra A L
inst✝¹⁰ : IsScalarTower A K L
inst✝⁹ : IsScalarTower A B L
inst✝⁸ : IsDomain A
inst✝⁷ : IsDomain B
inst✝⁶ : IsFractionRing A K
inst✝⁵ : IsIntegralClosure B A L
inst✝⁴ : IsFractionRing B L
inst✝³ : FiniteDimensional K L
inst✝² : IsSeparable K L
inst✝¹ : IsIntegrallyClosed A
inst✝ : IsDedekindDomain B
I J : FractionalIdeal B⁰ L
hI : I ≠ 0
hJ : J ≠ 0
⊢ 1 ≠ 0
state_after: no goals
Theorem: Lagrange.eval_basis_of_ne
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: simp_rw [Lagrange.basis, eval_prod, prod_eq_zero_iff]
state_before: F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s : Finset ι
v : ι → F
i j : ι
hij : i ≠ j
hj : j ∈ s
⊢ eval (v j) (Lagrange.basis s v i) = 0
state_after: F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s : Finset ι
v : ι → F
i j : ι
hij : i ≠ j
hj : j ∈ s
⊢ ∃ a ∈ s.erase i, eval (v j) (basisDivisor (v i) (v a)) = 0

tactic: exact ⟨j, ⟨mem_erase.mpr ⟨hij.symm, hj⟩, eval_basisDivisor_right⟩⟩
state_before: F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s : Finset ι
v : ι → F
i j : ι
hij : i ≠ j
hj : j ∈ s
⊢ ∃ a ∈ s.erase i, eval (v j) (basisDivisor (v i) (v a)) = 0
state_after: no goals
Theorem: Fin.map_valEmbedding_Ioc
File: Mathlib/Order/Interval/Finset/Fin.lean

tactic: simp [Ioc_eq_finset_subtype, Finset.fin, Finset.map_map, Ioc_filter_lt_of_lt_right]
state_before: n : ℕ
a b : Fin n
⊢ map valEmbedding (Ioc a b) = Ioc ↑a ↑b
state_after: no goals
Theorem: IsPGroup.to_sup_of_normal_right
File: Mathlib/GroupTheory/PGroup.lean

tactic: rw [← QuotientGroup.ker_mk' K, ← Subgroup.comap_map_eq]
state_before: p : ℕ
G : Type u_1
inst✝¹ : Group G
H K : Subgroup G
hH : IsPGroup p ↥H
hK : IsPGroup p ↥K
inst✝ : K.Normal
⊢ IsPGroup p ↥(H ⊔ K)
state_after: p : ℕ
G : Type u_1
inst✝¹ : Group G
H K : Subgroup G
hH : IsPGroup p ↥H
hK : IsPGroup p ↥K
inst✝ : K.Normal
⊢ IsPGroup p ↥(Subgroup.comap (QuotientGroup.mk' K) (Subgroup.map (QuotientGroup.mk' K) H))

tactic: apply (hH.map (QuotientGroup.mk' K)).comap_of_ker_isPGroup
state_before: p : ℕ
G : Type u_1
inst✝¹ : Group G
H K : Subgroup G
hH : IsPGroup p ↥H
hK : IsPGroup p ↥K
inst✝ : K.Normal
⊢ IsPGroup p ↥(Subgroup.comap (QuotientGroup.mk' K) (Subgroup.map (QuotientGroup.mk' K) H))
state_after: case hϕ
p : ℕ
G : Type u_1
inst✝¹ : Group G
H K : Subgroup G
hH : IsPGroup p ↥H
hK : IsPGroup p ↥K
inst✝ : K.Normal
⊢ IsPGroup p ↥(QuotientGroup.mk' K).ker

tactic: rwa [QuotientGroup.ker_mk']
state_before: case hϕ
p : ℕ
G : Type u_1
inst✝¹ : Group G
H K : Subgroup G
hH : IsPGroup p ↥H
hK : IsPGroup p ↥K
inst✝ : K.Normal
⊢ IsPGroup p ↥(QuotientGroup.mk' K).ker
state_after: no goals
Theorem: HasDerivWithinAt.div_const
File: Mathlib/Analysis/Calculus/Deriv/Mul.lean

tactic: simpa only [div_eq_mul_inv] using hc.mul_const d⁻¹
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
E : Type w
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
G : Type u_1
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_2
inst✝¹ : NontriviallyNormedField 𝕜'
inst✝ : NormedAlgebra 𝕜 𝕜'
c d✝ : 𝕜 → 𝕜'
c' d' : 𝕜'
hc : HasDerivWithinAt c c' s x
d : 𝕜'
⊢ HasDerivWithinAt (fun x => c x / d) (c' / d) s x
state_after: no goals
Theorem: Continuous.div
File: Mathlib/Topology/Algebra/GroupWithZero.lean

tactic: simpa only [div_eq_mul_inv] using hf.mul (hg.inv₀ h₀)
state_before: α : Type u_1
β : Type u_2
G₀ : Type u_3
inst✝⁵ : GroupWithZero G₀
inst✝⁴ : TopologicalSpace G₀
inst✝³ : HasContinuousInv₀ G₀
inst✝² : ContinuousMul G₀
f g : α → G₀
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s : Set α
a : α
hf : Continuous f
hg : Continuous g
h₀ : ∀ (x : α), g x ≠ 0
⊢ Continuous (f / g)
state_after: no goals
Theorem: Complex.continuousAt_arg
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: have h₀ : abs x ≠ 0 := by
  rw [abs.ne_zero_iff]
  exact slitPlane_ne_zero h
state_before: a x z : ℂ
h : x ∈ slitPlane
⊢ ContinuousAt arg x
state_after: a x z : ℂ
h : x ∈ slitPlane
h₀ : abs x ≠ 0
⊢ ContinuousAt arg x

tactic: rw [mem_slitPlane_iff, ← lt_or_lt_iff_ne] at h
state_before: a x z : ℂ
h : x ∈ slitPlane
h₀ : abs x ≠ 0
⊢ ContinuousAt arg x
state_after: a x z : ℂ
h : 0 < x.re ∨ x.im < 0 ∨ 0 < x.im
h₀ : abs x ≠ 0
⊢ ContinuousAt arg x

tactic: rcases h with (hx_re | hx_im | hx_im)
state_before: a x z : ℂ
h : 0 < x.re ∨ x.im < 0 ∨ 0 < x.im
h₀ : abs x ≠ 0
⊢ ContinuousAt arg x
state_after: case inl
a x z : ℂ
h₀ : abs x ≠ 0
hx_re : 0 < x.re
⊢ ContinuousAt arg x

case inr.inl
a x z : ℂ
h₀ : abs x ≠ 0
hx_im : x.im < 0
⊢ ContinuousAt arg x

case inr.inr
a x z : ℂ
h₀ : abs x ≠ 0
hx_im : 0 < x.im
⊢ ContinuousAt arg x

tactic: exacts [(Real.continuousAt_arcsin.comp
        (continuous_im.continuousAt.div continuous_abs.continuousAt h₀)).congr
    (arg_eq_nhds_of_re_pos hx_re).symm,
  (Real.continuous_arccos.continuousAt.comp
          (continuous_re.continuousAt.div continuous_abs.continuousAt h₀)).neg.congr
    (arg_eq_nhds_of_im_neg hx_im).symm,
  (Real.continuous_arccos.continuousAt.comp
        (continuous_re.continuousAt.div continuous_abs.continuousAt h₀)).congr
    (arg_eq_nhds_of_im_pos hx_im).symm]
state_before: case inl
a x z : ℂ
h₀ : abs x ≠ 0
hx_re : 0 < x.re
⊢ ContinuousAt arg x

case inr.inl
a x z : ℂ
h₀ : abs x ≠ 0
hx_im : x.im < 0
⊢ ContinuousAt arg x

case inr.inr
a x z : ℂ
h₀ : abs x ≠ 0
hx_im : 0 < x.im
⊢ ContinuousAt arg x
state_after: no goals

tactic: rw [abs.ne_zero_iff]
state_before: a x z : ℂ
h : x ∈ slitPlane
⊢ abs x ≠ 0
state_after: a x z : ℂ
h : x ∈ slitPlane
⊢ x ≠ 0

tactic: exact slitPlane_ne_zero h
state_before: a x z : ℂ
h : x ∈ slitPlane
⊢ x ≠ 0
state_after: no goals
Theorem: Orientation.rightAngleRotation_rightAngleRotation
File: Mathlib/Analysis/InnerProductSpace/TwoDim.lean

tactic: rw [rightAngleRotation]
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x : E
⊢ o.rightAngleRotation (o.rightAngleRotation x) = -x
state_after: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x : E
⊢ (LinearIsometryEquiv.ofLinearIsometry o.rightAngleRotationAux₂ (-o.rightAngleRotationAux₁) ⋯ ⋯)
      ((LinearIsometryEquiv.ofLinearIsometry o.rightAngleRotationAux₂ (-o.rightAngleRotationAux₁) ⋯ ⋯) x) =
    -x

tactic: exact o.rightAngleRotationAux₁_rightAngleRotationAux₁ x
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x : E
⊢ (LinearIsometryEquiv.ofLinearIsometry o.rightAngleRotationAux₂ (-o.rightAngleRotationAux₁) ⋯ ⋯)
      ((LinearIsometryEquiv.ofLinearIsometry o.rightAngleRotationAux₂ (-o.rightAngleRotationAux₁) ⋯ ⋯) x) =
    -x
state_after: no goals
Theorem: compare_iff
File: Mathlib/Init/Order/Defs.lean

tactic: cases o <;> simp only [Ordering.toRel]
state_before: α : Type u
inst✝ : LinearOrder α
a b : α
o : Ordering
⊢ compare a b = o ↔ o.toRel a b
state_after: case lt
α : Type u
inst✝ : LinearOrder α
a b : α
⊢ compare a b = Ordering.lt ↔ a < b

case eq
α : Type u
inst✝ : LinearOrder α
a b : α
⊢ compare a b = Ordering.eq ↔ a = b

case gt
α : Type u
inst✝ : LinearOrder α
a b : α
⊢ compare a b = Ordering.gt ↔ a > b

tactic: exact compare_lt_iff_lt
state_before: case lt
α : Type u
inst✝ : LinearOrder α
a b : α
⊢ compare a b = Ordering.lt ↔ a < b
state_after: no goals

tactic: exact compare_eq_iff_eq
state_before: case eq
α : Type u
inst✝ : LinearOrder α
a b : α
⊢ compare a b = Ordering.eq ↔ a = b
state_after: no goals

tactic: exact compare_gt_iff_gt
state_before: case gt
α : Type u
inst✝ : LinearOrder α
a b : α
⊢ compare a b = Ordering.gt ↔ a > b
state_after: no goals
Theorem: ZMod.natCast_natAbs_valMinAbs
File: Mathlib/Data/ZMod/Basic.lean

tactic: have : (a.val : ℤ) - n ≤ 0 := by
  erw [sub_nonpos, Int.ofNat_le]
  exact a.val_le
state_before: n : ℕ
inst✝ : NeZero n
a : ZMod n
⊢ ↑a.valMinAbs.natAbs = if a.val ≤ n / 2 then a else -a
state_after: n : ℕ
inst✝ : NeZero n
a : ZMod n
this : ↑a.val - ↑n ≤ 0
⊢ ↑a.valMinAbs.natAbs = if a.val ≤ n / 2 then a else -a

tactic: rw [valMinAbs_def_pos]
state_before: n : ℕ
inst✝ : NeZero n
a : ZMod n
this : ↑a.val - ↑n ≤ 0
⊢ ↑a.valMinAbs.natAbs = if a.val ≤ n / 2 then a else -a
state_after: n : ℕ
inst✝ : NeZero n
a : ZMod n
this : ↑a.val - ↑n ≤ 0
⊢ ↑(if a.val ≤ n / 2 then ↑a.val else ↑a.val - ↑n).natAbs = if a.val ≤ n / 2 then a else -a

tactic: split_ifs
state_before: n : ℕ
inst✝ : NeZero n
a : ZMod n
this : ↑a.val - ↑n ≤ 0
⊢ ↑(if a.val ≤ n / 2 then ↑a.val else ↑a.val - ↑n).natAbs = if a.val ≤ n / 2 then a else -a
state_after: case pos
n : ℕ
inst✝ : NeZero n
a : ZMod n
this : ↑a.val - ↑n ≤ 0
h✝ : a.val ≤ n / 2
⊢ ↑(↑a.val).natAbs = a

case neg
n : ℕ
inst✝ : NeZero n
a : ZMod n
this : ↑a.val - ↑n ≤ 0
h✝ : ¬a.val ≤ n / 2
⊢ ↑(↑a.val - ↑n).natAbs = -a

tactic: erw [sub_nonpos, Int.ofNat_le]
state_before: n : ℕ
inst✝ : NeZero n
a : ZMod n
⊢ ↑a.val - ↑n ≤ 0
state_after: n : ℕ
inst✝ : NeZero n
a : ZMod n
⊢ a.val ≤ n

tactic: exact a.val_le
state_before: n : ℕ
inst✝ : NeZero n
a : ZMod n
⊢ a.val ≤ n
state_after: no goals

tactic: rw [Int.natAbs_ofNat, natCast_zmod_val]
state_before: case pos
n : ℕ
inst✝ : NeZero n
a : ZMod n
this : ↑a.val - ↑n ≤ 0
h✝ : a.val ≤ n / 2
⊢ ↑(↑a.val).natAbs = a
state_after: no goals

tactic: rw [← Int.cast_natCast, Int.ofNat_natAbs_of_nonpos this, Int.cast_neg, Int.cast_sub,
  Int.cast_natCast, Int.cast_natCast, natCast_self, sub_zero, natCast_zmod_val]
state_before: case neg
n : ℕ
inst✝ : NeZero n
a : ZMod n
this : ↑a.val - ↑n ≤ 0
h✝ : ¬a.val ≤ n / 2
⊢ ↑(↑a.val - ↑n).natAbs = -a
state_after: no goals
Theorem: AlgebraicClosure.toStepOfLE'.succ
File: Mathlib/FieldTheory/IsAlgClosed/AlgebraicClosure.lean

tactic: ext x
state_before: k : Type u
inst✝ : Field k
m n : ℕ
h : m ≤ n
⊢ AlgebraicClosure.toStepOfLE' k m n.succ ⋯ = ⇑(toStepSucc k n) ∘ AlgebraicClosure.toStepOfLE' k m n h
state_after: case h
k : Type u
inst✝ : Field k
m n : ℕ
h : m ≤ n
x : Step k m
⊢ AlgebraicClosure.toStepOfLE' k m n.succ ⋯ x = (⇑(toStepSucc k n) ∘ AlgebraicClosure.toStepOfLE' k m n h) x

tactic: convert Nat.leRecOn_succ h x
state_before: case h
k : Type u
inst✝ : Field k
m n : ℕ
h : m ≤ n
x : Step k m
⊢ AlgebraicClosure.toStepOfLE' k m n.succ ⋯ x = (⇑(toStepSucc k n) ∘ AlgebraicClosure.toStepOfLE' k m n h) x
state_after: case h.convert_1
k : Type u
inst✝ : Field k
m n : ℕ
h : m ≤ n
x : Step k m
⊢ m ≤ n + 1

tactic: exact h.trans n.le_succ
state_before: case h.convert_1
k : Type u
inst✝ : Field k
m n : ℕ
h : m ≤ n
x : Step k m
⊢ m ≤ n + 1
state_after: no goals