ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: sup_assoc
File: Mathlib/Order/Lattice.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝ : SemilatticeSup α
a✝ b✝ c✝ d a b c x : α
⊢ a ⊔ b ⊔ c ≤ x ↔ a ⊔ (b ⊔ c) ≤ x
state_after: α : Type u
β : Type v
inst✝ : SemilatticeSup α
a✝ b✝ c✝ d a b c x : α
⊢ (a ≤ x ∧ b ≤ x) ∧ c ≤ x ↔ a ≤ x ∧ b ≤ x ∧ c ≤ x
tactic: simp only [sup_le_iff]
state_before: α : Type u
β : Type v
inst✝ : SemilatticeSup α
a✝ b✝ c✝ d a b c x : α
⊢ (a ≤ x ∧ b ≤ x) ∧ c ≤ x ↔ a ≤ x ∧ b ≤ x ∧ c ≤ x
state_after: no goals
tactic: rw [and_assoc]
Theorem: Matrix.IsHermitian.exists_eigenvector_of_ne_zero
File: Mathlib/LinearAlgebra/Matrix/Spectrum.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝¹ : RCLike 𝕜
n : Type u_2
inst✝ : Fintype n
A : Matrix n n 𝕜
hA : A.IsHermitian
h_ne : A ≠ 0
⊢ ∃ v t, t ≠ 0 ∧ v ≠ 0 ∧ A *ᵥ v = t • v
state_after: no goals
tactic: classical
  have : hA.eigenvalues ≠ 0 := by
    contrapose! h_ne
    have := hA.spectral_theorem
    rwa [h_ne, Pi.comp_zero, RCLike.ofReal_zero, (by rfl : Function.const n (0 : 𝕜) = fun _ ↦ 0),
      diagonal_zero, mul_zero, zero_mul] at this
  obtain ⟨i, hi⟩ := Function.ne_iff.mp this
  exact ⟨_, _, hi, hA.eigenvectorBasis.orthonormal.ne_zero i, hA.mulVec_eigenvectorBasis i⟩
Theorem: Polynomial.toFinsupp_add
File: Mathlib/Algebra/Polynomial/Basic.lean

Proof steps:
state_before: R : Type u
a✝ b✝ : R
m n : ℕ
inst✝ : Semiring R
p q a b : R[X]
⊢ (a + b).toFinsupp = a.toFinsupp + b.toFinsupp
state_after: case ofFinsupp
R : Type u
a b✝ : R
m n : ℕ
inst✝ : Semiring R
p q b : R[X]
toFinsupp✝ : R[ℕ]
⊢ ({ toFinsupp := toFinsupp✝ } + b).toFinsupp = { toFinsupp := toFinsupp✝ }.toFinsupp + b.toFinsupp
tactic: cases a
state_before: case ofFinsupp
R : Type u
a b✝ : R
m n : ℕ
inst✝ : Semiring R
p q b : R[X]
toFinsupp✝ : R[ℕ]
⊢ ({ toFinsupp := toFinsupp✝ } + b).toFinsupp = { toFinsupp := toFinsupp✝ }.toFinsupp + b.toFinsupp
state_after: case ofFinsupp.ofFinsupp
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
toFinsupp✝¹ toFinsupp✝ : R[ℕ]
⊢ ({ toFinsupp := toFinsupp✝¹ } + { toFinsupp := toFinsupp✝ }).toFinsupp =
    { toFinsupp := toFinsupp✝¹ }.toFinsupp + { toFinsupp := toFinsupp✝ }.toFinsupp
tactic: cases b
state_before: case ofFinsupp.ofFinsupp
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
toFinsupp✝¹ toFinsupp✝ : R[ℕ]
⊢ ({ toFinsupp := toFinsupp✝¹ } + { toFinsupp := toFinsupp✝ }).toFinsupp =
    { toFinsupp := toFinsupp✝¹ }.toFinsupp + { toFinsupp := toFinsupp✝ }.toFinsupp
state_after: no goals
tactic: rw [← ofFinsupp_add]
Theorem: MeasureTheory.measurableEquiv_range_coe_nat_of_infinite_of_countable
File: Mathlib/MeasureTheory/Constructions/Polish/EmbeddingReal.lean

Proof steps:
state_before: α : Type u_1
inst✝³ : MeasurableSpace α
inst✝² : StandardBorelSpace α
inst✝¹ : Infinite α
inst✝ : Countable α
⊢ Nonempty (α ≃ᵐ ↑(range Nat.cast))
state_after: α : Type u_1
inst✝³ : MeasurableSpace α
inst✝² : StandardBorelSpace α
inst✝¹ : Infinite α
inst✝ : Countable α
this : PolishSpace ↑(range Nat.cast)
⊢ Nonempty (α ≃ᵐ ↑(range Nat.cast))
tactic: have : PolishSpace (range ((↑) : ℕ → ℝ)) :=
    Nat.closedEmbedding_coe_real.isClosedMap.isClosed_range.polishSpace
state_before: α : Type u_1
inst✝³ : MeasurableSpace α
inst✝² : StandardBorelSpace α
inst✝¹ : Infinite α
inst✝ : Countable α
this : PolishSpace ↑(range Nat.cast)
⊢ Nonempty (α ≃ᵐ ↑(range Nat.cast))
state_after: α : Type u_1
inst✝³ : MeasurableSpace α
inst✝² : StandardBorelSpace α
inst✝¹ : Infinite α
inst✝ : Countable α
this : PolishSpace ↑(range Nat.cast)
⊢ α ≃ ↑(range Nat.cast)
tactic: refine ⟨PolishSpace.Equiv.measurableEquiv ?_⟩
state_before: α : Type u_1
inst✝³ : MeasurableSpace α
inst✝² : StandardBorelSpace α
inst✝¹ : Infinite α
inst✝ : Countable α
this : PolishSpace ↑(range Nat.cast)
⊢ α ≃ ↑(range Nat.cast)
state_after: α : Type u_1
inst✝³ : MeasurableSpace α
inst✝² : StandardBorelSpace α
inst✝¹ : Infinite α
inst✝ : Countable α
this : PolishSpace ↑(range Nat.cast)
⊢ ℕ ≃ ↑(range Nat.cast)
tactic: refine (nonempty_equiv_of_countable.some : α ≃ ℕ).trans ?_
state_before: α : Type u_1
inst✝³ : MeasurableSpace α
inst✝² : StandardBorelSpace α
inst✝¹ : Infinite α
inst✝ : Countable α
this : PolishSpace ↑(range Nat.cast)
⊢ ℕ ≃ ↑(range Nat.cast)
state_after: no goals
tactic: exact Equiv.ofInjective ((↑) : ℕ → ℝ) Nat.cast_injective
Theorem: ContinuousMultilinearMap.norm_iteratedFDeriv_le
File: Mathlib/Analysis/Calculus/FDeriv/Analytic.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁷ : NontriviallyNormedField 𝕜
E✝ : Type u
inst✝⁶ : NormedAddCommGroup E✝
inst✝⁵ : NormedSpace 𝕜 E✝
F : Type v
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace 𝕜 F
ι : Type u_2
E : ι → Type u_3
inst✝² : (i : ι) → NormedAddCommGroup (E i)
inst✝¹ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝ : Fintype ι
f : ContinuousMultilinearMap 𝕜 E F
n✝ : ℕ∞
x✝ : (i : ι) → E i
n : ℕ
x : (i : ι) → E i
⊢ ‖iteratedFDeriv 𝕜 n (⇑f) x‖ ≤ ↑((Fintype.card ι).descFactorial n) * ‖f‖ * ‖x‖ ^ (Fintype.card ι - n)
state_after: 𝕜 : Type u_1
inst✝⁷ : NontriviallyNormedField 𝕜
E✝ : Type u
inst✝⁶ : NormedAddCommGroup E✝
inst✝⁵ : NormedSpace 𝕜 E✝
F : Type v
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace 𝕜 F
ι : Type u_2
E : ι → Type u_3
inst✝² : (i : ι) → NormedAddCommGroup (E i)
inst✝¹ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝ : Fintype ι
f : ContinuousMultilinearMap 𝕜 E F
n✝ : ℕ∞
x✝ : (i : ι) → E i
n : ℕ
x : (i : ι) → E i
⊢ ‖f.iteratedFDeriv n x‖ ≤ ↑((Fintype.card ι).descFactorial n) * ‖f‖ * ‖x‖ ^ (Fintype.card ι - n)
tactic: rw [f.iteratedFDeriv_eq]
state_before: 𝕜 : Type u_1
inst✝⁷ : NontriviallyNormedField 𝕜
E✝ : Type u
inst✝⁶ : NormedAddCommGroup E✝
inst✝⁵ : NormedSpace 𝕜 E✝
F : Type v
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace 𝕜 F
ι : Type u_2
E : ι → Type u_3
inst✝² : (i : ι) → NormedAddCommGroup (E i)
inst✝¹ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝ : Fintype ι
f : ContinuousMultilinearMap 𝕜 E F
n✝ : ℕ∞
x✝ : (i : ι) → E i
n : ℕ
x : (i : ι) → E i
⊢ ‖f.iteratedFDeriv n x‖ ≤ ↑((Fintype.card ι).descFactorial n) * ‖f‖ * ‖x‖ ^ (Fintype.card ι - n)
state_after: no goals
tactic: exact f.norm_iteratedFDeriv_le' n x
Theorem: SemidirectProduct.map_inr
File: Mathlib/GroupTheory/SemidirectProduct.lean

Proof steps:
state_before: N : Type u_1
G : Type u_2
H : Type u_3
inst✝⁴ : Group N
inst✝³ : Group G
inst✝² : Group H
φ : G →* MulAut N
N₁ : Type u_4
G₁ : Type u_5
inst✝¹ : Group N₁
inst✝ : Group G₁
φ₁ : G₁ →* MulAut N₁
f₁ : N →* N₁
f₂ : G →* G₁
h : ∀ (g : G), f₁.comp (MulEquiv.toMonoidHom (φ g)) = (MulEquiv.toMonoidHom (φ₁ (f₂ g))).comp f₁
g : G
⊢ (map f₁ f₂ h) (inr g) = inr (f₂ g)
state_after: no goals
tactic: simp [map]
Theorem: DFinsupp.piecewise_single_erase
File: Mathlib/Data/DFinsupp/Basic.lean

Proof steps:
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
s : Finset ι
x✝ : (i : ↑↑s) → β ↑i
i✝ : ι
x : Π₀ (i : ι), β i
i : ι
inst✝ : (i' : ι) → Decidable (i' ∈ {i})
⊢ (single i (x i)).piecewise (erase i x) {i} = x
state_after: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
s : Finset ι
x✝ : (i : ↑↑s) → β ↑i
i✝ : ι
x : Π₀ (i : ι), β i
i : ι
inst✝ : (i' : ι) → Decidable (i' ∈ {i})
j : ι
⊢ ((single i (x i)).piecewise (erase i x) {i}) j = x j
tactic: ext j
state_before: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
s : Finset ι
x✝ : (i : ↑↑s) → β ↑i
i✝ : ι
x : Π₀ (i : ι), β i
i : ι
inst✝ : (i' : ι) → Decidable (i' ∈ {i})
j : ι
⊢ ((single i (x i)).piecewise (erase i x) {i}) j = x j
state_after: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
s : Finset ι
x✝ : (i : ↑↑s) → β ↑i
i✝ : ι
x : Π₀ (i : ι), β i
i : ι
inst✝ : (i' : ι) → Decidable (i' ∈ {i})
j : ι
⊢ (if j ∈ {i} then (single i (x i)) j else (erase i x) j) = x j
tactic: rw [piecewise_apply]
state_before: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
s : Finset ι
x✝ : (i : ↑↑s) → β ↑i
i✝ : ι
x : Π₀ (i : ι), β i
i : ι
inst✝ : (i' : ι) → Decidable (i' ∈ {i})
j : ι
⊢ (if j ∈ {i} then (single i (x i)) j else (erase i x) j) = x j
state_after: case pos
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
s : Finset ι
x✝ : (i : ↑↑s) → β ↑i
i✝ : ι
x : Π₀ (i : ι), β i
i : ι
inst✝ : (i' : ι) → Decidable (i' ∈ {i})
j : ι
h : j ∈ {i}
⊢ (single i (x i)) j = x j

case neg
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
s : Finset ι
x✝ : (i : ↑↑s) → β ↑i
i✝ : ι
x : Π₀ (i : ι), β i
i : ι
inst✝ : (i' : ι) → Decidable (i' ∈ {i})
j : ι
h : j ∉ {i}
⊢ (erase i x) j = x j
tactic: split_ifs with h
Theorem: inv_smul_lt_iff_of_neg
File: Mathlib/Algebra/Order/Module/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
a✝ a₁ a₂ : α
b b₁✝ b₂✝ : β
inst✝³ : LinearOrderedField α
inst✝² : OrderedAddCommGroup β
inst✝¹ : Module α β
a : α
b₁ b₂ : β
inst✝ : PosSMulStrictMono α β
h : a < 0
⊢ a⁻¹ • b₁ < b₂ ↔ a • b₂ < b₁
state_after: no goals
tactic: rw [← smul_lt_smul_iff_of_neg_left h, smul_inv_smul₀ h.ne]
Theorem: Stream'.Seq.join_append
File: Mathlib/Data/Seq/Seq.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
S T : Seq (Seq1 α)
⊢ (S.append T).join = S.join.append T.join
state_after: case bisim
α : Type u
β : Type v
γ : Type w
S T : Seq (Seq1 α)
⊢ IsBisimulation fun s1 s2 => ∃ s S T, s1 = s.append (S.append T).join ∧ s2 = s.append (S.join.append T.join)

case r
α : Type u
β : Type v
γ : Type w
S T : Seq (Seq1 α)
⊢ ∃ s S_1 T_1,
    (S.append T).join = s.append (S_1.append T_1).join ∧ S.join.append T.join = s.append (S_1.join.append T_1.join)
tactic: apply
    eq_of_bisim fun s1 s2 =>
      ∃ s S T, s1 = append s (join (append S T)) ∧ s2 = append s (append (join S) (join T))
Theorem: Computation.of_think_mem
File: Mathlib/Data/Seq/Computation.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
s : Computation α
a : α
n : ℕ
h : (fun b => some a = b) ((↑s.think).get n)
⊢ a ∈ s
state_after: case zero
α : Type u
β : Type v
γ : Type w
s : Computation α
a : α
h : some a = (↑s.think).get 0
⊢ a ∈ s

case succ
α : Type u
β : Type v
γ : Type w
s : Computation α
a : α
n' : ℕ
h : some a = (↑s.think).get (n' + 1)
⊢ a ∈ s
tactic: cases' n with n'
Theorem: Int.clog_of_right_le_zero
File: Mathlib/Data/Int/Log.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r : R
hr : r ≤ 0
⊢ clog b r = 0
state_after: R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r : R
hr : r ≤ 0
⊢ ⌊r⁻¹⌋₊ < b ∨ b ≤ 1
tactic: rw [clog, if_neg (hr.trans_lt zero_lt_one).not_le, neg_eq_zero, Int.natCast_eq_zero,
    Nat.log_eq_zero_iff]
state_before: R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r : R
hr : r ≤ 0
⊢ ⌊r⁻¹⌋₊ < b ∨ b ≤ 1
state_after: case inl
R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r : R
hr : r ≤ 0
hb : b ≤ 1
⊢ ⌊r⁻¹⌋₊ < b ∨ b ≤ 1

case inr
R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r : R
hr : r ≤ 0
hb : 1 < b
⊢ ⌊r⁻¹⌋₊ < b ∨ b ≤ 1
tactic: rcases le_or_lt b 1 with hb | hb
Theorem: MeasureTheory.AEEqFun.toGerm_injective
File: Mathlib/MeasureTheory/Function/AEEqFun.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : MeasurableSpace α
μ ν : Measure α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f g : α →ₘ[μ] β
H : f.toGerm = g.toGerm
⊢ ↑↑f = ↑↑g
state_after: no goals
tactic: rwa [← toGerm_eq, ← toGerm_eq]
Theorem: IsLocalization.coeSubmodule_bot
File: Mathlib/RingTheory/Localization/Submodule.lean

Proof steps:
state_before: R : Type u_1
inst✝³ : CommRing R
M : Submonoid R
S : Type u_2
inst✝² : CommRing S
inst✝¹ : Algebra R S
P : Type u_3
inst✝ : CommRing P
⊢ coeSubmodule S ⊥ = ⊥
state_after: no goals
tactic: rw [coeSubmodule, Submodule.map_bot]
Theorem: _private.Mathlib.SetTheory.Cardinal.Subfield.0.Subfield.surjective_ofWType
File: Mathlib/SetTheory/Cardinal/Subfield.lean

Proof steps:
state_before: α : Type u
s : Set α
inst✝ : DivisionRing α
⊢ Function.Surjective (WType.elim (↥(closure s)) (Subfield.operate s))
state_after: α : Type u
s : Set α
inst✝ : DivisionRing α
⊢ Set.range (WType.elim (↥(closure s)) (Subfield.operate s)) = Set.univ
tactic: rw [← Set.range_iff_surjective]
state_before: α : Type u
s : Set α
inst✝ : DivisionRing α
⊢ Set.range (WType.elim (↥(closure s)) (Subfield.operate s)) = Set.univ
state_after: no goals
tactic: exact SetLike.coe_set_eq.mpr (rangeOfWType_eq_top s)
Theorem: Pi.isAtom_single
File: Mathlib/Order/Atoms.lean

Proof steps:
state_before: ι✝ : Sort u_1
α : Type u_2
β : Type u_3
ι : Type u_4
π : ι → Type u
i : ι
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → PartialOrder (π i)
inst✝ : (i : ι) → OrderBot (π i)
a : π i
h : IsAtom a
⊢ IsAtom (Function.update ⊥ i a i)
state_after: no goals
tactic: simpa
Theorem: le_mul_of_le_one_left
File: Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
β : Type u_1
inst✝⁵ : Semiring α
inst✝⁴ : Preorder α
a b c d : α
inst✝³ : ExistsAddOfLE α
inst✝² : MulPosMono α
inst✝¹ : CovariantClass α α (swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝ : ContravariantClass α α (swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
hb : b ≤ 0
h : a ≤ 1
⊢ b ≤ a * b
state_after: no goals
tactic: simpa only [one_mul] using mul_le_mul_of_nonpos_right h hb
Theorem: Module.End.iSup_genEigenspace_le_smul
File: Mathlib/LinearAlgebra/Eigenspace/Basic.lean

Proof steps:
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
μ t : R
⊢ ⨆ k, (f.genEigenspace μ) k ≤ ⨆ k, ((t • f).genEigenspace (t * μ)) k
state_after: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
μ t : R
m : M
hm : m ∈ ⨆ k, (f.genEigenspace μ) k
⊢ m ∈ ⨆ k, ((t • f).genEigenspace (t * μ)) k
tactic: intro m hm
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
μ t : R
m : M
hm : m ∈ ⨆ k, (f.genEigenspace μ) k
⊢ m ∈ ⨆ k, ((t • f).genEigenspace (t * μ)) k
state_after: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
μ t : R
m : M
hm : ∃ k, ((f - μ • 1) ^ k) m = 0
⊢ ∃ k, ((t • f - (t * μ) • 1) ^ k) m = 0
tactic: simp only [Submodule.mem_iSup_of_chain, mem_genEigenspace] at hm ⊢
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
μ t : R
m : M
hm : ∃ k, ((f - μ • 1) ^ k) m = 0
⊢ ∃ k, ((t • f - (t * μ) • 1) ^ k) m = 0
state_after: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
μ t : R
m : M
hm : ∃ k, ((f - μ • 1) ^ k) m = 0
k : ℕ
hk : ((f - μ • 1) ^ k) m = 0
⊢ ((t • f - (t * μ) • 1) ^ k) m = 0
tactic: refine Exists.imp (fun k hk ↦ ?_) hm
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
μ t : R
m : M
hm : ∃ k, ((f - μ • 1) ^ k) m = 0
k : ℕ
hk : ((f - μ • 1) ^ k) m = 0
⊢ ((t • f - (t * μ) • 1) ^ k) m = 0
state_after: no goals
tactic: rw [mul_smul, ← smul_sub, smul_pow, LinearMap.smul_apply, hk, smul_zero]
Theorem: SetTheory.PGame.moveLeft_nim
File: Mathlib/SetTheory/Game/Nim.lean

Proof steps:
state_before: o : Ordinal.{u_1}
i : ↑(Set.Iio o)
⊢ (nim o).moveLeft (toLeftMovesNim i) = nim ↑i
state_after: no goals
tactic: simp
Theorem: Real.sq_sqrt
File: Mathlib/Data/Real/Sqrt.lean

Proof steps:
state_before: x y : ℝ
h : 0 ≤ x
⊢ √x ^ 2 = x
state_after: no goals
tactic: rw [sq, mul_self_sqrt h]
Theorem: AddAction.zsmul_add_period_vadd
File: Mathlib/Dynamics/PeriodicPts.lean

Proof steps:
state_before: α : Type v
G : Type u
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u
inst✝¹ : Monoid M
inst✝ : MulAction M α
i : ℤ
g : G
a : α
⊢ g ^ (i + ↑(period g a)) • a = g ^ i • a
state_after: no goals
tactic: rw [← zpow_mod_period_smul, Int.add_emod_self, zpow_mod_period_smul]
Theorem: List.getLast_cons
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a : α
l : List α
⊢ ∀ (h : l ≠ []), (a :: l).getLast ⋯ = l.getLast h
state_after: case nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a : α
h✝ : [] ≠ []
⊢ [a].getLast ⋯ = [].getLast h✝

case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a head✝ : α
tail✝ : List α
tail_ih✝ : ∀ (h : tail✝ ≠ []), (a :: tail✝).getLast ⋯ = tail✝.getLast h
h✝ : head✝ :: tail✝ ≠ []
⊢ (a :: head✝ :: tail✝).getLast ⋯ = (head✝ :: tail✝).getLast h✝
tactic: induction l <;> intros
Theorem: Sym2.map_id
File: Mathlib/Data/Sym/Sym2.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
⊢ map id = id
state_after: case h.mk.mk
α : Type u_1
β : Type u_2
γ : Type u_3
x✝ : Sym2 α
x y : α
⊢ map id (Quot.mk (Rel α) (x, y)) = id (Quot.mk (Rel α) (x, y))
tactic: ext ⟨⟨x, y⟩⟩
state_before: case h.mk.mk
α : Type u_1
β : Type u_2
γ : Type u_3
x✝ : Sym2 α
x y : α
⊢ map id (Quot.mk (Rel α) (x, y)) = id (Quot.mk (Rel α) (x, y))
state_after: no goals
tactic: rfl
Theorem: MeasureTheory.stoppedProcess_eq
File: Mathlib/Probability/Process/Stopping.lean

Proof steps:
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
f : Filtration ℕ m
u : ℕ → Ω → β
τ π : Ω → ℕ
inst✝ : AddCommMonoid β
n : ℕ
⊢ stoppedProcess u τ n = {a | n ≤ τ a}.indicator (u n) + ∑ i ∈ Finset.range n, {ω | τ ω = i}.indicator (u i)
state_after: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
f : Filtration ℕ m
u : ℕ → Ω → β
τ π : Ω → ℕ
inst✝ : AddCommMonoid β
n : ℕ
⊢ {a | n ≤ τ a}.indicator (u n) + ∑ i ∈ Finset.Iio n, {ω | τ ω = i}.indicator (u i) =
    {a | n ≤ τ a}.indicator (u n) + ∑ i ∈ Finset.range n, {ω | τ ω = i}.indicator (u i)
tactic: rw [stoppedProcess_eq'' n]
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
f : Filtration ℕ m
u : ℕ → Ω → β
τ π : Ω → ℕ
inst✝ : AddCommMonoid β
n : ℕ
⊢ {a | n ≤ τ a}.indicator (u n) + ∑ i ∈ Finset.Iio n, {ω | τ ω = i}.indicator (u i) =
    {a | n ≤ τ a}.indicator (u n) + ∑ i ∈ Finset.range n, {ω | τ ω = i}.indicator (u i)
state_after: case e_a.e_s.a
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
f : Filtration ℕ m
u : ℕ → Ω → β
τ π : Ω → ℕ
inst✝ : AddCommMonoid β
n i : ℕ
⊢ i ∈ Finset.Iio n ↔ i ∈ Finset.range n
tactic: congr with i
state_before: case e_a.e_s.a
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
f : Filtration ℕ m
u : ℕ → Ω → β
τ π : Ω → ℕ
inst✝ : AddCommMonoid β
n i : ℕ
⊢ i ∈ Finset.Iio n ↔ i ∈ Finset.range n
state_after: no goals
tactic: rw [Finset.mem_Iio, Finset.mem_range]
Theorem: Finsupp.graph_zero
File: Mathlib/Data/Finsupp/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : Zero M
⊢ graph 0 = ∅
state_after: no goals
tactic: simp [graph]
Theorem: CategoryTheory.Sieve.functorPushforward_id
File: Mathlib/CategoryTheory/Sites/Sieves.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f : Y ⟶ X
S R✝ : Sieve X
E : Type u₃
inst✝ : Category.{v₃, u₃} E
G : D ⥤ E
R : Sieve X
⊢ functorPushforward (𝟭 C) R = R
state_after: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
X✝ Y Z : C
f✝ : Y ⟶ X✝
S R✝ : Sieve X✝
E : Type u₃
inst✝ : Category.{v₃, u₃} E
G : D ⥤ E
R : Sieve X✝
X : C
f : X ⟶ (𝟭 C).obj X✝
⊢ (functorPushforward (𝟭 C) R).arrows f ↔ R.arrows f
tactic: ext X f
state_before: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
X✝ Y Z : C
f✝ : Y ⟶ X✝
S R✝ : Sieve X✝
E : Type u₃
inst✝ : Category.{v₃, u₃} E
G : D ⥤ E
R : Sieve X✝
X : C
f : X ⟶ (𝟭 C).obj X✝
⊢ (functorPushforward (𝟭 C) R).arrows f ↔ R.arrows f
state_after: case h.mp
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
X✝ Y Z : C
f✝ : Y ⟶ X✝
S R✝ : Sieve X✝
E : Type u₃
inst✝ : Category.{v₃, u₃} E
G : D ⥤ E
R : Sieve X✝
X : C
f : X ⟶ (𝟭 C).obj X✝
⊢ (functorPushforward (𝟭 C) R).arrows f → R.arrows f

case h.mpr
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
X✝ Y Z : C
f✝ : Y ⟶ X✝
S R✝ : Sieve X✝
E : Type u₃
inst✝ : Category.{v₃, u₃} E
G : D ⥤ E
R : Sieve X✝
X : C
f : X ⟶ (𝟭 C).obj X✝
⊢ R.arrows f → (functorPushforward (𝟭 C) R).arrows f
tactic: constructor
Theorem: Fin.card_Ioi
File: Mathlib/Order/Interval/Finset/Fin.lean

Proof steps:
state_before: n : ℕ
a b : Fin n
⊢ (Ioi a).card = n - 1 - ↑a
state_after: no goals
tactic: rw [← card_map, map_valEmbedding_Ioi, Nat.card_Ioc]
Theorem: Subgroup.mem_rightTransversals_iff_existsUnique_mul_inv_mem
File: Mathlib/GroupTheory/Complement.lean

Proof steps:
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
⊢ S ∈ rightTransversals T ↔ ∀ (g : G), ∃! s, g * (↑s)⁻¹ ∈ T
state_after: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
⊢ (∀ (g : G), ∃! x, ↑x.1 * ↑x.2 = g) ↔ ∀ (g : G), ∃! s, g * (↑s)⁻¹ ∈ T
tactic: rw [rightTransversals, Set.mem_setOf_eq, isComplement_iff_existsUnique]
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
⊢ (∀ (g : G), ∃! x, ↑x.1 * ↑x.2 = g) ↔ ∀ (g : G), ∃! s, g * (↑s)⁻¹ ∈ T
state_after: case refine_1
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
h : ∀ (g : G), ∃! x, ↑x.1 * ↑x.2 = g
g : G
⊢ ∃! s, g * (↑s)⁻¹ ∈ T

case refine_2
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
h : ∀ (g : G), ∃! s, g * (↑s)⁻¹ ∈ T
g : G
⊢ ∃! x, ↑x.1 * ↑x.2 = g
tactic: refine ⟨fun h g => ?_, fun h g => ?_⟩
Theorem: LinearMap.BilinForm.isSkewAdjoint_iff_neg_self_adjoint
File: Mathlib/LinearAlgebra/BilinearForm/Properties.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝¹⁸ : CommSemiring R
inst✝¹⁷ : AddCommMonoid M
inst✝¹⁶ : Module R M
R₁ : Type u_3
M₁ : Type u_4
inst✝¹⁵ : CommRing R₁
inst✝¹⁴ : AddCommGroup M₁
inst✝¹³ : Module R₁ M₁
V : Type u_5
K : Type u_6
inst✝¹² : Field K
inst✝¹¹ : AddCommGroup V
inst✝¹⁰ : Module K V
M'✝ : Type u_7
M''✝ : Type u_8
inst✝⁹ : AddCommMonoid M'✝
inst✝⁸ : AddCommMonoid M''✝
inst✝⁷ : Module R M'✝
inst✝⁶ : Module R M''✝
B : BilinForm R M
B₁ : BilinForm R₁ M₁
F : BilinForm R M
M' : Type u_9
inst✝⁵ : AddCommMonoid M'
inst✝⁴ : Module R M'
B' : BilinForm R M'
f✝ f' : M →ₗ[R] M'
g g' : M' →ₗ[R] M
M₁' : Type u_10
inst✝³ : AddCommGroup M₁'
inst✝² : Module R₁ M₁'
B₁' : BilinForm R₁ M₁'
f₁ f₁' : M₁ →ₗ[R₁] M₁'
g₁ g₁' : M₁' →ₗ[R₁] M₁
B₂' : BilinForm R M'
f₂ f₂' : M →ₗ[R] M'
g₂ g₂' : M' →ₗ[R] M
M'' : Type u_11
inst✝¹ : AddCommMonoid M''
inst✝ : Module R M''
B'' : BilinForm R M''
B₂ : ?m.316755
F₂ : BilinForm R M
f : Module.End R₁ M₁
⊢ (∀ (x y : M₁), (B₁ (f x)) y = (B₁ x) ((-f) y)) ↔ ∀ (x y : M₁), (B₁ (f x)) y = ((-B₁) x) (f y)
state_after: no goals
tactic: simp only [LinearMap.neg_apply, BilinForm.neg_apply, BilinForm.neg_right]