1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Equiv.Perm.decomposeFin_symm_apply_succ
File: Mathlib/GroupTheory/Perm/Fin.lean

tactic: refine Fin.cases ?_ ?_ p
state_before: n : ℕ
e : Perm (Fin n)
p : Fin (n + 1)
x : Fin n
⊢ (decomposeFin.symm (p, e)) x.succ = (swap 0 p) (e x).succ
state_after: case refine_1
n : ℕ
e : Perm (Fin n)
p : Fin (n + 1)
x : Fin n
⊢ (decomposeFin.symm (0, e)) x.succ = (swap 0 0) (e x).succ

case refine_2
n : ℕ
e : Perm (Fin n)
p : Fin (n + 1)
x : Fin n
⊢ ∀ (i : Fin n), (decomposeFin.symm (i.succ, e)) x.succ = (swap 0 i.succ) (e x).succ

tactic: simp [Equiv.Perm.decomposeFin, EquivFunctor.map]
state_before: case refine_1
n : ℕ
e : Perm (Fin n)
p : Fin (n + 1)
x : Fin n
⊢ (decomposeFin.symm (0, e)) x.succ = (swap 0 0) (e x).succ
state_after: no goals

tactic: intro i
state_before: case refine_2
n : ℕ
e : Perm (Fin n)
p : Fin (n + 1)
x : Fin n
⊢ ∀ (i : Fin n), (decomposeFin.symm (i.succ, e)) x.succ = (swap 0 i.succ) (e x).succ
state_after: case refine_2
n : ℕ
e : Perm (Fin n)
p : Fin (n + 1)
x i : Fin n
⊢ (decomposeFin.symm (i.succ, e)) x.succ = (swap 0 i.succ) (e x).succ

tactic: by_cases h : i = e x
state_before: case refine_2
n : ℕ
e : Perm (Fin n)
p : Fin (n + 1)
x i : Fin n
⊢ (decomposeFin.symm (i.succ, e)) x.succ = (swap 0 i.succ) (e x).succ
state_after: case pos
n : ℕ
e : Perm (Fin n)
p : Fin (n + 1)
x i : Fin n
h : i = e x
⊢ (decomposeFin.symm (i.succ, e)) x.succ = (swap 0 i.succ) (e x).succ

case neg
n : ℕ
e : Perm (Fin n)
p : Fin (n + 1)
x i : Fin n
h : ¬i = e x
⊢ (decomposeFin.symm (i.succ, e)) x.succ = (swap 0 i.succ) (e x).succ

tactic: simp [h, Equiv.Perm.decomposeFin, EquivFunctor.map]
state_before: case pos
n : ℕ
e : Perm (Fin n)
p : Fin (n + 1)
x i : Fin n
h : i = e x
⊢ (decomposeFin.symm (i.succ, e)) x.succ = (swap 0 i.succ) (e x).succ
state_after: no goals

tactic: simp [h, Fin.succ_ne_zero, Equiv.Perm.decomposeFin, EquivFunctor.map,
  swap_apply_def, Ne.symm h]
state_before: case neg
n : ℕ
e : Perm (Fin n)
p : Fin (n + 1)
x i : Fin n
h : ¬i = e x
⊢ (decomposeFin.symm (i.succ, e)) x.succ = (swap 0 i.succ) (e x).succ
state_after: no goals
Theorem: CategoryTheory.Arrow.hom.congr_right
File: Mathlib/CategoryTheory/Comma/Arrow.lean

tactic: rw [h]
state_before: T : Type u
inst✝ : Category.{v, u} T
f g : Arrow T
φ₁ φ₂ : f ⟶ g
h : φ₁ = φ₂
⊢ φ₁.right = φ₂.right
state_after: no goals
Theorem: Filter.tendsto_div_const_atTop_of_pos
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: simpa only [div_eq_mul_inv] using tendsto_mul_const_atTop_of_pos (inv_pos.2 hr)
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : LinearOrderedSemifield α
l : Filter β
f : β → α
r c : α
n : ℕ
hr : 0 < r
⊢ Tendsto (fun x => f x / r) l atTop ↔ Tendsto f l atTop
state_after: no goals
Theorem: CategoryTheory.μ_naturalityₗ
File: Mathlib/CategoryTheory/Monoidal/End.lean

tactic: rw [← tensorHom_id, ← μ_naturality₂ F f (𝟙 n) X]
state_before: C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m n m' : M
f : m ⟶ m'
X : C
⊢ (F.obj n).map ((F.map f).app X) ≫ (F.μ m' n).app X = (F.μ m n).app X ≫ (F.map (f ▷ n)).app X
state_after: C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m n m' : M
f : m ⟶ m'
X : C
⊢ (F.obj n).map ((F.map f).app X) ≫ (F.μ m' n).app X =
    (F.map (𝟙 n)).app ((F.obj m).obj X) ≫ (F.obj n).map ((F.map f).app X) ≫ (F.μ m' n).app X

tactic: simp
state_before: C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m n m' : M
f : m ⟶ m'
X : C
⊢ (F.obj n).map ((F.map f).app X) ≫ (F.μ m' n).app X =
    (F.map (𝟙 n)).app ((F.obj m).obj X) ≫ (F.obj n).map ((F.map f).app X) ≫ (F.μ m' n).app X
state_after: no goals
Theorem: Multiset.erase_cons_tail_of_mem
File: Mathlib/Data/Multiset/Basic.lean

tactic: rcases eq_or_ne a b with rfl | hab
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s t : Multiset α
a b : α
h : a ∈ s
⊢ (b ::ₘ s).erase a = b ::ₘ s.erase a
state_after: case inl
α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s t : Multiset α
a : α
h : a ∈ s
⊢ (a ::ₘ s).erase a = a ::ₘ s.erase a

case inr
α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s t : Multiset α
a b : α
h : a ∈ s
hab : a ≠ b
⊢ (b ::ₘ s).erase a = b ::ₘ s.erase a

tactic: simp [cons_erase h]
state_before: case inl
α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s t : Multiset α
a : α
h : a ∈ s
⊢ (a ::ₘ s).erase a = a ::ₘ s.erase a
state_after: no goals

tactic: exact s.erase_cons_tail hab.symm
state_before: case inr
α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s t : Multiset α
a b : α
h : a ∈ s
hab : a ≠ b
⊢ (b ::ₘ s).erase a = b ::ₘ s.erase a
state_after: no goals
Theorem: fib_golden_exp'
File: Mathlib/Data/Real/GoldenRatio.lean

tactic: induction n with
| zero => norm_num
| succ n ih =>
  calc
    _ = φ * (Nat.fib n) + φ ^ 2 * (Nat.fib (n + 1)) := by
      simp only [Nat.fib_add_one (Nat.succ_ne_zero n), Nat.succ_sub_succ_eq_sub, tsub_zero,
        Nat.cast_add, gold_sq]; ring
    _ = φ * ((Nat.fib n) + φ * (Nat.fib (n + 1))) := by ring
    _ = φ ^ (n + 2) := by rw [add_comm, ih]; ring
state_before: n : ℕ
⊢ φ * ↑(Nat.fib (n + 1)) + ↑(Nat.fib n) = φ ^ (n + 1)
state_after: no goals

tactic: norm_num
state_before: case zero

⊢ φ * ↑(Nat.fib (0 + 1)) + ↑(Nat.fib 0) = φ ^ (0 + 1)
state_after: no goals

tactic: calc
  _ = φ * (Nat.fib n) + φ ^ 2 * (Nat.fib (n + 1)) := by
    simp only [Nat.fib_add_one (Nat.succ_ne_zero n), Nat.succ_sub_succ_eq_sub, tsub_zero,
      Nat.cast_add, gold_sq]; ring
  _ = φ * ((Nat.fib n) + φ * (Nat.fib (n + 1))) := by ring
  _ = φ ^ (n + 2) := by rw [add_comm, ih]; ring
state_before: case succ
n : ℕ
ih : φ * ↑(Nat.fib (n + 1)) + ↑(Nat.fib n) = φ ^ (n + 1)
⊢ φ * ↑(Nat.fib (n + 1 + 1)) + ↑(Nat.fib (n + 1)) = φ ^ (n + 1 + 1)
state_after: no goals

tactic: simp only [Nat.fib_add_one (Nat.succ_ne_zero n), Nat.succ_sub_succ_eq_sub, tsub_zero,
  Nat.cast_add, gold_sq]
state_before: n : ℕ
ih : φ * ↑(Nat.fib (n + 1)) + ↑(Nat.fib n) = φ ^ (n + 1)
⊢ φ * ↑(Nat.fib (n + 1 + 1)) + ↑(Nat.fib (n + 1)) = φ * ↑(Nat.fib n) + φ ^ 2 * ↑(Nat.fib (n + 1))
state_after: n : ℕ
ih : φ * ↑(Nat.fib (n + 1)) + ↑(Nat.fib n) = φ ^ (n + 1)
⊢ φ * (↑(Nat.fib n) + ↑(Nat.fib n.succ)) + ↑(Nat.fib (n + 1)) = φ * ↑(Nat.fib n) + (φ + 1) * ↑(Nat.fib (n + 1))

tactic: ring
state_before: n : ℕ
ih : φ * ↑(Nat.fib (n + 1)) + ↑(Nat.fib n) = φ ^ (n + 1)
⊢ φ * (↑(Nat.fib n) + ↑(Nat.fib n.succ)) + ↑(Nat.fib (n + 1)) = φ * ↑(Nat.fib n) + (φ + 1) * ↑(Nat.fib (n + 1))
state_after: no goals

tactic: ring
state_before: n : ℕ
ih : φ * ↑(Nat.fib (n + 1)) + ↑(Nat.fib n) = φ ^ (n + 1)
⊢ φ * ↑(Nat.fib n) + φ ^ 2 * ↑(Nat.fib (n + 1)) = φ * (↑(Nat.fib n) + φ * ↑(Nat.fib (n + 1)))
state_after: no goals

tactic: rw [add_comm, ih]
state_before: n : ℕ
ih : φ * ↑(Nat.fib (n + 1)) + ↑(Nat.fib n) = φ ^ (n + 1)
⊢ φ * (↑(Nat.fib n) + φ * ↑(Nat.fib (n + 1))) = φ ^ (n + 2)
state_after: n : ℕ
ih : φ * ↑(Nat.fib (n + 1)) + ↑(Nat.fib n) = φ ^ (n + 1)
⊢ φ * φ ^ (n + 1) = φ ^ (n + 2)

tactic: ring
state_before: n : ℕ
ih : φ * ↑(Nat.fib (n + 1)) + ↑(Nat.fib n) = φ ^ (n + 1)
⊢ φ * φ ^ (n + 1) = φ ^ (n + 2)
state_after: no goals
Theorem: multiplicity.mul
File: Mathlib/RingTheory/Multiplicity.lean

tactic: rw [← PartENat.natCast_get (finite_iff_dom.1 h.1), ←
    PartENat.natCast_get (finite_iff_dom.1 h.2), ←
    PartENat.natCast_get (finite_iff_dom.1 (finite_mul hp h.1 h.2)), ← Nat.cast_add,
    PartENat.natCast_inj, multiplicity.mul' hp]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p a b : α
hp : Prime p
h : Finite p a ∧ Finite p b
⊢ multiplicity p (a * b) = multiplicity p a + multiplicity p b
state_after: no goals

tactic: rw [eq_top_iff_not_finite.2 (mt (finite_mul_iff hp).1 h)]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p a b : α
hp : Prime p
h : ¬(Finite p a ∧ Finite p b)
⊢ multiplicity p (a * b) = multiplicity p a + multiplicity p b
state_after: α : Type u_1
β : Type u_2
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p a b : α
hp : Prime p
h : ¬(Finite p a ∧ Finite p b)
⊢ ⊤ = multiplicity p a + multiplicity p b

tactic: cases' not_and_or.1 h with h h <;> simp [eq_top_iff_not_finite.2 h]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p a b : α
hp : Prime p
h : ¬(Finite p a ∧ Finite p b)
⊢ ⊤ = multiplicity p a + multiplicity p b
state_after: no goals
Theorem: Complex.cpow_mul_int
File: Mathlib/Analysis/SpecialFunctions/Pow/Complex.lean

tactic: rw [mul_comm, cpow_int_mul]
state_before: x y : ℂ
n : ℤ
⊢ x ^ (y * ↑n) = (x ^ y) ^ n
state_after: no goals
Theorem: Finpartition.exists_equipartition_card_eq
File: Mathlib/Combinatorics/SimpleGraph/Regularity/Equitabilise.lean

tactic: rw [← pos_iff_ne_zero] at hn
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
m n a b : ℕ
P : Finpartition s
h : a * m + b * (m + 1) = s.card
hn : n ≠ 0
hs : n ≤ s.card
⊢ ∃ P, P.IsEquipartition ∧ P.parts.card = n
state_after: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
m n a b : ℕ
P : Finpartition s
h : a * m + b * (m + 1) = s.card
hn : 0 < n
hs : n ≤ s.card
⊢ ∃ P, P.IsEquipartition ∧ P.parts.card = n

tactic: have : (n - s.card % n) * (s.card / n) + s.card % n * (s.card / n + 1) = s.card := by
  rw [tsub_mul, mul_add, ← add_assoc,
    tsub_add_cancel_of_le (Nat.mul_le_mul_right _ (mod_lt _ hn).le), mul_one, add_comm,
    mod_add_div]
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
m n a b : ℕ
P : Finpartition s
h : a * m + b * (m + 1) = s.card
hn : 0 < n
hs : n ≤ s.card
⊢ ∃ P, P.IsEquipartition ∧ P.parts.card = n
state_after: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
m n a b : ℕ
P : Finpartition s
h : a * m + b * (m + 1) = s.card
hn : 0 < n
hs : n ≤ s.card
this : (n - s.card % n) * (s.card / n) + s.card % n * (s.card / n + 1) = s.card
⊢ ∃ P, P.IsEquipartition ∧ P.parts.card = n

tactic: refine
  ⟨(indiscrete (card_pos.1 <| hn.trans_le hs).ne_empty).equitabilise this,
    equitabilise_isEquipartition, ?_⟩
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
m n a b : ℕ
P : Finpartition s
h : a * m + b * (m + 1) = s.card
hn : 0 < n
hs : n ≤ s.card
this : (n - s.card % n) * (s.card / n) + s.card % n * (s.card / n + 1) = s.card
⊢ ∃ P, P.IsEquipartition ∧ P.parts.card = n
state_after: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
m n a b : ℕ
P : Finpartition s
h : a * m + b * (m + 1) = s.card
hn : 0 < n
hs : n ≤ s.card
this : (n - s.card % n) * (s.card / n) + s.card % n * (s.card / n + 1) = s.card
⊢ (equitabilise this).parts.card = n

tactic: rw [card_parts_equitabilise _ _ (Nat.div_pos hs hn).ne', tsub_add_cancel_of_le (mod_lt _ hn).le]
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
m n a b : ℕ
P : Finpartition s
h : a * m + b * (m + 1) = s.card
hn : 0 < n
hs : n ≤ s.card
this : (n - s.card % n) * (s.card / n) + s.card % n * (s.card / n + 1) = s.card
⊢ (equitabilise this).parts.card = n
state_after: no goals

tactic: rw [tsub_mul, mul_add, ← add_assoc,
  tsub_add_cancel_of_le (Nat.mul_le_mul_right _ (mod_lt _ hn).le), mul_one, add_comm,
  mod_add_div]
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
m n a b : ℕ
P : Finpartition s
h : a * m + b * (m + 1) = s.card
hn : 0 < n
hs : n ≤ s.card
⊢ (n - s.card % n) * (s.card / n) + s.card % n * (s.card / n + 1) = s.card
state_after: no goals
Theorem: div_mul_div_cancel'
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [← mul_div_assoc, div_mul_cancel]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a✝ b✝ c✝ d : G
n : ℤ
a b c : G
⊢ a / b * (b / c) = a / c
state_after: no goals
Theorem: Int.testBit_bit_zero
File: Mathlib/Data/Int/Bitwise.lean

tactic: rw [bit_coe_nat]
state_before: b : Bool
n : ℕ
⊢ (bit b ↑n).testBit 0 = b
state_after: b : Bool
n : ℕ
⊢ (↑(Nat.bit b n)).testBit 0 = b

tactic: apply Nat.testBit_bit_zero
state_before: b : Bool
n : ℕ
⊢ (↑(Nat.bit b n)).testBit 0 = b
state_after: no goals

tactic: rw [bit_negSucc]
state_before: b : Bool
n : ℕ
⊢ (bit b -[n+1]).testBit 0 = b
state_after: b : Bool
n : ℕ
⊢ -[Nat.bit (!b) n+1].testBit 0 = b

tactic: dsimp [testBit]
state_before: b : Bool
n : ℕ
⊢ -[Nat.bit (!b) n+1].testBit 0 = b
state_after: b : Bool
n : ℕ
⊢ (!(Nat.bit (!b) n).testBit 0) = b

tactic: rw [Nat.testBit_bit_zero]
state_before: b : Bool
n : ℕ
⊢ (!(Nat.bit (!b) n).testBit 0) = b
state_after: b : Bool
n : ℕ
⊢ (!!b) = b

tactic: cases b <;>
rfl
state_before: b : Bool
n : ℕ
⊢ (!!b) = b
state_after: no goals
Theorem: MvPolynomial.homogeneousComponent_homogeneous_polynomial
File: Mathlib/RingTheory/MvPolynomial/Homogeneous.lean

tactic: convert weightedHomogeneousComponent_weighted_homogeneous_polynomial m n p h
state_before: σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝¹ inst✝ : CommSemiring R
n✝ : ℕ
φ ψ : MvPolynomial σ R
m n : ℕ
p : MvPolynomial σ R
h : p ∈ homogeneousSubmodule σ R n
⊢ (homogeneousComponent m) p = if m = n then p else 0
state_after: no goals
Theorem: Real.sum_le_exp_of_nonneg
File: Mathlib/Data/Complex/Exponential.lean

tactic: refine le_lim (CauSeq.le_of_exists ⟨n, fun j hj => ?_⟩)
state_before: x✝ y x : ℝ
hx : 0 ≤ x
n : ℕ
⊢ ∑ i ∈ range n, x ^ i / ↑i ! ≤ CauSeq.lim ⟨fun n => (↑(exp' ↑x) n).re, ⋯⟩
state_after: x✝ y x : ℝ
hx : 0 ≤ x
n j : ℕ
hj : j ≥ n
⊢ ↑(const _root_.abs (∑ i ∈ range n, x ^ i / ↑i !)) j ≤ ↑⟨fun n => (↑(exp' ↑x) n).re, ⋯⟩ j

tactic: simp only [exp', const_apply, re_sum]
state_before: x✝ y x : ℝ
hx : 0 ≤ x
n j : ℕ
hj : j ≥ n
⊢ ↑(const _root_.abs (∑ i ∈ range n, x ^ i / ↑i !)) j ≤ ↑⟨fun n => (↑(exp' ↑x) n).re, ⋯⟩ j
state_after: x✝ y x : ℝ
hx : 0 ≤ x
n j : ℕ
hj : j ≥ n
⊢ ∑ i ∈ range n, x ^ i / ↑i ! ≤ ∑ i ∈ range j, (↑x ^ i / ↑i !).re

tactic: norm_cast
state_before: x✝ y x : ℝ
hx : 0 ≤ x
n j : ℕ
hj : j ≥ n
⊢ ∑ i ∈ range n, x ^ i / ↑i ! ≤ ∑ i ∈ range j, (↑x ^ i / ↑i !).re
state_after: x✝ y x : ℝ
hx : 0 ≤ x
n j : ℕ
hj : j ≥ n
⊢ ∑ i ∈ range n, x ^ i / ↑i ! ≤ ∑ i ∈ range j, x ^ i / ↑i !

tactic: refine sum_le_sum_of_subset_of_nonneg (range_mono hj) fun _ _ _ ↦ ?_
state_before: x✝ y x : ℝ
hx : 0 ≤ x
n j : ℕ
hj : j ≥ n
⊢ ∑ i ∈ range n, x ^ i / ↑i ! ≤ ∑ i ∈ range j, x ^ i / ↑i !
state_after: x✝³ y x : ℝ
hx : 0 ≤ x
n j : ℕ
hj : j ≥ n
x✝² : ℕ
x✝¹ : x✝² ∈ range j
x✝ : x✝² ∉ range n
⊢ 0 ≤ x ^ x✝² / ↑x✝²!

tactic: positivity
state_before: x✝³ y x : ℝ
hx : 0 ≤ x
n j : ℕ
hj : j ≥ n
x✝² : ℕ
x✝¹ : x✝² ∈ range j
x✝ : x✝² ∉ range n
⊢ 0 ≤ x ^ x✝² / ↑x✝²!
state_after: no goals

tactic: rw [exp, Complex.exp, ← cauSeqRe, lim_re]
state_before: x✝ y x : ℝ
hx : 0 ≤ x
n : ℕ
⊢ CauSeq.lim ⟨fun n => (↑(exp' ↑x) n).re, ⋯⟩ = rexp x
state_after: no goals
Theorem: Monoid.PushoutI.NormalWord.of_smul_eq_smul
File: Mathlib/GroupTheory/PushoutI.lean

tactic: rw [summand_smul_def, summand_smul_def']
state_before: ι : Type u_1
G : ι → Type u_2
H : Type u_3
K : Type u_4
inst✝⁴ : Monoid K
inst✝³ : (i : ι) → Group (G i)
inst✝² : Group H
φ : (i : ι) → H →* G i
d : Transversal φ
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → DecidableEq (G i)
i : ι
g : G i
w : NormalWord d
⊢ (of i) g • w = g • w
state_after: no goals
Theorem: NFA.mem_accepts
File: Mathlib/Computability/NFA.lean

tactic: rfl
state_before: α : Type u
σ σ' : Type v
M : NFA α σ
x : List α
⊢ x ∈ M.accepts ↔ ∃ S ∈ M.accept, S ∈ M.evalFrom M.start x
state_after: no goals
Theorem: groupCohomology.resolution.quasiIso_forget₂_εToSingle₀
File: Mathlib/RepresentationTheory/GroupCohomology/Resolution.lean

tactic: have h : QuasiIso (forget₂ToModuleCatHomotopyEquiv k G).hom := inferInstance
state_before: k G : Type u
inst✝¹ : CommRing k
n : ℕ
inst✝ : Monoid G
⊢ QuasiIso (((forget₂ (Rep k G) (ModuleCat k)).mapHomologicalComplex (ComplexShape.down ℕ)).map (εToSingle₀ k G))
state_after: k G : Type u
inst✝¹ : CommRing k
n : ℕ
inst✝ : Monoid G
h : QuasiIso (forget₂ToModuleCatHomotopyEquiv k G).hom
⊢ QuasiIso (((forget₂ (Rep k G) (ModuleCat k)).mapHomologicalComplex (ComplexShape.down ℕ)).map (εToSingle₀ k G))

tactic: rw [← εToSingle₀_comp_eq k G] at h
state_before: k G : Type u
inst✝¹ : CommRing k
n : ℕ
inst✝ : Monoid G
h : QuasiIso (forget₂ToModuleCatHomotopyEquiv k G).hom
⊢ QuasiIso (((forget₂ (Rep k G) (ModuleCat k)).mapHomologicalComplex (ComplexShape.down ℕ)).map (εToSingle₀ k G))
state_after: k G : Type u
inst✝¹ : CommRing k
n : ℕ
inst✝ : Monoid G
h :
  QuasiIso
    (((forget₂ (Rep k G) (ModuleCat k)).mapHomologicalComplex (ComplexShape.down ℕ)).map (εToSingle₀ k G) ≫
      (HomologicalComplex.singleMapHomologicalComplex (forget₂ (Rep k G) (ModuleCat k)) (ComplexShape.down ℕ) 0).hom.app
        (Rep.trivial k G k))
⊢ QuasiIso (((forget₂ (Rep k G) (ModuleCat k)).mapHomologicalComplex (ComplexShape.down ℕ)).map (εToSingle₀ k G))

tactic: exact quasiIso_of_comp_right (hφφ' := h)
state_before: k G : Type u
inst✝¹ : CommRing k
n : ℕ
inst✝ : Monoid G
h :
  QuasiIso
    (((forget₂ (Rep k G) (ModuleCat k)).mapHomologicalComplex (ComplexShape.down ℕ)).map (εToSingle₀ k G) ≫
      (HomologicalComplex.singleMapHomologicalComplex (forget₂ (Rep k G) (ModuleCat k)) (ComplexShape.down ℕ) 0).hom.app
        (Rep.trivial k G k))
⊢ QuasiIso (((forget₂ (Rep k G) (ModuleCat k)).mapHomologicalComplex (ComplexShape.down ℕ)).map (εToSingle₀ k G))
state_after: no goals
Theorem: Order.not_isSuccLimit_succ_of_not_isMax
File: Mathlib/Order/SuccPred/Limit.lean

tactic: contrapose! ha
state_before: α : Type u_1
inst✝¹ : Preorder α
a : α
inst✝ : SuccOrder α
ha : ¬IsMax a
⊢ ¬IsSuccLimit (succ a)
state_after: α : Type u_1
inst✝¹ : Preorder α
a : α
inst✝ : SuccOrder α
ha : IsSuccLimit (succ a)
⊢ IsMax a

tactic: exact ha.isMax
state_before: α : Type u_1
inst✝¹ : Preorder α
a : α
inst✝ : SuccOrder α
ha : IsSuccLimit (succ a)
⊢ IsMax a
state_after: no goals
Theorem: MvPowerSeries.coeff_zero_X
File: Mathlib/RingTheory/MvPowerSeries/Basic.lean

tactic: classical
rw [coeff_X, if_neg]
intro h
exact one_ne_zero (single_eq_zero.mp h.symm)
state_before: σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
⊢ (coeff R 0) (X s) = 0
state_after: no goals

tactic: rw [coeff_X, if_neg]
state_before: σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
⊢ (coeff R 0) (X s) = 0
state_after: case hnc
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
⊢ ¬0 = single s 1

tactic: intro h
state_before: case hnc
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
⊢ ¬0 = single s 1
state_after: case hnc
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
h : 0 = single s 1
⊢ False

tactic: exact one_ne_zero (single_eq_zero.mp h.symm)
state_before: case hnc
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
h : 0 = single s 1
⊢ False
state_after: no goals
Theorem: WeierstrassCurve.Jacobian.dblXYZ_of_Y_eq'
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

tactic: rw [dblXYZ, dblX_of_Y_eq hQz hx hy hy', dblY_of_Y_eq hQz hx hy hy', dblZ_of_Y_eq hQz hx hy hy']
state_before: R : Type u
inst✝² : CommRing R
W' : Jacobian R
F : Type v
inst✝¹ : Field F
W : Jacobian F
inst✝ : NoZeroDivisors R
P Q : Fin 3 → R
hQz : Q z ≠ 0
hx : P x * Q z ^ 2 = Q x * P z ^ 2
hy : P y * Q z ^ 3 = Q y * P z ^ 3
hy' : P y * Q z ^ 3 = W'.negY Q * P z ^ 3
⊢ W'.dblXYZ P = ![W'.dblU P ^ 2, W'.dblU P ^ 3, 0]
state_after: no goals
Theorem: ContextFreeRule.rewrites_of_exists_parts
File: Mathlib/Computability/ContextFreeGrammar.lean

tactic: induction p with
| nil         => exact Rewrites.head q
| cons d l ih => exact Rewrites.cons d ih
state_before: T : Type uT
N : Type uN
r : ContextFreeRule T N
p q : List (Symbol T N)
⊢ r.Rewrites (p ++ [Symbol.nonterminal r.input] ++ q) (p ++ r.output ++ q)
state_after: no goals

tactic: exact Rewrites.head q
state_before: case nil
T : Type uT
N : Type uN
r : ContextFreeRule T N
q : List (Symbol T N)
⊢ r.Rewrites ([] ++ [Symbol.nonterminal r.input] ++ q) ([] ++ r.output ++ q)
state_after: no goals

tactic: exact Rewrites.cons d ih
state_before: case cons
T : Type uT
N : Type uN
r : ContextFreeRule T N
q : List (Symbol T N)
d : Symbol T N
l : List (Symbol T N)
ih : r.Rewrites (l ++ [Symbol.nonterminal r.input] ++ q) (l ++ r.output ++ q)
⊢ r.Rewrites (d :: l ++ [Symbol.nonterminal r.input] ++ q) (d :: l ++ r.output ++ q)
state_after: no goals
Theorem: Polynomial.content_X
File: Mathlib/RingTheory/Polynomial/Content.lean

tactic: rw [← mul_one X, content_X_mul, content_one]
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
⊢ X.content = 1
state_after: no goals
Theorem: Representation.asModuleEquiv_symm_map_rho
File: Mathlib/RepresentationTheory/Basic.lean

tactic: apply_fun ρ.asModuleEquiv
state_before: k : Type u_1
G : Type u_2
V : Type u_3
inst✝³ : CommSemiring k
inst✝² : Monoid G
inst✝¹ : AddCommMonoid V
inst✝ : Module k V
ρ : Representation k G V
g : G
x : V
⊢ ρ.asModuleEquiv.symm ((ρ g) x) = (of k G) g • ρ.asModuleEquiv.symm x
state_after: k : Type u_1
G : Type u_2
V : Type u_3
inst✝³ : CommSemiring k
inst✝² : Monoid G
inst✝¹ : AddCommMonoid V
inst✝ : Module k V
ρ : Representation k G V
g : G
x : V
⊢ ρ.asModuleEquiv (ρ.asModuleEquiv.symm ((ρ g) x)) = ρ.asModuleEquiv ((of k G) g • ρ.asModuleEquiv.symm x)

tactic: simp
state_before: k : Type u_1
G : Type u_2
V : Type u_3
inst✝³ : CommSemiring k
inst✝² : Monoid G
inst✝¹ : AddCommMonoid V
inst✝ : Module k V
ρ : Representation k G V
g : G
x : V
⊢ ρ.asModuleEquiv (ρ.asModuleEquiv.symm ((ρ g) x)) = ρ.asModuleEquiv ((of k G) g • ρ.asModuleEquiv.symm x)
state_after: no goals
Theorem: CategoryTheory.Functor.splitEpiCategoryImpOfIsEquivalence
File: Mathlib/CategoryTheory/Functor/EpiMono.lean

tactic: intro
state_before: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
E : Type u₃
inst✝² : Category.{v₃, u₃} E
F : C ⥤ D
X✝ Y✝ : C
f✝ : X✝ ⟶ Y✝
inst✝¹ : F.IsEquivalence
inst✝ : SplitEpiCategory C
X Y : D
f : X ⟶ Y
⊢ ∀ [inst : Epi f], IsSplitEpi f
state_after: C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
E : Type u₃
inst✝³ : Category.{v₃, u₃} E
F : C ⥤ D
X✝ Y✝ : C
f✝ : X✝ ⟶ Y✝
inst✝² : F.IsEquivalence
inst✝¹ : SplitEpiCategory C
X Y : D
f : X ⟶ Y
inst✝ : Epi f
⊢ IsSplitEpi f

tactic: rw [← F.inv.isSplitEpi_iff f]
state_before: C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
E : Type u₃
inst✝³ : Category.{v₃, u₃} E
F : C ⥤ D
X✝ Y✝ : C
f✝ : X✝ ⟶ Y✝
inst✝² : F.IsEquivalence
inst✝¹ : SplitEpiCategory C
X Y : D
f : X ⟶ Y
inst✝ : Epi f
⊢ IsSplitEpi f
state_after: C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
E : Type u₃
inst✝³ : Category.{v₃, u₃} E
F : C ⥤ D
X✝ Y✝ : C
f✝ : X✝ ⟶ Y✝
inst✝² : F.IsEquivalence
inst✝¹ : SplitEpiCategory C
X Y : D
f : X ⟶ Y
inst✝ : Epi f
⊢ IsSplitEpi (F.inv.map f)

tactic: apply isSplitEpi_of_epi
state_before: C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
E : Type u₃
inst✝³ : Category.{v₃, u₃} E
F : C ⥤ D
X✝ Y✝ : C
f✝ : X✝ ⟶ Y✝
inst✝² : F.IsEquivalence
inst✝¹ : SplitEpiCategory C
X Y : D
f : X ⟶ Y
inst✝ : Epi f
⊢ IsSplitEpi (F.inv.map f)
state_after: no goals
Theorem: orderOf_eq_zero
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: rwa [orderOf, minimalPeriod, dif_neg]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n m : ℕ
h : ¬IsOfFinOrder x
⊢ orderOf x = 0
state_after: no goals
Theorem: Orientation.oangle_sign_smul_right
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean

tactic: rcases lt_trichotomy r 0 with (h | h | h) <;> simp [h]
state_before: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x y : V
r : ℝ
⊢ (o.oangle x (r • y)).sign = SignType.sign r * (o.oangle x y).sign
state_after: no goals