ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: not_summable_of_antitone_of_neg
File: Mathlib/Analysis/SumOverResidueClass.lean

Proof steps:
state_before: f : ℕ → ℝ
hf : Antitone f
n : ℕ
hn : f n < 0
⊢ ¬Summable f
state_after: f : ℕ → ℝ
hf : Antitone f
n : ℕ
hn : f n < 0
hs : Summable f
⊢ False
tactic: intro hs
state_before: f : ℕ → ℝ
hf : Antitone f
n : ℕ
hn : f n < 0
hs : Summable f
⊢ False
state_after: f : ℕ → ℝ
hf : Antitone f
n : ℕ
hn : f n < 0
hs : Summable f
this : Filter.Tendsto f Filter.atTop (nhds 0)
⊢ False
tactic: have := hs.tendsto_atTop_zero
state_before: f : ℕ → ℝ
hf : Antitone f
n : ℕ
hn : f n < 0
hs : Summable f
this : Filter.Tendsto f Filter.atTop (nhds 0)
⊢ False
state_after: f : ℕ → ℝ
hf : Antitone f
n : ℕ
hn : f n < 0
hs : Summable f
this : ∀ ε > 0, ∃ N, ∀ n ≥ N, |f n| < ε
⊢ False
tactic: simp only [Metric.tendsto_atTop, dist_zero_right, Real.norm_eq_abs] at this
state_before: f : ℕ → ℝ
hf : Antitone f
n : ℕ
hn : f n < 0
hs : Summable f
this : ∀ ε > 0, ∃ N, ∀ n ≥ N, |f n| < ε
⊢ False
state_after: case intro
f : ℕ → ℝ
hf : Antitone f
n : ℕ
hn : f n < 0
hs : Summable f
this : ∀ ε > 0, ∃ N, ∀ n ≥ N, |f n| < ε
N : ℕ
hN : ∀ n_1 ≥ N, |f n_1| < |f n|
⊢ False
tactic: obtain ⟨N, hN⟩ := this (|f n|) (abs_pos_of_neg hn)
state_before: case intro
f : ℕ → ℝ
hf : Antitone f
n : ℕ
hn : f n < 0
hs : Summable f
this : ∀ ε > 0, ∃ N, ∀ n ≥ N, |f n| < ε
N : ℕ
hN : ∀ n_1 ≥ N, |f n_1| < |f n|
⊢ False
state_after: case intro
f : ℕ → ℝ
hf : Antitone f
n : ℕ
hn : f n < 0
hs : Summable f
this : ∀ ε > 0, ∃ N, ∀ n ≥ N, |f n| < ε
N : ℕ
hN : |f (max n N)| < |f n|
⊢ False
tactic: specialize hN (max n N) (n.le_max_right N)
state_before: case intro
f : ℕ → ℝ
hf : Antitone f
n : ℕ
hn : f n < 0
hs : Summable f
this : ∀ ε > 0, ∃ N, ∀ n ≥ N, |f n| < ε
N : ℕ
hN : |f (max n N)| < |f n|
⊢ False
state_after: case intro
f : ℕ → ℝ
hf : Antitone f
n : ℕ
hn : f n < 0
hs : Summable f
this : ∀ ε > 0, ∃ N, ∀ n ≥ N, |f n| < ε
N : ℕ
hN : ¬False
⊢ |f n| ≤ |f (max n N)|
tactic: contrapose! hN
state_before: case intro
f : ℕ → ℝ
hf : Antitone f
n : ℕ
hn : f n < 0
hs : Summable f
this : ∀ ε > 0, ∃ N, ∀ n ≥ N, |f n| < ε
N : ℕ
hN : ¬False
⊢ |f n| ≤ |f (max n N)|
state_after: case intro
f : ℕ → ℝ
hf : Antitone f
n : ℕ
hn : f n < 0
hs : Summable f
this : ∀ ε > 0, ∃ N, ∀ n ≥ N, |f n| < ε
N : ℕ
⊢ |f n| ≤ |f (max n N)|
tactic: clear hN
state_before: case intro
f : ℕ → ℝ
hf : Antitone f
n : ℕ
hn : f n < 0
hs : Summable f
this : ∀ ε > 0, ∃ N, ∀ n ≥ N, |f n| < ε
N : ℕ
⊢ |f n| ≤ |f (max n N)|
state_after: case intro
f : ℕ → ℝ
hf : Antitone f
n : ℕ
hn : f n < 0
hs : Summable f
this : ∀ ε > 0, ∃ N, ∀ n ≥ N, |f n| < ε
N : ℕ
H : f (max n N) ≤ f n
⊢ |f n| ≤ |f (max n N)|
tactic: have H : f (max n N) ≤ f n := hf (n.le_max_left N)
state_before: case intro
f : ℕ → ℝ
hf : Antitone f
n : ℕ
hn : f n < 0
hs : Summable f
this : ∀ ε > 0, ∃ N, ∀ n ≥ N, |f n| < ε
N : ℕ
H : f (max n N) ≤ f n
⊢ |f n| ≤ |f (max n N)|
state_after: no goals
tactic: rwa [abs_of_neg hn, abs_of_neg (H.trans_lt hn), neg_le_neg_iff]
Theorem: CategoryTheory.isDetector_iff_reflectsIsomorphisms_coyoneda_obj
File: Mathlib/CategoryTheory/Generator.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
G : C
⊢ IsDetector G ↔ (coyoneda.obj (op G)).ReflectsIsomorphisms
state_after: case refine_1
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
G : C
hG : IsDetector G
A✝ B✝ : C
f : A✝ ⟶ B✝
hf : IsIso ((coyoneda.obj (op G)).map f)
h : G ⟶ B✝
⊢ ∃! h', h' ≫ f = h

case refine_2
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
G : C
h : (coyoneda.obj (op G)).ReflectsIsomorphisms
X Y : C
f : X ⟶ Y
hf : ∀ (h : G ⟶ Y), ∃! h', h' ≫ f = h
⊢ IsIso f
tactic: refine
    ⟨fun hG => ⟨fun f hf => hG.def _ fun h => ?_⟩, fun h =>
      (isDetector_def _).2 fun X Y f hf => ?_⟩
Theorem: Ideal.ker_quotient_lift
File: Mathlib/RingTheory/Ideal/QuotientOperations.lean

Proof steps:
state_before: R : Type u
S : Type v
F : Type w
inst✝¹ : CommRing R
inst✝ : Semiring S
I : Ideal R
f : R →+* S
H : I ≤ ker f
⊢ ker (Quotient.lift I f H) = map (Quotient.mk I) (ker f)
state_after: case h
R : Type u
S : Type v
F : Type w
inst✝¹ : CommRing R
inst✝ : Semiring S
I : Ideal R
f : R →+* S
H : I ≤ ker f
⊢ ∀ (x : R ⧸ I), x ∈ ker (Quotient.lift I f H) ↔ x ∈ map (Quotient.mk I) (ker f)
tactic: apply Ideal.ext
state_before: case h
R : Type u
S : Type v
F : Type w
inst✝¹ : CommRing R
inst✝ : Semiring S
I : Ideal R
f : R →+* S
H : I ≤ ker f
⊢ ∀ (x : R ⧸ I), x ∈ ker (Quotient.lift I f H) ↔ x ∈ map (Quotient.mk I) (ker f)
state_after: case h
R : Type u
S : Type v
F : Type w
inst✝¹ : CommRing R
inst✝ : Semiring S
I : Ideal R
f : R →+* S
H : I ≤ ker f
x : R ⧸ I
⊢ x ∈ ker (Quotient.lift I f H) ↔ x ∈ map (Quotient.mk I) (ker f)
tactic: intro x
state_before: case h
R : Type u
S : Type v
F : Type w
inst✝¹ : CommRing R
inst✝ : Semiring S
I : Ideal R
f : R →+* S
H : I ≤ ker f
x : R ⧸ I
⊢ x ∈ ker (Quotient.lift I f H) ↔ x ∈ map (Quotient.mk I) (ker f)
state_after: case h.mp
R : Type u
S : Type v
F : Type w
inst✝¹ : CommRing R
inst✝ : Semiring S
I : Ideal R
f : R →+* S
H : I ≤ ker f
x : R ⧸ I
⊢ x ∈ ker (Quotient.lift I f H) → x ∈ map (Quotient.mk I) (ker f)

case h.mpr
R : Type u
S : Type v
F : Type w
inst✝¹ : CommRing R
inst✝ : Semiring S
I : Ideal R
f : R →+* S
H : I ≤ ker f
x : R ⧸ I
⊢ x ∈ map (Quotient.mk I) (ker f) → x ∈ ker (Quotient.lift I f H)
tactic: constructor
Theorem: Nat.Prime.dvd_factorial
File: Mathlib/Data/Nat/Prime/Basic.lean

Proof steps:
state_before: n✝ n p : ℕ
hp : Prime p
⊢ p ∣ (n + 1)! ↔ p ≤ n + 1
state_after: n✝ n p : ℕ
hp : Prime p
⊢ p ∣ n + 1 ∨ p ≤ n ↔ p ≤ n + 1
tactic: rw [factorial_succ, hp.dvd_mul, Prime.dvd_factorial hp]
state_before: n✝ n p : ℕ
hp : Prime p
⊢ p ∣ n + 1 ∨ p ≤ n ↔ p ≤ n + 1
state_after: no goals
tactic: exact
      ⟨fun h => h.elim (le_of_dvd (succ_pos _)) le_succ_of_le, fun h =>
        (_root_.lt_or_eq_of_le h).elim (Or.inr ∘ le_of_lt_succ) fun h => Or.inl <| by rw [h]⟩
Theorem: AddSubmonoid.LocalizationMap.mk'_add_eq_mk'_of_add
File: Mathlib/GroupTheory/MonoidLocalization/Basic.lean

Proof steps:
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : S.LocalizationMap N
x₁ x₂ : M
y : ↥S
⊢ f.mk' x₂ y * f.toMap x₁ = f.mk' (x₁ * x₂) y
state_after: no goals
tactic: rw [mul_comm, mul_mk'_eq_mk'_of_mul]
Theorem: IsometryEquiv.ediam_preimage
File: Mathlib/Topology/MetricSpace/Isometry.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
h : α ≃ᵢ β
s : Set β
⊢ EMetric.diam (⇑h ⁻¹' s) = EMetric.diam s
state_after: no goals
tactic: rw [← image_symm, ediam_image]
Theorem: CategoryTheory.Idempotents.KaroubiKaroubi.inverse_map_f
File: Mathlib/CategoryTheory/Idempotents/KaroubiKaroubi.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{?u.1672, u_1} C
P : Karoubi (Karoubi C)
⊢ P.p.f ≫ P.p.f = P.p.f
state_after: no goals
tactic: simpa only [hom_ext_iff] using P.idem
state_before: C : Type u_1
inst✝ : Category.{?u.1672, u_1} C
X✝ Y✝ : Karoubi (Karoubi C)
f : X✝ ⟶ Y✝
⊢ f.f.f =
    ((fun P => { X := P.X.X, p := P.p.f, idem := ⋯ }) X✝).p ≫
      f.f.f ≫ ((fun P => { X := P.X.X, p := P.p.f, idem := ⋯ }) Y✝).p
state_after: no goals
tactic: simpa only [hom_ext_iff] using f.comm
Theorem: Nat.fib_add
File: Mathlib/Data/Nat/Fib/Basic.lean

Proof steps:
state_before: m n : ℕ
⊢ fib (m + n + 1) = fib m * fib n + fib (m + 1) * fib (n + 1)
state_after: case zero
m : ℕ
⊢ fib (m + 0 + 1) = fib m * fib 0 + fib (m + 1) * fib (0 + 1)

case succ
n : ℕ
ih : ∀ (m : ℕ), fib (m + n + 1) = fib m * fib n + fib (m + 1) * fib (n + 1)
m : ℕ
⊢ fib (m + (n + 1) + 1) = fib m * fib (n + 1) + fib (m + 1) * fib (n + 1 + 1)
tactic: induction' n with n ih generalizing m
Theorem: MvPolynomial.quotientEquivQuotientMvPolynomial_rightInverse
File: Mathlib/RingTheory/Polynomial/Quotient.lean

Proof steps:
state_before: R : Type u_1
σ : Type u_2
inst✝ : CommRing R
r : R
I : Ideal R
⊢ Function.RightInverse
    (eval₂ (Ideal.Quotient.lift I ((Ideal.Quotient.mk (Ideal.map C I)).comp C) ⋯) fun i =>
      (Ideal.Quotient.mk (Ideal.map C I)) (X i))
    ⇑(Ideal.Quotient.lift (Ideal.map C I) (eval₂Hom (C.comp (Ideal.Quotient.mk I)) X) ⋯)
state_after: R : Type u_1
σ : Type u_2
inst✝ : CommRing R
r : R
I : Ideal R
f : MvPolynomial σ (R ⧸ I)
⊢ (Ideal.Quotient.lift (Ideal.map C I) (eval₂Hom (C.comp (Ideal.Quotient.mk I)) X) ⋯)
      (eval₂ (Ideal.Quotient.lift I ((Ideal.Quotient.mk (Ideal.map C I)).comp C) ⋯)
        (fun i => (Ideal.Quotient.mk (Ideal.map C I)) (X i)) f) =
    f
tactic: intro f
state_before: R : Type u_1
σ : Type u_2
inst✝ : CommRing R
r : R
I : Ideal R
f : MvPolynomial σ (R ⧸ I)
⊢ (Ideal.Quotient.lift (Ideal.map C I) (eval₂Hom (C.comp (Ideal.Quotient.mk I)) X) ⋯)
      (eval₂ (Ideal.Quotient.lift I ((Ideal.Quotient.mk (Ideal.map C I)).comp C) ⋯)
        (fun i => (Ideal.Quotient.mk (Ideal.map C I)) (X i)) f) =
    f
state_after: case h_C
R : Type u_1
σ : Type u_2
inst✝ : CommRing R
r : R
I : Ideal R
f : MvPolynomial σ (R ⧸ I)
⊢ ∀ (a : R ⧸ I),
    (Ideal.Quotient.lift (Ideal.map C I) (eval₂Hom (C.comp (Ideal.Quotient.mk I)) X) ⋯)
        (eval₂ (Ideal.Quotient.lift I ((Ideal.Quotient.mk (Ideal.map C I)).comp C) ⋯)
          (fun i => (Ideal.Quotient.mk (Ideal.map C I)) (X i)) (C a)) =
      C a

case h_add
R : Type u_1
σ : Type u_2
inst✝ : CommRing R
r : R
I : Ideal R
f : MvPolynomial σ (R ⧸ I)
⊢ ∀ (p q : MvPolynomial σ (R ⧸ I)),
    (Ideal.Quotient.lift (Ideal.map C I) (eval₂Hom (C.comp (Ideal.Quotient.mk I)) X) ⋯)
          (eval₂ (Ideal.Quotient.lift I ((Ideal.Quotient.mk (Ideal.map C I)).comp C) ⋯)
            (fun i => (Ideal.Quotient.mk (Ideal.map C I)) (X i)) p) =
        p →
      (Ideal.Quotient.lift (Ideal.map C I) (eval₂Hom (C.comp (Ideal.Quotient.mk I)) X) ⋯)
            (eval₂ (Ideal.Quotient.lift I ((Ideal.Quotient.mk (Ideal.map C I)).comp C) ⋯)
              (fun i => (Ideal.Quotient.mk (Ideal.map C I)) (X i)) q) =
          q →
        (Ideal.Quotient.lift (Ideal.map C I) (eval₂Hom (C.comp (Ideal.Quotient.mk I)) X) ⋯)
            (eval₂ (Ideal.Quotient.lift I ((Ideal.Quotient.mk (Ideal.map C I)).comp C) ⋯)
              (fun i => (Ideal.Quotient.mk (Ideal.map C I)) (X i)) (p + q)) =
          p + q

case h_X
R : Type u_1
σ : Type u_2
inst✝ : CommRing R
r : R
I : Ideal R
f : MvPolynomial σ (R ⧸ I)
⊢ ∀ (p : MvPolynomial σ (R ⧸ I)) (n : σ),
    (Ideal.Quotient.lift (Ideal.map C I) (eval₂Hom (C.comp (Ideal.Quotient.mk I)) X) ⋯)
          (eval₂ (Ideal.Quotient.lift I ((Ideal.Quotient.mk (Ideal.map C I)).comp C) ⋯)
            (fun i => (Ideal.Quotient.mk (Ideal.map C I)) (X i)) p) =
        p →
      (Ideal.Quotient.lift (Ideal.map C I) (eval₂Hom (C.comp (Ideal.Quotient.mk I)) X) ⋯)
          (eval₂ (Ideal.Quotient.lift I ((Ideal.Quotient.mk (Ideal.map C I)).comp C) ⋯)
            (fun i => (Ideal.Quotient.mk (Ideal.map C I)) (X i)) (p * X n)) =
        p * X n
tactic: apply induction_on f
Theorem: PartENat.withTopEquiv_symm_ofNat
File: Mathlib/Data/Nat/PartENat.lean

Proof steps:
state_before: n : ℕ
inst✝ : n.AtLeastTwo
⊢ withTopEquiv.symm (OfNat.ofNat n) = OfNat.ofNat n
state_after: no goals
tactic: simp
Theorem: IsIntegralClosure.mk'_algebraMap
File: Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁷ : CommRing R
inst✝⁶ : CommRing A
inst✝⁵ : CommRing B
inst✝⁴ : Algebra R B
inst✝³ : Algebra A B
inst✝² : IsIntegralClosure A R B
inst✝¹ : Algebra R A
inst✝ : IsScalarTower R A B
x : R
h : optParam (IsIntegral R ((algebraMap R B) x)) ⋯
⊢ (algebraMap A B) (mk' A ((algebraMap R B) x) h) = (algebraMap A B) ((algebraMap R A) x)
state_after: no goals
tactic: rw [algebraMap_mk', ← IsScalarTower.algebraMap_apply]
Theorem: CochainComplex.HomComplex.Cochain.leftShift_leftUnshift
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplexShift.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n✝ : ℤ
γ✝ γ₁ γ₂ : Cochain K L n✝
a n' : ℤ
γ : Cochain ((CategoryTheory.shiftFunctor (CochainComplex C ℤ) a).obj K) L n'
n : ℤ
hn' : n + a = n'
⊢ (γ.leftUnshift n hn').leftShift a n' hn' = γ
state_after: case h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n✝ : ℤ
γ✝ γ₁ γ₂ : Cochain K L n✝
a n' : ℤ
γ : Cochain ((CategoryTheory.shiftFunctor (CochainComplex C ℤ) a).obj K) L n'
n : ℤ
hn' : n + a = n'
p q : ℤ
hpq : p + n' = q
⊢ ((γ.leftUnshift n hn').leftShift a n' hn').v p q hpq = γ.v p q hpq
tactic: ext p q hpq
state_before: case h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n✝ : ℤ
γ✝ γ₁ γ₂ : Cochain K L n✝
a n' : ℤ
γ : Cochain ((CategoryTheory.shiftFunctor (CochainComplex C ℤ) a).obj K) L n'
n : ℤ
hn' : n + a = n'
p q : ℤ
hpq : p + n' = q
⊢ ((γ.leftUnshift n hn').leftShift a n' hn').v p q hpq = γ.v p q hpq
state_after: no goals
tactic: rw [(γ.leftUnshift n hn').leftShift_v a n' hn' p q hpq (q-n) (by omega),
    γ.leftUnshift_v n hn' (q-n) q (by omega) p hpq, Linear.comp_units_smul, smul_smul,
    Iso.hom_inv_id_assoc, Int.units_mul_self, one_smul]
Theorem: USize.size_eq
File: .lake/packages/batteries/Batteries/Data/UInt.lean

Proof steps:
state_before: ⊢ size = 2 ^ System.Platform.numBits
state_after: this : 1 ≤ 2 ^ System.Platform.numBits
⊢ size = 2 ^ System.Platform.numBits
tactic: have : 1 ≤ 2 ^ System.Platform.numBits := Nat.succ_le_of_lt (Nat.two_pow_pos _)
state_before: this : 1 ≤ 2 ^ System.Platform.numBits
⊢ size = 2 ^ System.Platform.numBits
state_after: no goals
tactic: rw [USize.size, Nat.sub_add_cancel this]
Theorem: AddSubgroup.nsmul_index_mem
File: Mathlib/GroupTheory/OrderOfElement.lean

Proof steps:
state_before: G✝ : Type u_1
H✝ : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝³ : Group G✝
inst✝² : Fintype G✝
x : G✝
n : ℕ
G : Type u_6
inst✝¹ : Group G
H : Subgroup G
inst✝ : H.Normal
g : G
⊢ g ^ H.index ∈ H
state_after: no goals
tactic: rw [← eq_one_iff, QuotientGroup.mk_pow H, index, pow_card_eq_one']
Theorem: MvPolynomial.vars_map_of_injective
File: Mathlib/Algebra/MvPolynomial/Variables.lean

Proof steps:
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p q : MvPolynomial σ R
inst✝ : CommSemiring S
f : R →+* S
hf : Injective ⇑f
⊢ ((map f) p).vars = p.vars
state_after: no goals
tactic: simp [vars, degrees_map_of_injective _ hf]
Theorem: UniqueFactorizationMonoid.normalizedFactors_one
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

Proof steps:
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
⊢ normalizedFactors 1 = 0
state_after: case inl
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
h : Subsingleton α
⊢ normalizedFactors 1 = 0

case inr
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
h : Nontrivial α
⊢ normalizedFactors 1 = 0
tactic: cases' subsingleton_or_nontrivial α with h h
Theorem: HomologicalComplex.dFrom_comp_xNextIso
File: Mathlib/Algebra/Homology/HomologicalComplex.lean

Proof steps:
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
i j : ι
r : c.Rel i j
⊢ C.dFrom i ≫ (C.xNextIso r).hom = C.d i j
state_after: no goals
tactic: simp [C.dFrom_eq r]
Theorem: ContextFreeGrammar.mem_reverse_language_iff_reverse_mem_language
File: Mathlib/Computability/ContextFreeGrammar.lean

Proof steps:
state_before: T : Type uT
g : ContextFreeGrammar T
w : List T
⊢ w ∈ g.reverse.language ↔ w.reverse ∈ g.language
state_after: T : Type uT
g : ContextFreeGrammar T
w : List T
hw : w.reverse ∈ g.language
⊢ w ∈ g.reverse.language
tactic: refine ⟨reverse_mem_language_of_mem_reverse_language _, fun hw => ?_⟩
state_before: T : Type uT
g : ContextFreeGrammar T
w : List T
hw : w.reverse ∈ g.language
⊢ w ∈ g.reverse.language
state_after: T : Type uT
g : ContextFreeGrammar T
w : List T
hw : w.reverse ∈ g.reverse.reverse.language
⊢ w ∈ g.reverse.language
tactic: rw [← ContextFreeGrammar.reverse_involutive g] at hw
state_before: T : Type uT
g : ContextFreeGrammar T
w : List T
hw : w.reverse ∈ g.reverse.reverse.language
⊢ w ∈ g.reverse.language
state_after: T : Type uT
g : ContextFreeGrammar T
w : List T
hw : w.reverse ∈ g.reverse.reverse.language
⊢ w.reverse.reverse ∈ g.reverse.language
tactic: rw [← List.reverse_reverse w]
state_before: T : Type uT
g : ContextFreeGrammar T
w : List T
hw : w.reverse ∈ g.reverse.reverse.language
⊢ w.reverse.reverse ∈ g.reverse.language
state_after: no goals
tactic: exact g.reverse.reverse_mem_language_of_mem_reverse_language hw
Theorem: Set.subset_centralizer_centralizer
File: Mathlib/Algebra/Group/Center.lean

Proof steps:
state_before: M : Type u_1
S T : Set M
inst✝ : Mul M
⊢ S ⊆ S.centralizer.centralizer
state_after: M : Type u_1
S T : Set M
inst✝ : Mul M
x : M
hx : x ∈ S
⊢ x ∈ S.centralizer.centralizer
tactic: intro x hx
state_before: M : Type u_1
S T : Set M
inst✝ : Mul M
x : M
hx : x ∈ S
⊢ x ∈ S.centralizer.centralizer
state_after: M : Type u_1
S T : Set M
inst✝ : Mul M
x : M
hx : x ∈ S
⊢ ∀ (m : M), (∀ m_1 ∈ S, m_1 * m = m * m_1) → m * x = x * m
tactic: simp only [Set.mem_centralizer_iff]
state_before: M : Type u_1
S T : Set M
inst✝ : Mul M
x : M
hx : x ∈ S
⊢ ∀ (m : M), (∀ m_1 ∈ S, m_1 * m = m * m_1) → m * x = x * m
state_after: no goals
tactic: exact fun y hy => (hy x hx).symm
Theorem: UpperSet.compl_iSup₂
File: Mathlib/Order/UpperLower/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝ : LE α
s t : UpperSet α
a : α
f : (i : ι) → κ i → UpperSet α
⊢ (⨆ i, ⨆ j, f i j).compl = ⨆ i, ⨆ j, (f i j).compl
state_after: no goals
tactic: simp_rw [UpperSet.compl_iSup]
Theorem: Turing.Tape.move_right_mk'
File: Mathlib/Computability/TuringMachine.lean

Proof steps:
state_before: Γ : Type u_1
inst✝ : Inhabited Γ
L R : ListBlank Γ
⊢ move Dir.right (mk' L R) = mk' (ListBlank.cons R.head L) R.tail
state_after: no goals
tactic: simp only [Tape.move, Tape.mk', ListBlank.head_cons, eq_self_iff_true, ListBlank.cons_head_tail,
    and_self_iff, ListBlank.tail_cons]
Theorem: DirectSum.ofList_dProd
File: Mathlib/Algebra/DirectSum/Ring.lean

Proof steps:
state_before: ι : Type u_1
inst✝³ : DecidableEq ι
A : ι → Type u_2
inst✝² : (i : ι) → AddCommMonoid (A i)
inst✝¹ : AddMonoid ι
inst✝ : GSemiring A
α : Type u_3
l : List α
fι : α → ι
fA : (a : α) → A (fι a)
⊢ (of A (l.dProdIndex fι)) (l.dProd fι fA) = (List.map (fun a => (of A (fι a)) (fA a)) l).prod
state_after: case nil
ι : Type u_1
inst✝³ : DecidableEq ι
A : ι → Type u_2
inst✝² : (i : ι) → AddCommMonoid (A i)
inst✝¹ : AddMonoid ι
inst✝ : GSemiring A
α : Type u_3
fι : α → ι
fA : (a : α) → A (fι a)
⊢ (of A ([].dProdIndex fι)) ([].dProd fι fA) = (List.map (fun a => (of A (fι a)) (fA a)) []).prod

case cons
ι : Type u_1
inst✝³ : DecidableEq ι
A : ι → Type u_2
inst✝² : (i : ι) → AddCommMonoid (A i)
inst✝¹ : AddMonoid ι
inst✝ : GSemiring A
α : Type u_3
fι : α → ι
fA : (a : α) → A (fι a)
head : α
tail : List α
tail_ih✝ : (of A (tail.dProdIndex fι)) (tail.dProd fι fA) = (List.map (fun a => (of A (fι a)) (fA a)) tail).prod
⊢ (of A ((head :: tail).dProdIndex fι)) ((head :: tail).dProd fι fA) =
    (List.map (fun a => (of A (fι a)) (fA a)) (head :: tail)).prod
tactic: induction' l with head tail
Theorem: Int.units_natAbs
File: Mathlib/Algebra/Group/Int.lean

Proof steps:
state_before: u✝ v : ℤ
u : ℤˣ
⊢ (↑u).natAbs * (↑u⁻¹).natAbs = 1
state_after: u✝ v : ℤ
u : ℤˣ
⊢ natAbs 1 = 1
tactic: rw [← natAbs_mul, Units.mul_inv]
state_before: u✝ v : ℤ
u : ℤˣ
⊢ natAbs 1 = 1
state_after: no goals
tactic: rfl
state_before: u✝ v : ℤ
u : ℤˣ
⊢ (↑u⁻¹).natAbs * (↑u).natAbs = 1
state_after: u✝ v : ℤ
u : ℤˣ
⊢ natAbs 1 = 1
tactic: rw [← natAbs_mul, Units.inv_mul]
state_before: u✝ v : ℤ
u : ℤˣ
⊢ natAbs 1 = 1
state_after: no goals
tactic: rfl
Theorem: Algebra.IsAlgebraic.algEquivEquivAlgHom_symm_apply
File: Mathlib/RingTheory/Algebraic.lean

Proof steps:
state_before: K : Type u_1
L : Type u_2
R : Type u_3
S : Type u_4
A : Type u_5
inst✝⁴ : CommRing K
inst✝³ : Field L
inst✝² : Algebra K L
inst✝¹ : NoZeroSMulDivisors K L
inst✝ : Algebra.IsAlgebraic K L
x✝ : L ≃ₐ[K] L
⊢ (fun ϕ => AlgEquiv.ofBijective ϕ ⋯) ((fun ϕ => ↑ϕ) x✝) = x✝
state_after: case h
K : Type u_1
L : Type u_2
R : Type u_3
S : Type u_4
A : Type u_5
inst✝⁴ : CommRing K
inst✝³ : Field L
inst✝² : Algebra K L
inst✝¹ : NoZeroSMulDivisors K L
inst✝ : Algebra.IsAlgebraic K L
x✝ : L ≃ₐ[K] L
a✝ : L
⊢ ((fun ϕ => AlgEquiv.ofBijective ϕ ⋯) ((fun ϕ => ↑ϕ) x✝)) a✝ = x✝ a✝
tactic: ext
state_before: case h
K : Type u_1
L : Type u_2
R : Type u_3
S : Type u_4
A : Type u_5
inst✝⁴ : CommRing K
inst✝³ : Field L
inst✝² : Algebra K L
inst✝¹ : NoZeroSMulDivisors K L
inst✝ : Algebra.IsAlgebraic K L
x✝ : L ≃ₐ[K] L
a✝ : L
⊢ ((fun ϕ => AlgEquiv.ofBijective ϕ ⋯) ((fun ϕ => ↑ϕ) x✝)) a✝ = x✝ a✝
state_after: no goals
tactic: rfl
state_before: K : Type u_1
L : Type u_2
R : Type u_3
S : Type u_4
A : Type u_5
inst✝⁴ : CommRing K
inst✝³ : Field L
inst✝² : Algebra K L
inst✝¹ : NoZeroSMulDivisors K L
inst✝ : Algebra.IsAlgebraic K L
x✝ : L →ₐ[K] L
⊢ (fun ϕ => ↑ϕ) ((fun ϕ => AlgEquiv.ofBijective ϕ ⋯) x✝) = x✝
state_after: case H
K : Type u_1
L : Type u_2
R : Type u_3
S : Type u_4
A : Type u_5
inst✝⁴ : CommRing K
inst✝³ : Field L
inst✝² : Algebra K L
inst✝¹ : NoZeroSMulDivisors K L
inst✝ : Algebra.IsAlgebraic K L
x✝¹ : L →ₐ[K] L
x✝ : L
⊢ ((fun ϕ => ↑ϕ) ((fun ϕ => AlgEquiv.ofBijective ϕ ⋯) x✝¹)) x✝ = x✝¹ x✝
tactic: ext
state_before: case H
K : Type u_1
L : Type u_2
R : Type u_3
S : Type u_4
A : Type u_5
inst✝⁴ : CommRing K
inst✝³ : Field L
inst✝² : Algebra K L
inst✝¹ : NoZeroSMulDivisors K L
inst✝ : Algebra.IsAlgebraic K L
x✝¹ : L →ₐ[K] L
x✝ : L
⊢ ((fun ϕ => ↑ϕ) ((fun ϕ => AlgEquiv.ofBijective ϕ ⋯) x✝¹)) x✝ = x✝¹ x✝
state_after: no goals
tactic: rfl
Theorem: AddAction.stabilizer_coe_finset
File: Mathlib/Algebra/Pointwise/Stabilizer.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
α : Type u_3
inst✝³ : Group G
inst✝² : Group H
inst✝¹ : MulAction G α
a : G
inst✝ : DecidableEq α
s : Finset α
⊢ stabilizer G ↑s = stabilizer G s
state_after: case h
G : Type u_1
H : Type u_2
α : Type u_3
inst✝³ : Group G
inst✝² : Group H
inst✝¹ : MulAction G α
a : G
inst✝ : DecidableEq α
s : Finset α
x✝ : G
⊢ x✝ ∈ stabilizer G ↑s ↔ x✝ ∈ stabilizer G s
tactic: ext
state_before: case h
G : Type u_1
H : Type u_2
α : Type u_3
inst✝³ : Group G
inst✝² : Group H
inst✝¹ : MulAction G α
a : G
inst✝ : DecidableEq α
s : Finset α
x✝ : G
⊢ x✝ ∈ stabilizer G ↑s ↔ x✝ ∈ stabilizer G s
state_after: no goals
tactic: simp [← Finset.coe_inj]