1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Matrix.isHermitian_transpose_iff
File: Mathlib/LinearAlgebra/Matrix/Hermitian.lean

tactic: intro h
state_before: α : Type u_1
β : Type u_2
m : Type u_3
n : Type u_4
A✝ : Matrix n n α
inst✝¹ : Star α
inst✝ : Star β
A : Matrix n n α
⊢ Aᵀ.IsHermitian → A.IsHermitian
state_after: α : Type u_1
β : Type u_2
m : Type u_3
n : Type u_4
A✝ : Matrix n n α
inst✝¹ : Star α
inst✝ : Star β
A : Matrix n n α
h : Aᵀ.IsHermitian
⊢ A.IsHermitian

tactic: rw [← transpose_transpose A]
state_before: α : Type u_1
β : Type u_2
m : Type u_3
n : Type u_4
A✝ : Matrix n n α
inst✝¹ : Star α
inst✝ : Star β
A : Matrix n n α
h : Aᵀ.IsHermitian
⊢ A.IsHermitian
state_after: α : Type u_1
β : Type u_2
m : Type u_3
n : Type u_4
A✝ : Matrix n n α
inst✝¹ : Star α
inst✝ : Star β
A : Matrix n n α
h : Aᵀ.IsHermitian
⊢ Aᵀᵀ.IsHermitian

tactic: exact IsHermitian.transpose h
state_before: α : Type u_1
β : Type u_2
m : Type u_3
n : Type u_4
A✝ : Matrix n n α
inst✝¹ : Star α
inst✝ : Star β
A : Matrix n n α
h : Aᵀ.IsHermitian
⊢ Aᵀᵀ.IsHermitian
state_after: no goals
Theorem: Set.invOf_mem_center
File: Mathlib/Algebra/Group/Center.lean

tactic: rw [Semigroup.mem_center_iff] at *
state_before: M : Type u_1
inst✝¹ : Monoid M
a : M
inst✝ : Invertible a
ha : a ∈ center M
⊢ ⅟a ∈ center M
state_after: M : Type u_1
inst✝¹ : Monoid M
a : M
inst✝ : Invertible a
ha : ∀ (g : M), g * a = a * g
⊢ ∀ (g : M), g * ⅟a = ⅟a * g
Theorem: FirstOrder.Language.ElementaryEmbedding.map_fun
File: Mathlib/ModelTheory/ElementaryMaps.lean

tactic: have h := φ.map_formula (Formula.graph f) (Fin.cons (funMap f x) x)
state_before: L : Language
M : Type u_1
N : Type u_2
P : Type u_3
Q : Type u_4
inst✝³ : L.Structure M
inst✝² : L.Structure N
inst✝¹ : L.Structure P
inst✝ : L.Structure Q
φ : M ↪ₑ[L] N
n : ℕ
f : L.Functions n
x : Fin n → M
⊢ φ (funMap f x) = funMap f (⇑φ ∘ x)
state_after: L : Language
M : Type u_1
N : Type u_2
P : Type u_3
Q : Type u_4
inst✝³ : L.Structure M
inst✝² : L.Structure N
inst✝¹ : L.Structure P
inst✝ : L.Structure Q
φ : M ↪ₑ[L] N
n : ℕ
f : L.Functions n
x : Fin n → M
h : (Formula.graph f).Realize (⇑φ ∘ Fin.cons (funMap f x) x) ↔ (Formula.graph f).Realize (Fin.cons (funMap f x) x)
⊢ φ (funMap f x) = funMap f (⇑φ ∘ x)

tactic: rw [Formula.realize_graph, Fin.comp_cons, Formula.realize_graph] at h
state_before: L : Language
M : Type u_1
N : Type u_2
P : Type u_3
Q : Type u_4
inst✝³ : L.Structure M
inst✝² : L.Structure N
inst✝¹ : L.Structure P
inst✝ : L.Structure Q
φ : M ↪ₑ[L] N
n : ℕ
f : L.Functions n
x : Fin n → M
h : (Formula.graph f).Realize (⇑φ ∘ Fin.cons (funMap f x) x) ↔ (Formula.graph f).Realize (Fin.cons (funMap f x) x)
⊢ φ (funMap f x) = funMap f (⇑φ ∘ x)
state_after: L : Language
M : Type u_1
N : Type u_2
P : Type u_3
Q : Type u_4
inst✝³ : L.Structure M
inst✝² : L.Structure N
inst✝¹ : L.Structure P
inst✝ : L.Structure Q
φ : M ↪ₑ[L] N
n : ℕ
f : L.Functions n
x : Fin n → M
h : funMap f (⇑φ ∘ x) = φ (funMap f x) ↔ funMap f x = funMap f x
⊢ φ (funMap f x) = funMap f (⇑φ ∘ x)

tactic: rw [eq_comm, h]
state_before: L : Language
M : Type u_1
N : Type u_2
P : Type u_3
Q : Type u_4
inst✝³ : L.Structure M
inst✝² : L.Structure N
inst✝¹ : L.Structure P
inst✝ : L.Structure Q
φ : M ↪ₑ[L] N
n : ℕ
f : L.Functions n
x : Fin n → M
h : funMap f (⇑φ ∘ x) = φ (funMap f x) ↔ funMap f x = funMap f x
⊢ φ (funMap f x) = funMap f (⇑φ ∘ x)
state_after: no goals
Theorem: QuotientGroup.ker_le_range_iff
File: Mathlib/GroupTheory/QuotientGroup.lean

tactic: exact DFunLike.congr_fun h ⟨x, hx⟩
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
I : Type w
inst✝¹ : Group I
f : G →* H
inst✝ : f.range.Normal
g : H →* I
h : (mk' f.range).comp g.ker.subtype = 1
x : H
hx : x ∈ g.ker
⊢ ↑x = 1
state_after: no goals
Theorem: StieltjesFunction.measure_const
File: Mathlib/MeasureTheory/Measure/Stieltjes.lean

tactic: simp
state_before: f : StieltjesFunction
c x✝² x✝¹ : ℝ
x✝ : x✝² < x✝¹
⊢ (StieltjesFunction.const c).measure (Ioc x✝² x✝¹) = 0 (Ioc x✝² x✝¹)
state_after: no goals
Theorem: Polynomial.degree_C
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

tactic: rw [degree, ← monomial_zero_left, support_monomial 0 ha, max_eq_sup_coe, sup_singleton,
  WithBot.coe_zero]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
ha : a ≠ 0
⊢ (C a).degree = 0
state_after: no goals
Theorem: Multiset.one_le_count_iff_mem
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [succ_le_iff, count_pos]
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ : Multiset α
a : α
s : Multiset α
⊢ 1 ≤ count a s ↔ a ∈ s
state_after: no goals
Theorem: Module.finite_of_rank_eq_nat
File: Mathlib/LinearAlgebra/Dimension/Finite.lean

tactic: nontriviality R
state_before: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁷ : Ring R
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : AddCommGroup M₁
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M₁
inst✝ : Free R M
n : ℕ
h : Module.rank R M = ↑n
⊢ Finite R M
state_after: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁷ : Ring R
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : AddCommGroup M₁
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M₁
inst✝ : Free R M
n : ℕ
h : Module.rank R M = ↑n
a✝ : Nontrivial R
⊢ Finite R M

tactic: obtain ⟨⟨ι, b⟩⟩ := Module.Free.exists_basis (R := R) (M := M)
state_before: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁷ : Ring R
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : AddCommGroup M₁
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M₁
inst✝ : Free R M
n : ℕ
h : Module.rank R M = ↑n
a✝ : Nontrivial R
⊢ Finite R M
state_after: case intro.mk
R : Type u
M M₁ : Type v
M' : Type v'
ι✝ : Type w
inst✝⁷ : Ring R
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : AddCommGroup M₁
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M₁
inst✝ : Free R M
n : ℕ
h : Module.rank R M = ↑n
a✝ : Nontrivial R
ι : Type v
b : Basis ι R M
⊢ Finite R M

tactic: have := mk_lt_aleph0_iff.mp <|
  b.linearIndependent.cardinal_le_rank |>.trans_eq h |>.trans_lt <| nat_lt_aleph0 n
state_before: case intro.mk
R : Type u
M M₁ : Type v
M' : Type v'
ι✝ : Type w
inst✝⁷ : Ring R
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : AddCommGroup M₁
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M₁
inst✝ : Free R M
n : ℕ
h : Module.rank R M = ↑n
a✝ : Nontrivial R
ι : Type v
b : Basis ι R M
⊢ Finite R M
state_after: case intro.mk
R : Type u
M M₁ : Type v
M' : Type v'
ι✝ : Type w
inst✝⁷ : Ring R
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : AddCommGroup M₁
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M₁
inst✝ : Free R M
n : ℕ
h : Module.rank R M = ↑n
a✝ : Nontrivial R
ι : Type v
b : Basis ι R M
this : _root_.Finite ι
⊢ Finite R M

tactic: exact Module.Finite.of_basis b
state_before: case intro.mk
R : Type u
M M₁ : Type v
M' : Type v'
ι✝ : Type w
inst✝⁷ : Ring R
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : AddCommGroup M₁
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M₁
inst✝ : Free R M
n : ℕ
h : Module.rank R M = ↑n
a✝ : Nontrivial R
ι : Type v
b : Basis ι R M
this : _root_.Finite ι
⊢ Finite R M
state_after: no goals
Theorem: MeasureTheory.L1.integral_eq_integral
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: simp only [integral, L1.integral, integral_eq_setToFun]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace ℝ E
hE : CompleteSpace E
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : SMulCommClass ℝ 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : CompleteSpace F
G : Type u_5
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
f : ↥(Lp E 1 μ)
⊢ integral f = ∫ (a : α), ↑↑f a ∂μ
state_after: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace ℝ E
hE : CompleteSpace E
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : SMulCommClass ℝ 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : CompleteSpace F
G : Type u_5
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
f : ↥(Lp E 1 μ)
⊢ integralCLM f = setToFun μ (weightedSMul μ) ⋯ ↑↑f

tactic: exact (L1.setToFun_eq_setToL1 (dominatedFinMeasAdditive_weightedSMul μ) f).symm
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace ℝ E
hE : CompleteSpace E
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : SMulCommClass ℝ 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : CompleteSpace F
G : Type u_5
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
f : ↥(Lp E 1 μ)
⊢ integralCLM f = setToFun μ (weightedSMul μ) ⋯ ↑↑f
state_after: no goals
Theorem: Set.inv_op_smul_set_distrib
File: Mathlib/Data/Set/Pointwise/SMul.lean

tactic: ext
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : Group α
inst✝ : MulAction α β
s✝ t A B : Set β
a✝ : α
x : β
a : α
s : Set α
⊢ (op a • s)⁻¹ = a⁻¹ • s⁻¹
state_after: case h
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : Group α
inst✝ : MulAction α β
s✝ t A B : Set β
a✝ : α
x : β
a : α
s : Set α
x✝ : α
⊢ x✝ ∈ (op a • s)⁻¹ ↔ x✝ ∈ a⁻¹ • s⁻¹

tactic: simp [mem_smul_set_iff_inv_smul_mem]
state_before: case h
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : Group α
inst✝ : MulAction α β
s✝ t A B : Set β
a✝ : α
x : β
a : α
s : Set α
x✝ : α
⊢ x✝ ∈ (op a • s)⁻¹ ↔ x✝ ∈ a⁻¹ • s⁻¹
state_after: no goals
Theorem: InnerProductGeometry.angle_neg_self_of_nonzero
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Basic.lean

tactic: rw [angle_comm, angle_self_neg_of_nonzero hx]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y x : V
hx : x ≠ 0
⊢ angle (-x) x = π
state_after: no goals
Theorem: Real.Angle.tan_eq_inv_of_two_zsmul_add_two_zsmul_eq_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: exact tan_eq_inv_of_two_nsmul_add_two_nsmul_eq_pi h
state_before: θ ψ : Angle
h : 2 • θ + 2 • ψ = ↑π
⊢ ψ.tan = θ.tan⁻¹
state_after: no goals
Theorem: Computation.orElse_empty
File: Mathlib/Data/Seq/Computation.lean

tactic: apply eq_of_bisim (fun c₁ c₂ => (c₂ <|> empty α) = c₁) _ rfl
state_before: α : Type u
β : Type v
γ : Type w
c : Computation α
⊢ (HOrElse.hOrElse c fun x => empty α) = c
state_after: α : Type u
β : Type v
γ : Type w
c : Computation α
⊢ IsBisimulation fun c₁ c₂ => (HOrElse.hOrElse c₂ fun x => empty α) = c₁

tactic: intro s' s h
state_before: α : Type u
β : Type v
γ : Type w
c : Computation α
⊢ IsBisimulation fun c₁ c₂ => (HOrElse.hOrElse c₂ fun x => empty α) = c₁
state_after: α : Type u
β : Type v
γ : Type w
c s' s : Computation α
h : (HOrElse.hOrElse s fun x => empty α) = s'
⊢ BisimO (fun c₁ c₂ => (HOrElse.hOrElse c₂ fun x => empty α) = c₁) s'.destruct s.destruct

tactic: rw [← h]
state_before: α : Type u
β : Type v
γ : Type w
c s' s : Computation α
h : (HOrElse.hOrElse s fun x => empty α) = s'
⊢ BisimO (fun c₁ c₂ => (HOrElse.hOrElse c₂ fun x => empty α) = c₁) s'.destruct s.destruct
state_after: α : Type u
β : Type v
γ : Type w
c s' s : Computation α
h : (HOrElse.hOrElse s fun x => empty α) = s'
⊢ BisimO (fun c₁ c₂ => (HOrElse.hOrElse c₂ fun x => empty α) = c₁) (HOrElse.hOrElse s fun x => empty α).destruct
    s.destruct

tactic: apply recOn s <;> intro s <;> rw [think_empty] <;> simp
state_before: α : Type u
β : Type v
γ : Type w
c s' s : Computation α
h : (HOrElse.hOrElse s fun x => empty α) = s'
⊢ BisimO (fun c₁ c₂ => (HOrElse.hOrElse c₂ fun x => empty α) = c₁) (HOrElse.hOrElse s fun x => empty α).destruct
    s.destruct
state_after: case h2
α : Type u
β : Type v
γ : Type w
c s' s✝ : Computation α
h : (HOrElse.hOrElse s✝ fun x => empty α) = s'
s : Computation α
⊢ (HOrElse.hOrElse s fun x => (empty α).think) = HOrElse.hOrElse s fun x => empty α

tactic: rw [← think_empty]
state_before: case h2
α : Type u
β : Type v
γ : Type w
c s' s✝ : Computation α
h : (HOrElse.hOrElse s✝ fun x => empty α) = s'
s : Computation α
⊢ (HOrElse.hOrElse s fun x => (empty α).think) = HOrElse.hOrElse s fun x => empty α
state_after: no goals
Theorem: Algebra.leftMulMatrix_eq_repr_mul
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

tactic: rw [leftMulMatrix_apply, toMatrix_lmul' b x i j]
state_before: R : Type u_1
S : Type u_2
inst✝⁴ : CommRing R
inst✝³ : Ring S
inst✝² : Algebra R S
m : Type u_3
inst✝¹ : Fintype m
inst✝ : DecidableEq m
b : Basis m R S
x : S
i j : m
⊢ (leftMulMatrix b) x i j = (b.repr (x * b j)) i
state_after: no goals
Theorem: Nat.size_eq_bits_len
File: Mathlib/Data/Nat/Size.lean

tactic: induction' n using Nat.binaryRec' with b n h ih
state_before: n : ℕ
⊢ n.bits.length = n.size
state_after: case z

⊢ (bits 0).length = size 0

case f
b : Bool
n : ℕ
h : n = 0 → b = true
ih : n.bits.length = n.size
⊢ (bit b n).bits.length = (bit b n).size

tactic: rw [size_bit, bits_append_bit _ _ h]
state_before: case f
b : Bool
n : ℕ
h : n = 0 → b = true
ih : n.bits.length = n.size
⊢ (bit b n).bits.length = (bit b n).size
state_after: case f
b : Bool
n : ℕ
h : n = 0 → b = true
ih : n.bits.length = n.size
⊢ (b :: n.bits).length = n.size.succ

case f
b : Bool
n : ℕ
h : n = 0 → b = true
ih : n.bits.length = n.size
⊢ bit b n ≠ 0

tactic: simp
state_before: case z

⊢ (bits 0).length = size 0
state_after: no goals

tactic: simp [ih]
state_before: case f
b : Bool
n : ℕ
h : n = 0 → b = true
ih : n.bits.length = n.size
⊢ (b :: n.bits).length = n.size.succ
state_after: no goals

tactic: simpa [bit_eq_zero_iff]
state_before: case f
b : Bool
n : ℕ
h : n = 0 → b = true
ih : n.bits.length = n.size
⊢ bit b n ≠ 0
state_after: no goals
Theorem: sup_himp_self_right
File: Mathlib/Order/Heyting/Basic.lean

tactic: rw [sup_himp_distrib, himp_self, inf_top_eq]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : GeneralizedHeytingAlgebra α
a✝ b✝ c d a b : α
⊢ a ⊔ b ⇨ b = a ⇨ b
state_after: no goals
Theorem: AlgebraicTopology.DoldKan.N₂Γ₂_inv_app_f_f
File: Mathlib/AlgebraicTopology/DoldKan/GammaCompN.lean

tactic: dsimp [N₂Γ₂]
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
X : Karoubi (ChainComplex C ℕ)
n : ℕ
⊢ (N₂Γ₂.inv.app X).f.f n =
    X.p.f n ≫ ((Γ₀.splitting X.X).cofan { unop := [n] }).inj (Splitting.IndexSet.id { unop := [n] })
state_after: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
X : Karoubi (ChainComplex C ℕ)
n : ℕ
⊢ ((((whiskeringLeft (ChainComplex C ℕ) (Karoubi (ChainComplex C ℕ)) (Karoubi (ChainComplex C ℕ))).obj
                    (toKaroubi (ChainComplex C ℕ))).preimage
                (N₁Γ₀.inv ≫ N₂Γ₂ToKaroubiIso.inv)).app
            X).f.f
      n =
    X.p.f n ≫ ((Γ₀.splitting X.X).cofan { unop := [n] }).inj (Splitting.IndexSet.id { unop := [n] })

tactic: simp only [whiskeringLeft_obj_preimage_app, NatTrans.comp_app, Functor.comp_map,
  Karoubi.comp_f, N₂Γ₂ToKaroubiIso_inv_app, HomologicalComplex.comp_f,
  N₁Γ₀_inv_app_f_f, toKaroubi_obj_X, Splitting.toKaroubiNondegComplexIsoN₁_hom_f_f,
  Γ₀.obj_obj, PInfty_on_Γ₀_splitting_summand_eq_self, N₂_map_f_f,
  Γ₂_map_f_app, unop_op, Karoubi.decompId_p_f, PInfty_f_idem_assoc,
  PInfty_on_Γ₀_splitting_summand_eq_self_assoc, Splitting.IndexSet.id_fst, SimplexCategory.len_mk,
  Splitting.ι_desc]
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
X : Karoubi (ChainComplex C ℕ)
n : ℕ
⊢ ((((whiskeringLeft (ChainComplex C ℕ) (Karoubi (ChainComplex C ℕ)) (Karoubi (ChainComplex C ℕ))).obj
                    (toKaroubi (ChainComplex C ℕ))).preimage
                (N₁Γ₀.inv ≫ N₂Γ₂ToKaroubiIso.inv)).app
            X).f.f
      n =
    X.p.f n ≫ ((Γ₀.splitting X.X).cofan { unop := [n] }).inj (Splitting.IndexSet.id { unop := [n] })
state_after: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
X : Karoubi (ChainComplex C ℕ)
n : ℕ
⊢ ((𝟭 (Karoubi (ChainComplex C ℕ))).map X.decompId_i).f.f n ≫
      X.p.f n ≫ ((Γ₀.splitting X.X).cofan { unop := [n] }).inj (Splitting.IndexSet.id { unop := [n] }) =
    X.p.f n ≫ ((Γ₀.splitting X.X).cofan { unop := [n] }).inj (Splitting.IndexSet.id { unop := [n] })

tactic: apply Karoubi.HomologicalComplex.p_idem_assoc
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
X : Karoubi (ChainComplex C ℕ)
n : ℕ
⊢ ((𝟭 (Karoubi (ChainComplex C ℕ))).map X.decompId_i).f.f n ≫
      X.p.f n ≫ ((Γ₀.splitting X.X).cofan { unop := [n] }).inj (Splitting.IndexSet.id { unop := [n] }) =
    X.p.f n ≫ ((Γ₀.splitting X.X).cofan { unop := [n] }).inj (Splitting.IndexSet.id { unop := [n] })
state_after: no goals
Theorem: SimpleGraph.Walk.exists_length_eq_zero_iff
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: constructor
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
⊢ (∃ p, p.length = 0) ↔ u = v
state_after: case mp
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
⊢ (∃ p, p.length = 0) → u = v

case mpr
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
⊢ u = v → ∃ p, p.length = 0

tactic: rintro ⟨p, hp⟩
state_before: case mp
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
⊢ (∃ p, p.length = 0) → u = v
state_after: case mp.intro
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : G.Walk u v
hp : p.length = 0
⊢ u = v

tactic: exact eq_of_length_eq_zero hp
state_before: case mp.intro
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : G.Walk u v
hp : p.length = 0
⊢ u = v
state_after: no goals

tactic: rintro rfl
state_before: case mpr
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
⊢ u = v → ∃ p, p.length = 0
state_after: case mpr
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u : V
⊢ ∃ p, p.length = 0

tactic: exact ⟨nil, rfl⟩
state_before: case mpr
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u : V
⊢ ∃ p, p.length = 0
state_after: no goals
Theorem: Surreal.Multiplication.ih1
File: Mathlib/SetTheory/Surreal/Multiplication.lean

tactic: rintro x₁ x₂ y' h₁ h₂ (rfl|hy) <;> apply ih (Args.P24 _ _ _)
state_before: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
ih : ∀ (a : Args), ArgsRel a (Args.P1 x y) → P124 a
⊢ IH1 x y
state_after: case inl
x x₁✝ x₂✝ x₃ x' y₁ y₂ y₃ y'✝ x₁ x₂ y' : PGame
h₁ : x₁.IsOption x
h₂ : x₂.IsOption x
ih : ∀ (a : Args), ArgsRel a (Args.P1 x y') → P124 a
⊢ ArgsRel (Args.P24 x₁ x₂ y') (Args.P1 x y')

case inr
x x₁✝ x₂✝ x₃ x' y y₁ y₂ y₃ y'✝ : PGame
ih : ∀ (a : Args), ArgsRel a (Args.P1 x y) → P124 a
x₁ x₂ y' : PGame
h₁ : x₁.IsOption x
h₂ : x₂.IsOption x
hy : y'.IsOption y
⊢ ArgsRel (Args.P24 x₁ x₂ y') (Args.P1 x y)

tactic: on_goal 2 => refine TransGen.tail ?_ (cutExpand_pair_right hy)
state_before: case inl
x x₁✝ x₂✝ x₃ x' y₁ y₂ y₃ y'✝ x₁ x₂ y' : PGame
h₁ : x₁.IsOption x
h₂ : x₂.IsOption x
ih : ∀ (a : Args), ArgsRel a (Args.P1 x y') → P124 a
⊢ ArgsRel (Args.P24 x₁ x₂ y') (Args.P1 x y')

case inr
x x₁✝ x₂✝ x₃ x' y y₁ y₂ y₃ y'✝ : PGame
ih : ∀ (a : Args), ArgsRel a (Args.P1 x y) → P124 a
x₁ x₂ y' : PGame
h₁ : x₁.IsOption x
h₂ : x₂.IsOption x
hy : y'.IsOption y
⊢ ArgsRel (Args.P24 x₁ x₂ y') (Args.P1 x y)
state_after: case inl
x x₁✝ x₂✝ x₃ x' y₁ y₂ y₃ y'✝ x₁ x₂ y' : PGame
h₁ : x₁.IsOption x
h₂ : x₂.IsOption x
ih : ∀ (a : Args), ArgsRel a (Args.P1 x y') → P124 a
⊢ ArgsRel (Args.P24 x₁ x₂ y') (Args.P1 x y')

case inr
x x₁✝ x₂✝ x₃ x' y y₁ y₂ y₃ y'✝ : PGame
ih : ∀ (a : Args), ArgsRel a (Args.P1 x y) → P124 a
x₁ x₂ y' : PGame
h₁ : x₁.IsOption x
h₂ : x₂.IsOption x
hy : y'.IsOption y
⊢ TransGen (CutExpand IsOption) (Args.P24 x₁ x₂ y').toMultiset {x, y'}

tactic: all_goals exact TransGen.single (cutExpand_double_left h₁ h₂)
state_before: case inl
x x₁✝ x₂✝ x₃ x' y₁ y₂ y₃ y'✝ x₁ x₂ y' : PGame
h₁ : x₁.IsOption x
h₂ : x₂.IsOption x
ih : ∀ (a : Args), ArgsRel a (Args.P1 x y') → P124 a
⊢ ArgsRel (Args.P24 x₁ x₂ y') (Args.P1 x y')

case inr
x x₁✝ x₂✝ x₃ x' y y₁ y₂ y₃ y'✝ : PGame
ih : ∀ (a : Args), ArgsRel a (Args.P1 x y) → P124 a
x₁ x₂ y' : PGame
h₁ : x₁.IsOption x
h₂ : x₂.IsOption x
hy : y'.IsOption y
⊢ TransGen (CutExpand IsOption) (Args.P24 x₁ x₂ y').toMultiset {x, y'}
state_after: no goals

tactic: refine TransGen.tail ?_ (cutExpand_pair_right hy)
state_before: case inr
x x₁✝ x₂✝ x₃ x' y y₁ y₂ y₃ y'✝ : PGame
ih : ∀ (a : Args), ArgsRel a (Args.P1 x y) → P124 a
x₁ x₂ y' : PGame
h₁ : x₁.IsOption x
h₂ : x₂.IsOption x
hy : y'.IsOption y
⊢ ArgsRel (Args.P24 x₁ x₂ y') (Args.P1 x y)
state_after: case inr
x x₁✝ x₂✝ x₃ x' y y₁ y₂ y₃ y'✝ : PGame
ih : ∀ (a : Args), ArgsRel a (Args.P1 x y) → P124 a
x₁ x₂ y' : PGame
h₁ : x₁.IsOption x
h₂ : x₂.IsOption x
hy : y'.IsOption y
⊢ TransGen (CutExpand IsOption) (Args.P24 x₁ x₂ y').toMultiset {x, y'}

tactic: exact TransGen.single (cutExpand_double_left h₁ h₂)
state_before: case inr
x x₁✝ x₂✝ x₃ x' y y₁ y₂ y₃ y'✝ : PGame
ih : ∀ (a : Args), ArgsRel a (Args.P1 x y) → P124 a
x₁ x₂ y' : PGame
h₁ : x₁.IsOption x
h₂ : x₂.IsOption x
hy : y'.IsOption y
⊢ TransGen (CutExpand IsOption) (Args.P24 x₁ x₂ y').toMultiset {x, y'}
state_after: no goals
Theorem: MeasureTheory.BorelCantelli.process_zero
File: Mathlib/Probability/Martingale/BorelCantelli.lean

tactic: rw [process, Finset.range_zero, Finset.sum_empty]
state_before: Ω : Type u_1
m0 : MeasurableSpace Ω
μ : Measure Ω
ℱ : Filtration ℕ m0
f : ℕ → Ω → ℝ
ω : Ω
r : ℝ
R : ℝ≥0
s : ℕ → Set Ω
⊢ process s 0 = 0
state_after: no goals
Theorem: Ordnode.dual_eraseMax
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: rw [← dual_dual (eraseMin _), dual_eraseMin, dual_dual]
state_before: α : Type u_1
t : Ordnode α
⊢ t.eraseMax.dual = t.dual.eraseMin
state_after: no goals
Theorem: Set.biInter_pair
File: Mathlib/Data/Set/Lattice.lean

tactic: rw [biInter_insert, biInter_singleton]
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
a b : α
s : α → Set β
⊢ ⋂ x ∈ {a, b}, s x = s a ∩ s b
state_after: no goals
Theorem: List.get?_range
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: simp [getElem?_range, h]
state_before: m n : Nat
h : m < n
⊢ (range n).get? m = some m
state_after: no goals
Theorem: Heyting.IsRegular.disjoint_compl_right_iff
File: Mathlib/Order/Heyting/Regular.lean

tactic: rw [← le_compl_iff_disjoint_right, hb.eq]
state_before: α : Type u_1
inst✝ : HeytingAlgebra α
a b : α
hb : IsRegular b
⊢ Disjoint a bᶜ ↔ a ≤ b
state_after: no goals
Theorem: Matrix.cons_vecMul_cons
File: Mathlib/Data/Matrix/Notation.lean

tactic: simp
state_before: α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝ : NonUnitalNonAssocSemiring α
x : α
v : Fin n → α
w : o' → α
B : Fin n → o' → α
⊢ vecCons x v ᵥ* of (vecCons w B) = x • w + v ᵥ* of B
state_after: no goals