1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: HurwitzZeta.continuousOn_sinKernel
File: Mathlib/NumberTheory/LSeries/HurwitzZetaOdd.lean

tactic: induction' a using QuotientAddGroup.induction_on' with a
state_before: a : UnitAddCircle
⊢ ContinuousOn (sinKernel a) (Ioi 0)
state_after: case H
a : ℝ
⊢ ContinuousOn (sinKernel ↑a) (Ioi 0)

tactic: suffices ContinuousOn (fun x ↦ (sinKernel a x : ℂ)) (Ioi 0) from
  (continuous_re.comp_continuousOn this).congr fun a _ ↦ (ofReal_re _).symm
state_before: case H
a : ℝ
⊢ ContinuousOn (sinKernel ↑a) (Ioi 0)
state_after: case H
a : ℝ
⊢ ContinuousOn (fun x => ↑(sinKernel (↑a) x)) (Ioi 0)

tactic: simp_rw [sinKernel_def]
state_before: case H
a : ℝ
⊢ ContinuousOn (fun x => ↑(sinKernel (↑a) x)) (Ioi 0)
state_after: case H
a : ℝ
⊢ ContinuousOn (fun x => jacobiTheta₂' (↑a) (I * ↑x) / (-2 * ↑π)) (Ioi 0)

tactic: apply (ContinuousAt.continuousOn (fun x hx ↦ ?_)).div_const
state_before: case H
a : ℝ
⊢ ContinuousOn (fun x => jacobiTheta₂' (↑a) (I * ↑x) / (-2 * ↑π)) (Ioi 0)
state_after: a x : ℝ
hx : x ∈ Ioi 0
⊢ ContinuousAt (fun x => jacobiTheta₂' (↑a) (I * ↑x)) x

tactic: have h := continuousAt_jacobiTheta₂' a (by rwa [I_mul_im, ofReal_re])
state_before: a x : ℝ
hx : x ∈ Ioi 0
⊢ ContinuousAt (fun x => jacobiTheta₂' (↑a) (I * ↑x)) x
state_after: a x : ℝ
hx : x ∈ Ioi 0
h : ContinuousAt (fun p => jacobiTheta₂' p.1 p.2) (↑a, I * ↑x)
⊢ ContinuousAt (fun x => jacobiTheta₂' (↑a) (I * ↑x)) x

tactic: fun_prop
state_before: a x : ℝ
hx : x ∈ Ioi 0
h : ContinuousAt (fun p => jacobiTheta₂' p.1 p.2) (↑a, I * ↑x)
⊢ ContinuousAt (fun x => jacobiTheta₂' (↑a) (I * ↑x)) x
state_after: no goals

tactic: rwa [I_mul_im, ofReal_re]
state_before: a x : ℝ
hx : x ∈ Ioi 0
⊢ 0 < ?m.61414.im
state_after: no goals
Theorem: Complex.sinh_zero
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [sinh]
state_before: x y : ℂ
⊢ sinh 0 = 0
state_after: no goals
Theorem: BoxIntegral.TaggedPrepartition.IsHenstock.disjUnion
File: Mathlib/Analysis/BoxIntegral/Partition/Tagged.lean

tactic: refine fun J hJ => (Finset.mem_union.1 hJ).elim (fun hJ => ?_) fun hJ => ?_
state_before: ι : Type u_1
I J : Box ι
π π₁ π₂ : TaggedPrepartition I
x : ι → ℝ
r r₁ r₂ : (ι → ℝ) → ↑(Ioi 0)
h₁ : π₁.IsHenstock
h₂ : π₂.IsHenstock
h : Disjoint π₁.iUnion π₂.iUnion
⊢ (π₁.disjUnion π₂ h).IsHenstock
state_after: case refine_1
ι : Type u_1
I J✝ : Box ι
π π₁ π₂ : TaggedPrepartition I
x : ι → ℝ
r r₁ r₂ : (ι → ℝ) → ↑(Ioi 0)
h₁ : π₁.IsHenstock
h₂ : π₂.IsHenstock
h : Disjoint π₁.iUnion π₂.iUnion
J : Box ι
hJ✝ : J ∈ π₁.disjUnion π₂ h
hJ : J ∈ π₁.boxes
⊢ (π₁.disjUnion π₂ h).tag J ∈ Box.Icc J

case refine_2
ι : Type u_1
I J✝ : Box ι
π π₁ π₂ : TaggedPrepartition I
x : ι → ℝ
r r₁ r₂ : (ι → ℝ) → ↑(Ioi 0)
h₁ : π₁.IsHenstock
h₂ : π₂.IsHenstock
h : Disjoint π₁.iUnion π₂.iUnion
J : Box ι
hJ✝ : J ∈ π₁.disjUnion π₂ h
hJ : J ∈ π₂.boxes
⊢ (π₁.disjUnion π₂ h).tag J ∈ Box.Icc J

tactic: rw [disjUnion_tag_of_mem_left _ hJ]
state_before: case refine_1
ι : Type u_1
I J✝ : Box ι
π π₁ π₂ : TaggedPrepartition I
x : ι → ℝ
r r₁ r₂ : (ι → ℝ) → ↑(Ioi 0)
h₁ : π₁.IsHenstock
h₂ : π₂.IsHenstock
h : Disjoint π₁.iUnion π₂.iUnion
J : Box ι
hJ✝ : J ∈ π₁.disjUnion π₂ h
hJ : J ∈ π₁.boxes
⊢ (π₁.disjUnion π₂ h).tag J ∈ Box.Icc J
state_after: case refine_1
ι : Type u_1
I J✝ : Box ι
π π₁ π₂ : TaggedPrepartition I
x : ι → ℝ
r r₁ r₂ : (ι → ℝ) → ↑(Ioi 0)
h₁ : π₁.IsHenstock
h₂ : π₂.IsHenstock
h : Disjoint π₁.iUnion π₂.iUnion
J : Box ι
hJ✝ : J ∈ π₁.disjUnion π₂ h
hJ : J ∈ π₁.boxes
⊢ π₁.tag J ∈ Box.Icc J

tactic: exact h₁ _ hJ
state_before: case refine_1
ι : Type u_1
I J✝ : Box ι
π π₁ π₂ : TaggedPrepartition I
x : ι → ℝ
r r₁ r₂ : (ι → ℝ) → ↑(Ioi 0)
h₁ : π₁.IsHenstock
h₂ : π₂.IsHenstock
h : Disjoint π₁.iUnion π₂.iUnion
J : Box ι
hJ✝ : J ∈ π₁.disjUnion π₂ h
hJ : J ∈ π₁.boxes
⊢ π₁.tag J ∈ Box.Icc J
state_after: no goals

tactic: rw [disjUnion_tag_of_mem_right _ hJ]
state_before: case refine_2
ι : Type u_1
I J✝ : Box ι
π π₁ π₂ : TaggedPrepartition I
x : ι → ℝ
r r₁ r₂ : (ι → ℝ) → ↑(Ioi 0)
h₁ : π₁.IsHenstock
h₂ : π₂.IsHenstock
h : Disjoint π₁.iUnion π₂.iUnion
J : Box ι
hJ✝ : J ∈ π₁.disjUnion π₂ h
hJ : J ∈ π₂.boxes
⊢ (π₁.disjUnion π₂ h).tag J ∈ Box.Icc J
state_after: case refine_2
ι : Type u_1
I J✝ : Box ι
π π₁ π₂ : TaggedPrepartition I
x : ι → ℝ
r r₁ r₂ : (ι → ℝ) → ↑(Ioi 0)
h₁ : π₁.IsHenstock
h₂ : π₂.IsHenstock
h : Disjoint π₁.iUnion π₂.iUnion
J : Box ι
hJ✝ : J ∈ π₁.disjUnion π₂ h
hJ : J ∈ π₂.boxes
⊢ π₂.tag J ∈ Box.Icc J

tactic: exact h₂ _ hJ
state_before: case refine_2
ι : Type u_1
I J✝ : Box ι
π π₁ π₂ : TaggedPrepartition I
x : ι → ℝ
r r₁ r₂ : (ι → ℝ) → ↑(Ioi 0)
h₁ : π₁.IsHenstock
h₂ : π₂.IsHenstock
h : Disjoint π₁.iUnion π₂.iUnion
J : Box ι
hJ✝ : J ∈ π₁.disjUnion π₂ h
hJ : J ∈ π₂.boxes
⊢ π₂.tag J ∈ Box.Icc J
state_after: no goals
Theorem: Nat.Prime.multiplicity_factorial
File: Mathlib/Data/Nat/Multiplicity.lean

tactic: simp [Ico, hp.multiplicity_one]
state_before: p : ℕ
hp : Prime p
b : ℕ
x✝ : log p 0 < b
⊢ multiplicity p 0! = ↑(∑ i ∈ Ico 1 b, 0 / p ^ i)
state_after: no goals

tactic: rw [factorial_succ, hp.multiplicity_mul, add_comm]
state_before: p : ℕ
hp : Prime p
n b : ℕ
hb : log p (n + 1) < b
⊢ multiplicity p (n + 1)! = multiplicity p n ! + multiplicity p (n + 1)
state_after: no goals

tactic: rw [multiplicity_factorial hp ((log_mono_right <| le_succ _).trans_lt hb), ←
  multiplicity_eq_card_pow_dvd hp.ne_one (succ_pos _) hb]
state_before: p : ℕ
hp : Prime p
n b : ℕ
hb : log p (n + 1) < b
⊢ multiplicity p n ! + multiplicity p (n + 1) =
    ↑(∑ i ∈ Ico 1 b, n / p ^ i) + ↑(filter (fun i => p ^ i ∣ n + 1) (Ico 1 b)).card
state_after: no goals

tactic: rw [sum_add_distrib, sum_boole]
state_before: p : ℕ
hp : Prime p
n b : ℕ
hb : log p (n + 1) < b
⊢ ↑(∑ i ∈ Ico 1 b, n / p ^ i) + ↑(filter (fun i => p ^ i ∣ n + 1) (Ico 1 b)).card =
    ↑(∑ i ∈ Ico 1 b, (n / p ^ i + if p ^ i ∣ n + 1 then 1 else 0))
state_after: p : ℕ
hp : Prime p
n b : ℕ
hb : log p (n + 1) < b
⊢ ↑(∑ i ∈ Ico 1 b, n / p ^ i) + ↑(filter (fun i => p ^ i ∣ n + 1) (Ico 1 b)).card =
    ↑(∑ x ∈ Ico 1 b, n / p ^ x + ↑(filter (fun x => p ^ x ∣ n + 1) (Ico 1 b)).card)

tactic: simp
state_before: p : ℕ
hp : Prime p
n b : ℕ
hb : log p (n + 1) < b
⊢ ↑(∑ i ∈ Ico 1 b, n / p ^ i) + ↑(filter (fun i => p ^ i ∣ n + 1) (Ico 1 b)).card =
    ↑(∑ x ∈ Ico 1 b, n / p ^ x + ↑(filter (fun x => p ^ x ∣ n + 1) (Ico 1 b)).card)
state_after: no goals
Theorem: RingCon.coe_iInf
File: Mathlib/RingTheory/Congruence/Basic.lean

tactic: rw [iInf, coe_sInf, ← Set.range_comp, sInf_range, Function.comp]
state_before: α : Type u_1
R : Type u_2
inst✝¹ : Add R
inst✝ : Mul R
ι : Sort u_3
f : ι → RingCon R
⊢ ⇑(iInf f) = ⨅ i, ⇑(f i)
state_after: no goals
Theorem: MulEquiv.mulDissociated_preimage
File: Mathlib/Combinatorics/Additive/Dissociation.lean

tactic: simp [MulDissociated, InjOn, ← e.finsetCongr.forall_congr_right, ← e.apply_eq_iff_eq,
  (Finset.map_injective _).eq_iff]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : CommGroup α
inst✝ : CommGroup β
s : Set α
t u : Finset α
d : ℕ
a : α
e : β ≃* α
⊢ MulDissociated (⇑e ⁻¹' s) ↔ MulDissociated s
state_after: no goals
Theorem: Complex.cos_nat_mul_two_pi_add_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: simpa only [cos_zero] using (cos_periodic.nat_mul n).add_antiperiod_eq cos_antiperiodic
state_before: n : ℕ
⊢ cos (↑n * (2 * ↑π) + ↑π) = -1
state_after: no goals
Theorem: rank_lt_rank_dual'
File: Mathlib/LinearAlgebra/Dimension/DivisionRing.lean

tactic: convert lift_rank_lt_rank_dual' h
state_before: K R : Type u
V✝ V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝² : DivisionRing K
V : Type u
inst✝¹ : AddCommGroup V
inst✝ : Module K V
h : ℵ₀ ≤ Module.rank K V
⊢ Module.rank K V < Module.rank Kᵐᵒᵖ (V →ₗ[K] K)
state_after: case h.e'_3
K R : Type u
V✝ V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝² : DivisionRing K
V : Type u
inst✝¹ : AddCommGroup V
inst✝ : Module K V
h : ℵ₀ ≤ Module.rank K V
⊢ Module.rank K V = lift.{u, u} (Module.rank K V)

tactic: rw [lift_id]
state_before: case h.e'_3
K R : Type u
V✝ V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝² : DivisionRing K
V : Type u
inst✝¹ : AddCommGroup V
inst✝ : Module K V
h : ℵ₀ ≤ Module.rank K V
⊢ Module.rank K V = lift.{u, u} (Module.rank K V)
state_after: no goals
Theorem: IsLocalization.mk'_mul_mk'_eq_one
File: Mathlib/RingTheory/Localization/Basic.lean

tactic: rw [← mk'_mul, mul_comm]
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
x y : ↥M
⊢ mk' S (↑x) y * mk' S (↑y) x = 1
state_after: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
x y : ↥M
⊢ mk' S (↑y * ↑x) (y * x) = 1

tactic: exact mk'_self _ _
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
x y : ↥M
⊢ mk' S (↑y * ↑x) (y * x) = 1
state_after: no goals
Theorem: Zsqrtd.norm_eq_of_associated
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

tactic: obtain ⟨u, rfl⟩ := h
state_before: d✝ d : ℤ
hd : d ≤ 0
x y : ℤ√d
h : Associated x y
⊢ x.norm = y.norm
state_after: case intro
d✝ d : ℤ
hd : d ≤ 0
x : ℤ√d
u : (ℤ√d)ˣ
⊢ x.norm = (x * ↑u).norm

tactic: rw [norm_mul, (norm_eq_one_iff' hd _).mpr u.isUnit, mul_one]
state_before: case intro
d✝ d : ℤ
hd : d ≤ 0
x : ℤ√d
u : (ℤ√d)ˣ
⊢ x.norm = (x * ↑u).norm
state_after: no goals
Theorem: Quiver.Path.obj_eq_of_cons_eq_cons
File: Mathlib/Combinatorics/Quiver/Path.lean

tactic: injection h
state_before: V : Type u
inst✝ : Quiver V
a b c d : V
p : Path a b
p' : Path a c
e : b ⟶ d
e' : c ⟶ d
h : p.cons e = p'.cons e'
⊢ b = c
state_after: no goals
Theorem: imaginaryPart_apply_coe
File: Mathlib/Data/Complex/Module.lean

tactic: unfold imaginaryPart
state_before: A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
a : A
⊢ ↑(ℑ a) = -I • 2⁻¹ • (a - star a)
state_after: A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
a : A
⊢ ↑((skewAdjoint.negISMul ∘ₗ skewAdjointPart ℝ) a) = -I • 2⁻¹ • (a - star a)

tactic: simp only [LinearMap.coe_comp, Function.comp_apply, skewAdjoint.negISMul_apply_coe,
  skewAdjointPart_apply_coe, invOf_eq_inv, neg_smul]
state_before: A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
a : A
⊢ ↑((skewAdjoint.negISMul ∘ₗ skewAdjointPart ℝ) a) = -I • 2⁻¹ • (a - star a)
state_after: no goals
Theorem: Finset.mem_symmDiff
File: Mathlib/Data/Finset/Basic.lean

tactic: simp_rw [symmDiff, sup_eq_union, mem_union, mem_sdiff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t : Finset α
a b : α
⊢ a ∈ s ∆ t ↔ a ∈ s ∧ a ∉ t ∨ a ∈ t ∧ a ∉ s
state_after: no goals
Theorem: SetTheory.PGame.lt_def
File: Mathlib/SetTheory/Surreal/Basic.lean

tactic: rw [← lf_iff_lt ox oy, lf_def]
state_before: x y : PGame
ox : x.Numeric
oy : y.Numeric
⊢ x < y ↔
    (∃ i,
        (∀ (i' : x.LeftMoves), x.moveLeft i' < y.moveLeft i) ∧
          ∀ (j : (y.moveLeft i).RightMoves), x < (y.moveLeft i).moveRight j) ∨
      ∃ j,
        (∀ (i : (x.moveRight j).LeftMoves), (x.moveRight j).moveLeft i < y) ∧
          ∀ (j' : y.RightMoves), x.moveRight j < y.moveRight j'
state_after: x y : PGame
ox : x.Numeric
oy : y.Numeric
⊢ ((∃ i,
        (∀ (i' : x.LeftMoves), x.moveLeft i' ⧏ y.moveLeft i) ∧
          ∀ (j : (y.moveLeft i).RightMoves), x ⧏ (y.moveLeft i).moveRight j) ∨
      ∃ j,
        (∀ (i : (x.moveRight j).LeftMoves), (x.moveRight j).moveLeft i ⧏ y) ∧
          ∀ (j' : y.RightMoves), x.moveRight j ⧏ y.moveRight j') ↔
    (∃ i,
        (∀ (i' : x.LeftMoves), x.moveLeft i' < y.moveLeft i) ∧
          ∀ (j : (y.moveLeft i).RightMoves), x < (y.moveLeft i).moveRight j) ∨
      ∃ j,
        (∀ (i : (x.moveRight j).LeftMoves), (x.moveRight j).moveLeft i < y) ∧
          ∀ (j' : y.RightMoves), x.moveRight j < y.moveRight j'

tactic: refine or_congr ?_ ?_ <;> refine exists_congr fun x_1 => ?_ <;> refine and_congr ?_ ?_ <;>
    refine forall_congr' fun i => lf_iff_lt ?_ ?_ <;>
  apply_rules [Numeric.moveLeft, Numeric.moveRight]
state_before: x y : PGame
ox : x.Numeric
oy : y.Numeric
⊢ ((∃ i,
        (∀ (i' : x.LeftMoves), x.moveLeft i' ⧏ y.moveLeft i) ∧
          ∀ (j : (y.moveLeft i).RightMoves), x ⧏ (y.moveLeft i).moveRight j) ∨
      ∃ j,
        (∀ (i : (x.moveRight j).LeftMoves), (x.moveRight j).moveLeft i ⧏ y) ∧
          ∀ (j' : y.RightMoves), x.moveRight j ⧏ y.moveRight j') ↔
    (∃ i,
        (∀ (i' : x.LeftMoves), x.moveLeft i' < y.moveLeft i) ∧
          ∀ (j : (y.moveLeft i).RightMoves), x < (y.moveLeft i).moveRight j) ∨
      ∃ j,
        (∀ (i : (x.moveRight j).LeftMoves), (x.moveRight j).moveLeft i < y) ∧
          ∀ (j' : y.RightMoves), x.moveRight j < y.moveRight j'
state_after: no goals
Theorem: toIcoDiv_apply_left
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: simp [hp]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b c : α
n : ℤ
a : α
⊢ a - 0 • p ∈ Set.Ico a (a + p)
state_after: no goals
Theorem: NNRat.den_inv_of_ne_zero
File: Mathlib/Algebra/Order/Field/Rat.lean

tactic: rw [inv_def, divNat, den, coe_mk, Rat.divInt_ofNat, ← Rat.mk_eq_mkRat _ _ (num_ne_zero.mpr hq)]
state_before: q : ℚ≥0
hq : q ≠ 0
⊢ q⁻¹.den = q.num
state_after: q : ℚ≥0
hq : q ≠ 0
⊢ (↑q.den).natAbs.Coprime q.num

tactic: simpa using q.coprime_num_den.symm
state_before: q : ℚ≥0
hq : q ≠ 0
⊢ (↑q.den).natAbs.Coprime q.num
state_after: no goals
Theorem: Subsemigroup.prod_top
File: Mathlib/Algebra/Group/Subsemigroup/Operations.lean

tactic: simp [mem_prod, MulHom.coe_fst]
state_before: M : Type u_1
N : Type u_2
P : Type u_3
σ : Type u_4
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
S s : Subsemigroup M
x : M × N
⊢ x ∈ s.prod ⊤ ↔ x ∈ comap (MulHom.fst M N) s
state_after: no goals
Theorem: Ideal.prod_le_prime
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

tactic: by_cases hP0 : P = ⊥
state_before: R : Type u_1
A : Type u_2
K : Type u_3
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Field K
inst✝ : IsDedekindDomain R
ι : Type u_4
s : Finset ι
f : ι → Ideal R
P : Ideal R
hP : P.IsPrime
⊢ ∏ i ∈ s, f i ≤ P ↔ ∃ i ∈ s, f i ≤ P
state_after: case pos
R : Type u_1
A : Type u_2
K : Type u_3
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Field K
inst✝ : IsDedekindDomain R
ι : Type u_4
s : Finset ι
f : ι → Ideal R
P : Ideal R
hP : P.IsPrime
hP0 : P = ⊥
⊢ ∏ i ∈ s, f i ≤ P ↔ ∃ i ∈ s, f i ≤ P

case neg
R : Type u_1
A : Type u_2
K : Type u_3
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Field K
inst✝ : IsDedekindDomain R
ι : Type u_4
s : Finset ι
f : ι → Ideal R
P : Ideal R
hP : P.IsPrime
hP0 : ¬P = ⊥
⊢ ∏ i ∈ s, f i ≤ P ↔ ∃ i ∈ s, f i ≤ P

tactic: simp only [← Ideal.dvd_iff_le]
state_before: case neg
R : Type u_1
A : Type u_2
K : Type u_3
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Field K
inst✝ : IsDedekindDomain R
ι : Type u_4
s : Finset ι
f : ι → Ideal R
P : Ideal R
hP : P.IsPrime
hP0 : ¬P = ⊥
⊢ ∏ i ∈ s, f i ≤ P ↔ ∃ i ∈ s, f i ≤ P
state_after: case neg
R : Type u_1
A : Type u_2
K : Type u_3
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Field K
inst✝ : IsDedekindDomain R
ι : Type u_4
s : Finset ι
f : ι → Ideal R
P : Ideal R
hP : P.IsPrime
hP0 : ¬P = ⊥
⊢ P ∣ ∏ i ∈ s, f i ↔ ∃ i ∈ s, P ∣ f i

tactic: exact ((Ideal.prime_iff_isPrime hP0).mpr hP).dvd_finset_prod_iff _
state_before: case neg
R : Type u_1
A : Type u_2
K : Type u_3
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Field K
inst✝ : IsDedekindDomain R
ι : Type u_4
s : Finset ι
f : ι → Ideal R
P : Ideal R
hP : P.IsPrime
hP0 : ¬P = ⊥
⊢ P ∣ ∏ i ∈ s, f i ↔ ∃ i ∈ s, P ∣ f i
state_after: no goals

tactic: simp only [hP0, le_bot_iff]
state_before: case pos
R : Type u_1
A : Type u_2
K : Type u_3
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Field K
inst✝ : IsDedekindDomain R
ι : Type u_4
s : Finset ι
f : ι → Ideal R
P : Ideal R
hP : P.IsPrime
hP0 : P = ⊥
⊢ ∏ i ∈ s, f i ≤ P ↔ ∃ i ∈ s, f i ≤ P
state_after: case pos
R : Type u_1
A : Type u_2
K : Type u_3
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Field K
inst✝ : IsDedekindDomain R
ι : Type u_4
s : Finset ι
f : ι → Ideal R
P : Ideal R
hP : P.IsPrime
hP0 : P = ⊥
⊢ ∏ i ∈ s, f i = ⊥ ↔ ∃ i ∈ s, f i = ⊥

tactic: rw [← Ideal.zero_eq_bot, Finset.prod_eq_zero_iff]
state_before: case pos
R : Type u_1
A : Type u_2
K : Type u_3
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Field K
inst✝ : IsDedekindDomain R
ι : Type u_4
s : Finset ι
f : ι → Ideal R
P : Ideal R
hP : P.IsPrime
hP0 : P = ⊥
⊢ ∏ i ∈ s, f i = ⊥ ↔ ∃ i ∈ s, f i = ⊥
state_after: no goals
Theorem: Multiset.noncommProd_induction
File: Mathlib/Data/Finset/NoncommProd.lean

tactic: induction' s using Quotient.inductionOn with l
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
inst✝¹ : Monoid α
inst✝ : Monoid β
s : Multiset α
comm : {x | x ∈ s}.Pairwise Commute
p : α → Prop
hom : ∀ (a b : α), p a → p b → p (a * b)
unit : p 1
base : ∀ x ∈ s, p x
⊢ p (s.noncommProd comm)
state_after: case h
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
inst✝¹ : Monoid α
inst✝ : Monoid β
p : α → Prop
hom : ∀ (a b : α), p a → p b → p (a * b)
unit : p 1
l : List α
comm : {x | x ∈ ⟦l⟧}.Pairwise Commute
base : ∀ x ∈ ⟦l⟧, p x
⊢ p (noncommProd ⟦l⟧ comm)

tactic: simp only [quot_mk_to_coe, noncommProd_coe, mem_coe] at base ⊢
state_before: case h
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
inst✝¹ : Monoid α
inst✝ : Monoid β
p : α → Prop
hom : ∀ (a b : α), p a → p b → p (a * b)
unit : p 1
l : List α
comm : {x | x ∈ ⟦l⟧}.Pairwise Commute
base : ∀ x ∈ ⟦l⟧, p x
⊢ p (noncommProd ⟦l⟧ comm)
state_after: case h
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
inst✝¹ : Monoid α
inst✝ : Monoid β
p : α → Prop
hom : ∀ (a b : α), p a → p b → p (a * b)
unit : p 1
l : List α
comm : {x | x ∈ ⟦l⟧}.Pairwise Commute
base : ∀ x ∈ l, p x
⊢ p l.prod

tactic: exact l.prod_induction p hom unit base
state_before: case h
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
inst✝¹ : Monoid α
inst✝ : Monoid β
p : α → Prop
hom : ∀ (a b : α), p a → p b → p (a * b)
unit : p 1
l : List α
comm : {x | x ∈ ⟦l⟧}.Pairwise Commute
base : ∀ x ∈ l, p x
⊢ p l.prod
state_after: no goals
Theorem: Matrix.conjTranspose_sub
File: Mathlib/Data/Matrix/Basic.lean

tactic: simp
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝¹ : AddGroup α
inst✝ : StarAddMonoid α
M N : Matrix m n α
⊢ ∀ (i : n) (j : m), (M - N)ᴴ i j = (Mᴴ - Nᴴ) i j
state_after: no goals
Theorem: Function.Commute.iterate_pos_eq_iff_map_eq
File: Mathlib/Order/Iterate.lean

tactic: simp only [le_antisymm_iff, h.iterate_pos_le_iff_map_le hf hg hn,
  h.symm.iterate_pos_le_iff_map_le' hg hf hn]
state_before: α : Type u_1
inst✝ : LinearOrder α
f g : α → α
h : Commute f g
hf : Monotone f
hg : StrictMono g
x : α
n : ℕ
hn : 0 < n
⊢ f^[n] x = g^[n] x ↔ f x = g x
state_after: no goals
Theorem: LieModule.Weight.weightSpaceOf_ne_bot
File: Mathlib/Algebra/Lie/Weights/Basic.lean

tactic: have : ⨅ x, weightSpaceOf M (χ x) x ≠ ⊥ := χ.weightSpace_ne_bot
state_before: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ : Weight R L M
x : L
⊢ weightSpaceOf M (χ x) x ≠ ⊥
state_after: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ : Weight R L M
x : L
this : ⨅ x, weightSpaceOf M (χ x) x ≠ ⊥
⊢ weightSpaceOf M (χ x) x ≠ ⊥

tactic: contrapose! this
state_before: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ : Weight R L M
x : L
this : ⨅ x, weightSpaceOf M (χ x) x ≠ ⊥
⊢ weightSpaceOf M (χ x) x ≠ ⊥
state_after: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ : Weight R L M
x : L
this : weightSpaceOf M (χ x) x = ⊥
⊢ ⨅ x, weightSpaceOf M (χ x) x = ⊥

tactic: rw [eq_bot_iff]
state_before: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ : Weight R L M
x : L
this : weightSpaceOf M (χ x) x = ⊥
⊢ ⨅ x, weightSpaceOf M (χ x) x = ⊥
state_after: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ : Weight R L M
x : L
this : weightSpaceOf M (χ x) x = ⊥
⊢ ⨅ x, weightSpaceOf M (χ x) x ≤ ⊥

tactic: exact le_of_le_of_eq (iInf_le _ _) this
state_before: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ : Weight R L M
x : L
this : weightSpaceOf M (χ x) x = ⊥
⊢ ⨅ x, weightSpaceOf M (χ x) x ≤ ⊥
state_after: no goals
Theorem: xInTermsOfW_eq
File: Mathlib/RingTheory/WittVector/WittPolynomial.lean

tactic: rw [xInTermsOfW, ← Fin.sum_univ_eq_sum_range]
state_before: p : ℕ
R : Type u_1
inst✝² : CommRing R
inst✝¹ : DecidableEq R
inst✝ : Invertible ↑p
n : ℕ
⊢ xInTermsOfW p R n = (X n - ∑ i ∈ range n, C (↑p ^ i) * xInTermsOfW p R i ^ p ^ (n - i)) * C (⅟↑p ^ n)
state_after: no goals
Theorem: Set.op_smul_set_smul_eq_smul_smul_set
File: Mathlib/Data/Set/Pointwise/SMul.lean

tactic: ext
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : SMul αᵐᵒᵖ β
inst✝¹ : SMul β γ
inst✝ : SMul α γ
a : α
s : Set β
t : Set γ
h : ∀ (a : α) (b : β) (c : γ), (op a • b) • c = b • a • c
⊢ (op a • s) • t = s • a • t
state_after: case h
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : SMul αᵐᵒᵖ β
inst✝¹ : SMul β γ
inst✝ : SMul α γ
a : α
s : Set β
t : Set γ
h : ∀ (a : α) (b : β) (c : γ), (op a • b) • c = b • a • c
x✝ : γ
⊢ x✝ ∈ (op a • s) • t ↔ x✝ ∈ s • a • t

tactic: simp [mem_smul, mem_smul_set, h]
state_before: case h
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : SMul αᵐᵒᵖ β
inst✝¹ : SMul β γ
inst✝ : SMul α γ
a : α
s : Set β
t : Set γ
h : ∀ (a : α) (b : β) (c : γ), (op a • b) • c = b • a • c
x✝ : γ
⊢ x✝ ∈ (op a • s) • t ↔ x✝ ∈ s • a • t
state_after: no goals