ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.GradedObject.comapEquiv_inverse
File: Mathlib/CategoryTheory/GradedObject.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
β γ : Type w
e : β ≃ γ
⊢ ⇑e ∘ ⇑e.symm = fun i => i
state_after: case h
C : Type u
inst✝ : Category.{v, u} C
β γ : Type w
e : β ≃ γ
x✝ : γ
⊢ (⇑e ∘ ⇑e.symm) x✝ = x✝
tactic: ext
state_before: case h
C : Type u
inst✝ : Category.{v, u} C
β γ : Type w
e : β ≃ γ
x✝ : γ
⊢ (⇑e ∘ ⇑e.symm) x✝ = x✝
state_after: no goals
tactic: simp
state_before: C : Type u
inst✝ : Category.{v, u} C
β γ : Type w
e : β ≃ γ
⊢ (fun i => i) = ⇑e.symm ∘ ⇑e
state_after: case h
C : Type u
inst✝ : Category.{v, u} C
β γ : Type w
e : β ≃ γ
x✝ : β
⊢ x✝ = (⇑e.symm ∘ ⇑e) x✝
tactic: ext
state_before: case h
C : Type u
inst✝ : Category.{v, u} C
β γ : Type w
e : β ≃ γ
x✝ : β
⊢ x✝ = (⇑e.symm ∘ ⇑e) x✝
state_after: no goals
tactic: simp
Theorem: List.Perm.bagInter_left
File: Mathlib/Data/List/Perm.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a : α
inst✝ : DecidableEq α
l t₁ t₂ : List α
p : t₁ ~ t₂
⊢ l.bagInter t₁ = l.bagInter t₂
state_after: case nil
α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
inst✝ : DecidableEq α
t₁ t₂ : List α
p : t₁ ~ t₂
⊢ [].bagInter t₁ = [].bagInter t₂

case cons
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
inst✝ : DecidableEq α
a : α
l : List α
IH : ∀ {t₁ t₂ : List α}, t₁ ~ t₂ → l.bagInter t₁ = l.bagInter t₂
t₁ t₂ : List α
p : t₁ ~ t₂
⊢ (a :: l).bagInter t₁ = (a :: l).bagInter t₂
tactic: induction' l with a l IH generalizing t₁ t₂ p
state_before: case cons
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
inst✝ : DecidableEq α
a : α
l : List α
IH : ∀ {t₁ t₂ : List α}, t₁ ~ t₂ → l.bagInter t₁ = l.bagInter t₂
t₁ t₂ : List α
p : t₁ ~ t₂
⊢ (a :: l).bagInter t₁ = (a :: l).bagInter t₂
state_after: case pos
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
inst✝ : DecidableEq α
a : α
l : List α
IH : ∀ {t₁ t₂ : List α}, t₁ ~ t₂ → l.bagInter t₁ = l.bagInter t₂
t₁ t₂ : List α
p : t₁ ~ t₂
h : a ∈ t₁
⊢ (a :: l).bagInter t₁ = (a :: l).bagInter t₂

case neg
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
inst✝ : DecidableEq α
a : α
l : List α
IH : ∀ {t₁ t₂ : List α}, t₁ ~ t₂ → l.bagInter t₁ = l.bagInter t₂
t₁ t₂ : List α
p : t₁ ~ t₂
h : a ∉ t₁
⊢ (a :: l).bagInter t₁ = (a :: l).bagInter t₂
tactic: by_cases h : a ∈ t₁
Theorem: MvPowerSeries.monomial_def
File: Mathlib/RingTheory/MvPowerSeries/Basic.lean

Proof steps:
state_before: σ : Type u_1
R : Type u_2
inst✝¹ : Semiring R
inst✝ : DecidableEq σ
n : σ →₀ ℕ
⊢ monomial R n = LinearMap.stdBasis R (fun x => R) n
state_after: σ : Type u_1
R : Type u_2
inst✝¹ : Semiring R
inst✝ : DecidableEq σ
n : σ →₀ ℕ
⊢ LinearMap.stdBasis R (fun x => R) n = LinearMap.stdBasis R (fun x => R) n
tactic: rw [monomial]
state_before: σ : Type u_1
R : Type u_2
inst✝¹ : Semiring R
inst✝ : DecidableEq σ
n : σ →₀ ℕ
⊢ LinearMap.stdBasis R (fun x => R) n = LinearMap.stdBasis R (fun x => R) n
state_after: no goals
tactic: convert rfl
Theorem: Order.Ioc_succ_right
File: Mathlib/Order/SuccPred/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a b : α
h : a < succ b
⊢ Ioc a (succ b) = insert (succ b) (Ioc a b)
state_after: no goals
tactic: simp_rw [← Ioi_inter_Iic, Iic_succ, inter_insert_of_mem (mem_Ioi.2 h)]
Theorem: MeasureTheory.BorelCantelli.predictablePart_process_ae_eq
File: Mathlib/Probability/Martingale/BorelCantelli.lean

Proof steps:
state_before: Ω : Type u_1
m0 : MeasurableSpace Ω
μ✝ : Measure Ω
ℱ✝ : Filtration ℕ m0
f : ℕ → Ω → ℝ
ω : Ω
r : ℝ
R : ℝ≥0
s✝ : ℕ → Set Ω
ℱ : Filtration ℕ m0
μ : Measure Ω
s : ℕ → Set Ω
n : ℕ
⊢ predictablePart (process s) ℱ μ n = ∑ k ∈ Finset.range n, μ[(s (k + 1)).indicator 1|↑ℱ k]
state_after: Ω : Type u_1
m0 : MeasurableSpace Ω
μ✝ : Measure Ω
ℱ✝ : Filtration ℕ m0
f : ℕ → Ω → ℝ
ω : Ω
r : ℝ
R : ℝ≥0
s✝ : ℕ → Set Ω
ℱ : Filtration ℕ m0
μ : Measure Ω
s : ℕ → Set Ω
n : ℕ
this :
  martingalePart (process s) ℱ μ n = ∑ k ∈ Finset.range n, ((s (k + 1)).indicator 1 - μ[(s (k + 1)).indicator 1|↑ℱ k])
⊢ predictablePart (process s) ℱ μ n = ∑ k ∈ Finset.range n, μ[(s (k + 1)).indicator 1|↑ℱ k]
tactic: have := martingalePart_process_ae_eq ℱ μ s n
state_before: Ω : Type u_1
m0 : MeasurableSpace Ω
μ✝ : Measure Ω
ℱ✝ : Filtration ℕ m0
f : ℕ → Ω → ℝ
ω : Ω
r : ℝ
R : ℝ≥0
s✝ : ℕ → Set Ω
ℱ : Filtration ℕ m0
μ : Measure Ω
s : ℕ → Set Ω
n : ℕ
this :
  martingalePart (process s) ℱ μ n = ∑ k ∈ Finset.range n, ((s (k + 1)).indicator 1 - μ[(s (k + 1)).indicator 1|↑ℱ k])
⊢ predictablePart (process s) ℱ μ n = ∑ k ∈ Finset.range n, μ[(s (k + 1)).indicator 1|↑ℱ k]
state_after: Ω : Type u_1
m0 : MeasurableSpace Ω
μ✝ : Measure Ω
ℱ✝ : Filtration ℕ m0
f : ℕ → Ω → ℝ
ω : Ω
r : ℝ
R : ℝ≥0
s✝ : ℕ → Set Ω
ℱ : Filtration ℕ m0
μ : Measure Ω
s : ℕ → Set Ω
n : ℕ
this :
  ∑ k ∈ Finset.range n, (s (k + 1)).indicator 1 - predictablePart (process s) ℱ μ n =
    ∑ k ∈ Finset.range n, (s (k + 1)).indicator 1 - ∑ x ∈ Finset.range n, μ[(s (x + 1)).indicator 1|↑ℱ x]
⊢ predictablePart (process s) ℱ μ n = ∑ k ∈ Finset.range n, μ[(s (k + 1)).indicator 1|↑ℱ k]
tactic: simp_rw [martingalePart, process, Finset.sum_sub_distrib] at this
state_before: Ω : Type u_1
m0 : MeasurableSpace Ω
μ✝ : Measure Ω
ℱ✝ : Filtration ℕ m0
f : ℕ → Ω → ℝ
ω : Ω
r : ℝ
R : ℝ≥0
s✝ : ℕ → Set Ω
ℱ : Filtration ℕ m0
μ : Measure Ω
s : ℕ → Set Ω
n : ℕ
this :
  ∑ k ∈ Finset.range n, (s (k + 1)).indicator 1 - predictablePart (process s) ℱ μ n =
    ∑ k ∈ Finset.range n, (s (k + 1)).indicator 1 - ∑ x ∈ Finset.range n, μ[(s (x + 1)).indicator 1|↑ℱ x]
⊢ predictablePart (process s) ℱ μ n = ∑ k ∈ Finset.range n, μ[(s (k + 1)).indicator 1|↑ℱ k]
state_after: no goals
tactic: exact sub_right_injective this
Theorem: IsAlgebraic.inv_iff
File: Mathlib/RingTheory/Algebraic.lean

Proof steps:
state_before: R : Type u
S : Type u_1
A : Type v
inst✝⁸ : CommRing R
inst✝⁷ : CommRing S
inst✝⁶ : Ring A
inst✝⁵ : Algebra R A
inst✝⁴ : Algebra R S
inst✝³ : Algebra S A
inst✝² : IsScalarTower R S A
K : Type u_2
inst✝¹ : Field K
inst✝ : Algebra R K
x : K
⊢ IsAlgebraic R x⁻¹ ↔ IsAlgebraic R x
state_after: case pos
R : Type u
S : Type u_1
A : Type v
inst✝⁸ : CommRing R
inst✝⁷ : CommRing S
inst✝⁶ : Ring A
inst✝⁵ : Algebra R A
inst✝⁴ : Algebra R S
inst✝³ : Algebra S A
inst✝² : IsScalarTower R S A
K : Type u_2
inst✝¹ : Field K
inst✝ : Algebra R K
x : K
hx : x = 0
⊢ IsAlgebraic R x⁻¹ ↔ IsAlgebraic R x

case neg
R : Type u
S : Type u_1
A : Type v
inst✝⁸ : CommRing R
inst✝⁷ : CommRing S
inst✝⁶ : Ring A
inst✝⁵ : Algebra R A
inst✝⁴ : Algebra R S
inst✝³ : Algebra S A
inst✝² : IsScalarTower R S A
K : Type u_2
inst✝¹ : Field K
inst✝ : Algebra R K
x : K
hx : ¬x = 0
⊢ IsAlgebraic R x⁻¹ ↔ IsAlgebraic R x
tactic: by_cases hx : x = 0
state_before: case neg
R : Type u
S : Type u_1
A : Type v
inst✝⁸ : CommRing R
inst✝⁷ : CommRing S
inst✝⁶ : Ring A
inst✝⁵ : Algebra R A
inst✝⁴ : Algebra R S
inst✝³ : Algebra S A
inst✝² : IsScalarTower R S A
K : Type u_2
inst✝¹ : Field K
inst✝ : Algebra R K
x : K
hx : ¬x = 0
⊢ IsAlgebraic R x⁻¹ ↔ IsAlgebraic R x
state_after: case neg
R : Type u
S : Type u_1
A : Type v
inst✝⁸ : CommRing R
inst✝⁷ : CommRing S
inst✝⁶ : Ring A
inst✝⁵ : Algebra R A
inst✝⁴ : Algebra R S
inst✝³ : Algebra S A
inst✝² : IsScalarTower R S A
K : Type u_2
inst✝¹ : Field K
inst✝ : Algebra R K
x : K
hx : ¬x = 0
this : Invertible x := invertibleOfNonzero hx
⊢ IsAlgebraic R x⁻¹ ↔ IsAlgebraic R x
tactic: letI := invertibleOfNonzero hx
state_before: case neg
R : Type u
S : Type u_1
A : Type v
inst✝⁸ : CommRing R
inst✝⁷ : CommRing S
inst✝⁶ : Ring A
inst✝⁵ : Algebra R A
inst✝⁴ : Algebra R S
inst✝³ : Algebra S A
inst✝² : IsScalarTower R S A
K : Type u_2
inst✝¹ : Field K
inst✝ : Algebra R K
x : K
hx : ¬x = 0
this : Invertible x := invertibleOfNonzero hx
⊢ IsAlgebraic R x⁻¹ ↔ IsAlgebraic R x
state_after: no goals
tactic: exact IsAlgebraic.invOf_iff (R := R) (x := x)
Theorem: IsCompact.mul
File: Mathlib/Topology/Algebra/Monoid.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
s t : Set M
hs : IsCompact s
ht : IsCompact t
⊢ IsCompact (s * t)
state_after: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
s t : Set M
hs : IsCompact s
ht : IsCompact t
⊢ IsCompact ((fun x => x.1 * x.2) '' s ×ˢ t)
tactic: rw [← image_mul_prod]
state_before: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
s t : Set M
hs : IsCompact s
ht : IsCompact t
⊢ IsCompact ((fun x => x.1 * x.2) '' s ×ˢ t)
state_after: no goals
tactic: exact (hs.prod ht).image continuous_mul
Theorem: Stream'.WSeq.dropn_ofSeq
File: Mathlib/Data/Seq/WSeq.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
s : Seq α
n : ℕ
⊢ (↑s).drop (n + 1) = ↑(s.drop (n + 1))
state_after: α : Type u
β : Type v
γ : Type w
s : Seq α
n : ℕ
⊢ ((↑s).drop n).tail = ↑(s.drop n).tail
tactic: simp only [drop, Nat.add_eq, Nat.add_zero, Seq.drop]
state_before: α : Type u
β : Type v
γ : Type w
s : Seq α
n : ℕ
⊢ ((↑s).drop n).tail = ↑(s.drop n).tail
state_after: no goals
tactic: rw [dropn_ofSeq s n, tail_ofSeq]
Theorem: CategoryTheory.Adjunction.CoreHomEquiv.homEquiv_naturality_left
File: Mathlib/CategoryTheory/Adjunction/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreHomEquiv F G
X' X : C
Y Y' : D
f : X' ⟶ X
g : F.obj X ⟶ Y
⊢ (adj.homEquiv X' Y) (F.map f ≫ g) = f ≫ (adj.homEquiv X Y) g
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreHomEquiv F G
X' X : C
Y Y' : D
f : X' ⟶ X
g : F.obj X ⟶ Y
⊢ F.map f ≫ g = (adj.homEquiv X' Y).symm (f ≫ (adj.homEquiv X Y) g)
tactic: rw [← Equiv.eq_symm_apply]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreHomEquiv F G
X' X : C
Y Y' : D
f : X' ⟶ X
g : F.obj X ⟶ Y
⊢ F.map f ≫ g = (adj.homEquiv X' Y).symm (f ≫ (adj.homEquiv X Y) g)
state_after: no goals
tactic: simp
Theorem: MulChar.trivial_apply
File: Mathlib/NumberTheory/MulChar/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : CommMonoid R
R' : Type u_2
inst✝ : CommMonoidWithZero R'
⊢ R → R'
state_after: no goals
tactic: classical exact fun x => if IsUnit x then 1 else 0
state_before: R : Type u_1
inst✝¹ : CommMonoid R
R' : Type u_2
inst✝ : CommMonoidWithZero R'
⊢ ∀ (a : R), ¬IsUnit a → (↑{ toFun := fun x => if IsUnit x then 1 else 0, map_one' := ⋯, map_mul' := ⋯ }).toFun a = 0
state_after: R : Type u_1
inst✝¹ : CommMonoid R
R' : Type u_2
inst✝ : CommMonoidWithZero R'
a : R
ha : ¬IsUnit a
⊢ (↑{ toFun := fun x => if IsUnit x then 1 else 0, map_one' := ⋯, map_mul' := ⋯ }).toFun a = 0
tactic: intro a ha
state_before: R : Type u_1
inst✝¹ : CommMonoid R
R' : Type u_2
inst✝ : CommMonoidWithZero R'
a : R
ha : ¬IsUnit a
⊢ (↑{ toFun := fun x => if IsUnit x then 1 else 0, map_one' := ⋯, map_mul' := ⋯ }).toFun a = 0
state_after: no goals
tactic: simp only [ha, if_false]
state_before: R : Type u_1
inst✝¹ : CommMonoid R
R' : Type u_2
inst✝ : CommMonoidWithZero R'
⊢ (if IsUnit 1 then 1 else 0) = 1
state_after: no goals
tactic: simp only [isUnit_one, if_true]
state_before: R : Type u_1
inst✝¹ : CommMonoid R
R' : Type u_2
inst✝ : CommMonoidWithZero R'
⊢ ∀ (x y : R),
    { toFun := fun x => if IsUnit x then 1 else 0, map_one' := ⋯ }.toFun (x * y) =
      { toFun := fun x => if IsUnit x then 1 else 0, map_one' := ⋯ }.toFun x *
        { toFun := fun x => if IsUnit x then 1 else 0, map_one' := ⋯ }.toFun y
state_after: R : Type u_1
inst✝¹ : CommMonoid R
R' : Type u_2
inst✝ : CommMonoidWithZero R'
x y : R
⊢ { toFun := fun x => if IsUnit x then 1 else 0, map_one' := ⋯ }.toFun (x * y) =
    { toFun := fun x => if IsUnit x then 1 else 0, map_one' := ⋯ }.toFun x *
      { toFun := fun x => if IsUnit x then 1 else 0, map_one' := ⋯ }.toFun y
tactic: intro x y
state_before: R : Type u_1
inst✝¹ : CommMonoid R
R' : Type u_2
inst✝ : CommMonoidWithZero R'
x y : R
⊢ { toFun := fun x => if IsUnit x then 1 else 0, map_one' := ⋯ }.toFun (x * y) =
    { toFun := fun x => if IsUnit x then 1 else 0, map_one' := ⋯ }.toFun x *
      { toFun := fun x => if IsUnit x then 1 else 0, map_one' := ⋯ }.toFun y
state_after: no goals
tactic: classical
      simp only [IsUnit.mul_iff, boole_mul]
      split_ifs <;> tauto
Theorem: List.length_eraseIdx
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α : Type u_1
head✝ : α
tail✝ : List α
x✝ : 0 < (head✝ :: tail✝).length
⊢ ((head✝ :: tail✝).eraseIdx 0).length = (head✝ :: tail✝).length - 1
state_after: no goals
tactic: simp [eraseIdx]
state_before: α : Type u_1
x : α
xs : List α
i : Nat
h : i + 1 < (x :: xs).length
⊢ ((x :: xs).eraseIdx (i + 1)).length = (x :: xs).length - 1
state_after: α : Type u_1
x : α
xs : List α
i : Nat
h : i + 1 < (x :: xs).length
this : i < xs.length
⊢ ((x :: xs).eraseIdx (i + 1)).length = (x :: xs).length - 1
tactic: have : i < length xs := Nat.lt_of_succ_lt_succ h
state_before: α : Type u_1
x : α
xs : List α
i : Nat
h : i + 1 < (x :: xs).length
this : i < xs.length
⊢ ((x :: xs).eraseIdx (i + 1)).length = (x :: xs).length - 1
state_after: α : Type u_1
x : α
xs : List α
i : Nat
h : i + 1 < (x :: xs).length
this : i < xs.length
⊢ (xs.eraseIdx i).length + 1 = xs.length
tactic: simp [eraseIdx, ← Nat.add_one]
state_before: α : Type u_1
x : α
xs : List α
i : Nat
h : i + 1 < (x :: xs).length
this : i < xs.length
⊢ (xs.eraseIdx i).length + 1 = xs.length
state_after: no goals
tactic: rw [length_eraseIdx this, Nat.sub_add_cancel (Nat.lt_of_le_of_lt (Nat.zero_le _) this)]
Theorem: Subgroup.index_center_le_pow
File: Mathlib/GroupTheory/Index.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
inst✝³ : Group G
inst✝² : Group G'
H K L : Subgroup G
inst✝¹ : Finite ↑(commutatorSet G)
inst✝ : Group.FG G
⊢ (center G).index ≤ Nat.card ↑(commutatorSet G) ^ Group.rank G
state_after: case intro.intro
G : Type u_1
G' : Type u_2
inst✝³ : Group G
inst✝² : Group G'
H K L : Subgroup G
inst✝¹ : Finite ↑(commutatorSet G)
inst✝ : Group.FG G
S : Finset G
hS1 : S.card = Group.rank G
hS2 : closure ↑S = ⊤
⊢ (center G).index ≤ Nat.card ↑(commutatorSet G) ^ Group.rank G
tactic: obtain ⟨S, hS1, hS2⟩ := Group.rank_spec G
state_before: case intro.intro
G : Type u_1
G' : Type u_2
inst✝³ : Group G
inst✝² : Group G'
H K L : Subgroup G
inst✝¹ : Finite ↑(commutatorSet G)
inst✝ : Group.FG G
S : Finset G
hS1 : S.card = Group.rank G
hS2 : closure ↑S = ⊤
⊢ (center G).index ≤ Nat.card ↑(commutatorSet G) ^ Group.rank G
state_after: case intro.intro
G : Type u_1
G' : Type u_2
inst✝³ : Group G
inst✝² : Group G'
H K L : Subgroup G
inst✝¹ : Finite ↑(commutatorSet G)
inst✝ : Group.FG G
S : Finset G
hS1 : S.card = Group.rank G
hS2 : closure ↑S = ⊤
⊢ (center G).index ≤ Nat.card (↑↑S → ↑(commutatorSet G))
tactic: rw [← hS1, ← Fintype.card_coe, ← Nat.card_eq_fintype_card, ← Finset.coe_sort_coe, ← Nat.card_fun]
state_before: case intro.intro
G : Type u_1
G' : Type u_2
inst✝³ : Group G
inst✝² : Group G'
H K L : Subgroup G
inst✝¹ : Finite ↑(commutatorSet G)
inst✝ : Group.FG G
S : Finset G
hS1 : S.card = Group.rank G
hS2 : closure ↑S = ⊤
⊢ (center G).index ≤ Nat.card (↑↑S → ↑(commutatorSet G))
state_after: no goals
tactic: exact Finite.card_le_of_embedding (quotientCenterEmbedding hS2)
Theorem: Ordinal.typein_top
File: Mathlib/SetTheory/Ordinal/Basic.lean

Proof steps:
state_before: α✝ : Type u
β✝ : Type u_1
γ : Type u_2
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
α β : Type u_3
r : α → α → Prop
s : β → β → Prop
inst✝¹ : IsWellOrder α r
inst✝ : IsWellOrder β s
f : r ≺i s
x✝ : ↑{b | s b f.top}
a : β
h : a ∈ {b | s b f.top}
⊢ ∃ a_1,
    (RelEmbedding.codRestrict {b | s b f.top} { toRelEmbedding := f.toRelEmbedding, init' := ⋯ }.toRelEmbedding ⋯) a_1 =
      ⟨a, h⟩
state_after: case intro
α✝ : Type u
β✝ : Type u_1
γ : Type u_2
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
α β : Type u_3
r : α → α → Prop
s : β → β → Prop
inst✝¹ : IsWellOrder α r
inst✝ : IsWellOrder β s
f : r ≺i s
x✝ : ↑{b | s b f.top}
b : α
h : f.toRelEmbedding b ∈ {b | s b f.top}
⊢ ∃ a,
    (RelEmbedding.codRestrict {b | s b f.top} { toRelEmbedding := f.toRelEmbedding, init' := ⋯ }.toRelEmbedding ⋯) a =
      ⟨f.toRelEmbedding b, h⟩
tactic: rcases f.down.1 h with ⟨b, rfl⟩
state_before: case intro
α✝ : Type u
β✝ : Type u_1
γ : Type u_2
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
α β : Type u_3
r : α → α → Prop
s : β → β → Prop
inst✝¹ : IsWellOrder α r
inst✝ : IsWellOrder β s
f : r ≺i s
x✝ : ↑{b | s b f.top}
b : α
h : f.toRelEmbedding b ∈ {b | s b f.top}
⊢ ∃ a,
    (RelEmbedding.codRestrict {b | s b f.top} { toRelEmbedding := f.toRelEmbedding, init' := ⋯ }.toRelEmbedding ⋯) a =
      ⟨f.toRelEmbedding b, h⟩
state_after: no goals
tactic: exact ⟨b, rfl⟩
Theorem: CategoryTheory.ShortComplex.opcyclesMap'_smul
File: Mathlib/Algebra/Homology/ShortComplex/Linear.lean

Proof steps:
state_before: R : Type u_1
C : Type u_2
inst✝³ : Semiring R
inst✝² : Category.{u_3, u_2} C
inst✝¹ : Preadditive C
inst✝ : Linear R C
S₁ S₂ : ShortComplex C
φ φ' : S₁ ⟶ S₂
h₁ : S₁.RightHomologyData
h₂ : S₂.RightHomologyData
a : R
⊢ opcyclesMap' (a • φ) h₁ h₂ = a • opcyclesMap' φ h₁ h₂
state_after: R : Type u_1
C : Type u_2
inst✝³ : Semiring R
inst✝² : Category.{u_3, u_2} C
inst✝¹ : Preadditive C
inst✝ : Linear R C
S₁ S₂ : ShortComplex C
φ φ' : S₁ ⟶ S₂
h₁ : S₁.RightHomologyData
h₂ : S₂.RightHomologyData
a : R
γ : RightHomologyMapData φ h₁ h₂
⊢ opcyclesMap' (a • φ) h₁ h₂ = a • opcyclesMap' φ h₁ h₂
tactic: have γ : RightHomologyMapData φ h₁ h₂ := default
state_before: R : Type u_1
C : Type u_2
inst✝³ : Semiring R
inst✝² : Category.{u_3, u_2} C
inst✝¹ : Preadditive C
inst✝ : Linear R C
S₁ S₂ : ShortComplex C
φ φ' : S₁ ⟶ S₂
h₁ : S₁.RightHomologyData
h₂ : S₂.RightHomologyData
a : R
γ : RightHomologyMapData φ h₁ h₂
⊢ opcyclesMap' (a • φ) h₁ h₂ = a • opcyclesMap' φ h₁ h₂
state_after: no goals
tactic: simp only [(γ.smul a).opcyclesMap'_eq, RightHomologyMapData.smul_φQ, γ.opcyclesMap'_eq]
Theorem: Multiset.noncommProd_cons
File: Mathlib/Data/Finset/NoncommProd.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
inst✝¹ : Monoid α
inst✝ : Monoid β
s : Multiset α
a : α
comm : {x | x ∈ a ::ₘ s}.Pairwise Commute
⊢ (a ::ₘ s).noncommProd comm = a * s.noncommProd ⋯
state_after: case h
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
inst✝¹ : Monoid α
inst✝ : Monoid β
a : α
a✝ : List α
comm : {x | x ∈ a ::ₘ ⟦a✝⟧}.Pairwise Commute
⊢ (a ::ₘ ⟦a✝⟧).noncommProd comm = a * noncommProd ⟦a✝⟧ ⋯
tactic: induction s using Quotient.inductionOn
state_before: case h
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
inst✝¹ : Monoid α
inst✝ : Monoid β
a : α
a✝ : List α
comm : {x | x ∈ a ::ₘ ⟦a✝⟧}.Pairwise Commute
⊢ (a ::ₘ ⟦a✝⟧).noncommProd comm = a * noncommProd ⟦a✝⟧ ⋯
state_after: no goals
tactic: simp
Theorem: AddOreLocalization.oreSub_vadd_oreSub
File: Mathlib/RingTheory/OreLocalization/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝² : Monoid R
S : Submonoid R
inst✝¹ : OreSet S
X : Type u_2
inst✝ : MulAction R X
r₁ : R
r₂ : X
s₁ s₂ : ↥S
⊢ (r₁ /ₒ s₁) • (r₂ /ₒ s₂) = oreNum r₁ s₂ • r₂ /ₒ (oreDenom r₁ s₂ * s₁)
state_after: no goals
tactic: with_unfolding_all rfl
Theorem: SimpleGraph.Walk.mem_support_append_iff
File: Mathlib/Combinatorics/SimpleGraph/Walk.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
t u v w : V
p : G.Walk u v
p' : G.Walk v w
⊢ t ∈ (p.append p').support ↔ t ∈ p.support ∨ t ∈ p'.support
state_after: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
t u v w : V
p : G.Walk u v
p' : G.Walk v w
⊢ t = u ∨ t ∈ p.support.tail ∨ t ∈ p'.support.tail ↔ (t = u ∨ t ∈ p.support.tail) ∨ t = v ∨ t ∈ p'.support.tail
tactic: simp only [mem_support_iff, mem_tail_support_append_iff]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
t u v w : V
p : G.Walk u v
p' : G.Walk v w
⊢ t = u ∨ t ∈ p.support.tail ∨ t ∈ p'.support.tail ↔ (t = u ∨ t ∈ p.support.tail) ∨ t = v ∨ t ∈ p'.support.tail
state_after: no goals
tactic: obtain rfl | h := eq_or_ne t v <;> obtain rfl | h' := eq_or_ne t u <;>
    -- this `have` triggers the unusedHavesSuffices linter:
    (try have := h'.symm) <;> simp [*]
Theorem: Function.periodicOrbit_chain
File: Mathlib/Dynamics/PeriodicPts.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
f✝ fa : α → α
fb : β → β
x✝ y : α
m n : ℕ
r : α → α → Prop
f : α → α
x : α
⊢ Cycle.Chain r (periodicOrbit f x) ↔ ∀ n < minimalPeriod f x, r (f^[n] x) (f^[n + 1] x)
state_after: case pos
α : Type u_1
β : Type u_2
f✝ fa : α → α
fb : β → β
x✝ y : α
m n : ℕ
r : α → α → Prop
f : α → α
x : α
hx : x ∈ periodicPts f
⊢ Cycle.Chain r (periodicOrbit f x) ↔ ∀ n < minimalPeriod f x, r (f^[n] x) (f^[n + 1] x)

case neg
α : Type u_1
β : Type u_2
f✝ fa : α → α
fb : β → β
x✝ y : α
m n : ℕ
r : α → α → Prop
f : α → α
x : α
hx : x ∉ periodicPts f
⊢ Cycle.Chain r (periodicOrbit f x) ↔ ∀ n < minimalPeriod f x, r (f^[n] x) (f^[n + 1] x)
tactic: by_cases hx : x ∈ periodicPts f
Theorem: Filter.HasBasis.mem_uniformity_iff
File: Mathlib/Topology/UniformSpace/Basic.lean

Proof steps:
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
p : β → Prop
s : β → Set (α × α)
h : (𝓤 α).HasBasis p s
t : Set (α × α)
⊢ (∃ i, p i ∧ s i ⊆ t) ↔ ∃ i, p i ∧ ∀ (a b : α), (a, b) ∈ s i → (a, b) ∈ t
state_after: no goals
tactic: simp only [Prod.forall, subset_def]