ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: DirichletCharacter.factorsThrough_one_iff
File: Mathlib/NumberTheory/DirichletCharacter/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommMonoidWithZero R
n : ℕ
χ : DirichletCharacter R n
⊢ χ.FactorsThrough 1 ↔ χ = 1
state_after: R : Type u_1
inst✝ : CommMonoidWithZero R
n : ℕ
χ : DirichletCharacter R n
x✝ : χ.FactorsThrough 1
w✝ : 1 ∣ n
χ₀ : DirichletCharacter R 1
hχ₀ : χ = (changeLevel w✝) χ₀
⊢ χ = 1
tactic: refine ⟨fun ⟨_, χ₀, hχ₀⟩ ↦ ?_,
          fun h ↦ ⟨one_dvd n, 1, by rw [h, changeLevel_one]⟩⟩
state_before: R : Type u_1
inst✝ : CommMonoidWithZero R
n : ℕ
χ : DirichletCharacter R n
x✝ : χ.FactorsThrough 1
w✝ : 1 ∣ n
χ₀ : DirichletCharacter R 1
hχ₀ : χ = (changeLevel w✝) χ₀
⊢ χ = 1
state_after: no goals
tactic: rwa [level_one χ₀, changeLevel_one] at hχ₀
Theorem: CategoryTheory.ProjectiveResolution.liftFOne_zero_comm
File: Mathlib/CategoryTheory/Abelian/ProjectiveResolution.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Abelian C
Y Z : C
f : Y ⟶ Z
P : ProjectiveResolution Y
Q : ProjectiveResolution Z
⊢ liftFOne f P Q ≫ Q.complex.d 1 0 = P.complex.d 1 0 ≫ liftFZero f P Q
state_after: no goals
tactic: apply Q.exact₀.liftFromProjective_comp
Theorem: Set.empty_nsmul
File: Mathlib/Data/Set/Pointwise/Basic.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Monoid α
s t : Set α
a : α
m n✝ n : ℕ
hn : n ≠ 0
⊢ ∅ ^ n = ∅
state_after: no goals
tactic: match n with
  | n + 1 => rw [pow_succ', empty_mul]
Theorem: CompositionAsSet.blocks_partial_sum
File: Mathlib/Combinatorics/Enumerative/Composition.lean

Proof steps:
state_before: n : ℕ
c : CompositionAsSet n
i : ℕ
h : i < c.boundaries.card
⊢ (take i c.blocks).sum = ↑(c.boundary ⟨i, h⟩)
state_after: case zero
n : ℕ
c : CompositionAsSet n
h : 0 < c.boundaries.card
⊢ (take 0 c.blocks).sum = ↑(c.boundary ⟨0, h⟩)

case succ
n : ℕ
c : CompositionAsSet n
i : ℕ
IH : ∀ (h : i < c.boundaries.card), (take i c.blocks).sum = ↑(c.boundary ⟨i, h⟩)
h : i + 1 < c.boundaries.card
⊢ (take (i + 1) c.blocks).sum = ↑(c.boundary ⟨i + 1, h⟩)
tactic: induction' i with i IH
state_before: case succ
n : ℕ
c : CompositionAsSet n
i : ℕ
IH : ∀ (h : i < c.boundaries.card), (take i c.blocks).sum = ↑(c.boundary ⟨i, h⟩)
h : i + 1 < c.boundaries.card
⊢ (take (i + 1) c.blocks).sum = ↑(c.boundary ⟨i + 1, h⟩)
state_after: case succ
n : ℕ
c : CompositionAsSet n
i : ℕ
IH : ∀ (h : i < c.boundaries.card), (take i c.blocks).sum = ↑(c.boundary ⟨i, h⟩)
h : i + 1 < c.boundaries.card
A : i < c.blocks.length
⊢ (take (i + 1) c.blocks).sum = ↑(c.boundary ⟨i + 1, h⟩)
tactic: have A : i < c.blocks.length := by
    rw [c.card_boundaries_eq_succ_length] at h
    simp [blocks, Nat.lt_of_succ_lt_succ h]
state_before: case succ
n : ℕ
c : CompositionAsSet n
i : ℕ
IH : ∀ (h : i < c.boundaries.card), (take i c.blocks).sum = ↑(c.boundary ⟨i, h⟩)
h : i + 1 < c.boundaries.card
A : i < c.blocks.length
⊢ (take (i + 1) c.blocks).sum = ↑(c.boundary ⟨i + 1, h⟩)
state_after: case succ
n : ℕ
c : CompositionAsSet n
i : ℕ
IH : ∀ (h : i < c.boundaries.card), (take i c.blocks).sum = ↑(c.boundary ⟨i, h⟩)
h : i + 1 < c.boundaries.card
A : i < c.blocks.length
B : i < c.boundaries.card
⊢ (take (i + 1) c.blocks).sum = ↑(c.boundary ⟨i + 1, h⟩)
tactic: have B : i < c.boundaries.card := lt_of_lt_of_le A (by simp [blocks, length, Nat.sub_le])
state_before: case succ
n : ℕ
c : CompositionAsSet n
i : ℕ
IH : ∀ (h : i < c.boundaries.card), (take i c.blocks).sum = ↑(c.boundary ⟨i, h⟩)
h : i + 1 < c.boundaries.card
A : i < c.blocks.length
B : i < c.boundaries.card
⊢ (take (i + 1) c.blocks).sum = ↑(c.boundary ⟨i + 1, h⟩)
state_after: case succ
n : ℕ
c : CompositionAsSet n
i : ℕ
IH : ∀ (h : i < c.boundaries.card), (take i c.blocks).sum = ↑(c.boundary ⟨i, h⟩)
h : i + 1 < c.boundaries.card
A : i < c.blocks.length
B : i < c.boundaries.card
⊢ ↑(c.boundary ⟨i, B⟩) + c.blocks[i] = ↑(c.boundary ⟨i + 1, h⟩)
tactic: rw [sum_take_succ _ _ A, IH B]
state_before: case succ
n : ℕ
c : CompositionAsSet n
i : ℕ
IH : ∀ (h : i < c.boundaries.card), (take i c.blocks).sum = ↑(c.boundary ⟨i, h⟩)
h : i + 1 < c.boundaries.card
A : i < c.blocks.length
B : i < c.boundaries.card
⊢ ↑(c.boundary ⟨i, B⟩) + c.blocks[i] = ↑(c.boundary ⟨i + 1, h⟩)
state_after: no goals
tactic: simp [blocks, blocksFun, get_ofFn]
Theorem: Cardinal.toENatAux_le_nat
File: Mathlib/SetTheory/Cardinal/ENat.lean

Proof steps:
state_before: x : Cardinal.{u_1}
n : ℕ
⊢ x.toENatAux ≤ ↑n ↔ x ≤ ↑n
state_after: no goals
tactic: cases lt_or_le x ℵ₀ with
  | inl hx => lift x to ℕ using hx; simp
  | inr hx => simp [toENatAux_eq_top hx, (nat_lt_aleph0 n).trans_le hx]
Theorem: norm_inv'
File: Mathlib/Analysis/Normed/Group/Basic.lean

Proof steps:
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a✝ a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
a : E
⊢ ‖a⁻¹‖ = ‖a‖
state_after: no goals
tactic: simpa using norm_div_rev 1 a
Theorem: EisensteinSeries.eisSummand_extension_differentiableOn
File: Mathlib/NumberTheory/ModularForms/EisensteinSeries/MDifferentiable.lean

Proof steps:
state_before: k : ℤ
a : Fin 2 → ℤ
⊢ DifferentiableOn ℂ (eisSummand k a ∘ ↑ofComplex) {z | 0 < z.im}
state_after: k : ℤ
a : Fin 2 → ℤ
⊢ ∀ x ∈ {z | 0 < z.im}, (eisSummand k a ∘ ↑ofComplex) x = (↑(a 0) * x + ↑(a 1)) ^ (-k)
tactic: apply DifferentiableOn.congr (div_linear_zpow_differentiableOn k a)
state_before: k : ℤ
a : Fin 2 → ℤ
⊢ ∀ x ∈ {z | 0 < z.im}, (eisSummand k a ∘ ↑ofComplex) x = (↑(a 0) * x + ↑(a 1)) ^ (-k)
state_after: k : ℤ
a : Fin 2 → ℤ
z : ℂ
hz : z ∈ {z | 0 < z.im}
⊢ (eisSummand k a ∘ ↑ofComplex) z = (↑(a 0) * z + ↑(a 1)) ^ (-k)
tactic: intro z hz
state_before: k : ℤ
a : Fin 2 → ℤ
z : ℂ
hz : z ∈ {z | 0 < z.im}
⊢ (eisSummand k a ∘ ↑ofComplex) z = (↑(a 0) * z + ↑(a 1)) ^ (-k)
state_after: case intro
k : ℤ
a : Fin 2 → ℤ
z : ℍ
⊢ (eisSummand k a ∘ ↑ofComplex) ↑z = (↑(a 0) * ↑z + ↑(a 1)) ^ (-k)
tactic: lift z to ℍ using hz
state_before: case intro
k : ℤ
a : Fin 2 → ℤ
z : ℍ
⊢ (eisSummand k a ∘ ↑ofComplex) ↑z = (↑(a 0) * ↑z + ↑(a 1)) ^ (-k)
state_after: no goals
tactic: apply comp_ofComplex
Theorem: PNat.Coprime.pow
File: Mathlib/Data/PNat/Prime.lean

Proof steps:
state_before: m n : ℕ+
k l : ℕ
h : m.Coprime n
⊢ (↑m ^ k).Coprime (↑n ^ l)
state_after: m n : ℕ+
k l : ℕ
h : (↑m).Coprime ↑n
⊢ (↑m ^ k).Coprime (↑n ^ l)
tactic: rw [← coprime_coe] at *
state_before: m n : ℕ+
k l : ℕ
h : (↑m).Coprime ↑n
⊢ (↑m ^ k).Coprime (↑n ^ l)
state_after: case H1
m n : ℕ+
k l : ℕ
h : (↑m).Coprime ↑n
⊢ (↑m).Coprime ↑n
tactic: apply Nat.Coprime.pow
state_before: case H1
m n : ℕ+
k l : ℕ
h : (↑m).Coprime ↑n
⊢ (↑m).Coprime ↑n
state_after: no goals
tactic: apply h
Theorem: Nat.factoredNumbers_empty
File: Mathlib/NumberTheory/SmoothNumbers.lean

Proof steps:
state_before: ⊢ factoredNumbers ∅ = {1}
state_after: case h
m : ℕ
⊢ m ∈ factoredNumbers ∅ ↔ m ∈ {1}
tactic: ext m
state_before: case h
m : ℕ
⊢ m ∈ factoredNumbers ∅ ↔ m ∈ {1}
state_after: no goals
tactic: simp only [mem_factoredNumbers, Finset.not_mem_empty, ← List.eq_nil_iff_forall_not_mem,
    primeFactorsList_eq_nil, and_or_left, not_and_self_iff, ne_and_eq_iff_right zero_ne_one,
    false_or, Set.mem_singleton_iff]
Theorem: MulAction.smul_fixedBy
File: Mathlib/GroupTheory/GroupAction/FixedPoints.lean

Proof steps:
state_before: α : Type u_1
G : Type u_2
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u_3
inst✝¹ : Monoid M
inst✝ : MulAction M α
g h : G
⊢ h • fixedBy α g = fixedBy α (h * g * h⁻¹)
state_after: case h
α : Type u_1
G : Type u_2
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u_3
inst✝¹ : Monoid M
inst✝ : MulAction M α
g h : G
a : α
⊢ a ∈ h • fixedBy α g ↔ a ∈ fixedBy α (h * g * h⁻¹)
tactic: ext a
state_before: case h
α : Type u_1
G : Type u_2
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u_3
inst✝¹ : Monoid M
inst✝ : MulAction M α
g h : G
a : α
⊢ a ∈ h • fixedBy α g ↔ a ∈ fixedBy α (h * g * h⁻¹)
state_after: no goals
tactic: simp_rw [Set.mem_smul_set_iff_inv_smul_mem, mem_fixedBy, mul_smul, smul_eq_iff_eq_inv_smul h]
Theorem: Nat.exists_mul_self
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n✝ k : ℕ
p q : ℕ → Prop
x : ℕ
x✝ : ∃ n, n * n = x
n : ℕ
hn : n * n = x
⊢ x.sqrt * x.sqrt = x
state_after: no goals
tactic: rw [← hn, sqrt_eq]
Theorem: Subgroup.card_quotient_dvd_card
File: Mathlib/GroupTheory/Coset.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Group α
s✝ t s : Subgroup α
⊢ Nat.card (α ⧸ s) ∣ Nat.card α
state_after: no goals
tactic: simp [card_eq_card_quotient_mul_card_subgroup s, @dvd_mul_right ℕ]
Theorem: Rel.swap_mem_interedges_iff
File: Mathlib/Combinatorics/SimpleGraph/Density.lean

Proof steps:
state_before: 𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
r : α → α → Prop
inst✝ : DecidableRel r
s s₁ s₂ t t₁ t₂ : Finset α
a b : α
hr : Symmetric r
x : α × α
⊢ x.swap ∈ interedges r s t ↔ x ∈ interedges r t s
state_after: 𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
r : α → α → Prop
inst✝ : DecidableRel r
s s₁ s₂ t t₁ t₂ : Finset α
a b : α
hr : Symmetric r
x : α × α
⊢ x.swap.1 ∈ s ∧ x.swap.2 ∈ t ∧ r x.swap.2 x.swap.1 ↔ x.1 ∈ t ∧ x.2 ∈ s ∧ r x.1 x.2
tactic: rw [mem_interedges_iff, mem_interedges_iff, hr.iff]
state_before: 𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
r : α → α → Prop
inst✝ : DecidableRel r
s s₁ s₂ t t₁ t₂ : Finset α
a b : α
hr : Symmetric r
x : α × α
⊢ x.swap.1 ∈ s ∧ x.swap.2 ∈ t ∧ r x.swap.2 x.swap.1 ↔ x.1 ∈ t ∧ x.2 ∈ s ∧ r x.1 x.2
state_after: no goals
tactic: exact and_left_comm
Theorem: TruncatedWittVector.coeff_zero
File: Mathlib/RingTheory/WittVector/Truncated.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝ : CommRing R
i : Fin n
⊢ coeff i 0 = 0
state_after: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝ : CommRing R
i : Fin n
⊢ coeff i (truncateFun n 0) = 0
tactic: show coeff i (truncateFun _ 0 : TruncatedWittVector p n R) = 0
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝ : CommRing R
i : Fin n
⊢ coeff i (truncateFun n 0) = 0
state_after: no goals
tactic: rw [coeff_truncateFun, WittVector.zero_coeff]
Theorem: QuotientGroup.comap_comap_center
File: Mathlib/GroupTheory/QuotientGroup.lean

Proof steps:
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
φ : G →* H
H₁ : Subgroup G
inst✝¹ : H₁.Normal
H₂ : Subgroup (G ⧸ H₁)
inst✝ : H₂.Normal
⊢ Subgroup.comap (mk' H₁) (Subgroup.comap (mk' H₂) (Subgroup.center ((G ⧸ H₁) ⧸ H₂))) =
    Subgroup.comap (mk' (Subgroup.comap (mk' H₁) H₂)) (Subgroup.center (G ⧸ Subgroup.comap (mk' H₁) H₂))
state_after: case h
G : Type u
inst✝⁴ : Group G
N : Subgroup G
nN : N.Normal
H : Type v
inst✝³ : Group H
M : Type x
inst✝² : Monoid M
φ : G →* H
H₁ : Subgroup G
inst✝¹ : H₁.Normal
H₂ : Subgroup (G ⧸ H₁)
inst✝ : H₂.Normal
x : G
⊢ x ∈ Subgroup.comap (mk' H₁) (Subgroup.comap (mk' H₂) (Subgroup.center ((G ⧸ H₁) ⧸ H₂))) ↔
    x ∈ Subgroup.comap (mk' (Subgroup.comap (mk' H₁) H₂)) (Subgroup.center (G ⧸ Subgroup.comap (mk' H₁) H₂))
tactic: ext x
state_before: case h
G : Type u
inst✝⁴ : Group G
N : Subgroup G
nN : N.Normal
H : Type v
inst✝³ : Group H
M : Type x
inst✝² : Monoid M
φ : G →* H
H₁ : Subgroup G
inst✝¹ : H₁.Normal
H₂ : Subgroup (G ⧸ H₁)
inst✝ : H₂.Normal
x : G
⊢ x ∈ Subgroup.comap (mk' H₁) (Subgroup.comap (mk' H₂) (Subgroup.center ((G ⧸ H₁) ⧸ H₂))) ↔
    x ∈ Subgroup.comap (mk' (Subgroup.comap (mk' H₁) H₂)) (Subgroup.center (G ⧸ Subgroup.comap (mk' H₁) H₂))
state_after: no goals
tactic: simp only [mk'_apply, Subgroup.mem_comap, Subgroup.mem_center_iff, forall_mk, ← mk_mul,
    eq_iff_div_mem, mk_div]
Theorem: abs_sub_nonpos
File: Mathlib/Algebra/Order/Group/Abs.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a b c d : α
⊢ a = b → |a - b| ≤ 0
state_after: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a c d : α
⊢ |a - a| ≤ 0
tactic: rintro rfl
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a c d : α
⊢ |a - a| ≤ 0
state_after: no goals
tactic: rw [sub_self, abs_zero]
Theorem: Module.isTorsionBySet_iff_torsionBySet_eq_top
File: Mathlib/Algebra/Module/Torsion.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set R
a : R
h : torsionBySet R M s = ⊤
x : M
⊢ ∀ ⦃a : ↑s⦄, ↑a • x = 0
state_after: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set R
a : R
h : torsionBySet R M s = ⊤
x : M
⊢ x ∈ ⊤
tactic: rw [← mem_torsionBySet_iff, h]
state_before: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set R
a : R
h : torsionBySet R M s = ⊤
x : M
⊢ x ∈ ⊤
state_after: no goals
tactic: trivial
Theorem: pow_one
File: Mathlib/Algebra/Group/Defs.lean

Proof steps:
state_before: G : Type u_1
M : Type u_2
inst✝ : Monoid M
a✝ b c : M
m n : ℕ
a : M
⊢ a ^ 1 = a
state_after: no goals
tactic: rw [pow_succ, pow_zero, one_mul]
Theorem: AffineSubspace.Parallel.trans
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s₁ s₂ s₃ : AffineSubspace k P
h₁₂ : s₁ ∥ s₂
h₂₃ : s₂ ∥ s₃
⊢ s₁ ∥ s₃
state_after: case intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s₁ s₃ : AffineSubspace k P
v₁₂ : V
h₂₃ : map (↑(constVAdd k P v₁₂)) s₁ ∥ s₃
⊢ s₁ ∥ s₃
tactic: rcases h₁₂ with ⟨v₁₂, rfl⟩
state_before: case intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s₁ s₃ : AffineSubspace k P
v₁₂ : V
h₂₃ : map (↑(constVAdd k P v₁₂)) s₁ ∥ s₃
⊢ s₁ ∥ s₃
state_after: case intro.intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s₁ : AffineSubspace k P
v₁₂ v₂₃ : V
⊢ s₁ ∥ map (↑(constVAdd k P v₂₃)) (map (↑(constVAdd k P v₁₂)) s₁)
tactic: rcases h₂₃ with ⟨v₂₃, rfl⟩
state_before: case intro.intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s₁ : AffineSubspace k P
v₁₂ v₂₃ : V
⊢ s₁ ∥ map (↑(constVAdd k P v₂₃)) (map (↑(constVAdd k P v₁₂)) s₁)
state_after: case intro.intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s₁ : AffineSubspace k P
v₁₂ v₂₃ : V
⊢ map (↑(constVAdd k P v₂₃)) (map (↑(constVAdd k P v₁₂)) s₁) = map (↑(constVAdd k P (v₂₃ + v₁₂))) s₁
tactic: refine ⟨v₂₃ + v₁₂, ?_⟩
state_before: case intro.intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s₁ : AffineSubspace k P
v₁₂ v₂₃ : V
⊢ map (↑(constVAdd k P v₂₃)) (map (↑(constVAdd k P v₁₂)) s₁) = map (↑(constVAdd k P (v₂₃ + v₁₂))) s₁
state_after: no goals
tactic: rw [map_map, ← coe_trans_to_affineMap, ← constVAdd_add]
Theorem: Function.extend_apply'
File: Mathlib/Logic/Function/Basic.lean

Proof steps:
state_before: α : Sort u_1
β : Sort u_2
γ : Sort u_3
f : α → β
g : α → γ
e' : β → γ
b : β
hb : ¬∃ a, f a = b
⊢ extend f g e' b = e' b
state_after: no goals
tactic: simp [Function.extend_def, hb]
Theorem: Finset.prod_range_div_prod_range
File: Mathlib/Algebra/BigOperators/Intervals.lean

Proof steps:
state_before: α✝ : Type u_1
M : Type u_2
inst✝¹ : CommMonoid M
s₂ s₁ s : Finset α✝
a : α✝
g f✝ : α✝ → M
α : Type u_3
inst✝ : CommGroup α
f : ℕ → α
n m : ℕ
hnm : n ≤ m
⊢ (∏ k ∈ range m, f k) / ∏ k ∈ range n, f k = ∏ k ∈ filter (fun k => n ≤ k) (range m), f k
state_after: α✝ : Type u_1
M : Type u_2
inst✝¹ : CommMonoid M
s₂ s₁ s : Finset α✝
a : α✝
g f✝ : α✝ → M
α : Type u_3
inst✝ : CommGroup α
f : ℕ → α
n m : ℕ
hnm : n ≤ m
⊢ ∏ k ∈ Ico n m, f k = ∏ k ∈ filter (fun k => n ≤ k) (range m), f k
tactic: rw [← prod_Ico_eq_div f hnm]
state_before: α✝ : Type u_1
M : Type u_2
inst✝¹ : CommMonoid M
s₂ s₁ s : Finset α✝
a : α✝
g f✝ : α✝ → M
α : Type u_3
inst✝ : CommGroup α
f : ℕ → α
n m : ℕ
hnm : n ≤ m
⊢ ∏ k ∈ Ico n m, f k = ∏ k ∈ filter (fun k => n ≤ k) (range m), f k
state_after: case e_s
α✝ : Type u_1
M : Type u_2
inst✝¹ : CommMonoid M
s₂ s₁ s : Finset α✝
a : α✝
g f✝ : α✝ → M
α : Type u_3
inst✝ : CommGroup α
f : ℕ → α
n m : ℕ
hnm : n ≤ m
⊢ Ico n m = filter (fun k => n ≤ k) (range m)
tactic: congr
state_before: case e_s
α✝ : Type u_1
M : Type u_2
inst✝¹ : CommMonoid M
s₂ s₁ s : Finset α✝
a : α✝
g f✝ : α✝ → M
α : Type u_3
inst✝ : CommGroup α
f : ℕ → α
n m : ℕ
hnm : n ≤ m
⊢ Ico n m = filter (fun k => n ≤ k) (range m)
state_after: case e_s.a
α✝ : Type u_1
M : Type u_2
inst✝¹ : CommMonoid M
s₂ s₁ s : Finset α✝
a : α✝
g f✝ : α✝ → M
α : Type u_3
inst✝ : CommGroup α
f : ℕ → α
n m : ℕ
hnm : n ≤ m
⊢ ∀ (a : ℕ), a ∈ Ico n m ↔ a ∈ filter (fun k => n ≤ k) (range m)
tactic: apply Finset.ext
state_before: case e_s.a
α✝ : Type u_1
M : Type u_2
inst✝¹ : CommMonoid M
s₂ s₁ s : Finset α✝
a : α✝
g f✝ : α✝ → M
α : Type u_3
inst✝ : CommGroup α
f : ℕ → α
n m : ℕ
hnm : n ≤ m
⊢ ∀ (a : ℕ), a ∈ Ico n m ↔ a ∈ filter (fun k => n ≤ k) (range m)
state_after: case e_s.a
α✝ : Type u_1
M : Type u_2
inst✝¹ : CommMonoid M
s₂ s₁ s : Finset α✝
a : α✝
g f✝ : α✝ → M
α : Type u_3
inst✝ : CommGroup α
f : ℕ → α
n m : ℕ
hnm : n ≤ m
⊢ ∀ (a : ℕ), n ≤ a ∧ a < m ↔ a < m ∧ n ≤ a
tactic: simp only [mem_Ico, mem_filter, mem_range, *]
state_before: case e_s.a
α✝ : Type u_1
M : Type u_2
inst✝¹ : CommMonoid M
s₂ s₁ s : Finset α✝
a : α✝
g f✝ : α✝ → M
α : Type u_3
inst✝ : CommGroup α
f : ℕ → α
n m : ℕ
hnm : n ≤ m
⊢ ∀ (a : ℕ), n ≤ a ∧ a < m ↔ a < m ∧ n ≤ a
state_after: no goals
tactic: tauto
Theorem: Basis.toDual_range
File: Mathlib/LinearAlgebra/Dual.lean

Proof steps:
state_before: R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι : Type uι
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : DecidableEq ι
b : Basis ι R M
inst✝ : _root_.Finite ι
⊢ range b.toDual = ⊤
state_after: R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι : Type uι
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : DecidableEq ι
b : Basis ι R M
inst✝ : _root_.Finite ι
f : Dual R M
⊢ f ∈ range b.toDual
tactic: refine eq_top_iff'.2 fun f => ?_
state_before: R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι : Type uι
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : DecidableEq ι
b : Basis ι R M
inst✝ : _root_.Finite ι
f : Dual R M
⊢ f ∈ range b.toDual
state_after: R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι : Type uι
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : DecidableEq ι
b : Basis ι R M
inst✝ : _root_.Finite ι
f : Dual R M
lin_comb : ι →₀ R := Finsupp.equivFunOnFinite.symm fun i => f (b i)
⊢ f ∈ range b.toDual
tactic: let lin_comb : ι →₀ R := Finsupp.equivFunOnFinite.symm fun i => f (b i)
state_before: R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι : Type uι
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : DecidableEq ι
b : Basis ι R M
inst✝ : _root_.Finite ι
f : Dual R M
lin_comb : ι →₀ R := Finsupp.equivFunOnFinite.symm fun i => f (b i)
⊢ f ∈ range b.toDual
state_after: R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι : Type uι
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : DecidableEq ι
b : Basis ι R M
inst✝ : _root_.Finite ι
f : Dual R M
lin_comb : ι →₀ R := Finsupp.equivFunOnFinite.symm fun i => f (b i)
i : ι
⊢ (b.toDual ((Finsupp.total ι M R ⇑b) lin_comb)) (b i) = f (b i)
tactic: refine ⟨Finsupp.total ι M R b lin_comb, b.ext fun i => ?_⟩
state_before: R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι : Type uι
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : DecidableEq ι
b : Basis ι R M
inst✝ : _root_.Finite ι
f : Dual R M
lin_comb : ι →₀ R := Finsupp.equivFunOnFinite.symm fun i => f (b i)
i : ι
⊢ (b.toDual ((Finsupp.total ι M R ⇑b) lin_comb)) (b i) = f (b i)
state_after: R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι : Type uι
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : DecidableEq ι
b : Basis ι R M
inst✝ : _root_.Finite ι
f : Dual R M
lin_comb : ι →₀ R := Finsupp.equivFunOnFinite.symm fun i => f (b i)
i : ι
⊢ lin_comb i = f (b i)
tactic: rw [b.toDual_eq_repr _ i, repr_total b]
state_before: R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι : Type uι
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : DecidableEq ι
b : Basis ι R M
inst✝ : _root_.Finite ι
f : Dual R M
lin_comb : ι →₀ R := Finsupp.equivFunOnFinite.symm fun i => f (b i)
i : ι
⊢ lin_comb i = f (b i)
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.ShortComplex.LeftHomologyData.cyclesIso_inv_comp_iCycles
File: Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean

Proof steps:
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.LeftHomologyData
inst✝ : S.HasLeftHomology
⊢ h.cyclesIso.inv ≫ S.iCycles = h.i
state_after: no goals
tactic: simp only [← h.cyclesIso_hom_comp_i, Iso.inv_hom_id_assoc]
Theorem: CategoryTheory.Functor.mapZeroObject_inv
File: Mathlib/CategoryTheory/Limits/Preserves/Shapes/Zero.lean

Proof steps:
state_before: C : Type u₁
inst✝⁷ : Category.{v₁, u₁} C
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
E : Type u₃
inst✝⁵ : Category.{v₃, u₃} E
inst✝⁴ : HasZeroObject C
inst✝³ : HasZeroObject D
inst✝² : HasZeroMorphisms C
inst✝¹ : HasZeroMorphisms D
F : C ⥤ D
inst✝ : F.PreservesZeroMorphisms
⊢ 0 ≫ 0 = 𝟙 (F.obj 0)
state_after: no goals
tactic: rw [← F.map_id, id_zero, F.map_zero, zero_comp]
state_before: C : Type u₁
inst✝⁷ : Category.{v₁, u₁} C
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
E : Type u₃
inst✝⁵ : Category.{v₃, u₃} E
inst✝⁴ : HasZeroObject C
inst✝³ : HasZeroObject D
inst✝² : HasZeroMorphisms C
inst✝¹ : HasZeroMorphisms D
F : C ⥤ D
inst✝ : F.PreservesZeroMorphisms
⊢ 0 ≫ 0 = 𝟙 0
state_after: no goals
tactic: rw [id_zero, comp_zero]
Theorem: GenContFract.of_s_head
File: Mathlib/Algebra/ContinuedFractions/Computation/Translations.lean

Proof steps:
state_before: K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
n : ℕ
h : fract v ≠ 0
⊢ (of v).s.head = some { a := 1, b := ↑⌊(fract v)⁻¹⌋ }
state_after: K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
n : ℕ
h : fract v ≠ 0
⊢ (of v).s.get? 0 = some { a := 1, b := ↑⌊(fract v)⁻¹⌋ }
tactic: change (of v).s.get? 0 = _
state_before: K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
n : ℕ
h : fract v ≠ 0
⊢ (of v).s.get? 0 = some { a := 1, b := ↑⌊(fract v)⁻¹⌋ }
state_after: K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
n : ℕ
h : fract v ≠ 0
⊢ (match some (IntFractPair.of (IntFractPair.of v).fr⁻¹), some ∘ fun p => { a := 1, b := ↑p.b } with
    | none, x => none
    | some a, f => f a) =
    some { a := 1, b := ↑⌊(fract v)⁻¹⌋ }
tactic: rw [of_s_head_aux, stream_succ_of_some (stream_zero v) h, Option.bind]
state_before: K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
n : ℕ
h : fract v ≠ 0
⊢ (match some (IntFractPair.of (IntFractPair.of v).fr⁻¹), some ∘ fun p => { a := 1, b := ↑p.b } with
    | none, x => none
    | some a, f => f a) =
    some { a := 1, b := ↑⌊(fract v)⁻¹⌋ }
state_after: no goals
tactic: rfl