ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: ZMod.smul_mem
File: Mathlib/Data/ZMod/Module.lean

Proof steps:
state_before: n : ℕ
M : Type u_1
M₁ : Type u_2
F : Type u_3
S : Type u_4
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : FunLike F M M₁
inst✝⁴ : AddMonoidHomClass F M M₁
inst✝³ : Module (ZMod n) M
inst✝² : Module (ZMod n) M₁
inst✝¹ : SetLike S M
inst✝ : AddSubgroupClass S M
x : M
K : S
hx : x ∈ K
c : ZMod n
⊢ c • x ∈ K
state_after: n : ℕ
M : Type u_1
M₁ : Type u_2
F : Type u_3
S : Type u_4
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : FunLike F M M₁
inst✝⁴ : AddMonoidHomClass F M M₁
inst✝³ : Module (ZMod n) M
inst✝² : Module (ZMod n) M₁
inst✝¹ : SetLike S M
inst✝ : AddSubgroupClass S M
x : M
K : S
hx : x ∈ K
c : ZMod n
⊢ c.cast • x ∈ K
tactic: rw [← ZMod.intCast_zmod_cast c, Int.cast_smul_eq_nsmul]
state_before: n : ℕ
M : Type u_1
M₁ : Type u_2
F : Type u_3
S : Type u_4
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : FunLike F M M₁
inst✝⁴ : AddMonoidHomClass F M M₁
inst✝³ : Module (ZMod n) M
inst✝² : Module (ZMod n) M₁
inst✝¹ : SetLike S M
inst✝ : AddSubgroupClass S M
x : M
K : S
hx : x ∈ K
c : ZMod n
⊢ c.cast • x ∈ K
state_after: no goals
tactic: exact zsmul_mem hx (cast c)
Theorem: List.forIn_eq_bindList
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: m : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : α → β → m (ForInStep β)
l : List α
init : β
⊢ forIn l init f = ForInStep.run <$> ForInStep.bindList f l (ForInStep.yield init)
state_after: case cons
m : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : α → β → m (ForInStep β)
head✝ : α
tail✝ : List α
tail_ih✝ : ∀ (init : β), forIn tail✝ init f = ForInStep.run <$> ForInStep.bindList f tail✝ (ForInStep.yield init)
init : β
⊢ (do
      let x ← f head✝ init
      match x with
        | ForInStep.done b => pure b
        | ForInStep.yield b => do
          let a ← ForInStep.bindList f tail✝ (ForInStep.yield b)
          pure a.run) =
    do
    let x ← f head✝ init
    let a ← ForInStep.bindList f tail✝ x
    pure a.run
tactic: induction l generalizing init <;> simp [*, map_eq_pure_bind]
state_before: case cons
m : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : α → β → m (ForInStep β)
head✝ : α
tail✝ : List α
tail_ih✝ : ∀ (init : β), forIn tail✝ init f = ForInStep.run <$> ForInStep.bindList f tail✝ (ForInStep.yield init)
init : β
⊢ (do
      let x ← f head✝ init
      match x with
        | ForInStep.done b => pure b
        | ForInStep.yield b => do
          let a ← ForInStep.bindList f tail✝ (ForInStep.yield b)
          pure a.run) =
    do
    let x ← f head✝ init
    let a ← ForInStep.bindList f tail✝ x
    pure a.run
state_after: case cons.e_a
m : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : α → β → m (ForInStep β)
head✝ : α
tail✝ : List α
tail_ih✝ : ∀ (init : β), forIn tail✝ init f = ForInStep.run <$> ForInStep.bindList f tail✝ (ForInStep.yield init)
init : β
⊢ (fun x =>
      match x with
      | ForInStep.done b => pure b
      | ForInStep.yield b => do
        let a ← ForInStep.bindList f tail✝ (ForInStep.yield b)
        pure a.run) =
    fun x => do
    let a ← ForInStep.bindList f tail✝ x
    pure a.run
tactic: congr
state_before: case cons.e_a
m : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : α → β → m (ForInStep β)
head✝ : α
tail✝ : List α
tail_ih✝ : ∀ (init : β), forIn tail✝ init f = ForInStep.run <$> ForInStep.bindList f tail✝ (ForInStep.yield init)
init : β
⊢ (fun x =>
      match x with
      | ForInStep.done b => pure b
      | ForInStep.yield b => do
        let a ← ForInStep.bindList f tail✝ (ForInStep.yield b)
        pure a.run) =
    fun x => do
    let a ← ForInStep.bindList f tail✝ x
    pure a.run
state_after: no goals
tactic: ext (b | b) <;> simp
Theorem: WittVector.verschiebung_frobenius_comm
File: Mathlib/RingTheory/WittVector/Identities.lean

Proof steps:
state_before: p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CharP R p
x : 𝕎 R
⊢ verschiebung (frobenius x) = frobenius (verschiebung x)
state_after: no goals
tactic: rw [verschiebung_frobenius, frobenius_verschiebung]
Theorem: one_add_mul_sub_le_pow
File: Mathlib/Algebra/Order/Ring/Pow.lean

Proof steps:
state_before: R : Type u_1
inst✝ : LinearOrderedRing R
a : R
n✝ : ℕ
H : -1 ≤ a
n : ℕ
⊢ 1 + ↑n * (a - 1) ≤ a ^ n
state_after: R : Type u_1
inst✝ : LinearOrderedRing R
a : R
n✝ : ℕ
H : -1 ≤ a
n : ℕ
this : -2 ≤ a - 1
⊢ 1 + ↑n * (a - 1) ≤ a ^ n
tactic: have : -2 ≤ a - 1 := by
    rwa [← one_add_one_eq_two, neg_add, ← sub_eq_add_neg, sub_le_sub_iff_right]
state_before: R : Type u_1
inst✝ : LinearOrderedRing R
a : R
n✝ : ℕ
H : -1 ≤ a
n : ℕ
this : -2 ≤ a - 1
⊢ 1 + ↑n * (a - 1) ≤ a ^ n
state_after: no goals
tactic: simpa only [add_sub_cancel] using one_add_mul_le_pow this n
Theorem: contDiff_all_iff_nat
File: Mathlib/Analysis/Calculus/ContDiff/Defs.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
⊢ (∀ (n : ℕ∞), ContDiff 𝕜 n f) ↔ ∀ (n : ℕ), ContDiff 𝕜 (↑n) f
state_after: no goals
tactic: simp only [← contDiffOn_univ, contDiffOn_all_iff_nat]
Theorem: List.Perm.diff_left
File: .lake/packages/batteries/Batteries/Data/List/Perm.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
l t₁ t₂ : List α
h : t₁ ~ t₂
⊢ l.diff t₁ = l.diff t₂
state_after: no goals
tactic: induction h generalizing l with try simp [List.diff]
  | cons x _ ih => apply ite_congr rfl <;> (intro; apply ih)
  | swap x y =>
    if h : x = y then
      simp [h]
    else
      simp [mem_erase_of_ne h, mem_erase_of_ne (Ne.symm h), erase_comm x y]
      split <;> simp [h]
  | trans => simp only [*]
Theorem: Monoid.CoprodI.Word.cons_eq_smul
File: Mathlib/GroupTheory/CoprodI.lean

Proof steps:
state_before: ι : Type u_1
M : ι → Type u_2
inst✝³ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝² : Monoid N
inst✝¹ : (i : ι) → DecidableEq (M i)
inst✝ : DecidableEq ι
i : ι
m : M i
ls : Word M
h1 : ls.fstIdx ≠ some i
h2 : m ≠ 1
⊢ cons m ls h1 h2 = of m • ls
state_after: ι : Type u_1
M : ι → Type u_2
inst✝³ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝² : Monoid N
inst✝¹ : (i : ι) → DecidableEq (M i)
inst✝ : DecidableEq ι
i : ι
m : M i
ls : Word M
h1 : ls.fstIdx ≠ some i
h2 : m ≠ 1
⊢ cons m ls h1 h2 =
    rcons
      (let __src := { head := 1, tail := ls, fstIdx_ne := ?m.192609 };
      { head := m * { head := 1, tail := ls, fstIdx_ne := ?m.192609 }.head, tail := __src.tail, fstIdx_ne := ⋯ })

ι : Type u_1
M : ι → Type u_2
inst✝³ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝² : Monoid N
inst✝¹ : (i : ι) → DecidableEq (M i)
inst✝ : DecidableEq ι
i : ι
m : M i
ls : Word M
h1 : ls.fstIdx ≠ some i
h2 : m ≠ 1
⊢ ls.fstIdx ≠ some i
tactic: rw [of_smul_def, equivPair_eq_of_fstIdx_ne _]
Theorem: NNReal.hasSum_coe
File: Mathlib/Topology/Instances/NNReal.lean

Proof steps:
state_before: α : Type u_1
f : α → ℝ≥0
r : ℝ≥0
⊢ HasSum (fun a => ↑(f a)) ↑r ↔ HasSum f r
state_after: no goals
tactic: simp only [HasSum, ← coe_sum, tendsto_coe]
Theorem: smul_one_smul
File: Mathlib/Algebra/Group/Action/Defs.lean

Proof steps:
state_before: M✝ : Type u_1
N✝ : Type u_2
G : Type u_3
H : Type u_4
A : Type u_5
B : Type u_6
α : Type u_7
β : Type u_8
γ : Type u_9
δ : Type u_10
M : Type u_11
N : Type u_12
inst✝⁴ : Monoid N
inst✝³ : SMul M N
inst✝² : MulAction N α
inst✝¹ : SMul M α
inst✝ : IsScalarTower M N α
x : M
y : α
⊢ (x • 1) • y = x • y
state_after: no goals
tactic: rw [smul_assoc, one_smul]
Theorem: Set.finite_image2
File: Mathlib/Data/Set/Finite.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s✝ t✝ : Set α
f : α → β → γ
s : Set α
t : Set β
a : α
b : β
hfs : ∀ b ∈ t, InjOn (fun x => f x b) s
hft : ∀ a ∈ s, InjOn (f a) t
⊢ (image2 f s t).Finite ↔ s.Finite ∧ t.Finite ∨ s = ∅ ∨ t = ∅
state_after: α : Type u
β : Type v
ι : Sort w
γ : Type x
s✝ t✝ : Set α
f : α → β → γ
s : Set α
t : Set β
a : α
b : β
hfs : ∀ b ∈ t, InjOn (fun x => f x b) s
hft : ∀ a ∈ s, InjOn (f a) t
⊢ ¬(s.Infinite ∧ t.Nonempty ∨ t.Infinite ∧ s.Nonempty) ↔ s.Finite ∧ t.Finite ∨ s = ∅ ∨ t = ∅
tactic: rw [← not_infinite, infinite_image2 hfs hft]
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s✝ t✝ : Set α
f : α → β → γ
s : Set α
t : Set β
a : α
b : β
hfs : ∀ b ∈ t, InjOn (fun x => f x b) s
hft : ∀ a ∈ s, InjOn (f a) t
⊢ ¬(s.Infinite ∧ t.Nonempty ∨ t.Infinite ∧ s.Nonempty) ↔ s.Finite ∧ t.Finite ∨ s = ∅ ∨ t = ∅
state_after: α : Type u
β : Type v
ι : Sort w
γ : Type x
s✝ t✝ : Set α
f : α → β → γ
s : Set α
t : Set β
a : α
b : β
hfs : ∀ b ∈ t, InjOn (fun x => f x b) s
hft : ∀ a ∈ s, InjOn (f a) t
⊢ (s.Finite ∨ t = ∅) ∧ (t.Finite ∨ s = ∅) ↔ s.Finite ∧ t.Finite ∨ s = ∅ ∨ t = ∅
tactic: simp [not_or, -not_and, not_and_or, not_nonempty_iff_eq_empty]
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s✝ t✝ : Set α
f : α → β → γ
s : Set α
t : Set β
a : α
b : β
hfs : ∀ b ∈ t, InjOn (fun x => f x b) s
hft : ∀ a ∈ s, InjOn (f a) t
⊢ (s.Finite ∨ t = ∅) ∧ (t.Finite ∨ s = ∅) ↔ s.Finite ∧ t.Finite ∨ s = ∅ ∨ t = ∅
state_after: no goals
tactic: aesop
Theorem: Multiset.mem_sum
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
s : Finset ι
m : ι → Multiset α
⊢ a ∈ ∑ i ∈ s, m i ↔ ∃ i ∈ s, a ∈ m i
state_after: no goals
tactic: induction' s using Finset.cons_induction <;> simp [*]
Theorem: CochainComplex.mappingCone.triangleRotateShortComplex_X₂
File: Mathlib/Algebra/Homology/HomotopyCategory/DegreewiseSplit.lean

Proof steps:
state_before: C : Type u_1
inst✝² : Category.{?u.282061, u_1} C
inst✝¹ : Preadditive C
S : ShortComplex (CochainComplex C ℤ)
σ : (n : ℤ) → (S.map (eval C (ComplexShape.up ℤ) n)).Splitting
inst✝ : HasBinaryBiproducts C
K L : CochainComplex C ℤ
φ : K ⟶ L
⊢ (triangle φ).rotate.mor₁ ≫ (triangle φ).rotate.mor₂ = 0
state_after: no goals
tactic: simp
Theorem: AddEquiv.comp_left_injective
File: Mathlib/Algebra/Group/Equiv/Basic.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
A : Type u_4
B : Type u_5
M : Type u_6
N : Type u_7
P : Type u_8
Q : Type u_9
G : Type u_10
H : Type u_11
inst✝³ : EquivLike F α β
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
e : M ≃* N
f : N →* P
⊢ (fun f => f.comp ↑e.symm) (f.comp ↑e) = f
state_after: no goals
tactic: simp [MonoidHom.comp_assoc]
Theorem: Sat.Fmla.reify_or
File: Mathlib/Tactic/Sat/FromLRAT.lean

Proof steps:
state_before: v : Valuation
f₁ : Fmla
a : Prop
f₂ : Fmla
b : Prop
h₁ : reify v f₁ a
h₂ : reify v f₂ b
⊢ reify v (f₁.and f₂) (a ∨ b)
state_after: v : Valuation
f₁ : Fmla
a : Prop
f₂ : Fmla
b : Prop
h₁ : reify v f₁ a
h₂ : reify v f₂ b
H : ¬v.satisfies_fmla (f₁.and f₂)
hn : ¬(a ∨ b)
c : Clause
h : c ∈ f₁.and f₂
hn' : ¬v.satisfies c
⊢ False
tactic: refine ⟨fun H ↦ by_contra fun hn ↦ H ⟨fun c h ↦ by_contra fun hn' ↦ ?_⟩⟩
state_before: v : Valuation
f₁ : Fmla
a : Prop
f₂ : Fmla
b : Prop
h₁ : reify v f₁ a
h₂ : reify v f₂ b
H : ¬v.satisfies_fmla (f₁.and f₂)
hn : ¬(a ∨ b)
c : Clause
h : c ∈ f₁.and f₂
hn' : ¬v.satisfies c
⊢ False
state_after: case inl
v : Valuation
f₁ : Fmla
a : Prop
f₂ : Fmla
b : Prop
h₁ : reify v f₁ a
h₂ : reify v f₂ b
H : ¬v.satisfies_fmla (f₁.and f₂)
hn : ¬(a ∨ b)
c : Clause
h✝ : c ∈ f₁.and f₂
hn' : ¬v.satisfies c
h : c ∈ f₁
⊢ False

case inr
v : Valuation
f₁ : Fmla
a : Prop
f₂ : Fmla
b : Prop
h₁ : reify v f₁ a
h₂ : reify v f₂ b
H : ¬v.satisfies_fmla (f₁.and f₂)
hn : ¬(a ∨ b)
c : Clause
h✝ : c ∈ f₁.and f₂
hn' : ¬v.satisfies c
h : c ∈ f₂
⊢ False
tactic: rcases List.mem_append.1 h with h | h
Theorem: AddLECancellable.add_le_add_iff_right
File: Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : LE α
inst✝¹ : Mul α
i : IsSymmOp α α fun x x_1 => x * x_1
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c : α
ha : MulLECancellable a
⊢ b * a ≤ c * a ↔ b ≤ c
state_after: no goals
tactic: rw [i.symm_op b, i.symm_op c, ha.mul_le_mul_iff_left]
Theorem: Multiset.mem_powersetAux
File: Mathlib/Data/Multiset/Powerset.lean

Proof steps:
state_before: α : Type u_1
l : List α
s : Multiset α
⊢ ∀ (a : List α), ⟦a⟧ ∈ powersetAux l ↔ ⟦a⟧ ≤ ↑l
state_after: no goals
tactic: simp [powersetAux_eq_map_coe, Subperm, and_comm]
Theorem: List.length_filter_lt_length_iff_exists
File: Mathlib/Data/List/Count.lean

Proof steps:
state_before: α : Type u_1
l✝ : List α
p q : α → Bool
l : List α
⊢ (filter p l).length < l.length ↔ ∃ x, x ∈ l ∧ ¬p x = true
state_after: no goals
tactic: simpa [length_eq_countP_add_countP p l, countP_eq_length_filter] using
  countP_pos (fun x => ¬p x) (l := l)
Theorem: AddSubgroup.vadd_apply_eq_vadd_apply_neg_vadd
File: Mathlib/GroupTheory/Complement.lean

Proof steps:
state_before: G : Type u_1
inst✝³ : Group G
H K : Subgroup G
S T✝ : Set G
F : Type u_2
inst✝² : Group F
inst✝¹ : MulAction F G
inst✝ : QuotientAction F H
f : F
T : ↑(leftTransversals ↑H)
q : G ⧸ H
⊢ ↑((toEquiv ⋯) q) = f • ↑((toEquiv ⋯) (f⁻¹ • q))
state_after: no goals
tactic: rw [smul_toEquiv, smul_inv_smul]
Theorem: Profinite.NobelingProof.ord_term_aux
File: Mathlib/Topology/Category/Profinite/Nobeling.lean

Proof steps:
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
ho : o < Ordinal.type fun x x_1 => x < x_1
⊢ ord I (term I ho) = o
state_after: no goals
tactic: simp only [ord, term, Ordinal.typein_enum]
Theorem: List.getElem?_zip_eq_some
File: Mathlib/Data/List/Zip.lean

Proof steps:
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
l₁ : List α
l₂ : List β
z : α × β
i : ℕ
⊢ (l₁.zip l₂)[i]? = some z ↔ l₁[i]? = some z.1 ∧ l₂[i]? = some z.2
state_after: case mk
α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
l₁ : List α
l₂ : List β
i : ℕ
fst✝ : α
snd✝ : β
⊢ (l₁.zip l₂)[i]? = some (fst✝, snd✝) ↔ l₁[i]? = some (fst✝, snd✝).1 ∧ l₂[i]? = some (fst✝, snd✝).2
tactic: cases z
state_before: case mk
α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
l₁ : List α
l₂ : List β
i : ℕ
fst✝ : α
snd✝ : β
⊢ (l₁.zip l₂)[i]? = some (fst✝, snd✝) ↔ l₁[i]? = some (fst✝, snd✝).1 ∧ l₂[i]? = some (fst✝, snd✝).2
state_after: case mk
α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
l₁ : List α
l₂ : List β
i : ℕ
fst✝ : α
snd✝ : β
⊢ (∃ x y, l₁[i]? = some x ∧ l₂[i]? = some y ∧ (x, y) = (fst✝, snd✝)) ↔
    l₁[i]? = some (fst✝, snd✝).1 ∧ l₂[i]? = some (fst✝, snd✝).2
tactic: rw [zip, getElem?_zipWith_eq_some]
state_before: case mk
α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
l₁ : List α
l₂ : List β
i : ℕ
fst✝ : α
snd✝ : β
⊢ (∃ x y, l₁[i]? = some x ∧ l₂[i]? = some y ∧ (x, y) = (fst✝, snd✝)) ↔
    l₁[i]? = some (fst✝, snd✝).1 ∧ l₂[i]? = some (fst✝, snd✝).2
state_after: case mk.mp
α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
l₁ : List α
l₂ : List β
i : ℕ
fst✝ : α
snd✝ : β
⊢ (∃ x y, l₁[i]? = some x ∧ l₂[i]? = some y ∧ (x, y) = (fst✝, snd✝)) →
    l₁[i]? = some (fst✝, snd✝).1 ∧ l₂[i]? = some (fst✝, snd✝).2

case mk.mpr
α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
l₁ : List α
l₂ : List β
i : ℕ
fst✝ : α
snd✝ : β
⊢ l₁[i]? = some (fst✝, snd✝).1 ∧ l₂[i]? = some (fst✝, snd✝).2 →
    ∃ x y, l₁[i]? = some x ∧ l₂[i]? = some y ∧ (x, y) = (fst✝, snd✝)
tactic: constructor
Theorem: BoxIntegral.Box.measurableSet_coe
File: Mathlib/Analysis/BoxIntegral/Partition/Measure.lean

Proof steps:
state_before: ι : Type u_1
I : Box ι
inst✝ : Countable ι
⊢ MeasurableSet ↑I
state_after: ι : Type u_1
I : Box ι
inst✝ : Countable ι
⊢ MeasurableSet (univ.pi fun i => Ioc (I.lower i) (I.upper i))
tactic: rw [coe_eq_pi]
state_before: ι : Type u_1
I : Box ι
inst✝ : Countable ι
⊢ MeasurableSet (univ.pi fun i => Ioc (I.lower i) (I.upper i))
state_after: no goals
tactic: exact MeasurableSet.univ_pi fun i => measurableSet_Ioc
Theorem: Submodule.map_smul'
File: Mathlib/Algebra/Module/Submodule/Map.lean

Proof steps:
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
K : Type u_9
V : Type u_10
V₂ : Type u_11
inst✝⁴ : Semifield K
inst✝³ : AddCommMonoid V
inst✝² : Module K V
inst✝¹ : AddCommMonoid V₂
inst✝ : Module K V₂
f : V →ₗ[K] V₂
p : Submodule K V
a : K
⊢ map (a • f) p = ⨆ (_ : a ≠ 0), map f p
state_after: no goals
tactic: classical by_cases h : a = 0 <;> simp [h, Submodule.map_smul]
Theorem: multiplicity.pow_multiplicity_dvd
File: Mathlib/RingTheory/Multiplicity.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : Monoid α
inst✝² : Monoid β
inst✝¹ : DecidableRel fun x x_1 => x ∣ x_1
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
h : Finite a b
⊢ ↑((multiplicity a b).get h) ≤ multiplicity a b
state_after: no goals
tactic: rw [PartENat.natCast_get]
Theorem: Polynomial.nextCoeff_C_mul_X_add_C
File: Mathlib/Algebra/Polynomial/Degree/Lemmas.lean

Proof steps:
state_before: R : Type u
S : Type v
ι : Type w
a✝ b : R
m n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p q : R[X]
a : R
ha : a ≠ 0
c : R
⊢ (C a * X + C c).nextCoeff = c
state_after: no goals
tactic: rw [nextCoeff_of_natDegree_pos] <;> simp [ha]
Theorem: transGen_of_succ_of_reflexive
File: Mathlib/Order/SuccPred/Relation.lean

Proof steps:
state_before: α : Type u_1
inst✝² : LinearOrder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
r : α → α → Prop
n m : α
hr : Reflexive r
h1 : ∀ i ∈ Ico n m, r i (succ i)
h2 : ∀ i ∈ Ico m n, r (succ i) i
⊢ TransGen r n m
state_after: case inl
α : Type u_1
inst✝² : LinearOrder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
r : α → α → Prop
m : α
hr : Reflexive r
h1 : ∀ i ∈ Ico m m, r i (succ i)
h2 : ∀ i ∈ Ico m m, r (succ i) i
⊢ TransGen r m m

case inr
α : Type u_1
inst✝² : LinearOrder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
r : α → α → Prop
n m : α
hr : Reflexive r
h1 : ∀ i ∈ Ico n m, r i (succ i)
h2 : ∀ i ∈ Ico m n, r (succ i) i
hmn : m ≠ n
⊢ TransGen r n m
tactic: rcases eq_or_ne m n with (rfl | hmn)
state_before: case inr
α : Type u_1
inst✝² : LinearOrder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
r : α → α → Prop
n m : α
hr : Reflexive r
h1 : ∀ i ∈ Ico n m, r i (succ i)
h2 : ∀ i ∈ Ico m n, r (succ i) i
hmn : m ≠ n
⊢ TransGen r n m
state_after: no goals
tactic: exact transGen_of_succ_of_ne r h1 h2 hmn.symm
Theorem: AlgebraicTopology.DoldKan.PInftyToNormalizedMooreComplex_f
File: Mathlib/AlgebraicTopology/DoldKan/Normalized.lean

Proof steps:
state_before: A : Type u_1
inst✝¹ : Category.{?u.8680, u_1} A
inst✝ : Abelian A
X✝ X : SimplicialObject A
n : ℕ
⊢ (fun n => (NormalizedMooreComplex.objX X n).factorThru (PInfty.f n) ⋯) (n + 1) ≫ NormalizedMooreComplex.objD X n =
    AlternatingFaceMapComplex.objD X n ≫ (fun n => (NormalizedMooreComplex.objX X n).factorThru (PInfty.f n) ⋯) n
state_after: A : Type u_1
inst✝¹ : Category.{?u.8680, u_1} A
inst✝ : Abelian A
X✝ X : SimplicialObject A
n : ℕ
⊢ PInfty.f (n + 1) ≫ ((alternatingFaceMapComplex A).obj X).d (n + 1) n =
    ((alternatingFaceMapComplex A).obj X).d (n + 1) n ≫ PInfty.f n
tactic: rw [← cancel_mono (NormalizedMooreComplex.objX X n).arrow, assoc, assoc, factorThru_arrow,
      ← inclusionOfMooreComplexMap_f, ← normalizedMooreComplex_objD,
      ← (inclusionOfMooreComplexMap X).comm (n + 1) n, inclusionOfMooreComplexMap_f,
      factorThru_arrow_assoc, ← alternatingFaceMapComplex_obj_d]
state_before: A : Type u_1
inst✝¹ : Category.{?u.8680, u_1} A
inst✝ : Abelian A
X✝ X : SimplicialObject A
n : ℕ
⊢ PInfty.f (n + 1) ≫ ((alternatingFaceMapComplex A).obj X).d (n + 1) n =
    ((alternatingFaceMapComplex A).obj X).d (n + 1) n ≫ PInfty.f n
state_after: no goals
tactic: exact PInfty.comm (n + 1) n
Theorem: Bool.not_iff_not
File: Mathlib/Data/Bool/Basic.lean

Proof steps:
state_before: ⊢ ∀ {b : Bool}, (!b) = true ↔ ¬b = true
state_after: no goals
tactic: simp
Theorem: Complex.abs_cos_add_sin_mul_I
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x : ℝ
⊢ abs (cos ↑x + sin ↑x * I) = 1
state_after: x : ℝ
this : Real.sin x ^ 2 + Real.cos x ^ 2 = 1
⊢ abs (cos ↑x + sin ↑x * I) = 1
tactic: have := Real.sin_sq_add_cos_sq x
state_before: x : ℝ
this : Real.sin x ^ 2 + Real.cos x ^ 2 = 1
⊢ abs (cos ↑x + sin ↑x * I) = 1
state_after: no goals
tactic: simp_all [add_comm, abs, normSq, sq, sin_ofReal_re, cos_ofReal_re, mul_re]
Theorem: HomologicalComplex₂.flipEquivalenceUnitIso_hom_app_f_f
File: Mathlib/Algebra/Homology/HomologicalBicomplex.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.21503, u_1} C
inst✝ : HasZeroMorphisms C
I₁ : Type u_2
I₂ : Type u_3
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
K : HomologicalComplex₂ C c₁ c₂
i₁ : I₁
⊢ ∀ (i j : I₂),
    c₂.Rel i j →
      ((fun i₂ => Iso.refl ((((𝟭 (HomologicalComplex₂ C c₁ c₂)).obj K).X i₁).X i₂)) i).hom ≫
          (((flipFunctor C c₁ c₂ ⋙ flipFunctor C c₂ c₁).obj K).X i₁).d i j =
        (((𝟭 (HomologicalComplex₂ C c₁ c₂)).obj K).X i₁).d i j ≫
          ((fun i₂ => Iso.refl ((((𝟭 (HomologicalComplex₂ C c₁ c₂)).obj K).X i₁).X i₂)) j).hom
state_after: no goals
tactic: aesop_cat
state_before: C : Type u_1
inst✝¹ : Category.{?u.21503, u_1} C
inst✝ : HasZeroMorphisms C
I₁ : Type u_2
I₂ : Type u_3
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
K : HomologicalComplex₂ C c₁ c₂
⊢ ∀ (i j : I₁),
    c₁.Rel i j →
      ((fun i₁ => Hom.isoOfComponents (fun i₂ => Iso.refl ((((𝟭 (HomologicalComplex₂ C c₁ c₂)).obj K).X i₁).X i₂)) ⋯)
              i).hom ≫
          ((flipFunctor C c₁ c₂ ⋙ flipFunctor C c₂ c₁).obj K).d i j =
        ((𝟭 (HomologicalComplex₂ C c₁ c₂)).obj K).d i j ≫
          ((fun i₁ =>
                Hom.isoOfComponents (fun i₂ => Iso.refl ((((𝟭 (HomologicalComplex₂ C c₁ c₂)).obj K).X i₁).X i₂)) ⋯)
              j).hom
state_after: no goals
tactic: aesop_cat
state_before: C : Type u_1
inst✝¹ : Category.{?u.21503, u_1} C
inst✝ : HasZeroMorphisms C
I₁ : Type u_2
I₂ : Type u_3
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
⊢ ∀ {X Y : HomologicalComplex₂ C c₁ c₂} (f : X ⟶ Y),
    (𝟭 (HomologicalComplex₂ C c₁ c₂)).map f ≫
        ((fun K =>
              Hom.isoOfComponents
                (fun i₁ =>
                  Hom.isoOfComponents (fun i₂ => Iso.refl ((((𝟭 (HomologicalComplex₂ C c₁ c₂)).obj K).X i₁).X i₂)) ⋯)
                ⋯)
            Y).hom =
      ((fun K =>
              Hom.isoOfComponents
                (fun i₁ =>
                  Hom.isoOfComponents (fun i₂ => Iso.refl ((((𝟭 (HomologicalComplex₂ C c₁ c₂)).obj K).X i₁).X i₂)) ⋯)
                ⋯)
            X).hom ≫
        (flipFunctor C c₁ c₂ ⋙ flipFunctor C c₂ c₁).map f
state_after: no goals
tactic: aesop_cat