ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Finset.range_add_eq_union
File: Mathlib/Order/Interval/Finset/Nat.lean

Proof steps:
state_before: a b c : ℕ
⊢ range (a + b) = range a ∪ map (addLeftEmbedding a) (range b)
state_after: a b c : ℕ
⊢ Ico 0 (a + b) = Ico 0 a ∪ image (⇑(addLeftEmbedding a)) (Ico 0 b)
tactic: rw [Finset.range_eq_Ico, map_eq_image]
state_before: a b c : ℕ
⊢ Ico 0 (a + b) = Ico 0 a ∪ image (⇑(addLeftEmbedding a)) (Ico 0 b)
state_after: case h.e'_3.h.e'_4
a b c : ℕ
⊢ image (⇑(addLeftEmbedding a)) (Ico 0 b) = Ico a (a + b)
tactic: convert (Ico_union_Ico_eq_Ico a.zero_le (a.le_add_right b)).symm
state_before: case h.e'_3.h.e'_4
a b c : ℕ
⊢ image (⇑(addLeftEmbedding a)) (Ico 0 b) = Ico a (a + b)
state_after: case h.e'_3.h.e'_4.a
a b c x : ℕ
⊢ x ∈ image (⇑(addLeftEmbedding a)) (Ico 0 b) ↔ x ∈ Ico a (a + b)
tactic: ext x
state_before: case h.e'_3.h.e'_4.a
a b c x : ℕ
⊢ x ∈ image (⇑(addLeftEmbedding a)) (Ico 0 b) ↔ x ∈ Ico a (a + b)
state_after: case h.e'_3.h.e'_4.a
a b c x : ℕ
⊢ (∃ a_1 < b, a + a_1 = x) ↔ a ≤ x ∧ x < a + b
tactic: simp only [Ico_zero_eq_range, mem_image, mem_range, addLeftEmbedding_apply, mem_Ico]
state_before: case h.e'_3.h.e'_4.a
a b c x : ℕ
⊢ (∃ a_1 < b, a + a_1 = x) ↔ a ≤ x ∧ x < a + b
state_after: case h.e'_3.h.e'_4.a.mp
a b c x : ℕ
⊢ (∃ a_1 < b, a + a_1 = x) → a ≤ x ∧ x < a + b

case h.e'_3.h.e'_4.a.mpr
a b c x : ℕ
⊢ a ≤ x ∧ x < a + b → ∃ a_2 < b, a + a_2 = x
tactic: constructor
Theorem: isClosed_le_of_isClosed_nonneg
File: Mathlib/Analysis/Normed/Order/Lattice.lean

Proof steps:
state_before: α : Type u_1
inst✝³ : NormedLatticeAddCommGroup α
G : Type u_2
inst✝² : OrderedAddCommGroup G
inst✝¹ : TopologicalSpace G
inst✝ : ContinuousSub G
h : IsClosed {x | 0 ≤ x}
⊢ IsClosed {p | p.1 ≤ p.2}
state_after: α : Type u_1
inst✝³ : NormedLatticeAddCommGroup α
G : Type u_2
inst✝² : OrderedAddCommGroup G
inst✝¹ : TopologicalSpace G
inst✝ : ContinuousSub G
h : IsClosed {x | 0 ≤ x}
this : {p | p.1 ≤ p.2} = (fun p => p.2 - p.1) ⁻¹' {x | 0 ≤ x}
⊢ IsClosed {p | p.1 ≤ p.2}
tactic: have : { p : G × G | p.fst ≤ p.snd } = (fun p : G × G => p.snd - p.fst) ⁻¹' { x : G | 0 ≤ x } :=
    by ext1 p; simp only [sub_nonneg, Set.preimage_setOf_eq]
state_before: α : Type u_1
inst✝³ : NormedLatticeAddCommGroup α
G : Type u_2
inst✝² : OrderedAddCommGroup G
inst✝¹ : TopologicalSpace G
inst✝ : ContinuousSub G
h : IsClosed {x | 0 ≤ x}
this : {p | p.1 ≤ p.2} = (fun p => p.2 - p.1) ⁻¹' {x | 0 ≤ x}
⊢ IsClosed {p | p.1 ≤ p.2}
state_after: α : Type u_1
inst✝³ : NormedLatticeAddCommGroup α
G : Type u_2
inst✝² : OrderedAddCommGroup G
inst✝¹ : TopologicalSpace G
inst✝ : ContinuousSub G
h : IsClosed {x | 0 ≤ x}
this : {p | p.1 ≤ p.2} = (fun p => p.2 - p.1) ⁻¹' {x | 0 ≤ x}
⊢ IsClosed ((fun p => p.2 - p.1) ⁻¹' {x | 0 ≤ x})
tactic: rw [this]
state_before: α : Type u_1
inst✝³ : NormedLatticeAddCommGroup α
G : Type u_2
inst✝² : OrderedAddCommGroup G
inst✝¹ : TopologicalSpace G
inst✝ : ContinuousSub G
h : IsClosed {x | 0 ≤ x}
this : {p | p.1 ≤ p.2} = (fun p => p.2 - p.1) ⁻¹' {x | 0 ≤ x}
⊢ IsClosed ((fun p => p.2 - p.1) ⁻¹' {x | 0 ≤ x})
state_after: no goals
tactic: exact IsClosed.preimage (continuous_snd.sub continuous_fst) h
Theorem: Matrix.posSemidef_self_mul_conjTranspose
File: Mathlib/LinearAlgebra/Matrix/PosDef.lean

Proof steps:
state_before: m : Type u_1
n : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝⁶ : Fintype m
inst✝⁵ : Fintype n
inst✝⁴ : CommRing R
inst✝³ : PartialOrder R
inst✝² : StarRing R
inst✝¹ : StarOrderedRing R
inst✝ : RCLike 𝕜
A : Matrix m n R
⊢ (A * Aᴴ).PosSemidef
state_after: no goals
tactic: simpa only [conjTranspose_conjTranspose] using posSemidef_conjTranspose_mul_self Aᴴ
Theorem: Submonoid.val_unitsTypeEquivIsUnitSubmonoid_symm_apply
File: Mathlib/Algebra/Group/Submonoid/Operations.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝¹ : SetLike A M
hA : SubmonoidClass A M
S' : A
inst✝ : Monoid M
x : ↥(IsUnit.submonoid M)
⊢ (fun x => ⟨↑x, ⋯⟩) ((fun x => IsUnit.unit ⋯) x) = x
state_after: no goals
tactic: simp_rw [IsUnit.unit_spec]
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝¹ : SetLike A M
hA : SubmonoidClass A M
S' : A
inst✝ : Monoid M
x y : Mˣ
⊢ { toFun := fun x => ⟨↑x, ⋯⟩, invFun := fun x => IsUnit.unit ⋯, left_inv := ⋯, right_inv := ⋯ }.toFun (x * y) =
    { toFun := fun x => ⟨↑x, ⋯⟩, invFun := fun x => IsUnit.unit ⋯, left_inv := ⋯, right_inv := ⋯ }.toFun x *
      { toFun := fun x => ⟨↑x, ⋯⟩, invFun := fun x => IsUnit.unit ⋯, left_inv := ⋯, right_inv := ⋯ }.toFun y
state_after: M : Type u_1
N : Type u_2
P : Type u_3
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝¹ : SetLike A M
hA : SubmonoidClass A M
S' : A
inst✝ : Monoid M
x y : Mˣ
⊢ ⟨↑x * ↑y, ⋯⟩ = ⟨↑x, ⋯⟩ * ⟨↑y, ⋯⟩
tactic: simp_rw [Units.val_mul]
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝¹ : SetLike A M
hA : SubmonoidClass A M
S' : A
inst✝ : Monoid M
x y : Mˣ
⊢ ⟨↑x * ↑y, ⋯⟩ = ⟨↑x, ⋯⟩ * ⟨↑y, ⋯⟩
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.MorphismProperty.FunctorialFactorizationData.fac_app
File: Mathlib/CategoryTheory/MorphismProperty/Factorization.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
W₁ W₂ : MorphismProperty C
data : W₁.FunctorialFactorizationData W₂
f : Arrow C
⊢ data.i.app f ≫ data.p.app f = f.hom
state_after: no goals
tactic: rw [← NatTrans.comp_app, fac,Arrow.leftToRight_app]
Theorem: Rat.divInt_neg'
File: .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean

Proof steps:
state_before: num den : Int
⊢ num /. -den = -num /. den
state_after: no goals
tactic: rw [← neg_divInt_neg, Int.neg_neg]
Theorem: Nat.prime_def_lt'
File: Mathlib/Data/Nat/Prime/Defs.lean

Proof steps:
state_before: n p : ℕ
p2 : 2 ≤ p
m : ℕ
h : m < p → m ∣ p → m = 1
m2 : 2 ≤ m
l : m < p
d : m ∣ p
⊢ 1 < 2
state_after: no goals
tactic: decide
state_before: n p : ℕ
p2 : 2 ≤ p
m : ℕ
h : 2 ≤ m → m < p → ¬m ∣ p
l : m < p
d : m ∣ p
⊢ m = 1
state_after: case zero
n p : ℕ
p2 : 2 ≤ p
h : 2 ≤ 0 → 0 < p → ¬0 ∣ p
l : 0 < p
d : 0 ∣ p
⊢ 0 = 1

case succ.zero
n p : ℕ
p2 : 2 ≤ p
h : 2 ≤ 0 + 1 → 0 + 1 < p → ¬0 + 1 ∣ p
l : 0 + 1 < p
d : 0 + 1 ∣ p
⊢ 0 + 1 = 1

case succ.succ
n p : ℕ
p2 : 2 ≤ p
m : ℕ
h : 2 ≤ m + 1 + 1 → m + 1 + 1 < p → ¬m + 1 + 1 ∣ p
l : m + 1 + 1 < p
d : m + 1 + 1 ∣ p
⊢ m + 1 + 1 = 1
tactic: rcases m with (_ | _ | m)
Theorem: Module.Ray.ne_neg_self
File: Mathlib/LinearAlgebra/Ray.lean

Proof steps:
state_before: R : Type u_1
inst✝⁵ : StrictOrderedCommRing R
M : Type u_2
N : Type u_3
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup N
inst✝² : Module R M
inst✝¹ : Module R N
x✝ y : M
inst✝ : NoZeroSMulDivisors R M
x : Ray R M
⊢ x ≠ -x
state_after: case h
R : Type u_1
inst✝⁵ : StrictOrderedCommRing R
M : Type u_2
N : Type u_3
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup N
inst✝² : Module R M
inst✝¹ : Module R N
x✝ y : M
inst✝ : NoZeroSMulDivisors R M
x : M
hx : x ≠ 0
⊢ rayOfNeZero R x hx ≠ -rayOfNeZero R x hx
tactic: induction' x using Module.Ray.ind with x hx
state_before: case h
R : Type u_1
inst✝⁵ : StrictOrderedCommRing R
M : Type u_2
N : Type u_3
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup N
inst✝² : Module R M
inst✝¹ : Module R N
x✝ y : M
inst✝ : NoZeroSMulDivisors R M
x : M
hx : x ≠ 0
⊢ rayOfNeZero R x hx ≠ -rayOfNeZero R x hx
state_after: case h
R : Type u_1
inst✝⁵ : StrictOrderedCommRing R
M : Type u_2
N : Type u_3
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup N
inst✝² : Module R M
inst✝¹ : Module R N
x✝ y : M
inst✝ : NoZeroSMulDivisors R M
x : M
hx : x ≠ 0
⊢ ¬SameRay R x (-x)
tactic: rw [neg_rayOfNeZero, Ne, ray_eq_iff]
state_before: case h
R : Type u_1
inst✝⁵ : StrictOrderedCommRing R
M : Type u_2
N : Type u_3
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup N
inst✝² : Module R M
inst✝¹ : Module R N
x✝ y : M
inst✝ : NoZeroSMulDivisors R M
x : M
hx : x ≠ 0
⊢ ¬SameRay R x (-x)
state_after: no goals
tactic: exact mt eq_zero_of_sameRay_self_neg hx
Theorem: Ico_eq_locus_Ioc_eq_iUnion_Ioo
File: Mathlib/Algebra/Order/ToIntervalMod.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
⊢ {b | toIcoMod hp a b = toIocMod hp a b} = ⋃ z, Set.Ioo (a + z • p) (a + p + z • p)
state_after: case h
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
x✝ : α
⊢ x✝ ∈ {b | toIcoMod hp a b = toIocMod hp a b} ↔ x✝ ∈ ⋃ z, Set.Ioo (a + z • p) (a + p + z • p)
tactic: ext1
state_before: case h
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
x✝ : α
⊢ x✝ ∈ {b | toIcoMod hp a b = toIocMod hp a b} ↔ x✝ ∈ ⋃ z, Set.Ioo (a + z • p) (a + p + z • p)
state_after: no goals
tactic: simp_rw [Set.mem_setOf, Set.mem_iUnion, ← Set.sub_mem_Ioo_iff_left, ←
    not_modEq_iff_toIcoMod_eq_toIocMod, modEq_iff_not_forall_mem_Ioo_mod hp, not_forall,
    Classical.not_not]
Theorem: CauSeq.sup_eq_right
File: Mathlib/Algebra/Order/CauSeq/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrderedField α
a b : CauSeq α abs
h : a ≤ b
⊢ a ⊔ b ≈ b
state_after: case inl.intro.intro.intro
α : Type u_1
β : Type u_2
inst✝ : LinearOrderedField α
a b : CauSeq α abs
ε : α
ε0 : 0 < ε
i : ℕ
h : ∀ j ≥ i, ε ≤ ↑(b - a) j
⊢ a ⊔ b ≈ b

case inr
α : Type u_1
β : Type u_2
inst✝ : LinearOrderedField α
a b : CauSeq α abs
h : a ≈ b
⊢ a ⊔ b ≈ b
tactic: obtain ⟨ε, ε0 : _ < _, i, h⟩ | h := h
Theorem: Multiset.le_cons_erase
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ t : Multiset α
a✝ b : α
s : Multiset α
a : α
h : a ∉ s
⊢ s ≤ a ::ₘ s.erase a
state_after: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ t : Multiset α
a✝ b : α
s : Multiset α
a : α
h : a ∉ s
⊢ s ≤ a ::ₘ s
tactic: rw [erase_of_not_mem h]
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ t : Multiset α
a✝ b : α
s : Multiset α
a : α
h : a ∉ s
⊢ s ≤ a ::ₘ s
state_after: no goals
tactic: apply le_cons_self
Theorem: Equiv.piCongrLeft_sum_inl
File: Mathlib/Logic/Equiv/Basic.lean

Proof steps:
state_before: β : Sort ?u.112935
α : Sort ?u.112940
P : β → Sort w
e✝ : α ≃ β
ι'' : Sort u_2
ι : Type u_3
ι' : Type u_4
π : ι'' → Type u_1
e : ι ⊕ ι' ≃ ι''
f : (i : ι) → π (e (inl i))
g : (i : ι') → π (e (inr i))
i : ι
⊢ (piCongrLeft π e) ((sumPiEquivProdPi fun x => π (e x)).symm (f, g)) (e (inl i)) = f i
state_after: no goals
tactic: simp_rw [piCongrLeft_apply_eq_cast, sumPiEquivProdPi_symm_apply,
    sum_rec_congr _ _ _ (e.symm_apply_apply (inl i)), cast_cast, cast_eq]
Theorem: Set.Nonempty.subset_pair_iff_eq
File: Mathlib/Data/Set/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
hs : s.Nonempty
⊢ s ⊆ {a, b} ↔ s = {a} ∨ s = {b} ∨ s = {a, b}
state_after: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
hs : s.Nonempty
⊢ ¬s = ∅
tactic: rw [Set.subset_pair_iff_eq, or_iff_right]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
hs : s.Nonempty
⊢ ¬s = ∅
state_after: no goals
tactic: exact hs.ne_empty
Theorem: FreeGroup.toWord_injective
File: Mathlib/GroupTheory/FreeGroup/Basic.lean

Proof steps:
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
inst✝ : DecidableEq α
⊢ Function.Injective toWord
state_after: case mk.mk
α : Type u
L L₁✝ L₂✝ L₃ L₄ : List (α × Bool)
inst✝ : DecidableEq α
a₁✝ : FreeGroup α
L₁ : List (α × Bool)
a₂✝ : FreeGroup α
L₂ : List (α × Bool)
⊢ toWord (Quot.mk Red.Step L₁) = toWord (Quot.mk Red.Step L₂) → Quot.mk Red.Step L₁ = Quot.mk Red.Step L₂
tactic: rintro ⟨L₁⟩ ⟨L₂⟩
state_before: case mk.mk
α : Type u
L L₁✝ L₂✝ L₃ L₄ : List (α × Bool)
inst✝ : DecidableEq α
a₁✝ : FreeGroup α
L₁ : List (α × Bool)
a₂✝ : FreeGroup α
L₂ : List (α × Bool)
⊢ toWord (Quot.mk Red.Step L₁) = toWord (Quot.mk Red.Step L₂) → Quot.mk Red.Step L₁ = Quot.mk Red.Step L₂
state_after: no goals
tactic: exact reduce.exact
Theorem: SimpleGraph.hasse_preconnected_of_succ
File: Mathlib/Combinatorics/SimpleGraph/Hasse.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
a b : α
⊢ (hasse α).Reachable a b
state_after: α : Type u_1
β : Type u_2
inst✝² : LinearOrder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
a b : α
⊢ ReflTransGen (hasse α).Adj a b
tactic: rw [reachable_iff_reflTransGen]
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
a b : α
⊢ ReflTransGen (hasse α).Adj a b
state_after: no goals
tactic: exact
    reflTransGen_of_succ _ (fun c hc => Or.inl <| covBy_succ_of_not_isMax hc.2.not_isMax)
      fun c hc => Or.inr <| covBy_succ_of_not_isMax hc.2.not_isMax
Theorem: Nat.pow_lt_pow_iff_left
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
hn : n ≠ 0
⊢ a ^ n < b ^ n ↔ a < b
state_after: no goals
tactic: simp only [← Nat.not_le, Nat.pow_le_pow_iff_left hn]
Theorem: ENNReal.coe_inv_two
File: Mathlib/Data/ENNReal/Inv.lean

Proof steps:
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ ↑2⁻¹ = 2⁻¹
state_after: no goals
tactic: rw [coe_inv _root_.two_ne_zero, coe_two]
Theorem: Set.biInter_iUnion
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 α
t : α → Set β
⊢ ⋂ x ∈ ⋃ i, s i, t x = ⋂ i, ⋂ x ∈ s i, t x
state_after: no goals
tactic: simp [@iInter_comm _ ι]
Theorem: TensorProduct.directSum_symm_lof_tmul
File: Mathlib/LinearAlgebra/DirectSum/TensorProduct.lean

Proof steps:
state_before: R : Type u
inst✝¹⁴ : CommSemiring R
S : Type u_1
inst✝¹³ : Semiring S
inst✝¹² : Algebra R S
ι₁ : Type v₁
ι₂ : Type v₂
inst✝¹¹ : DecidableEq ι₁
inst✝¹⁰ : DecidableEq ι₂
M₁ : ι₁ → Type w₁
M₁' : Type w₁'
M₂ : ι₂ → Type w₂
M₂' : Type w₂'
inst✝⁹ : (i₁ : ι₁) → AddCommMonoid (M₁ i₁)
inst✝⁸ : AddCommMonoid M₁'
inst✝⁷ : (i₂ : ι₂) → AddCommMonoid (M₂ i₂)
inst✝⁶ : AddCommMonoid M₂'
inst✝⁵ : (i₁ : ι₁) → Module R (M₁ i₁)
inst✝⁴ : Module R M₁'
inst✝³ : (i₂ : ι₂) → Module R (M₂ i₂)
inst✝² : Module R M₂'
inst✝¹ : (i₁ : ι₁) → Module S (M₁ i₁)
inst✝ : ∀ (i₁ : ι₁), IsScalarTower R S (M₁ i₁)
i₁ : ι₁
m₁ : M₁ i₁
i₂ : ι₂
m₂ : M₂ i₂
⊢ (TensorProduct.directSum R S M₁ M₂).symm ((lof S (ι₁ × ι₂) (fun i => M₁ i.1 ⊗[R] M₂ i.2) (i₁, i₂)) (m₁ ⊗ₜ[R] m₂)) =
    (lof S ι₁ M₁ i₁) m₁ ⊗ₜ[R] (lof R ι₂ M₂ i₂) m₂
state_after: no goals
tactic: rw [LinearEquiv.symm_apply_eq, directSum_lof_tmul_lof]
Theorem: CategoryTheory.Functor.Monoidal.rightUnitor_inv_app
File: Mathlib/CategoryTheory/ChosenFiniteProducts/FunctorCategory.lean

Proof steps:
state_before: J : Type u_1
C : Type u_2
inst✝² : Category.{u_3, u_1} J
inst✝¹ : Category.{u_4, u_2} C
inst✝ : ChosenFiniteProducts C
F : J ⥤ C
j : J
⊢ (ρ_ F).inv.app j = (ρ_ (F.obj j)).inv
state_after: no goals
tactic: rw [← cancel_mono ((ρ_ (F.obj j)).hom), Iso.inv_hom_id, ← rightUnitor_hom_app,
    Iso.inv_hom_id_app]
Theorem: ProbabilityTheory.Kernel.sum_comap_seq
File: Mathlib/Probability/Kernel/Composition.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
δ : Type u_5
mγ : MeasurableSpace γ
mδ : MeasurableSpace δ
f : β → γ
g : γ → α
κ : Kernel α β
inst✝ : IsSFiniteKernel κ
hg : Measurable g
⊢ (Kernel.sum fun n => (κ.seq n).comap g hg) = κ.comap g hg
state_after: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
δ : Type u_5
mγ : MeasurableSpace γ
mδ : MeasurableSpace δ
f : β → γ
g : γ → α
κ : Kernel α β
inst✝ : IsSFiniteKernel κ
hg : Measurable g
a : γ
s : Set β
hs : MeasurableSet s
⊢ ((Kernel.sum fun n => (κ.seq n).comap g hg) a) s = ((κ.comap g hg) a) s
tactic: ext a s hs
state_before: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
δ : Type u_5
mγ : MeasurableSpace γ
mδ : MeasurableSpace δ
f : β → γ
g : γ → α
κ : Kernel α β
inst✝ : IsSFiniteKernel κ
hg : Measurable g
a : γ
s : Set β
hs : MeasurableSet s
⊢ ((Kernel.sum fun n => (κ.seq n).comap g hg) a) s = ((κ.comap g hg) a) s
state_after: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
δ : Type u_5
mγ : MeasurableSpace γ
mδ : MeasurableSpace δ
f : β → γ
g : γ → α
κ : Kernel α β
inst✝ : IsSFiniteKernel κ
hg : Measurable g
a : γ
s : Set β
hs : MeasurableSet s
⊢ ∑' (i : ℕ), (((κ.seq i).comap g hg) a) s = ∑' (i : ℕ), ((κ.seq i) (g a)) s
tactic: rw [Kernel.sum_apply, comap_apply' κ hg a s, Measure.sum_apply _ hs, ← measure_sum_seq κ,
    Measure.sum_apply _ hs]
state_before: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
δ : Type u_5
mγ : MeasurableSpace γ
mδ : MeasurableSpace δ
f : β → γ
g : γ → α
κ : Kernel α β
inst✝ : IsSFiniteKernel κ
hg : Measurable g
a : γ
s : Set β
hs : MeasurableSet s
⊢ ∑' (i : ℕ), (((κ.seq i).comap g hg) a) s = ∑' (i : ℕ), ((κ.seq i) (g a)) s
state_after: no goals
tactic: simp_rw [comap_apply' _ hg _ s]
Theorem: Complex.pow_cpow_nat_inv
File: Mathlib/Analysis/SpecialFunctions/Pow/Complex.lean

Proof steps:
state_before: x : ℂ
n : ℕ
h₀ : n ≠ 0
hlt : -(π / ↑n) < x.arg
hle : x.arg ≤ π / ↑n
⊢ (x ^ n) ^ (↑n)⁻¹ = x
state_after: case hlt
x : ℂ
n : ℕ
h₀ : n ≠ 0
hlt : -(π / ↑n) < x.arg
hle : x.arg ≤ π / ↑n
⊢ -π < ↑n * x.arg

case hle
x : ℂ
n : ℕ
h₀ : n ≠ 0
hlt : -(π / ↑n) < x.arg
hle : x.arg ≤ π / ↑n
⊢ ↑n * x.arg ≤ π
tactic: rw [← cpow_nat_mul', mul_inv_cancel (Nat.cast_ne_zero.2 h₀), cpow_one]
Theorem: CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.inverse_obj_X_obj
File: Mathlib/CategoryTheory/Monoidal/Internal/FunctorCategory.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
F : C ⥤ CommMon_ D
⊢ (β_ __src✝.X __src✝.X).hom ≫ __src✝.mul = __src✝.mul
state_after: case w.h
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
F : C ⥤ CommMon_ D
X : C
⊢ ((β_ __src✝.X __src✝.X).hom ≫ __src✝.mul).app X = __src✝.mul.app X
tactic: ext X
state_before: case w.h
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
F : C ⥤ CommMon_ D
X : C
⊢ ((β_ __src✝.X __src✝.X).hom ≫ __src✝.mul).app X = __src✝.mul.app X
state_after: no goals
tactic: exact (F.obj X).mul_comm
Theorem: odd_add_one_self
File: Mathlib/Algebra/Ring/Parity.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝¹ : Semiring α
inst✝ : Semiring β
a b : α
m n : ℕ
⊢ Odd (a + 1 + a)
state_after: no goals
tactic: simp [add_comm _ a]
Theorem: Subgroup.leftTransversals.diff_mul_diff
File: Mathlib/GroupTheory/Transfer.lean

Proof steps:
state_before: G : Type u_1
inst✝² : Group G
H : Subgroup G
A : Type u_2
inst✝¹ : CommGroup A
ϕ : ↥H →* A
R S T : ↑(leftTransversals ↑H)
inst✝ : H.FiniteIndex
q : G ⧸ H
x✝ : q ∈ univ
⊢ ⟨(↑((MemLeftTransversals.toEquiv ⋯) q))⁻¹ * ↑((MemLeftTransversals.toEquiv ⋯) q), ⋯⟩ *
      ⟨(↑((MemLeftTransversals.toEquiv ⋯) q))⁻¹ * ↑((MemLeftTransversals.toEquiv ⋯) q), ⋯⟩ =
    ⟨(↑((MemLeftTransversals.toEquiv ⋯) q))⁻¹ * ↑((MemLeftTransversals.toEquiv ⋯) q), ⋯⟩
state_after: no goals
tactic: simp_rw [Subtype.ext_iff, coe_mul, mul_assoc, mul_inv_cancel_left]
Theorem: Function.iterate_mul
File: Mathlib/Logic/Function/Iterate.lean

Proof steps:
state_before: α : Type u
β : Type v
f : α → α
m : ℕ
⊢ f^[m * 0] = f^[m]^[0]
state_after: no goals
tactic: simp only [Nat.mul_zero, iterate_zero]
state_before: α : Type u
β : Type v
f : α → α
m n : ℕ
⊢ f^[m * (n + 1)] = f^[m]^[n + 1]
state_after: no goals
tactic: simp only [Nat.mul_succ, Nat.mul_one, iterate_one, iterate_add, iterate_mul m n]
Theorem: List.Perm.countP_congr
File: .lake/packages/batteries/Batteries/Data/List/Perm.lean

Proof steps:
state_before: α : Type u_1
l₁ l₂ : List α
s : l₁ ~ l₂
p p' : α → Bool
hp : ∀ (x : α), x ∈ l₁ → p x = p' x
⊢ countP p l₁ = countP p' l₂
state_after: α : Type u_1
l₁ l₂ : List α
s : l₁ ~ l₂
p p' : α → Bool
hp : ∀ (x : α), x ∈ l₁ → p x = p' x
⊢ countP p l₁ = countP p' l₁
tactic: rw [← s.countP_eq p']
state_before: α : Type u_1
l₁ l₂ : List α
s : l₁ ~ l₂
p p' : α → Bool
hp : ∀ (x : α), x ∈ l₁ → p x = p' x
⊢ countP p l₁ = countP p' l₁
state_after: α : Type u_1
l₁ l₂ : List α
p p' : α → Bool
hp : ∀ (x : α), x ∈ l₁ → p x = p' x
⊢ countP p l₁ = countP p' l₁
tactic: clear s
state_before: α : Type u_1
l₁ l₂ : List α
p p' : α → Bool
hp : ∀ (x : α), x ∈ l₁ → p x = p' x
⊢ countP p l₁ = countP p' l₁
state_after: no goals
tactic: induction l₁ with
  | nil => rfl
  | cons y s hs =>
    simp only [mem_cons, forall_eq_or_imp] at hp
    simp only [countP_cons, hs hp.2, hp.1]
Theorem: LieModule.traceForm_apply_eq_zero_of_mem_lcs_of_mem_center
File: Mathlib/Algebra/Lie/TraceForm.lean

Proof steps:
state_before: R : Type u_1
K : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : LieRingModule L M
inst✝² : LieModule R L M
inst✝¹ : Module.Free R M
inst✝ : Module.Finite R M
x y : L
hx : x ∈ lowerCentralSeries R L L 1
hy : y ∈ LieAlgebra.center R L
⊢ ((traceForm R L M) x) y = 0
state_after: case hx
R : Type u_1
K : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : LieRingModule L M
inst✝² : LieModule R L M
inst✝¹ : Module.Free R M
inst✝ : Module.Finite R M
x y : L
hx : x ∈ lowerCentralSeries R L L 1
hy : y ∈ LieAlgebra.center R L
⊢ x ∈ ⊤.lcs L 1

case hy
R : Type u_1
K : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : LieRingModule L M
inst✝² : LieModule R L M
inst✝¹ : Module.Free R M
inst✝ : Module.Finite R M
x y : L
hx : x ∈ lowerCentralSeries R L L 1
hy : y ∈ LieAlgebra.center R L
⊢ y ∈ LieSubmodule.ucs 1 ⊥
tactic: apply traceForm_eq_zero_if_mem_lcs_of_mem_ucs R L M 1
Theorem: IsCompactlyGenerated.BooleanGenerators.isAtomistic_of_sSup_eq_top
File: Mathlib/Order/BooleanGenerators.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : CompleteLattice α
inst✝ : IsCompactlyGenerated α
S : Set α
hS : BooleanGenerators S
h : sSup S = ⊤
⊢ IsAtomistic α
state_after: α : Type u_1
inst✝¹ : CompleteLattice α
inst✝ : IsCompactlyGenerated α
S : Set α
hS : BooleanGenerators S
h : sSup S = ⊤
a : α
⊢ ∃ s, a = sSup s ∧ ∀ a ∈ s, IsAtom a
tactic: refine ⟨fun a ↦ ?_⟩
state_before: α : Type u_1
inst✝¹ : CompleteLattice α
inst✝ : IsCompactlyGenerated α
S : Set α
hS : BooleanGenerators S
h : sSup S = ⊤
a : α
⊢ ∃ s, a = sSup s ∧ ∀ a ∈ s, IsAtom a
state_after: case intro.intro
α : Type u_1
inst✝¹ : CompleteLattice α
inst✝ : IsCompactlyGenerated α
S : Set α
hS : BooleanGenerators S
h : sSup S = ⊤
a : α
s : Set α
hs : s ⊆ S
hs' : a = sSup s
⊢ ∃ s, a = sSup s ∧ ∀ a ∈ s, IsAtom a
tactic: obtain ⟨s, hs, hs'⟩ := hS.atomistic a (h ▸ le_top)
state_before: case intro.intro
α : Type u_1
inst✝¹ : CompleteLattice α
inst✝ : IsCompactlyGenerated α
S : Set α
hS : BooleanGenerators S
h : sSup S = ⊤
a : α
s : Set α
hs : s ⊆ S
hs' : a = sSup s
⊢ ∃ s, a = sSup s ∧ ∀ a ∈ s, IsAtom a
state_after: no goals
tactic: exact ⟨s, hs', fun I hI ↦ hS.isAtom I (hs hI)⟩