ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: List.ofFnRec_ofFn
File: Mathlib/Data/List/OfFn.lean

Proof steps:
state_before: α : Type u
C : List α → Sort u_1
h : (n : ℕ) → (f : Fin n → α) → C (ofFn f)
n : ℕ
f : Fin n → α
⊢ ofFnRec h (ofFn f) = h n f
state_after: α : Type u
C : List α → Sort u_1
h : (n : ℕ) → (f : Fin n → α) → C (ofFn f)
n : ℕ
f : Fin n → α
this : Function.RightInverse ⇑equivSigmaTuple.symm ⇑equivSigmaTuple
⊢ ofFnRec h (ofFn f) = h n f
tactic: have := (@equivSigmaTuple α).rightInverse_symm
state_before: α : Type u
C : List α → Sort u_1
h : (n : ℕ) → (f : Fin n → α) → C (ofFn f)
n : ℕ
f : Fin n → α
this : Function.RightInverse ⇑equivSigmaTuple.symm ⇑equivSigmaTuple
⊢ ofFnRec h (ofFn f) = h n f
state_after: α : Type u
C : List α → Sort u_1
h : (n : ℕ) → (f : Fin n → α) → C (ofFn f)
n : ℕ
f : Fin n → α
this : Function.RightInverse (fun f => ofFn f.snd) fun l => ⟨l.length, l.get⟩
⊢ ofFnRec h (ofFn f) = h n f
tactic: dsimp [equivSigmaTuple] at this
state_before: α : Type u
C : List α → Sort u_1
h : (n : ℕ) → (f : Fin n → α) → C (ofFn f)
n : ℕ
f : Fin n → α
this : Function.RightInverse (fun f => ofFn f.snd) fun l => ⟨l.length, l.get⟩
⊢ ofFnRec h (ofFn f) = h n f
state_after: α : Type u
C : List α → Sort u_1
h : (n : ℕ) → (f : Fin n → α) → C (ofFn f)
n : ℕ
f : Fin n → α
this✝ : Function.RightInverse (fun f => ofFn f.snd) fun l => ⟨l.length, l.get⟩
this :
  cast ⋯
      (h ⟨(ofFn ⟨n, f⟩.snd).length, (ofFn ⟨n, f⟩.snd).get⟩.fst ⟨(ofFn ⟨n, f⟩.snd).length, (ofFn ⟨n, f⟩.snd).get⟩.snd) =
    h ⟨n, f⟩.fst ⟨n, f⟩.snd
⊢ ofFnRec h (ofFn f) = h n f
tactic: have := this.cast_eq (fun s => h s.1 s.2) ⟨n, f⟩
state_before: α : Type u
C : List α → Sort u_1
h : (n : ℕ) → (f : Fin n → α) → C (ofFn f)
n : ℕ
f : Fin n → α
this✝ : Function.RightInverse (fun f => ofFn f.snd) fun l => ⟨l.length, l.get⟩
this :
  cast ⋯
      (h ⟨(ofFn ⟨n, f⟩.snd).length, (ofFn ⟨n, f⟩.snd).get⟩.fst ⟨(ofFn ⟨n, f⟩.snd).length, (ofFn ⟨n, f⟩.snd).get⟩.snd) =
    h ⟨n, f⟩.fst ⟨n, f⟩.snd
⊢ ofFnRec h (ofFn f) = h n f
state_after: α : Type u
C : List α → Sort u_1
h : (n : ℕ) → (f : Fin n → α) → C (ofFn f)
n : ℕ
f : Fin n → α
this✝ : Function.RightInverse (fun f => ofFn f.snd) fun l => ⟨l.length, l.get⟩
this : cast ⋯ (h (ofFn f).length (ofFn f).get) = h n f
⊢ ofFnRec h (ofFn f) = h n f
tactic: dsimp only at this
state_before: α : Type u
C : List α → Sort u_1
h : (n : ℕ) → (f : Fin n → α) → C (ofFn f)
n : ℕ
f : Fin n → α
this✝ : Function.RightInverse (fun f => ofFn f.snd) fun l => ⟨l.length, l.get⟩
this : cast ⋯ (h (ofFn f).length (ofFn f).get) = h n f
⊢ ofFnRec h (ofFn f) = h n f
state_after: no goals
tactic: rw [ofFnRec, ← this]
Theorem: AddSubgroup.norm_normedMk
File: Mathlib/Analysis/Normed/Group/Quotient.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
h : ↑S.topologicalClosure ≠ univ
⊢ ‖S.normedMk‖ = 1
state_after: M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
h : ↑S.topologicalClosure ≠ univ
⊢ 1 ≤ ‖S.normedMk‖
tactic: refine le_antisymm (norm_normedMk_le S) ?_
state_before: M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
h : ↑S.topologicalClosure ≠ univ
⊢ 1 ≤ ‖S.normedMk‖
state_after: case intro
M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
h : ↑S.topologicalClosure ≠ univ
x : M
hx : 0 < ‖↑x‖
⊢ 1 ≤ ‖S.normedMk‖
tactic: obtain ⟨x, hx⟩ : ∃ x : M, 0 < ‖(x : M ⧸ S)‖ := by
    refine (Set.nonempty_compl.2 h).imp fun x hx ↦ ?_
    exact (norm_nonneg _).lt_of_ne' <| mt (quotient_norm_eq_zero_iff S x).1 hx
state_before: case intro
M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
h : ↑S.topologicalClosure ≠ univ
x : M
hx : 0 < ‖↑x‖
⊢ 1 ≤ ‖S.normedMk‖
state_after: case intro
M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
h : ↑S.topologicalClosure ≠ univ
x : M
hx : 0 < ‖↑x‖
⊢ ‖↑x‖ ≤ ‖S.normedMk‖ * ‖↑x‖
tactic: refine (le_mul_iff_one_le_left hx).1 ?_
state_before: case intro
M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
h : ↑S.topologicalClosure ≠ univ
x : M
hx : 0 < ‖↑x‖
⊢ ‖↑x‖ ≤ ‖S.normedMk‖ * ‖↑x‖
state_after: no goals
tactic: exact norm_lift_apply_le S.normedMk (fun x ↦ (eq_zero_iff x).2) x
Theorem: FirstOrder.Language.BoundedFormula.semanticallyEquivalent_not_not
File: Mathlib/ModelTheory/Satisfiability.lean

Proof steps:
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
φ ψ : L.BoundedFormula α n
M : T.ModelType
v : α → ↑M
xs : Fin n → ↑M
⊢ (φ ⇔ ∼∼φ).Realize v xs
state_after: no goals
tactic: simp
Theorem: Valuation.Integers.isUnit_of_one'
File: Mathlib/RingTheory/Valuation/Integers.lean

Proof steps:
state_before: F : Type u
Γ₀ : Type v
inst✝³ : Field F
inst✝² : LinearOrderedCommGroupWithZero Γ₀
v : Valuation F Γ₀
O : Type w
inst✝¹ : CommRing O
inst✝ : Algebra O F
hv : v.Integers O
x : O
hvx : v ((algebraMap O F) x) = 1
⊢ IsUnit x
state_after: F : Type u
Γ₀ : Type v
inst✝³ : Field F
inst✝² : LinearOrderedCommGroupWithZero Γ₀
v : Valuation F Γ₀
O : Type w
inst✝¹ : CommRing O
inst✝ : Algebra O F
hv : v.Integers O
x : O
hvx : v ((algebraMap O F) x) = 1
⊢ (algebraMap O F) x ≠ 0
tactic: refine isUnit_of_one hv (IsUnit.mk0 _ ?_) hvx
state_before: F : Type u
Γ₀ : Type v
inst✝³ : Field F
inst✝² : LinearOrderedCommGroupWithZero Γ₀
v : Valuation F Γ₀
O : Type w
inst✝¹ : CommRing O
inst✝ : Algebra O F
hv : v.Integers O
x : O
hvx : v ((algebraMap O F) x) = 1
⊢ (algebraMap O F) x ≠ 0
state_after: no goals
tactic: simp only [← v.ne_zero_iff, hvx, ne_eq, one_ne_zero, not_false_eq_true]
Theorem: AddSubmonoid.centralizer_centralizer_centralizer
File: Mathlib/GroupTheory/Submonoid/Centralizer.lean

Proof steps:
state_before: M : Type u_1
S T : Set M
inst✝ : Monoid M
s : Set M
⊢ centralizer s.centralizer.centralizer = centralizer s
state_after: case a
M : Type u_1
S T : Set M
inst✝ : Monoid M
s : Set M
⊢ ↑(centralizer s.centralizer.centralizer) = ↑(centralizer s)
tactic: apply SetLike.coe_injective
state_before: case a
M : Type u_1
S T : Set M
inst✝ : Monoid M
s : Set M
⊢ ↑(centralizer s.centralizer.centralizer) = ↑(centralizer s)
state_after: no goals
tactic: simp only [coe_centralizer, Set.centralizer_centralizer_centralizer]
Theorem: CategoryTheory.Limits.IsZero.of_epi
File: Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : Epi f
i : IsZero X
⊢ IsZero Y
state_after: C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : Epi f
i : IsZero X
hf : f = 0
⊢ IsZero Y
tactic: have hf := i.eq_zero_of_src f
state_before: C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : Epi f
i : IsZero X
hf : f = 0
⊢ IsZero Y
state_after: C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y : C
i : IsZero X
inst✝ : Epi 0
⊢ IsZero Y
tactic: subst hf
state_before: C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y : C
i : IsZero X
inst✝ : Epi 0
⊢ IsZero Y
state_after: no goals
tactic: exact IsZero.of_epi_zero X Y
Theorem: QuotientGroup.preimage_image_coe
File: Mathlib/GroupTheory/QuotientGroup.lean

Proof steps:
state_before: G : Type u
inst✝² : Group G
N : Subgroup G
nN : N.Normal
H : Type v
inst✝¹ : Group H
M : Type x
inst✝ : Monoid M
s : Set G
⊢ mk ⁻¹' (mk '' s) = ↑N * s
state_after: case h
G : Type u
inst✝² : Group G
N : Subgroup G
nN : N.Normal
H : Type v
inst✝¹ : Group H
M : Type x
inst✝ : Monoid M
s : Set G
a : G
⊢ a ∈ mk ⁻¹' (mk '' s) ↔ a ∈ ↑N * s
tactic: ext a
state_before: case h
G : Type u
inst✝² : Group G
N : Subgroup G
nN : N.Normal
H : Type v
inst✝¹ : Group H
M : Type x
inst✝ : Monoid M
s : Set G
a : G
⊢ a ∈ mk ⁻¹' (mk '' s) ↔ a ∈ ↑N * s
state_after: case h.mp
G : Type u
inst✝² : Group G
N : Subgroup G
nN : N.Normal
H : Type v
inst✝¹ : Group H
M : Type x
inst✝ : Monoid M
s : Set G
a : G
⊢ a ∈ mk ⁻¹' (mk '' s) → a ∈ ↑N * s

case h.mpr
G : Type u
inst✝² : Group G
N : Subgroup G
nN : N.Normal
H : Type v
inst✝¹ : Group H
M : Type x
inst✝ : Monoid M
s : Set G
a : G
⊢ a ∈ ↑N * s → a ∈ mk ⁻¹' (mk '' s)
tactic: constructor
Theorem: EuclideanDomain.lcm_zero_left
File: Mathlib/Algebra/EuclideanDomain/Basic.lean

Proof steps:
state_before: R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
x : R
⊢ lcm 0 x = 0
state_after: no goals
tactic: rw [lcm, zero_mul, zero_div]
Theorem: MeasureTheory.pdf.uniformPDF_eq_pdf
File: Mathlib/Probability/Distributions/Uniform.lean

Proof steps:
state_before: E : Type u_1
inst✝ : MeasurableSpace E
m μ : Measure E
Ω : Type u_2
x✝ : MeasurableSpace Ω
ℙ : Measure Ω
X : Ω → E
s : Set E
hs : MeasurableSet s
hu : IsUniform X s ℙ μ
⊢ (fun x => uniformPDF s x μ) =ᶠ[ae μ] pdf X ℙ μ
state_after: E : Type u_1
inst✝ : MeasurableSpace E
m μ : Measure E
Ω : Type u_2
x✝ : MeasurableSpace Ω
ℙ : Measure Ω
X : Ω → E
s : Set E
hs : MeasurableSet s
hu : IsUniform X s ℙ μ
⊢ (fun x => s.indicator ((μ s)⁻¹ • 1) x) =ᶠ[ae μ] pdf X ℙ μ
tactic: unfold uniformPDF
state_before: E : Type u_1
inst✝ : MeasurableSpace E
m μ : Measure E
Ω : Type u_2
x✝ : MeasurableSpace Ω
ℙ : Measure Ω
X : Ω → E
s : Set E
hs : MeasurableSet s
hu : IsUniform X s ℙ μ
⊢ (fun x => s.indicator ((μ s)⁻¹ • 1) x) =ᶠ[ae μ] pdf X ℙ μ
state_after: no goals
tactic: exact Filter.EventuallyEq.trans (pdf.IsUniform.pdf_eq hs hu).symm (ae_eq_refl _)
Theorem: ArithmeticFunction.ppow_succ
File: Mathlib/NumberTheory/ArithmeticFunction.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
f : ArithmeticFunction R
k : ℕ
kpos : 0 < k
⊢ f.ppow (k + 1) = (f.ppow k).pmul f
state_after: case h
R : Type u_1
inst✝ : Semiring R
f : ArithmeticFunction R
k : ℕ
kpos : 0 < k
x : ℕ
⊢ (f.ppow (k + 1)) x = ((f.ppow k).pmul f) x
tactic: ext x
state_before: case h
R : Type u_1
inst✝ : Semiring R
f : ArithmeticFunction R
k : ℕ
kpos : 0 < k
x : ℕ
⊢ (f.ppow (k + 1)) x = ((f.ppow k).pmul f) x
state_after: case h
R : Type u_1
inst✝ : Semiring R
f : ArithmeticFunction R
k : ℕ
kpos : 0 < k
x : ℕ
⊢ f x ^ k * f x = ((f.ppow k).pmul f) x
tactic: rw [ppow_apply (Nat.succ_pos k), _root_.pow_succ]
state_before: case h
R : Type u_1
inst✝ : Semiring R
f : ArithmeticFunction R
k : ℕ
kpos : 0 < k
x : ℕ
⊢ f x ^ k * f x = ((f.ppow k).pmul f) x
state_after: no goals
tactic: induction k <;> simp
Theorem: AlgebraicTopology.DoldKan.PInfty_comp_map_mono_eq_zero
File: Mathlib/AlgebraicTopology/DoldKan/NCompGamma.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
n : ℕ
Δ' : SimplexCategory
i : Δ' ⟶ [n]
hi : Mono i
h₁ : Δ'.len ≠ n
h₂ : ¬Isδ₀ i
⊢ PInfty.f n ≫ X.map i.op = 0
state_after: case h
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
n m : ℕ
i : [m] ⟶ [n]
hi : Mono i
h₁ : [m].len ≠ n
h₂ : ¬Isδ₀ i
⊢ PInfty.f n ≫ X.map i.op = 0
tactic: induction' Δ' using SimplexCategory.rec with m
state_before: case h
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
n m : ℕ
i : [m] ⟶ [n]
hi : Mono i
h₁ : [m].len ≠ n
h₂ : ¬Isδ₀ i
⊢ PInfty.f n ≫ X.map i.op = 0
state_after: case h.intro
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
n m : ℕ
i : [m] ⟶ [n]
hi : Mono i
h₁ : [m].len ≠ n
h₂ : ¬Isδ₀ i
k : ℕ
hk : [n].len = [m].len + k + 1
⊢ PInfty.f n ≫ X.map i.op = 0
tactic: obtain ⟨k, hk⟩ := Nat.exists_eq_add_of_lt (len_lt_of_mono i fun h => by
        rw [← h] at h₁
        exact h₁ rfl)
state_before: case h.intro
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
n m : ℕ
i : [m] ⟶ [n]
hi : Mono i
h₁ : [m].len ≠ n
h₂ : ¬Isδ₀ i
k : ℕ
hk : [n].len = [m].len + k + 1
⊢ PInfty.f n ≫ X.map i.op = 0
state_after: case h.intro
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
n m : ℕ
i : [m] ⟶ [n]
hi : Mono i
h₁ : [m].len ≠ n
h₂ : ¬Isδ₀ i
k : ℕ
hk : n = m + k + 1
⊢ PInfty.f n ≫ X.map i.op = 0
tactic: simp only [len_mk] at hk
state_before: case h.intro
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
n m : ℕ
i : [m] ⟶ [n]
hi : Mono i
h₁ : [m].len ≠ n
h₂ : ¬Isδ₀ i
k : ℕ
hk : n = m + k + 1
⊢ PInfty.f n ≫ X.map i.op = 0
state_after: case h.intro.zero
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
n m : ℕ
i : [m] ⟶ [n]
hi : Mono i
h₁ : [m].len ≠ n
h₂ : ¬Isδ₀ i
hk : n = m + 0 + 1
⊢ PInfty.f n ≫ X.map i.op = 0

case h.intro.succ
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
n m : ℕ
i : [m] ⟶ [n]
hi : Mono i
h₁ : [m].len ≠ n
h₂ : ¬Isδ₀ i
k : ℕ
hk : n = m + (k + 1) + 1
⊢ PInfty.f n ≫ X.map i.op = 0
tactic: rcases k with _|k
Theorem: Matrix.cons_mul
File: Mathlib/Data/Matrix/Notation.lean

Proof steps:
state_before: α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : Fintype n'
v : n' → α
A : Fin m → n' → α
B : Matrix n' o' α
⊢ of (vecCons v A) * B = of (vecCons (v ᵥ* B) (of.symm (of A * B)))
state_after: case a
α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : Fintype n'
v : n' → α
A : Fin m → n' → α
B : Matrix n' o' α
i : Fin m.succ
j : o'
⊢ (of (vecCons v A) * B) i j = of (vecCons (v ᵥ* B) (of.symm (of A * B))) i j
tactic: ext i j
state_before: case a
α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : Fintype n'
v : n' → α
A : Fin m → n' → α
B : Matrix n' o' α
i : Fin m.succ
j : o'
⊢ (of (vecCons v A) * B) i j = of (vecCons (v ᵥ* B) (of.symm (of A * B))) i j
state_after: case a.refine_1
α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : Fintype n'
v : n' → α
A : Fin m → n' → α
B : Matrix n' o' α
i : Fin m.succ
j : o'
⊢ (of (vecCons v A) * B) 0 j = of (vecCons (v ᵥ* B) (of.symm (of A * B))) 0 j

case a.refine_2
α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : Fintype n'
v : n' → α
A : Fin m → n' → α
B : Matrix n' o' α
i : Fin m.succ
j : o'
⊢ ∀ (i : Fin m), (of (vecCons v A) * B) i.succ j = of (vecCons (v ᵥ* B) (of.symm (of A * B))) i.succ j
tactic: refine Fin.cases ?_ ?_ i
state_before: case a.refine_2
α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : Fintype n'
v : n' → α
A : Fin m → n' → α
B : Matrix n' o' α
i : Fin m.succ
j : o'
⊢ ∀ (i : Fin m), (of (vecCons v A) * B) i.succ j = of (vecCons (v ᵥ* B) (of.symm (of A * B))) i.succ j
state_after: no goals
tactic: simp [mul_val_succ]
Theorem: SimpleGraph.deleteEdges_empty
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

Proof steps:
state_before: ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v w : V
e : Sym2 V
H : SimpleGraph V
s s₁ s₂ : Set (Sym2 V)
⊢ G.deleteEdges ∅ = G
state_after: no goals
tactic: simp [deleteEdges]
Theorem: Polynomial.mirror_zero
File: Mathlib/Algebra/Polynomial/Mirror.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
p q : R[X]
⊢ mirror 0 = 0
state_after: no goals
tactic: simp [mirror]
Theorem: SimpleGraph.IsNClique.map
File: Mathlib/Combinatorics/SimpleGraph/Clique.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
s : Finset α
a b c : α
h : G.IsNClique n s
f : α ↪ β
⊢ (SimpleGraph.map f G).IsClique ↑(map f s)
state_after: α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
s : Finset α
a b c : α
h : G.IsNClique n s
f : α ↪ β
⊢ (SimpleGraph.map f G).IsClique (⇑f '' ↑s)
tactic: rw [coe_map]
state_before: α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
s : Finset α
a b c : α
h : G.IsNClique n s
f : α ↪ β
⊢ (SimpleGraph.map f G).IsClique (⇑f '' ↑s)
state_after: no goals
tactic: exact h.1.map
Theorem: Finset.weightedVSub_vadd
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_4
s✝ : Finset ι
ι₂ : Type u_5
s₂ : Finset ι₂
s : Finset ι
w : ι → k
h : ∑ i ∈ s, w i = 0
p : ι → P
v : V
⊢ (s.weightedVSub (v +ᵥ p)) w = (s.weightedVSub p) w
state_after: no goals
tactic: rw [weightedVSub, weightedVSubOfPoint_vadd,
    weightedVSub_eq_weightedVSubOfPoint_of_sum_eq_zero _ _ _ h]
Theorem: TruncatedWittVector.commutes_symm'
File: Mathlib/RingTheory/WittVector/Compare.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝ : CommRing R
m : ℕ
hm : n ≤ m
x : TruncatedWittVector p m (ZMod p)
⊢ (zmodEquivTrunc p n).symm ((truncate hm) x) = (ZMod.castHom ⋯ (ZMod (p ^ n))) ((zmodEquivTrunc p m).symm x)
state_after: case a
p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝ : CommRing R
m : ℕ
hm : n ≤ m
x : TruncatedWittVector p m (ZMod p)
⊢ (zmodEquivTrunc p n) ((zmodEquivTrunc p n).symm ((truncate hm) x)) =
    (zmodEquivTrunc p n) ((ZMod.castHom ⋯ (ZMod (p ^ n))) ((zmodEquivTrunc p m).symm x))
tactic: apply (zmodEquivTrunc p n).injective
state_before: case a
p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝ : CommRing R
m : ℕ
hm : n ≤ m
x : TruncatedWittVector p m (ZMod p)
⊢ (zmodEquivTrunc p n) ((zmodEquivTrunc p n).symm ((truncate hm) x)) =
    (zmodEquivTrunc p n) ((ZMod.castHom ⋯ (ZMod (p ^ n))) ((zmodEquivTrunc p m).symm x))
state_after: case a
p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝ : CommRing R
m : ℕ
hm : n ≤ m
x : TruncatedWittVector p m (ZMod p)
⊢ (zmodEquivTrunc p n) ((zmodEquivTrunc p n).symm ((truncate hm) x)) =
    (truncate hm) ((zmodEquivTrunc p m) ((zmodEquivTrunc p m).symm x))
tactic: rw [← commutes' _ _ hm]
state_before: case a
p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝ : CommRing R
m : ℕ
hm : n ≤ m
x : TruncatedWittVector p m (ZMod p)
⊢ (zmodEquivTrunc p n) ((zmodEquivTrunc p n).symm ((truncate hm) x)) =
    (truncate hm) ((zmodEquivTrunc p m) ((zmodEquivTrunc p m).symm x))
state_after: no goals
tactic: simp
Theorem: FreeGroup.Red.Step.sublist
File: Mathlib/GroupTheory/FreeGroup/Basic.lean

Proof steps:
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
H : Step L₁ L₂
⊢ L₂ <+ L₁
state_after: case not
α : Type u
L L₃ L₄ L₁✝ L₂✝ : List (α × Bool)
x✝ : α
b✝ : Bool
⊢ L₁✝ ++ L₂✝ <+ L₁✝ ++ (x✝, b✝) :: (x✝, !b✝) :: L₂✝
tactic: cases H
state_before: case not
α : Type u
L L₃ L₄ L₁✝ L₂✝ : List (α × Bool)
x✝ : α
b✝ : Bool
⊢ L₁✝ ++ L₂✝ <+ L₁✝ ++ (x✝, b✝) :: (x✝, !b✝) :: L₂✝
state_after: case not
α : Type u
L L₃ L₄ L₁✝ L₂✝ : List (α × Bool)
x✝ : α
b✝ : Bool
⊢ L₂✝ <+ (x✝, b✝) :: (x✝, !b✝) :: L₂✝
tactic: simp
state_before: case not
α : Type u
L L₃ L₄ L₁✝ L₂✝ : List (α × Bool)
x✝ : α
b✝ : Bool
⊢ L₂✝ <+ (x✝, b✝) :: (x✝, !b✝) :: L₂✝
state_after: case not.a
α : Type u
L L₃ L₄ L₁✝ L₂✝ : List (α × Bool)
x✝ : α
b✝ : Bool
⊢ L₂✝ <+ (x✝, !b✝) :: L₂✝
tactic: constructor
state_before: case not.a
α : Type u
L L₃ L₄ L₁✝ L₂✝ : List (α × Bool)
x✝ : α
b✝ : Bool
⊢ L₂✝ <+ (x✝, !b✝) :: L₂✝
state_after: case not.a.a
α : Type u
L L₃ L₄ L₁✝ L₂✝ : List (α × Bool)
x✝ : α
b✝ : Bool
⊢ L₂✝ <+ L₂✝
tactic: constructor
state_before: case not.a.a
α : Type u
L L₃ L₄ L₁✝ L₂✝ : List (α × Bool)
x✝ : α
b✝ : Bool
⊢ L₂✝ <+ L₂✝
state_after: no goals
tactic: rfl
Theorem: equivShrink_neg
File: Mathlib/Logic/Small/Group.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Neg α
inst✝ : Small.{u_2, u_1} α
x : α
⊢ (equivShrink α) (-x) = -(equivShrink α) x
state_after: α : Type u_1
inst✝¹ : Neg α
inst✝ : Small.{u_2, u_1} α
x : α
⊢ (equivShrink α) (-x) = (equivShrink α).symm.symm (-(equivShrink α).symm ((equivShrink α) x))
tactic: rw [Equiv.neg_def]
state_before: α : Type u_1
inst✝¹ : Neg α
inst✝ : Small.{u_2, u_1} α
x : α
⊢ (equivShrink α) (-x) = (equivShrink α).symm.symm (-(equivShrink α).symm ((equivShrink α) x))
state_after: no goals
tactic: simp
Theorem: Padic.rat_dense
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

Proof steps:
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
q : ℚ_[p]
ε : ℝ
hε : 0 < ε
ε' : ℚ
hε'l : 0 < ↑ε'
hε'r : ↑ε' < ε
⊢ 0 < ε'
state_after: no goals
tactic: simpa using hε'l
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
q : ℚ_[p]
ε : ℝ
hε : 0 < ε
ε' : ℚ
hε'l : 0 < ↑ε'
hε'r : ↑ε' < ε
r : ℚ
hr : padicNormE (q - ↑r) < ε'
⊢ ‖q - ↑r‖ < ↑ε'
state_after: no goals
tactic: simpa [Norm.norm] using hr
Theorem: inv_lt_self_iff
File: Mathlib/Algebra/Order/Group/Defs.lean

Proof steps:
state_before: α : Type u
inst✝ : LinearOrderedCommGroup α
a b c : α
⊢ a⁻¹ < a ↔ 1 < a
state_after: no goals
tactic: simp [inv_lt_iff_one_lt_mul]
Theorem: groupCohomology.resolution.actionDiagonalSucc_inv_apply
File: Mathlib/RepresentationTheory/GroupCohomology/Resolution.lean

Proof steps:
state_before: k G✝ : Type u
inst✝² : CommRing k
n✝ : ℕ
inst✝¹ : Group G✝
G : Type u
inst✝ : Group G
n : ℕ
g : G
f : Fin n → G
⊢ (actionDiagonalSucc G n).inv.hom (g, f) = g • partialProd f
state_after: k G✝ : Type u
inst✝² : CommRing k
n✝ : ℕ
inst✝¹ : Group G✝
G : Type u
inst✝ : Group G
n : ℕ
f : Fin n → G
⊢ ∀ (g : G), (actionDiagonalSucc G n).inv.hom (g, f) = g • partialProd f
tactic: revert g
state_before: k G✝ : Type u
inst✝² : CommRing k
n✝ : ℕ
inst✝¹ : Group G✝
G : Type u
inst✝ : Group G
n : ℕ
f : Fin n → G
⊢ ∀ (g : G), (actionDiagonalSucc G n).inv.hom (g, f) = g • partialProd f
state_after: case zero
k G✝ : Type u
inst✝² : CommRing k
n : ℕ
inst✝¹ : Group G✝
G : Type u
inst✝ : Group G
f : Fin 0 → G
⊢ ∀ (g : G), (actionDiagonalSucc G 0).inv.hom (g, f) = g • partialProd f

case succ
k G✝ : Type u
inst✝² : CommRing k
n✝ : ℕ
inst✝¹ : Group G✝
G : Type u
inst✝ : Group G
n : ℕ
hn : ∀ (f : Fin n → G) (g : G), (actionDiagonalSucc G n).inv.hom (g, f) = g • partialProd f
f : Fin (n + 1) → G
⊢ ∀ (g : G), (actionDiagonalSucc G (n + 1)).inv.hom (g, f) = g • partialProd f
tactic: induction' n with n hn
Theorem: CochainComplex.HomComplex.Cochain.leftShift_smul
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' : ℤ
hn' : n + a = n'
x : R
⊢ (x • γ).leftShift a n' hn' = x • γ.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' : ℤ
hn' : n + a = n'
x : R
p q : ℤ
hpq : p + n' = q
⊢ ((x • γ).leftShift a n' hn').v p q hpq = (x • γ.leftShift a n' hn').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' : ℤ
hn' : n + a = n'
x : R
p q : ℤ
hpq : p + n' = q
⊢ ((x • γ).leftShift a n' hn').v p q hpq = (x • γ.leftShift a n' hn').v p q hpq
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' : ℤ
hn' : n + a = n'
x : R
p q : ℤ
hpq : p + n' = q
⊢ ((x • γ).leftShift a n' hn').v p q hpq = x • (γ.leftShift a n' hn').v p q hpq
tactic: dsimp
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' : ℤ
hn' : n + a = n'
x : R
p q : ℤ
hpq : p + n' = q
⊢ ((x • γ).leftShift a n' hn').v p q hpq = x • (γ.leftShift a n' hn').v p q hpq
state_after: no goals
tactic: simp only [leftShift_v _ a n' hn' p q hpq (p + a) (by omega), smul_v, Linear.comp_smul,
    smul_comm x]
Theorem: Set.biUnion_of_singleton
File: Mathlib/Data/Set/Lattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
s : Set α
⊢ ∀ (x : α), x ∈ ⋃ x ∈ s, {x} ↔ x ∈ s
state_after: no goals
tactic: simp