1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: spectrum.map_inv
File: Mathlib/Algebra/Algebra/Spectrum.lean

tactic: refine Set.eq_of_subset_of_subset (fun k hk => ?_) fun k hk => ?_
state_before: 𝕜 : Type u
A : Type v
inst✝² : Field 𝕜
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
a : Aˣ
⊢ (σ ↑a)⁻¹ = σ ↑a⁻¹
state_after: case refine_1
𝕜 : Type u
A : Type v
inst✝² : Field 𝕜
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
a : Aˣ
k : 𝕜
hk : k ∈ (σ ↑a)⁻¹
⊢ k ∈ σ ↑a⁻¹

case refine_2
𝕜 : Type u
A : Type v
inst✝² : Field 𝕜
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
a : Aˣ
k : 𝕜
hk : k ∈ σ ↑a⁻¹
⊢ k ∈ (σ ↑a)⁻¹

tactic: rw [Set.mem_inv] at hk
state_before: case refine_1
𝕜 : Type u
A : Type v
inst✝² : Field 𝕜
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
a : Aˣ
k : 𝕜
hk : k ∈ (σ ↑a)⁻¹
⊢ k ∈ σ ↑a⁻¹
state_after: case refine_1
𝕜 : Type u
A : Type v
inst✝² : Field 𝕜
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
a : Aˣ
k : 𝕜
hk : k⁻¹ ∈ σ ↑a
⊢ k ∈ σ ↑a⁻¹

tactic: have : k ≠ 0 := by simpa only [inv_inv] using inv_ne_zero (ne_zero_of_mem_of_unit hk)
state_before: case refine_1
𝕜 : Type u
A : Type v
inst✝² : Field 𝕜
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
a : Aˣ
k : 𝕜
hk : k⁻¹ ∈ σ ↑a
⊢ k ∈ σ ↑a⁻¹
state_after: case refine_1
𝕜 : Type u
A : Type v
inst✝² : Field 𝕜
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
a : Aˣ
k : 𝕜
hk : k⁻¹ ∈ σ ↑a
this : k ≠ 0
⊢ k ∈ σ ↑a⁻¹

tactic: lift k to 𝕜ˣ using isUnit_iff_ne_zero.mpr this
state_before: case refine_1
𝕜 : Type u
A : Type v
inst✝² : Field 𝕜
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
a : Aˣ
k : 𝕜
hk : k⁻¹ ∈ σ ↑a
this : k ≠ 0
⊢ k ∈ σ ↑a⁻¹
state_after: case refine_1.intro
𝕜 : Type u
A : Type v
inst✝² : Field 𝕜
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
a : Aˣ
k : 𝕜ˣ
hk : (↑k)⁻¹ ∈ σ ↑a
this : ↑k ≠ 0
⊢ ↑k ∈ σ ↑a⁻¹

tactic: rw [← Units.val_inv_eq_inv_val k] at hk
state_before: case refine_1.intro
𝕜 : Type u
A : Type v
inst✝² : Field 𝕜
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
a : Aˣ
k : 𝕜ˣ
hk : (↑k)⁻¹ ∈ σ ↑a
this : ↑k ≠ 0
⊢ ↑k ∈ σ ↑a⁻¹
state_after: case refine_1.intro
𝕜 : Type u
A : Type v
inst✝² : Field 𝕜
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
a : Aˣ
k : 𝕜ˣ
hk : ↑k⁻¹ ∈ σ ↑a
this : ↑k ≠ 0
⊢ ↑k ∈ σ ↑a⁻¹

tactic: exact inv_mem_iff.mp hk
state_before: case refine_1.intro
𝕜 : Type u
A : Type v
inst✝² : Field 𝕜
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
a : Aˣ
k : 𝕜ˣ
hk : ↑k⁻¹ ∈ σ ↑a
this : ↑k ≠ 0
⊢ ↑k ∈ σ ↑a⁻¹
state_after: no goals

tactic: simpa only [inv_inv] using inv_ne_zero (ne_zero_of_mem_of_unit hk)
state_before: 𝕜 : Type u
A : Type v
inst✝² : Field 𝕜
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
a : Aˣ
k : 𝕜
hk : k⁻¹ ∈ σ ↑a
⊢ k ≠ 0
state_after: no goals

tactic: lift k to 𝕜ˣ using isUnit_iff_ne_zero.mpr (ne_zero_of_mem_of_unit hk)
state_before: case refine_2
𝕜 : Type u
A : Type v
inst✝² : Field 𝕜
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
a : Aˣ
k : 𝕜
hk : k ∈ σ ↑a⁻¹
⊢ k ∈ (σ ↑a)⁻¹
state_after: case refine_2.intro
𝕜 : Type u
A : Type v
inst✝² : Field 𝕜
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
a : Aˣ
k : 𝕜ˣ
hk : ↑k ∈ σ ↑a⁻¹
⊢ ↑k ∈ (σ ↑a)⁻¹

tactic: simpa only [Units.val_inv_eq_inv_val] using inv_mem_iff.mp hk
state_before: case refine_2.intro
𝕜 : Type u
A : Type v
inst✝² : Field 𝕜
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
a : Aˣ
k : 𝕜ˣ
hk : ↑k ∈ σ ↑a⁻¹
⊢ ↑k ∈ (σ ↑a)⁻¹
state_after: no goals
Theorem: Matrix.vecMul_neg
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝¹ : NonUnitalNonAssocRing α
inst✝ : Fintype m
v : m → α
A : Matrix m n α
⊢ v ᵥ* -A = -(v ᵥ* A)
state_after: case h
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝¹ : NonUnitalNonAssocRing α
inst✝ : Fintype m
v : m → α
A : Matrix m n α
x✝ : n
⊢ (v ᵥ* -A) x✝ = (-(v ᵥ* A)) x✝

tactic: apply dotProduct_neg
state_before: case h
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝¹ : NonUnitalNonAssocRing α
inst✝ : Fintype m
v : m → α
A : Matrix m n α
x✝ : n
⊢ (v ᵥ* -A) x✝ = (-(v ᵥ* A)) x✝
state_after: no goals
Theorem: MeasurableSpace.measurable_invariants_of_semiconj
File: Mathlib/MeasureTheory/MeasurableSpace/Invariants.lean

tactic: rw [← preimage_comp, hfg.comp_eq, preimage_comp, hs.2]
state_before: α : Type u_1
inst✝¹ : MeasurableSpace α
β : Type u_2
inst✝ : MeasurableSpace β
fa : α → α
fb : β → β
g : α → β
hg : Measurable g
hfg : Semiconj g fa fb
s : Set β
hs : MeasurableSet s
⊢ fa ⁻¹' (g ⁻¹' s) = g ⁻¹' s
state_after: no goals
Theorem: Filter.Germ.lt_def
File: Mathlib/Order/Filter/FilterProduct.lean

tactic: ext ⟨f⟩ ⟨g⟩
state_before: α : Type u
β : Type v
φ : Ultrafilter α
inst✝ : Preorder β
⊢ (fun x x_1 => x < x_1) = LiftRel fun x x_1 => x < x_1
state_after: case h.mk.h.mk.a
α : Type u
β : Type v
φ : Ultrafilter α
inst✝ : Preorder β
x✝¹ : (↑φ).Germ β
f : α → β
x✝ : (↑φ).Germ β
g : α → β
⊢ Quot.mk Setoid.r f < Quot.mk Setoid.r g ↔ LiftRel (fun x x_1 => x < x_1) (Quot.mk Setoid.r f) (Quot.mk Setoid.r g)

tactic: exact coe_lt
state_before: case h.mk.h.mk.a
α : Type u
β : Type v
φ : Ultrafilter α
inst✝ : Preorder β
x✝¹ : (↑φ).Germ β
f : α → β
x✝ : (↑φ).Germ β
g : α → β
⊢ Quot.mk Setoid.r f < Quot.mk Setoid.r g ↔ LiftRel (fun x x_1 => x < x_1) (Quot.mk Setoid.r f) (Quot.mk Setoid.r g)
state_after: no goals
Theorem: Filter.blimsup_mono
File: Mathlib/Order/LiminfLimsup.lean

tactic: tauto
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝ : CompleteLattice α
f g : Filter β
p q : β → Prop
u v : β → α
h : ∀ (x : β), p x → q x
a : α
ha : a ∈ {a | ∀ᶠ (x : β) in f, q x → u x ≤ a}
⊢ ∀ (x : β), (q x → u x ≤ a) → p x → u x ≤ a
state_after: no goals
Theorem: HahnSeries.mul_coeff_order_add_order
File: Mathlib/RingTheory/HahnSeries/Multiplication.lean

tactic: by_cases hx : x = 0
state_before: Γ✝ : Type u_1
Γ' : Type u_2
R : Type u_3
inst✝² : OrderedCancelAddCommMonoid Γ✝
Γ : Type u_4
inst✝¹ : LinearOrderedCancelAddCommMonoid Γ
inst✝ : NonUnitalNonAssocSemiring R
x y : HahnSeries Γ R
⊢ (x * y).coeff (x.order + y.order) = x.coeff x.order * y.coeff y.order
state_after: case pos
Γ✝ : Type u_1
Γ' : Type u_2
R : Type u_3
inst✝² : OrderedCancelAddCommMonoid Γ✝
Γ : Type u_4
inst✝¹ : LinearOrderedCancelAddCommMonoid Γ
inst✝ : NonUnitalNonAssocSemiring R
x y : HahnSeries Γ R
hx : x = 0
⊢ (x * y).coeff (x.order + y.order) = x.coeff x.order * y.coeff y.order

case neg
Γ✝ : Type u_1
Γ' : Type u_2
R : Type u_3
inst✝² : OrderedCancelAddCommMonoid Γ✝
Γ : Type u_4
inst✝¹ : LinearOrderedCancelAddCommMonoid Γ
inst✝ : NonUnitalNonAssocSemiring R
x y : HahnSeries Γ R
hx : ¬x = 0
⊢ (x * y).coeff (x.order + y.order) = x.coeff x.order * y.coeff y.order

tactic: by_cases hy : y = 0
state_before: case neg
Γ✝ : Type u_1
Γ' : Type u_2
R : Type u_3
inst✝² : OrderedCancelAddCommMonoid Γ✝
Γ : Type u_4
inst✝¹ : LinearOrderedCancelAddCommMonoid Γ
inst✝ : NonUnitalNonAssocSemiring R
x y : HahnSeries Γ R
hx : ¬x = 0
⊢ (x * y).coeff (x.order + y.order) = x.coeff x.order * y.coeff y.order
state_after: case pos
Γ✝ : Type u_1
Γ' : Type u_2
R : Type u_3
inst✝² : OrderedCancelAddCommMonoid Γ✝
Γ : Type u_4
inst✝¹ : LinearOrderedCancelAddCommMonoid Γ
inst✝ : NonUnitalNonAssocSemiring R
x y : HahnSeries Γ R
hx : ¬x = 0
hy : y = 0
⊢ (x * y).coeff (x.order + y.order) = x.coeff x.order * y.coeff y.order

case neg
Γ✝ : Type u_1
Γ' : Type u_2
R : Type u_3
inst✝² : OrderedCancelAddCommMonoid Γ✝
Γ : Type u_4
inst✝¹ : LinearOrderedCancelAddCommMonoid Γ
inst✝ : NonUnitalNonAssocSemiring R
x y : HahnSeries Γ R
hx : ¬x = 0
hy : ¬y = 0
⊢ (x * y).coeff (x.order + y.order) = x.coeff x.order * y.coeff y.order

tactic: rw [order_of_ne hx, order_of_ne hy, mul_coeff, Finset.addAntidiagonal_min_add_min,
  Finset.sum_singleton]
state_before: case neg
Γ✝ : Type u_1
Γ' : Type u_2
R : Type u_3
inst✝² : OrderedCancelAddCommMonoid Γ✝
Γ : Type u_4
inst✝¹ : LinearOrderedCancelAddCommMonoid Γ
inst✝ : NonUnitalNonAssocSemiring R
x y : HahnSeries Γ R
hx : ¬x = 0
hy : ¬y = 0
⊢ (x * y).coeff (x.order + y.order) = x.coeff x.order * y.coeff y.order
state_after: no goals

tactic: simp [hx, mul_coeff]
state_before: case pos
Γ✝ : Type u_1
Γ' : Type u_2
R : Type u_3
inst✝² : OrderedCancelAddCommMonoid Γ✝
Γ : Type u_4
inst✝¹ : LinearOrderedCancelAddCommMonoid Γ
inst✝ : NonUnitalNonAssocSemiring R
x y : HahnSeries Γ R
hx : x = 0
⊢ (x * y).coeff (x.order + y.order) = x.coeff x.order * y.coeff y.order
state_after: no goals

tactic: simp [hy, mul_coeff]
state_before: case pos
Γ✝ : Type u_1
Γ' : Type u_2
R : Type u_3
inst✝² : OrderedCancelAddCommMonoid Γ✝
Γ : Type u_4
inst✝¹ : LinearOrderedCancelAddCommMonoid Γ
inst✝ : NonUnitalNonAssocSemiring R
x y : HahnSeries Γ R
hx : ¬x = 0
hy : y = 0
⊢ (x * y).coeff (x.order + y.order) = x.coeff x.order * y.coeff y.order
state_after: no goals
Theorem: ArithmeticFunction.IsMultiplicative.pdiv
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: simp [hf, hg]
state_before: R : Type u_1
inst✝ : CommGroupWithZero R
f g : ArithmeticFunction R
hf : f.IsMultiplicative
hg : g.IsMultiplicative
⊢ (f.pdiv g) 1 = 1
state_after: no goals

tactic: simp only [pdiv_apply, map_mul_of_coprime hf cop, map_mul_of_coprime hg cop,
  div_eq_mul_inv, mul_inv]
state_before: R : Type u_1
inst✝ : CommGroupWithZero R
f g : ArithmeticFunction R
hf : f.IsMultiplicative
hg : g.IsMultiplicative
m n : ℕ
cop : m.Coprime n
⊢ (f.pdiv g) (m * n) = (f.pdiv g) m * (f.pdiv g) n
state_after: R : Type u_1
inst✝ : CommGroupWithZero R
f g : ArithmeticFunction R
hf : f.IsMultiplicative
hg : g.IsMultiplicative
m n : ℕ
cop : m.Coprime n
⊢ f m * f n * ((g m)⁻¹ * (g n)⁻¹) = f m * (g m)⁻¹ * (f n * (g n)⁻¹)

tactic: apply mul_mul_mul_comm
state_before: R : Type u_1
inst✝ : CommGroupWithZero R
f g : ArithmeticFunction R
hf : f.IsMultiplicative
hg : g.IsMultiplicative
m n : ℕ
cop : m.Coprime n
⊢ f m * f n * ((g m)⁻¹ * (g n)⁻¹) = f m * (g m)⁻¹ * (f n * (g n)⁻¹)
state_after: no goals
Theorem: Composition.index_exists
File: Mathlib/Combinatorics/Enumerative/Composition.lean

tactic: have n_pos : 0 < n := lt_of_le_of_lt (zero_le j) h
state_before: n : ℕ
c : Composition n
j : ℕ
h : j < n
⊢ ∃ i, j < c.sizeUpTo (i + 1) ∧ i < c.length
state_after: n : ℕ
c : Composition n
j : ℕ
h : j < n
n_pos : 0 < n
⊢ ∃ i, j < c.sizeUpTo (i + 1) ∧ i < c.length

tactic: have : 0 < c.blocks.sum := by rwa [← c.blocks_sum] at n_pos
state_before: n : ℕ
c : Composition n
j : ℕ
h : j < n
n_pos : 0 < n
⊢ ∃ i, j < c.sizeUpTo (i + 1) ∧ i < c.length
state_after: n : ℕ
c : Composition n
j : ℕ
h : j < n
n_pos : 0 < n
this : 0 < c.blocks.sum
⊢ ∃ i, j < c.sizeUpTo (i + 1) ∧ i < c.length

tactic: have length_pos : 0 < c.blocks.length := length_pos_of_sum_pos (blocks c) this
state_before: n : ℕ
c : Composition n
j : ℕ
h : j < n
n_pos : 0 < n
this : 0 < c.blocks.sum
⊢ ∃ i, j < c.sizeUpTo (i + 1) ∧ i < c.length
state_after: n : ℕ
c : Composition n
j : ℕ
h : j < n
n_pos : 0 < n
this : 0 < c.blocks.sum
length_pos : 0 < c.blocks.length
⊢ ∃ i, j < c.sizeUpTo (i + 1) ∧ i < c.length

tactic: refine ⟨c.length - 1, ?_, Nat.pred_lt (ne_of_gt length_pos)⟩
state_before: n : ℕ
c : Composition n
j : ℕ
h : j < n
n_pos : 0 < n
this : 0 < c.blocks.sum
length_pos : 0 < c.blocks.length
⊢ ∃ i, j < c.sizeUpTo (i + 1) ∧ i < c.length
state_after: n : ℕ
c : Composition n
j : ℕ
h : j < n
n_pos : 0 < n
this : 0 < c.blocks.sum
length_pos : 0 < c.blocks.length
⊢ j < c.sizeUpTo (c.length - 1 + 1)

tactic: have : c.length - 1 + 1 = c.length := Nat.succ_pred_eq_of_pos length_pos
state_before: n : ℕ
c : Composition n
j : ℕ
h : j < n
n_pos : 0 < n
this : 0 < c.blocks.sum
length_pos : 0 < c.blocks.length
⊢ j < c.sizeUpTo (c.length - 1 + 1)
state_after: n : ℕ
c : Composition n
j : ℕ
h : j < n
n_pos : 0 < n
this✝ : 0 < c.blocks.sum
length_pos : 0 < c.blocks.length
this : c.length - 1 + 1 = c.length
⊢ j < c.sizeUpTo (c.length - 1 + 1)

tactic: simp [this, h]
state_before: n : ℕ
c : Composition n
j : ℕ
h : j < n
n_pos : 0 < n
this✝ : 0 < c.blocks.sum
length_pos : 0 < c.blocks.length
this : c.length - 1 + 1 = c.length
⊢ j < c.sizeUpTo (c.length - 1 + 1)
state_after: no goals

tactic: rwa [← c.blocks_sum] at n_pos
state_before: n : ℕ
c : Composition n
j : ℕ
h : j < n
n_pos : 0 < n
⊢ 0 < c.blocks.sum
state_after: no goals
Theorem: Nat.divisors_zero
File: Mathlib/NumberTheory/Divisors.lean

tactic: ext
state_before: n : ℕ
⊢ divisors 0 = ∅
state_after: case a
n a✝ : ℕ
⊢ a✝ ∈ divisors 0 ↔ a✝ ∈ ∅

tactic: simp
state_before: case a
n a✝ : ℕ
⊢ a✝ ∈ divisors 0 ↔ a✝ ∈ ∅
state_after: no goals
Theorem: descPochhammer_int_eq_ascFactorial
File: Mathlib/RingTheory/Polynomial/Pochhammer.lean

tactic: rw [← Nat.cast_add, descPochhammer_eval_eq_descFactorial ℤ (a + b) b,
  Nat.add_descFactorial_eq_ascFactorial]
state_before: R : Type u
inst✝ : Ring R
a b : ℕ
⊢ eval (↑a + ↑b) (descPochhammer ℤ b) = ↑((a + 1).ascFactorial b)
state_after: no goals
Theorem: NumberField.InfinitePlace.IsUnramified.of_restrictScalars
File: Mathlib/NumberTheory/NumberField/Embeddings.lean

tactic: rw [InfinitePlace.isUnramified_iff_mult_le, ← h.eq, IsScalarTower.algebraMap_eq k K F,
  InfinitePlace.comap_comp]
state_before: k : Type u_1
inst✝⁷ : Field k
K : Type u_2
inst✝⁶ : Field K
F : Type u_3
inst✝⁵ : Field F
inst✝⁴ : NumberField K
inst✝³ : Algebra k K
inst✝² : Algebra k F
inst✝¹ : Algebra K F
inst✝ : IsScalarTower k K F
σ : K ≃ₐ[k] K
w✝ : InfinitePlace K
w : InfinitePlace F
h : IsUnramified k w
⊢ IsUnramified K w
state_after: k : Type u_1
inst✝⁷ : Field k
K : Type u_2
inst✝⁶ : Field K
F : Type u_3
inst✝⁵ : Field F
inst✝⁴ : NumberField K
inst✝³ : Algebra k K
inst✝² : Algebra k F
inst✝¹ : Algebra K F
inst✝ : IsScalarTower k K F
σ : K ≃ₐ[k] K
w✝ : InfinitePlace K
w : InfinitePlace F
h : IsUnramified k w
⊢ ((w.comap (algebraMap K F)).comap (algebraMap k K)).mult ≤ (w.comap (algebraMap K F)).mult

tactic: exact InfinitePlace.mult_comap_le _ _
state_before: k : Type u_1
inst✝⁷ : Field k
K : Type u_2
inst✝⁶ : Field K
F : Type u_3
inst✝⁵ : Field F
inst✝⁴ : NumberField K
inst✝³ : Algebra k K
inst✝² : Algebra k F
inst✝¹ : Algebra K F
inst✝ : IsScalarTower k K F
σ : K ≃ₐ[k] K
w✝ : InfinitePlace K
w : InfinitePlace F
h : IsUnramified k w
⊢ ((w.comap (algebraMap K F)).comap (algebraMap k K)).mult ≤ (w.comap (algebraMap K F)).mult
state_after: no goals
Theorem: Matroid.restrict_eq_freeOn_iff
File: Mathlib/Data/Matroid/Constructions.lean

tactic: rw [eq_freeOn_iff, and_iff_right M.restrict_ground_eq, restrict_indep_iff,
  and_iff_left Subset.rfl]
state_before: α : Type u_1
M : Matroid α
E B I X R J : Set α
⊢ M ↾ I = freeOn I ↔ M.Indep I
state_after: no goals
Theorem: zero_zpow
File: Mathlib/Algebra/GroupWithZero/Basic.lean

tactic: rw [zpow_natCast, zero_pow]
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : GroupWithZero G₀
a b c : G₀
n : ℕ
h : ↑n ≠ 0
⊢ 0 ^ ↑n = 0
state_after: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : GroupWithZero G₀
a b c : G₀
n : ℕ
h : ↑n ≠ 0
⊢ n ≠ 0

tactic: simpa [Int.natCast_eq_zero] using h
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : GroupWithZero G₀
a b c : G₀
n : ℕ
h : ↑n ≠ 0
⊢ n ≠ 0
state_after: no goals

tactic: simp
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : GroupWithZero G₀
a b c : G₀
n : ℕ
x✝ : Int.negSucc n ≠ 0
⊢ 0 ^ Int.negSucc n = 0
state_after: no goals
Theorem: BoundedContinuousFunction.nndist_eq_iSup
File: Mathlib/Topology/ContinuousFunction/Bounded.lean

tactic: simp_rw [val_eq_coe, coe_iSup, coe_nndist]
state_before: F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : PseudoMetricSpace β
inst✝ : PseudoMetricSpace γ
f g : α →ᵇ β
x : α
C : ℝ
⊢ ⨆ x, dist (f x) (g x) = ↑(⨆ x, nndist (f x) (g x))
state_after: no goals
Theorem: Complex.hasStrictDerivAt_sin
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean

tactic: simp only [cos, div_eq_mul_inv]
state_before: x : ℂ
⊢ HasStrictDerivAt sin (cos x) x
state_after: x : ℂ
⊢ HasStrictDerivAt sin ((cexp (x * I) + cexp (-x * I)) * 2⁻¹) x

tactic: convert ((((hasStrictDerivAt_id x).neg.mul_const I).cexp.sub
  ((hasStrictDerivAt_id x).mul_const I).cexp).mul_const I).mul_const (2 : ℂ)⁻¹ using 1
state_before: x : ℂ
⊢ HasStrictDerivAt sin ((cexp (x * I) + cexp (-x * I)) * 2⁻¹) x
state_after: case h.e'_7
x : ℂ
⊢ (cexp (x * I) + cexp (-x * I)) * 2⁻¹ = (cexp (-id x * I) * (-1 * I) - cexp (id x * I) * (1 * I)) * I * 2⁻¹

tactic: simp only [Function.comp, id]
state_before: case h.e'_7
x : ℂ
⊢ (cexp (x * I) + cexp (-x * I)) * 2⁻¹ = (cexp (-id x * I) * (-1 * I) - cexp (id x * I) * (1 * I)) * I * 2⁻¹
state_after: case h.e'_7
x : ℂ
⊢ (cexp (x * I) + cexp (-x * I)) * 2⁻¹ = (cexp (-x * I) * (-1 * I) - cexp (x * I) * (1 * I)) * I * 2⁻¹

tactic: rw [sub_mul, mul_assoc, mul_assoc, I_mul_I, neg_one_mul, neg_neg, mul_one, one_mul, mul_assoc,
  I_mul_I, mul_neg_one, sub_neg_eq_add, add_comm]
state_before: case h.e'_7
x : ℂ
⊢ (cexp (x * I) + cexp (-x * I)) * 2⁻¹ = (cexp (-x * I) * (-1 * I) - cexp (x * I) * (1 * I)) * I * 2⁻¹
state_after: no goals
Theorem: Nat.forall_lt_succ
File: Mathlib/Data/Nat/Defs.lean

tactic: simp only [Nat.lt_succ_iff, Nat.le_iff_lt_or_eq, or_comm, forall_eq_or_imp, and_comm]
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
⊢ (∀ (m : ℕ), m < n + 1 → p m) ↔ (∀ (m : ℕ), m < n → p m) ∧ p n
state_after: no goals
Theorem: CategoryTheory.Idempotents.KaroubiKaroubi.idem_f
File: Mathlib/CategoryTheory/Idempotents/KaroubiKaroubi.lean

tactic: simpa only [hom_ext_iff, comp_f] using P.idem
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
P : Karoubi (Karoubi C)
⊢ P.p.f ≫ P.p.f = P.p.f
state_after: no goals
Theorem: Finset.inter_insert_of_not_mem
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [inter_comm, insert_inter_of_not_mem h, inter_comm]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s s₁✝ s₂✝ t t₁ t₂ u v : Finset α
a✝ b : α
s₁ s₂ : Finset α
a : α
h : a ∉ s₁
⊢ s₁ ∩ insert a s₂ = s₁ ∩ s₂
state_after: no goals
Theorem: Complex.conj_I
File: Mathlib/Data/Complex/Basic.lean

tactic: simp
state_before: ⊢ ((starRingEnd ℂ) I).re = (-I).re ∧ ((starRingEnd ℂ) I).im = (-I).im
state_after: no goals
Theorem: Polynomial.natDegree_divX_eq_natDegree_tsub_one
File: Mathlib/Algebra/Polynomial/Inductions.lean

tactic: apply map_natDegree_eq_sub (φ := divX_hom)
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
p q : R[X]
⊢ p.divX.natDegree = p.natDegree - 1
state_after: case φ_k
R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
p q : R[X]
⊢ ∀ (f : R[X]), f.natDegree < 1 → divX_hom f = 0

case φ_mon
R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
p q : R[X]
⊢ ∀ (n : ℕ) (c : R), c ≠ 0 → (divX_hom ((monomial n) c)).natDegree = n - 1

tactic: intro f
state_before: case φ_k
R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
p q : R[X]
⊢ ∀ (f : R[X]), f.natDegree < 1 → divX_hom f = 0
state_after: case φ_k
R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
p q f : R[X]
⊢ f.natDegree < 1 → divX_hom f = 0

tactic: simpa [divX_hom, divX_eq_zero_iff] using eq_C_of_natDegree_eq_zero
state_before: case φ_k
R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
p q f : R[X]
⊢ f.natDegree < 1 → divX_hom f = 0
state_after: no goals

tactic: intros n c c0
state_before: case φ_mon
R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
p q : R[X]
⊢ ∀ (n : ℕ) (c : R), c ≠ 0 → (divX_hom ((monomial n) c)).natDegree = n - 1
state_after: case φ_mon
R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
c : R
c0 : c ≠ 0
⊢ (divX_hom ((monomial n) c)).natDegree = n - 1

tactic: rw [← C_mul_X_pow_eq_monomial, divX_hom_toFun, divX_C_mul, divX_X_pow]
state_before: case φ_mon
R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
c : R
c0 : c ≠ 0
⊢ (divX_hom ((monomial n) c)).natDegree = n - 1
state_after: case φ_mon
R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
c : R
c0 : c ≠ 0
⊢ (C c * if n = 0 then 0 else X ^ (n - 1)).natDegree = n - 1

tactic: split_ifs with n0
state_before: case φ_mon
R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
c : R
c0 : c ≠ 0
⊢ (C c * if n = 0 then 0 else X ^ (n - 1)).natDegree = n - 1
state_after: case pos
R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
c : R
c0 : c ≠ 0
n0 : n = 0
⊢ (C c * 0).natDegree = n - 1

case neg
R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
c : R
c0 : c ≠ 0
n0 : ¬n = 0
⊢ (C c * X ^ (n - 1)).natDegree = n - 1

tactic: simp [n0]
state_before: case pos
R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
c : R
c0 : c ≠ 0
n0 : n = 0
⊢ (C c * 0).natDegree = n - 1
state_after: no goals

tactic: exact natDegree_C_mul_X_pow (n - 1) c c0
state_before: case neg
R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
c : R
c0 : c ≠ 0
n0 : ¬n = 0
⊢ (C c * X ^ (n - 1)).natDegree = n - 1
state_after: no goals
Theorem: CategoryTheory.comonadToFunctor_mapIso_comonad_iso_mk
File: Mathlib/CategoryTheory/Monad/Basic.lean

tactic: ext
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
T : Monad C
G M N : Comonad C
f : M.toFunctor ≅ N.toFunctor
f_ε : ∀ (X : C), f.hom.app X ≫ N.ε.app X = M.ε.app X
f_δ : ∀ (X : C), f.hom.app X ≫ N.δ.app X = M.δ.app X ≫ f.hom.app (M.obj X) ≫ N.map (f.hom.app X)
⊢ (comonadToFunctor C).mapIso (ComonadIso.mk f f_ε f_δ) = f
state_after: case w.w.h
C : Type u₁
inst✝ : Category.{v₁, u₁} C
T : Monad C
G M N : Comonad C
f : M.toFunctor ≅ N.toFunctor
f_ε : ∀ (X : C), f.hom.app X ≫ N.ε.app X = M.ε.app X
f_δ : ∀ (X : C), f.hom.app X ≫ N.δ.app X = M.δ.app X ≫ f.hom.app (M.obj X) ≫ N.map (f.hom.app X)
x✝ : C
⊢ ((comonadToFunctor C).mapIso (ComonadIso.mk f f_ε f_δ)).hom.app x✝ = f.hom.app x✝

tactic: rfl
state_before: case w.w.h
C : Type u₁
inst✝ : Category.{v₁, u₁} C
T : Monad C
G M N : Comonad C
f : M.toFunctor ≅ N.toFunctor
f_ε : ∀ (X : C), f.hom.app X ≫ N.ε.app X = M.ε.app X
f_δ : ∀ (X : C), f.hom.app X ≫ N.δ.app X = M.δ.app X ≫ f.hom.app (M.obj X) ≫ N.map (f.hom.app X)
x✝ : C
⊢ ((comonadToFunctor C).mapIso (ComonadIso.mk f f_ε f_δ)).hom.app x✝ = f.hom.app x✝
state_after: no goals
Theorem: CategoryTheory.Grpd.piIsoPi_hom_π
File: Mathlib/CategoryTheory/Category/Grpd.lean

tactic: simp [piIsoPi]
state_before: J : Type u
f : J → Grpd
j : J
⊢ (piIsoPi J f).hom ≫ Limits.Pi.π f j = Pi.eval (fun i => ↑(f i)) j
state_after: J : Type u
f : J → Grpd
j : J
⊢ (piLimitFan f).π.app { as := j } = Pi.eval (fun i => ↑(f i)) j

tactic: rfl
state_before: J : Type u
f : J → Grpd
j : J
⊢ (piLimitFan f).π.app { as := j } = Pi.eval (fun i => ↑(f i)) j
state_after: no goals
Theorem: IsSeparatedMap.isClosed_eqLocus
File: Mathlib/Topology/SeparatedMap.lean

tactic: fun_prop
state_before: X : Type u_3
Y : Type u_2
A : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace A
f : X → Y
sep : IsSeparatedMap f
inj : IsLocallyInjective f
g₁ g₂ : A → X
h₁ : Continuous g₁
h₂ : Continuous g₂
he : f ∘ g₁ = f ∘ g₂
g : A → Function.Pullback f f := fun a => ⟨(g₁ a, g₂ a), ⋯⟩
⊢ Continuous g
state_after: no goals
Theorem: isOpenMap_iff_interior
File: Mathlib/Topology/Maps.lean

tactic: rw [hu.interior_eq]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
hs : ∀ (s : Set X), f '' interior s ⊆ interior (f '' s)
u : Set X
hu : IsOpen u
⊢ f '' u = f '' interior u
state_after: no goals
Theorem: CategoryTheory.GradedObject.ι_descMapObj
File: Mathlib/CategoryTheory/GradedObject.lean

tactic: apply Cofan.IsColimit.fac
state_before: I : Type u_1
J : Type u_2
K : Type u_3
C : Type u_4
inst✝³ : Category.{u_5, u_4} C
X Y Z : GradedObject I C
φ✝ : X ⟶ Y
e : X ≅ Y
ψ : Y ⟶ Z
p : I → J
j✝ : J
inst✝² : X.HasMap p
inst✝¹ : Y.HasMap p
inst✝ : Z.HasMap p
A : C
j : J
φ : (i : I) → p i = j → (X i ⟶ A)
i : I
hi : p i = j
⊢ X.ιMapObj p i j hi ≫ X.descMapObj p φ = φ i hi
state_after: no goals