ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: MvPolynomial.hom_congr_vars
File: Mathlib/Algebra/MvPolynomial/Variables.lean

Proof steps:
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p q : MvPolynomial σ R
inst✝ : CommSemiring S
f₁ f₂ : MvPolynomial σ R →+* S
p₁ p₂ : MvPolynomial σ R
hC : f₁.comp C = f₂.comp C
hv : ∀ i ∈ p₁.vars, i ∈ p₂.vars → f₁ (X i) = f₂ (X i)
hp : p₁ = p₂
⊢ f₁ = eval₂Hom (f₁.comp C) (⇑f₁ ∘ X)
state_after: no goals
tactic: ext <;> simp
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p q : MvPolynomial σ R
inst✝ : CommSemiring S
f₁ f₂ : MvPolynomial σ R →+* S
p₁ p₂ : MvPolynomial σ R
hC : f₁.comp C = f₂.comp C
hv : ∀ i ∈ p₁.vars, i ∈ p₂.vars → f₁ (X i) = f₂ (X i)
hp : p₁ = p₂
⊢ eval₂Hom (f₂.comp C) (⇑f₂ ∘ X) = f₂
state_after: no goals
tactic: ext <;> simp
Theorem: Rat.cast_add_of_ne_zero
File: Mathlib/Data/Rat/Cast/Defs.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
inst✝ : DivisionRing α
p q✝ q r : ℚ
hq : ↑q.den ≠ 0
hr : ↑r.den ≠ 0
⊢ ↑(q + r) = ↑q + ↑r
state_after: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
inst✝ : DivisionRing α
p q✝ q r : ℚ
hq : ↑q.den ≠ 0
hr : ↑r.den ≠ 0
⊢ ↑(q.num * ↑r.den + ↑q.den * r.num) / ↑(q.den * r.den) = (↑q.num * ↑r.den + ↑q.den * ↑r.num) / (↑q.den * ↑r.den)

case hb
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
inst✝ : DivisionRing α
p q✝ q r : ℚ
hq : ↑q.den ≠ 0
hr : ↑r.den ≠ 0
⊢ ↑(q.den * r.den) ≠ 0
tactic: rw [add_def', cast_mkRat_of_ne_zero, cast_def, cast_def, mul_comm r.num,
    (Nat.cast_commute _ _).div_add_div (Nat.commute_cast _ _) hq hr]
Theorem: TopologicalSpace.tendsto_nhds_generateFrom_iff
File: Mathlib/Topology/Order.lean

Proof steps:
state_before: α : Type u
β : Type u_1
m : α → β
f : Filter α
g : Set (Set β)
b : β
⊢ Tendsto m f (𝓝 b) ↔ ∀ s ∈ g, b ∈ s → m ⁻¹' s ∈ f
state_after: α : Type u
β : Type u_1
m : α → β
f : Filter α
g : Set (Set β)
b : β
⊢ (∀ i ∈ g, b ∈ i → ∀ᶠ (a : α) in f, m a ∈ i) ↔ ∀ s ∈ g, b ∈ s → m ⁻¹' s ∈ f
tactic: simp only [nhds_generateFrom, @forall_swap (b ∈ _), tendsto_iInf, mem_setOf_eq, and_imp,
    tendsto_principal]
state_before: α : Type u
β : Type u_1
m : α → β
f : Filter α
g : Set (Set β)
b : β
⊢ (∀ i ∈ g, b ∈ i → ∀ᶠ (a : α) in f, m a ∈ i) ↔ ∀ s ∈ g, b ∈ s → m ⁻¹' s ∈ f
state_after: no goals
tactic: rfl
Theorem: Fin.rev_castPred
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n m : ℕ
i : Fin (n + 1)
h : i ≠ last n
h' : optParam (i.rev ≠ 0) ⋯
⊢ (i.castPred h).rev = i.rev.pred h'
state_after: no goals
tactic: rw [← succ_inj, succ_pred, ← rev_castSucc, castSucc_castPred]
Theorem: Ideal.FG.map
File: Mathlib/RingTheory/Finiteness.lean

Proof steps:
state_before: R✝ : Type u_1
M : Type u_2
inst✝⁴ : Semiring R✝
inst✝³ : AddCommMonoid M
inst✝² : Module R✝ M
R : Type u_3
S : Type u_4
inst✝¹ : Semiring R
inst✝ : Semiring S
I : Ideal R
h : I.FG
f : R →+* S
⊢ (Ideal.map f I).FG
state_after: no goals
tactic: classical
    obtain ⟨s, hs⟩ := h
    refine ⟨s.image f, ?_⟩
    rw [Finset.coe_image, ← Ideal.map_span, hs]
Theorem: MulAction.smul_bijective_of_is_unit
File: Mathlib/GroupTheory/GroupAction/Pointwise.lean

Proof steps:
state_before: M : Type u_1
inst✝¹ : Monoid M
α : Type u_2
inst✝ : MulAction M α
m : M
hm : IsUnit m
⊢ Function.Bijective fun a => m • a
state_after: case intro
M : Type u_1
inst✝¹ : Monoid M
α : Type u_2
inst✝ : MulAction M α
m : Mˣ
⊢ Function.Bijective fun a => ↑m • a
tactic: lift m to Mˣ using hm
state_before: case intro
M : Type u_1
inst✝¹ : Monoid M
α : Type u_2
inst✝ : MulAction M α
m : Mˣ
⊢ Function.Bijective fun a => ↑m • a
state_after: case intro
M : Type u_1
inst✝¹ : Monoid M
α : Type u_2
inst✝ : MulAction M α
m : Mˣ
⊢ ∃ g, (Function.LeftInverse g fun a => ↑m • a) ∧ Function.RightInverse g fun a => ↑m • a
tactic: rw [Function.bijective_iff_has_inverse]
state_before: case intro
M : Type u_1
inst✝¹ : Monoid M
α : Type u_2
inst✝ : MulAction M α
m : Mˣ
⊢ ∃ g, (Function.LeftInverse g fun a => ↑m • a) ∧ Function.RightInverse g fun a => ↑m • a
state_after: case h
M : Type u_1
inst✝¹ : Monoid M
α : Type u_2
inst✝ : MulAction M α
m : Mˣ
⊢ (Function.LeftInverse (fun a => m⁻¹ • a) fun a => ↑m • a) ∧ Function.RightInverse (fun a => m⁻¹ • a) fun a => ↑m • a
tactic: use fun a ↦ m⁻¹ • a
state_before: case h
M : Type u_1
inst✝¹ : Monoid M
α : Type u_2
inst✝ : MulAction M α
m : Mˣ
⊢ (Function.LeftInverse (fun a => m⁻¹ • a) fun a => ↑m • a) ∧ Function.RightInverse (fun a => m⁻¹ • a) fun a => ↑m • a
state_after: case h.left
M : Type u_1
inst✝¹ : Monoid M
α : Type u_2
inst✝ : MulAction M α
m : Mˣ
⊢ Function.LeftInverse (fun a => m⁻¹ • a) fun a => ↑m • a

case h.right
M : Type u_1
inst✝¹ : Monoid M
α : Type u_2
inst✝ : MulAction M α
m : Mˣ
⊢ Function.RightInverse (fun a => m⁻¹ • a) fun a => ↑m • a
tactic: constructor
Theorem: Filter.compl_mem_coprodᵢ
File: Mathlib/Order/Filter/Pi.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
f f₁ f₂ : (i : ι) → Filter (α i)
s✝ : (i : ι) → Set (α i)
p : (i : ι) → α i → Prop
s : Set ((i : ι) → α i)
⊢ sᶜ ∈ Filter.coprodᵢ f ↔ ∀ (i : ι), (eval i '' s)ᶜ ∈ f i
state_after: no goals
tactic: simp only [Filter.coprodᵢ, mem_iSup, compl_mem_comap]
Theorem: Nat.sum_divisors_eq_sum_properDivisors_add_self
File: Mathlib/NumberTheory/Divisors.lean

Proof steps:
state_before: n : ℕ
⊢ ∑ i ∈ n.divisors, i = ∑ i ∈ n.properDivisors, i + n
state_after: case inl

⊢ ∑ i ∈ divisors 0, i = ∑ i ∈ properDivisors 0, i + 0

case inr
n : ℕ
hn : n ≠ 0
⊢ ∑ i ∈ n.divisors, i = ∑ i ∈ n.properDivisors, i + n
tactic: rcases Decidable.eq_or_ne n 0 with (rfl | hn)
Theorem: FirstOrder.Language.BoundedFormula.IsPrenex.relabel
File: Mathlib/ModelTheory/Complexity.lean

Proof steps:
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n l : ℕ
φ✝¹ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v : α → M
xs : Fin l → M
m : ℕ
φ : L.BoundedFormula α m
h✝ : φ.IsPrenex
f : α → β ⊕ Fin n
n✝ : ℕ
φ✝ : L.BoundedFormula α (n✝ + 1)
x✝ : φ✝.IsPrenex
h : (BoundedFormula.relabel f φ✝).IsPrenex
⊢ (BoundedFormula.relabel f (∀'φ✝)).IsPrenex
state_after: no goals
tactic: simp [h.all]
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n l : ℕ
φ✝¹ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v : α → M
xs : Fin l → M
m : ℕ
φ : L.BoundedFormula α m
h✝ : φ.IsPrenex
f : α → β ⊕ Fin n
n✝ : ℕ
φ✝ : L.BoundedFormula α (n✝ + 1)
x✝ : φ✝.IsPrenex
h : (BoundedFormula.relabel f φ✝).IsPrenex
⊢ (BoundedFormula.relabel f (∃'φ✝)).IsPrenex
state_after: no goals
tactic: simp [h.ex]
Theorem: AddOreLocalization.add_zero
File: Mathlib/RingTheory/OreLocalization/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝² : Monoid R
S : Submonoid R
inst✝¹ : OreSet S
X : Type ?u.89869
inst✝ : MulAction R X
x : OreLocalization S R
⊢ x * 1 = x
state_after: case c
R : Type u_1
inst✝² : Monoid R
S : Submonoid R
inst✝¹ : OreSet S
X : Type ?u.89869
inst✝ : MulAction R X
r : R
s : ↥S
⊢ r /ₒ s * 1 = r /ₒ s
tactic: induction' x with r s
state_before: case c
R : Type u_1
inst✝² : Monoid R
S : Submonoid R
inst✝¹ : OreSet S
X : Type ?u.89869
inst✝ : MulAction R X
r : R
s : ↥S
⊢ r /ₒ s * 1 = r /ₒ s
state_after: no goals
tactic: simp [OreLocalization.one_def, oreDiv_mul_char r (1 : R) s (1 : S) r 1 (by simp)]
Theorem: Nat.not_pos_pow_dvd
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a✝ b c d m n✝ k : ℕ
p q : ℕ → Prop
a n : ℕ
hp : 1 < a.succ
hk : 1 < n.succ
h : a.succ ^ n.succ ∣ a.succ
⊢ a.succ * a.succ ^ n ∣ a.succ * 1
state_after: no goals
tactic: simpa [pow_succ'] using h
state_before: a✝ b c d m n✝ k : ℕ
p q : ℕ → Prop
a n : ℕ
hp : 1 < a.succ
hk : 1 < n.succ
h : a.succ ^ n.succ ∣ a.succ
this✝¹ : a.succ * a.succ ^ n ∣ a.succ * 1
this✝ : a.succ ^ n ∣ 1
he : a.succ ^ n = 1
this : n < a.succ ^ n
⊢ n < 1
state_after: no goals
tactic: rwa [he] at this
state_before: a✝ b c d m n✝ k : ℕ
p q : ℕ → Prop
a n : ℕ
hp : 1 < a.succ
hk : 1 < n.succ
h : a.succ ^ n.succ ∣ a.succ
this✝³ : a.succ * a.succ ^ n ∣ a.succ * 1
this✝² : a.succ ^ n ∣ 1
he : a.succ ^ n = 1
this✝¹ : n < a.succ ^ n
this✝ : n < 1
this : n = 0
⊢ 1 < 1
state_after: no goals
tactic: rwa [this] at hk
state_before: a✝ b c d m n✝ k : ℕ
p q : ℕ → Prop
a n : ℕ
hp : 1 < a.succ
hk : 1 < n.succ
h : a.succ ^ n.succ ∣ a.succ
this✝⁴ : a.succ * a.succ ^ n ∣ a.succ * 1
this✝³ : a.succ ^ n ∣ 1
he : a.succ ^ n = 1
this✝² : n < a.succ ^ n
this✝¹ : n < 1
this✝ : n = 0
this : 1 < 1
⊢ ¬1 < 1
state_after: no goals
tactic: decide
Theorem: CategoryTheory.Equivalence.unitInv_app_inverse
File: Mathlib/CategoryTheory/Equivalence.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
Y : D
⊢ e.unitInv.app (e.inverse.obj Y) = e.inverse.map (e.counit.app Y)
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
Y : D
⊢ e.inverse.map (e.counit.app Y) = e.unitInv.app (e.inverse.obj Y)
tactic: symm
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
Y : D
⊢ e.inverse.map (e.counit.app Y) = e.unitInv.app (e.inverse.obj Y)
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
Y : D
⊢ 𝟙 (e.inverse.obj Y) = 𝟙 ((𝟭 C).obj (e.inverse.obj Y))
tactic: erw [← Iso.hom_comp_eq_id (e.unitIso.app _), unit_inverse_comp]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
Y : D
⊢ 𝟙 (e.inverse.obj Y) = 𝟙 ((𝟭 C).obj (e.inverse.obj Y))
state_after: no goals
tactic: rfl
Theorem: dvd_zero
File: Mathlib/Algebra/GroupWithZero/Divisibility.lean

Proof steps:
state_before: α : Type u_1
inst✝ : SemigroupWithZero α
a✝ a : α
⊢ a * 0 = 0
state_after: no goals
tactic: simp
Theorem: vadd_sub_assoc
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
inst✝² : DivInvMonoid β
inst✝¹ : SMul α β
inst✝ : IsScalarTower α β β
r : α
x y : β
⊢ r • x / y = r • (x / y)
state_after: no goals
tactic: simp [div_eq_mul_inv, smul_mul_assoc]
Theorem: ComplexShape.next_eq_self
File: Mathlib/Algebra/Homology/ComplexShape.lean

Proof steps:
state_before: ι : Type u_1
c : ComplexShape ι
j : ι
hj : ¬c.Rel j (c.next j)
k : ι
hk' : c.Rel j k
⊢ c.Rel j (c.next j)
state_after: no goals
tactic: simpa only [c.next_eq' hk'] using hk'
Theorem: CircleDeg1Lift.units_inv_apply_apply
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

Proof steps:
state_before: f✝ g : CircleDeg1Lift
f : CircleDeg1Liftˣ
x : ℝ
⊢ ↑f⁻¹ (↑f x) = x
state_after: no goals
tactic: simp only [← mul_apply, f.inv_mul, coe_one, id]
Theorem: Pell.ysq_dvd_yy
File: Mathlib/NumberTheory/PellMatiyasevic.lean

Proof steps:
state_before: a : ℕ
a1 : 1 < a
n : ℕ
⊢ yn a1 n * yn a1 n ∣ yn a1 n ^ 3
state_after: no goals
tactic: simp [_root_.pow_succ]
state_before: a : ℕ
a1 : 1 < a
n : ℕ
⊢ yn a1 n * yn a1 n ∣ yn a1 n * xn a1 n ^ (yn a1 n - 1) * yn a1 n
state_after: no goals
tactic: simp [mul_dvd_mul_left, mul_assoc]
Theorem: _private.Mathlib.Algebra.Order.Ring.WithTop.0.WithTop.distrib'
File: Mathlib/Algebra/Order/Ring/WithTop.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : CanonicallyOrderedCommSemiring α
a b c : WithTop α
⊢ (a + b) * c = a * c + b * c
state_after: case top
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : CanonicallyOrderedCommSemiring α
a b : WithTop α
⊢ (a + b) * ⊤ = a * ⊤ + b * ⊤

case coe
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : CanonicallyOrderedCommSemiring α
a b : WithTop α
c : α
⊢ (a + b) * ↑c = a * ↑c + b * ↑c
tactic: induction' c with c
Theorem: FreeAddGroup.Red.not_step_singleton
File: Mathlib/GroupTheory/FreeGroup/Basic.lean

Proof steps:
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
a : α
b : Bool
⊢ ¬Step [(a, b)] L
state_after: no goals
tactic: simp [Step.cons_left_iff, not_step_nil]
Theorem: MeasureTheory.laverage_zero
File: Mathlib/MeasureTheory/Integral/Average.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
m0 : MeasurableSpace α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : CompleteSpace E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
μ ν : Measure α
s t : Set α
f g : α → ℝ≥0∞
⊢ ⨍⁻ (_x : α), 0 ∂μ = 0
state_after: no goals
tactic: rw [laverage, lintegral_zero]
Theorem: CliffordAlgebra.star_ι
File: Mathlib/LinearAlgebra/CliffordAlgebra/Star.lean

Proof steps:
state_before: R : Type u_1
inst✝² : CommRing R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
m : M
⊢ star ((ι Q) m) = -(ι Q) m
state_after: no goals
tactic: rw [star_def, involute_ι, map_neg, reverse_ι]
Theorem: PowerBasis.equivAdjoinSimple_symm_aeval
File: Mathlib/FieldTheory/Adjoin.lean

Proof steps:
state_before: K : Type u_1
L : Type u_2
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Algebra K L
pb : PowerBasis K L
f : K[X]
⊢ pb.equivAdjoinSimple.symm ((aeval pb.gen) f) = (aeval (AdjoinSimple.gen K pb.gen)) f
state_after: no goals
tactic: rw [equivAdjoinSimple, equivOfMinpoly_symm, equivOfMinpoly_aeval, adjoin.powerBasis_gen]
Theorem: PosSMulStrictMono.lift
File: Mathlib/Algebra/Order/Module/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
a✝ a₁ a₂ : α
b b₁✝ b₂✝ : β
γ : Type u_3
inst✝⁸ : Zero α
inst✝⁷ : Preorder α
inst✝⁶ : Zero β
inst✝⁵ : Preorder β
inst✝⁴ : Zero γ
inst✝³ : Preorder γ
inst✝² : SMul α β
inst✝¹ : SMul α γ
f : β → γ
inst✝ : PosSMulStrictMono α γ
hf : ∀ {b₁ b₂ : β}, f b₁ ≤ f b₂ ↔ b₁ ≤ b₂
smul : ∀ (a : α) (b : β), f (a • b) = a • f b
a : α
ha : 0 < a
b₁ b₂ : β
hb : b₁ < b₂
⊢ a • b₁ < a • b₂
state_after: α : Type u_1
β : Type u_2
a✝ a₁ a₂ : α
b b₁✝ b₂✝ : β
γ : Type u_3
inst✝⁸ : Zero α
inst✝⁷ : Preorder α
inst✝⁶ : Zero β
inst✝⁵ : Preorder β
inst✝⁴ : Zero γ
inst✝³ : Preorder γ
inst✝² : SMul α β
inst✝¹ : SMul α γ
f : β → γ
inst✝ : PosSMulStrictMono α γ
hf : ∀ {b₁ b₂ : β}, f b₁ ≤ f b₂ ↔ b₁ ≤ b₂
a : α
ha : 0 < a
b₁ b₂ : β
smul : α → β → True
hb : f b₁ < f b₂
⊢ a • f b₁ < a • f b₂
tactic: simp only [← lt_iff_lt_of_le_iff_le' hf hf, smul] at *
state_before: α : Type u_1
β : Type u_2
a✝ a₁ a₂ : α
b b₁✝ b₂✝ : β
γ : Type u_3
inst✝⁸ : Zero α
inst✝⁷ : Preorder α
inst✝⁶ : Zero β
inst✝⁵ : Preorder β
inst✝⁴ : Zero γ
inst✝³ : Preorder γ
inst✝² : SMul α β
inst✝¹ : SMul α γ
f : β → γ
inst✝ : PosSMulStrictMono α γ
hf : ∀ {b₁ b₂ : β}, f b₁ ≤ f b₂ ↔ b₁ ≤ b₂
a : α
ha : 0 < a
b₁ b₂ : β
smul : α → β → True
hb : f b₁ < f b₂
⊢ a • f b₁ < a • f b₂
state_after: no goals
tactic: exact smul_lt_smul_of_pos_left hb ha
Theorem: Set.mem_sum_list_ofFn
File: Mathlib/Data/Set/Pointwise/ListOfFn.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 : ℕ
a : α
s : Fin n → Set α
⊢ a ∈ (List.ofFn s).prod ↔ ∃ f, (List.ofFn fun i => ↑(f i)).prod = a
state_after: case zero
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Monoid α
s✝ t : Set α
a✝ : α
m n : ℕ
a : α
s : Fin 0 → Set α
⊢ a ∈ (List.ofFn s).prod ↔ ∃ f, (List.ofFn fun i => ↑(f i)).prod = a

case succ
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Monoid α
s✝ t : Set α
a✝ : α
m n✝ n : ℕ
ih : ∀ {a : α} {s : Fin n → Set α}, a ∈ (List.ofFn s).prod ↔ ∃ f, (List.ofFn fun i => ↑(f i)).prod = a
a : α
s : Fin (n + 1) → Set α
⊢ a ∈ (List.ofFn s).prod ↔ ∃ f, (List.ofFn fun i => ↑(f i)).prod = a
tactic: induction' n with n ih generalizing a
Theorem: basis_toMatrix_mul_linearMap_toMatrix
File: Mathlib/LinearAlgebra/Matrix/Basis.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
κ : Type u_3
κ' : Type u_4
R : Type u_5
M : Type u_6
inst✝¹¹ : CommSemiring R
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : Module R M
R₂ : Type u_7
M₂ : Type u_8
inst✝⁸ : CommRing R₂
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R₂ M₂
e : Basis ι R M
v : ι' → M
i : ι
j : ι'
N : Type u_9
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
b : Basis ι R M
b' : Basis ι' R M
c : Basis κ R N
c' : Basis κ' R N
f : M →ₗ[R] N
inst✝³ : Fintype ι'
inst✝² : Finite κ
inst✝¹ : Fintype κ'
inst✝ : DecidableEq ι'
⊢ (toLin b' c) (c.toMatrix ⇑c' * (toMatrix b' c') f) = (toLin b' c) ((toMatrix b' c) f)
state_after: ι : Type u_1
ι' : Type u_2
κ : Type u_3
κ' : Type u_4
R : Type u_5
M : Type u_6
inst✝¹¹ : CommSemiring R
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : Module R M
R₂ : Type u_7
M₂ : Type u_8
inst✝⁸ : CommRing R₂
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R₂ M₂
e : Basis ι R M
v : ι' → M
i : ι
j : ι'
N : Type u_9
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
b : Basis ι R M
b' : Basis ι' R M
c : Basis κ R N
c' : Basis κ' R N
f : M →ₗ[R] N
inst✝³ : Fintype ι'
inst✝² : Finite κ
inst✝¹ : Fintype κ'
inst✝ : DecidableEq ι'
this : DecidableEq κ'
⊢ (toLin b' c) (c.toMatrix ⇑c' * (toMatrix b' c') f) = (toLin b' c) ((toMatrix b' c) f)
tactic: haveI := Classical.decEq κ'
state_before: ι : Type u_1
ι' : Type u_2
κ : Type u_3
κ' : Type u_4
R : Type u_5
M : Type u_6
inst✝¹¹ : CommSemiring R
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : Module R M
R₂ : Type u_7
M₂ : Type u_8
inst✝⁸ : CommRing R₂
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R₂ M₂
e : Basis ι R M
v : ι' → M
i : ι
j : ι'
N : Type u_9
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
b : Basis ι R M
b' : Basis ι' R M
c : Basis κ R N
c' : Basis κ' R N
f : M →ₗ[R] N
inst✝³ : Fintype ι'
inst✝² : Finite κ
inst✝¹ : Fintype κ'
inst✝ : DecidableEq ι'
this : DecidableEq κ'
⊢ (toLin b' c) (c.toMatrix ⇑c' * (toMatrix b' c') f) = (toLin b' c) ((toMatrix b' c) f)
state_after: no goals
tactic: rw [toLin_toMatrix, toLin_mul b' c' c, toLin_toMatrix, c.toLin_toMatrix, LinearMap.id_comp]
Theorem: Irreducible.isRelPrime_iff_not_dvd
File: Mathlib/Algebra/Associated/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : Monoid α
p n : α
hp : Irreducible p
⊢ IsRelPrime p n ↔ ¬p ∣ n
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : Monoid α
p n : α
hp : Irreducible p
hpn : ¬p ∣ n
d : α
hdp : d ∣ p
hdn : d ∣ n
⊢ IsUnit d
tactic: refine ⟨fun h contra ↦ hp.not_unit (h dvd_rfl contra), fun hpn d hdp hdn ↦ ?_⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : Monoid α
p n : α
hp : Irreducible p
hpn : ¬p ∣ n
d : α
hdp : d ∣ p
hdn : d ∣ n
⊢ IsUnit d
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : Monoid α
p n : α
hp : Irreducible p
d : α
hdp : d ∣ p
hdn : d ∣ n
hpn : ¬IsUnit d
⊢ p ∣ n
tactic: contrapose! hpn
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : Monoid α
p n : α
hp : Irreducible p
d : α
hdp : d ∣ p
hdn : d ∣ n
hpn : ¬IsUnit d
⊢ p ∣ n
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : Monoid α
p n : α
hp : Irreducible p
d : α
hdp : d ∣ p
hdn : d ∣ n
hpn : ¬IsUnit d
⊢ p ~ᵤ d
tactic: suffices Associated p d from this.dvd.trans hdn
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : Monoid α
p n : α
hp : Irreducible p
d : α
hdp : d ∣ p
hdn : d ∣ n
hpn : ¬IsUnit d
⊢ p ~ᵤ d
state_after: no goals
tactic: exact (hp.dvd_iff.mp hdp).resolve_left hpn
Theorem: ZetaAsymptotics.term_tsum_one
File: Mathlib/NumberTheory/Harmonic/ZetaAsymp.lean

Proof steps:
state_before: ⊢ HasSum (fun n => term (n + 1) 1) (1 - γ)
state_after: ⊢ Tendsto (fun n => ∑ i ∈ Finset.range n, term (i + 1) 1) atTop (𝓝 (1 - γ))
tactic: rw [hasSum_iff_tendsto_nat_of_nonneg (fun n ↦ term_nonneg (n + 1) 1)]
state_before: ⊢ Tendsto (fun n => ∑ i ∈ Finset.range n, term (i + 1) 1) atTop (𝓝 (1 - γ))
state_after: ⊢ Tendsto (fun N => term_sum 1 N) atTop (𝓝 (1 - γ))
tactic: show Tendsto (fun N ↦ term_sum 1 N) atTop _
state_before: ⊢ Tendsto (fun N => term_sum 1 N) atTop (𝓝 (1 - γ))
state_after: ⊢ Tendsto (fun N => -↑(harmonic (N + 1)) + log (↑N + 1) + 1) atTop (𝓝 (-γ + 1))
tactic: simp_rw [term_sum_one, sub_eq_neg_add]
state_before: ⊢ Tendsto (fun N => -↑(harmonic (N + 1)) + log (↑N + 1) + 1) atTop (𝓝 (-γ + 1))
state_after: ⊢ Tendsto (fun N => -↑(harmonic (N + 1)) + log (↑N + 1)) atTop (𝓝 (-γ))
tactic: refine Tendsto.add ?_ tendsto_const_nhds
state_before: ⊢ Tendsto (fun N => -↑(harmonic (N + 1)) + log (↑N + 1)) atTop (𝓝 (-γ))
state_after: this : Tendsto (fun x => -(eulerMascheroniSeq' ∘ fun a => a + 1) x) atTop (𝓝 (-γ))
⊢ Tendsto (fun N => -↑(harmonic (N + 1)) + log (↑N + 1)) atTop (𝓝 (-γ))
tactic: have := (tendsto_eulerMascheroniSeq'.comp (tendsto_add_atTop_nat 1)).neg
state_before: this : Tendsto (fun x => -(eulerMascheroniSeq' ∘ fun a => a + 1) x) atTop (𝓝 (-γ))
⊢ Tendsto (fun N => -↑(harmonic (N + 1)) + log (↑N + 1)) atTop (𝓝 (-γ))
state_after: this : Tendsto (fun x => -(eulerMascheroniSeq' ∘ fun a => a + 1) x) atTop (𝓝 (-γ))
n : ℕ
⊢ -(eulerMascheroniSeq' ∘ fun a => a + 1) n = (fun N => -↑(harmonic (N + 1)) + log (↑N + 1)) n
tactic: refine this.congr' (eventually_of_forall (fun n ↦ ?_))
state_before: this : Tendsto (fun x => -(eulerMascheroniSeq' ∘ fun a => a + 1) x) atTop (𝓝 (-γ))
n : ℕ
⊢ -(eulerMascheroniSeq' ∘ fun a => a + 1) n = (fun N => -↑(harmonic (N + 1)) + log (↑N + 1)) n
state_after: this : Tendsto (fun x => -(eulerMascheroniSeq' ∘ fun a => a + 1) x) atTop (𝓝 (-γ))
n : ℕ
⊢ -(↑(harmonic (n + 1)) - log ↑(n + 1)) = -↑(harmonic (n + 1)) + log (↑n + 1)
tactic: simp_rw [Function.comp_apply, eulerMascheroniSeq', if_false]
state_before: this : Tendsto (fun x => -(eulerMascheroniSeq' ∘ fun a => a + 1) x) atTop (𝓝 (-γ))
n : ℕ
⊢ -(↑(harmonic (n + 1)) - log ↑(n + 1)) = -↑(harmonic (n + 1)) + log (↑n + 1)
state_after: this : Tendsto (fun x => -(eulerMascheroniSeq' ∘ fun a => a + 1) x) atTop (𝓝 (-γ))
n : ℕ
⊢ -(↑(harmonic (n + 1)) - log (↑n + 1)) = -↑(harmonic (n + 1)) + log (↑n + 1)
tactic: push_cast
state_before: this : Tendsto (fun x => -(eulerMascheroniSeq' ∘ fun a => a + 1) x) atTop (𝓝 (-γ))
n : ℕ
⊢ -(↑(harmonic (n + 1)) - log (↑n + 1)) = -↑(harmonic (n + 1)) + log (↑n + 1)
state_after: no goals
tactic: abel
Theorem: Ideal.constr_basisSpanSingleton
File: Mathlib/RingTheory/Ideal/Basis.lean

Proof steps:
state_before: ι : Type u_1
R : Type u_2
S : Type u_3
inst✝⁶ : CommSemiring R
inst✝⁵ : CommRing S
inst✝⁴ : IsDomain S
inst✝³ : Algebra R S
N : Type u_4
inst✝² : Semiring N
inst✝¹ : Module N S
inst✝ : SMulCommClass R N S
b : Basis ι R S
x : S
hx : x ≠ 0
i : ι
⊢ ((↑(b.constr N)).toFun (Subtype.val ∘ ⇑(basisSpanSingleton b hx))) (b i) = ((Algebra.lmul R S) x) (b i)
state_after: no goals
tactic: erw [Basis.constr_basis, Function.comp_apply, basisSpanSingleton_apply, LinearMap.mul_apply']
Theorem: SetTheory.PGame.impartialAux_def
File: Mathlib/SetTheory/Game/Impartial.lean

Proof steps:
state_before: G : PGame
⊢ G.ImpartialAux ↔
    G ≈ -G ∧ (∀ (i : G.LeftMoves), (G.moveLeft i).ImpartialAux) ∧ ∀ (j : G.RightMoves), (G.moveRight j).ImpartialAux
state_after: no goals
tactic: rw [ImpartialAux]
Theorem: _private.Mathlib.Data.Sign.0.SignType.le_trans
File: Mathlib/Data/Sign.lean

Proof steps:
state_before: a b c : SignType
x✝¹ : a ≤ b
x✝ : b ≤ c
⊢ a ≤ c
state_after: no goals
tactic: cases a <;> cases b <;> cases c <;> tauto
Theorem: Nat.card_preimage_of_injOn
File: Mathlib/SetTheory/Cardinal/Finite.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s✝ t : Set α
f : α → β
s : Set β
hf : InjOn f (f ⁻¹' s)
hsf : s ⊆ range f
⊢ Nat.card ↑(f ⁻¹' s) = Nat.card ↑s
state_after: no goals
tactic: rw [← Nat.card_image_of_injOn hf, image_preimage_eq_iff.2 hsf]
Theorem: Rat.div_int_inj
File: Mathlib/Data/Rat/Lemmas.lean

Proof steps:
state_before: a b c d : ℤ
hb0 : 0 < b
hd0 : 0 < d
h1 : a.natAbs.Coprime b.natAbs
h2 : c.natAbs.Coprime d.natAbs
h : ↑a / ↑b = ↑c / ↑d
⊢ a = c ∧ b = d
state_after: case left
a b c d : ℤ
hb0 : 0 < b
hd0 : 0 < d
h1 : a.natAbs.Coprime b.natAbs
h2 : c.natAbs.Coprime d.natAbs
h : ↑a / ↑b = ↑c / ↑d
⊢ a = c

case right
a b c d : ℤ
hb0 : 0 < b
hd0 : 0 < d
h1 : a.natAbs.Coprime b.natAbs
h2 : c.natAbs.Coprime d.natAbs
h : ↑a / ↑b = ↑c / ↑d
⊢ b = d
tactic: apply And.intro