1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: UpperHalfPlane.mul_smul'
File: Mathlib/Analysis/Complex/UpperHalfPlane/Basic.lean

tactic: ext1
state_before: x y : ↥GL(2, ℝ)⁺
z : ℍ
⊢ smulAux (x * y) z = smulAux x (smulAux y z)
state_after: case h
x y : ↥GL(2, ℝ)⁺
z : ℍ
⊢ ↑(smulAux (x * y) z) = ↑(smulAux x (smulAux y z))

tactic: change _ / _ = (_ * (_ / _) + _) / _
state_before: case h
x y : ↥GL(2, ℝ)⁺
z : ℍ
⊢ ↑(smulAux (x * y) z) = ↑(smulAux x (smulAux y z))
state_after: case h
x y : ↥GL(2, ℝ)⁺
z : ℍ
⊢ num (x * y) z / denom (x * y) z = (↑(↑↑x 0 0) * (num y z / denom y z) + ↑(↑↑x 0 1)) / denom x (smulAux y z)

tactic: rw [denom_cocycle]
state_before: case h
x y : ↥GL(2, ℝ)⁺
z : ℍ
⊢ num (x * y) z / denom (x * y) z = (↑(↑↑x 0 0) * (num y z / denom y z) + ↑(↑↑x 0 1)) / denom x (smulAux y z)
state_after: case h
x y : ↥GL(2, ℝ)⁺
z : ℍ
⊢ num (x * y) z / (denom x (smulAux y z) * denom y z) =
    (↑(↑↑x 0 0) * (num y z / denom y z) + ↑(↑↑x 0 1)) / denom x (smulAux y z)

tactic: field_simp [denom_ne_zero]
state_before: case h
x y : ↥GL(2, ℝ)⁺
z : ℍ
⊢ num (x * y) z / (denom x (smulAux y z) * denom y z) =
    (↑(↑↑x 0 0) * (num y z / denom y z) + ↑(↑↑x 0 1)) / denom x (smulAux y z)
state_after: case h
x y : ↥GL(2, ℝ)⁺
z : ℍ
⊢ num (x * y) z * (denom y z * denom x (smulAux y z)) =
    (↑(↑↑x 0 0) * num y z + ↑(↑↑x 0 1) * denom y z) * (denom x (smulAux y z) * denom y z)

tactic: simp only [Matrix.mul_apply, dotProduct, Fin.sum_univ_succ, num, denom, Subgroup.coe_mul,
  GeneralLinearGroup.coe_mul, Fintype.univ_ofSubsingleton, Fin.mk_zero, Finset.sum_singleton,
  Fin.succ_zero_eq_one, Complex.ofReal_add, Complex.ofReal_mul]
state_before: case h
x y : ↥GL(2, ℝ)⁺
z : ℍ
⊢ num (x * y) z * (denom y z * denom x (smulAux y z)) =
    (↑(↑↑x 0 0) * num y z + ↑(↑↑x 0 1) * denom y z) * (denom x (smulAux y z) * denom y z)
state_after: case h
x y : ↥GL(2, ℝ)⁺
z : ℍ
⊢ ((↑(↑↑x 0 0) * ↑(↑↑y 0 0) + ↑(↑↑x 0 1) * ↑(↑↑y 1 0)) * ↑z + (↑(↑↑x 0 0) * ↑(↑↑y 0 1) + ↑(↑↑x 0 1) * ↑(↑↑y 1 1))) *
      ((↑(↑↑y 1 0) * ↑z + ↑(↑↑y 1 1)) * (↑(↑↑x 1 0) * ↑(smulAux y z) + ↑(↑↑x 1 1))) =
    (↑(↑↑x 0 0) * (↑(↑↑y 0 0) * ↑z + ↑(↑↑y 0 1)) + ↑(↑↑x 0 1) * (↑(↑↑y 1 0) * ↑z + ↑(↑↑y 1 1))) *
      ((↑(↑↑x 1 0) * ↑(smulAux y z) + ↑(↑↑x 1 1)) * (↑(↑↑y 1 0) * ↑z + ↑(↑↑y 1 1)))

tactic: ring
state_before: case h
x y : ↥GL(2, ℝ)⁺
z : ℍ
⊢ ((↑(↑↑x 0 0) * ↑(↑↑y 0 0) + ↑(↑↑x 0 1) * ↑(↑↑y 1 0)) * ↑z + (↑(↑↑x 0 0) * ↑(↑↑y 0 1) + ↑(↑↑x 0 1) * ↑(↑↑y 1 1))) *
      ((↑(↑↑y 1 0) * ↑z + ↑(↑↑y 1 1)) * (↑(↑↑x 1 0) * ↑(smulAux y z) + ↑(↑↑x 1 1))) =
    (↑(↑↑x 0 0) * (↑(↑↑y 0 0) * ↑z + ↑(↑↑y 0 1)) + ↑(↑↑x 0 1) * (↑(↑↑y 1 0) * ↑z + ↑(↑↑y 1 1))) *
      ((↑(↑↑x 1 0) * ↑(smulAux y z) + ↑(↑↑x 1 1)) * (↑(↑↑y 1 0) * ↑z + ↑(↑↑y 1 1)))
state_after: no goals
Theorem: PEquiv.ofSet_eq_refl
File: Mathlib/Data/PEquiv.lean

tactic: rw [Set.eq_univ_iff_forall]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type x
s✝ : Set α
inst✝¹ : DecidablePred fun x => x ∈ s✝
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
h : ofSet s = PEquiv.refl α
⊢ s = Set.univ
state_after: α : Type u
β : Type v
γ : Type w
δ : Type x
s✝ : Set α
inst✝¹ : DecidablePred fun x => x ∈ s✝
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
h : ofSet s = PEquiv.refl α
⊢ ∀ (x : α), x ∈ s

tactic: intro
state_before: α : Type u
β : Type v
γ : Type w
δ : Type x
s✝ : Set α
inst✝¹ : DecidablePred fun x => x ∈ s✝
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
h : ofSet s = PEquiv.refl α
⊢ ∀ (x : α), x ∈ s
state_after: α : Type u
β : Type v
γ : Type w
δ : Type x
s✝ : Set α
inst✝¹ : DecidablePred fun x => x ∈ s✝
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
h : ofSet s = PEquiv.refl α
x✝ : α
⊢ x✝ ∈ s

tactic: rw [← mem_ofSet_self_iff, h]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type x
s✝ : Set α
inst✝¹ : DecidablePred fun x => x ∈ s✝
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
h : ofSet s = PEquiv.refl α
x✝ : α
⊢ x✝ ∈ s
state_after: α : Type u
β : Type v
γ : Type w
δ : Type x
s✝ : Set α
inst✝¹ : DecidablePred fun x => x ∈ s✝
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
h : ofSet s = PEquiv.refl α
x✝ : α
⊢ x✝ ∈ (PEquiv.refl α) x✝

tactic: exact rfl
state_before: α : Type u
β : Type v
γ : Type w
δ : Type x
s✝ : Set α
inst✝¹ : DecidablePred fun x => x ∈ s✝
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
h : ofSet s = PEquiv.refl α
x✝ : α
⊢ x✝ ∈ (PEquiv.refl α) x✝
state_after: no goals

tactic: simp only [← ofSet_univ, h]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type x
s✝ : Set α
inst✝¹ : DecidablePred fun x => x ∈ s✝
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
h : s = Set.univ
⊢ ofSet s = PEquiv.refl α
state_after: no goals
Theorem: PartENat.coe_succ_le_iff
File: Mathlib/Data/Nat/PartENat.lean

tactic: rw [Nat.succ_eq_add_one n, Nat.cast_add, Nat.cast_one, add_one_le_iff_lt (natCast_ne_top n)]
state_before: n : ℕ
e : PartENat
⊢ ↑n.succ ≤ e ↔ ↑n < e
state_after: no goals
Theorem: uniformEmbedding_translate_mul
File: Mathlib/Topology/Algebra/UniformGroup.lean

tactic: nth_rw 1 [← uniformity_translate_mul a, comap_map]
state_before: α : Type u_1
β : Type u_2
inst✝² : UniformSpace α
inst✝¹ : Group α
inst✝ : UniformGroup α
a : α
⊢ comap (fun x => (x.1 * a, x.2 * a)) (𝓤 α) = 𝓤 α
state_after: α : Type u_1
β : Type u_2
inst✝² : UniformSpace α
inst✝¹ : Group α
inst✝ : UniformGroup α
a : α
⊢ Function.Injective fun x => (x.1 * a, x.2 * a)

tactic: rintro ⟨p₁, p₂⟩ ⟨q₁, q₂⟩
state_before: α : Type u_1
β : Type u_2
inst✝² : UniformSpace α
inst✝¹ : Group α
inst✝ : UniformGroup α
a : α
⊢ Function.Injective fun x => (x.1 * a, x.2 * a)
state_after: case mk.mk
α : Type u_1
β : Type u_2
inst✝² : UniformSpace α
inst✝¹ : Group α
inst✝ : UniformGroup α
a p₁ p₂ q₁ q₂ : α
⊢ (fun x => (x.1 * a, x.2 * a)) (p₁, p₂) = (fun x => (x.1 * a, x.2 * a)) (q₁, q₂) → (p₁, p₂) = (q₁, q₂)

tactic: simp only [Prod.mk.injEq, mul_left_inj, imp_self]
state_before: case mk.mk
α : Type u_1
β : Type u_2
inst✝² : UniformSpace α
inst✝¹ : Group α
inst✝ : UniformGroup α
a p₁ p₂ q₁ q₂ : α
⊢ (fun x => (x.1 * a, x.2 * a)) (p₁, p₂) = (fun x => (x.1 * a, x.2 * a)) (q₁, q₂) → (p₁, p₂) = (q₁, q₂)
state_after: no goals
Theorem: Submodule.closure_neg
File: Mathlib/Algebra/Module/Submodule/Pointwise.lean

tactic: apply le_antisymm
state_before: α : Type u_1
R : Type u_2
M : Type u_3
inst✝² : Semiring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
s : Set M
⊢ span R (-s) = -span R s
state_after: case a
α : Type u_1
R : Type u_2
M : Type u_3
inst✝² : Semiring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
s : Set M
⊢ span R (-s) ≤ -span R s

case a
α : Type u_1
R : Type u_2
M : Type u_3
inst✝² : Semiring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
s : Set M
⊢ -span R s ≤ span R (-s)

tactic: rw [span_le, coe_set_neg, ← Set.neg_subset, neg_neg]
state_before: case a
α : Type u_1
R : Type u_2
M : Type u_3
inst✝² : Semiring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
s : Set M
⊢ span R (-s) ≤ -span R s
state_after: case a
α : Type u_1
R : Type u_2
M : Type u_3
inst✝² : Semiring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
s : Set M
⊢ s ⊆ ↑(span R s)

tactic: exact subset_span
state_before: case a
α : Type u_1
R : Type u_2
M : Type u_3
inst✝² : Semiring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
s : Set M
⊢ s ⊆ ↑(span R s)
state_after: no goals

tactic: rw [neg_le, span_le, coe_set_neg, ← Set.neg_subset]
state_before: case a
α : Type u_1
R : Type u_2
M : Type u_3
inst✝² : Semiring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
s : Set M
⊢ -span R s ≤ span R (-s)
state_after: case a
α : Type u_1
R : Type u_2
M : Type u_3
inst✝² : Semiring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
s : Set M
⊢ -s ⊆ ↑(span R (-s))

tactic: exact subset_span
state_before: case a
α : Type u_1
R : Type u_2
M : Type u_3
inst✝² : Semiring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
s : Set M
⊢ -s ⊆ ↑(span R (-s))
state_after: no goals
Theorem: integrableOn_Icc_iff_integrableOn_Ioo'
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

tactic: rw [integrableOn_Icc_iff_integrableOn_Ioc' ha, integrableOn_Ioc_iff_integrableOn_Ioo' hb]
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
inst✝¹ : PartialOrder α
inst✝ : MeasurableSingletonClass α
f : α → E
μ : Measure α
a b : α
ha : μ {a} ≠ ⊤
hb : μ {b} ≠ ⊤
⊢ IntegrableOn f (Icc a b) μ ↔ IntegrableOn f (Ioo a b) μ
state_after: no goals
Theorem: LinearIsometry.inner_map_map
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: simp [inner_eq_sum_norm_sq_div_four, ← f.norm_map]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁸ : _root_.RCLike 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : InnerProductSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace ℝ F
ι : Type u_4
ι' : Type u_5
ι'' : Type u_6
E' : Type u_7
inst✝³ : NormedAddCommGroup E'
inst✝² : InnerProductSpace 𝕜 E'
E'' : Type u_8
inst✝¹ : NormedAddCommGroup E''
inst✝ : InnerProductSpace 𝕜 E''
f : E →ₗᵢ[𝕜] E'
x y : E
⊢ ⟪f x, f y⟫_𝕜 = ⟪x, y⟫_𝕜
state_after: no goals
Theorem: periodic_circleMap
File: Mathlib/MeasureTheory/Integral/CircleIntegral.lean

tactic: simp [circleMap, add_mul, exp_periodic _]
state_before: E : Type u_1
inst✝ : NormedAddCommGroup E
c : ℂ
R θ : ℝ
⊢ circleMap c R (θ + 2 * π) = circleMap c R θ
state_after: no goals
Theorem: MeasureTheory.prob_compl_eq_zero_iff₀
File: Mathlib/MeasureTheory/Measure/Typeclasses.lean

tactic: rw [prob_compl_eq_one_sub₀ hs, tsub_eq_zero_iff_le, one_le_prob_iff]
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s t : Set α
inst✝ : IsProbabilityMeasure μ
p : α → Prop
f : β → α
hs : NullMeasurableSet s μ
⊢ μ sᶜ = 0 ↔ μ s = 1
state_after: no goals
Theorem: Set.empty_definable_iff
File: Mathlib/ModelTheory/Definability.lean

tactic: rw [Definable, Equiv.exists_congr_left (LEquiv.addEmptyConstants L (∅ : Set M)).onFormula]
state_before: M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s : Set (α → M)
⊢ ∅.Definable L s ↔ ∃ φ, s = setOf φ.Realize
state_after: M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s : Set (α → M)
⊢ (∃ φ, s = setOf φ.Realize) ↔ ∃ b, s = setOf ((LEquiv.addEmptyConstants L ↑∅).onFormula.symm b).Realize

tactic: simp [-constantsOn]
state_before: M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s : Set (α → M)
⊢ (∃ φ, s = setOf φ.Realize) ↔ ∃ b, s = setOf ((LEquiv.addEmptyConstants L ↑∅).onFormula.symm b).Realize
state_after: no goals
Theorem: Batteries.AssocList.toList_eraseP
File: .lake/packages/batteries/Batteries/Data/AssocList.lean

tactic: induction l <;> simp [List.eraseP, cond]
state_before: α : Type u_1
β : Type u_2
p : α → β → Bool
l : AssocList α β
⊢ (eraseP p l).toList =
    List.eraseP
      (fun x =>
        match x with
        | (a, b) => p a b)
      l.toList
state_after: case cons
α : Type u_1
β : Type u_2
p : α → β → Bool
key✝ : α
value✝ : β
tail✝ : AssocList α β
tail_ih✝ :
  (eraseP p tail✝).toList =
    List.eraseP
      (fun x =>
        match x with
        | (a, b) => p a b)
      tail✝.toList
⊢ (match p key✝ value✝ with
      | true => tail✝
      | false => cons key✝ value✝ (eraseP p tail✝)).toList =
    match p key✝ value✝ with
    | true => tail✝.toList
    | false => (key✝, value✝) :: List.eraseP (fun x => p x.fst x.snd) tail✝.toList

tactic: split <;> simp [*]
state_before: case cons
α : Type u_1
β : Type u_2
p : α → β → Bool
key✝ : α
value✝ : β
tail✝ : AssocList α β
tail_ih✝ :
  (eraseP p tail✝).toList =
    List.eraseP
      (fun x =>
        match x with
        | (a, b) => p a b)
      tail✝.toList
⊢ (match p key✝ value✝ with
      | true => tail✝
      | false => cons key✝ value✝ (eraseP p tail✝)).toList =
    match p key✝ value✝ with
    | true => tail✝.toList
    | false => (key✝, value✝) :: List.eraseP (fun x => p x.fst x.snd) tail✝.toList
state_after: no goals
Theorem: LinearMap.trace_mul_cycle'
File: Mathlib/LinearAlgebra/Trace.lean

tactic: rw [← mul_assoc, LinearMap.trace_mul_comm]
state_before: R : Type u
inst✝⁶ : CommSemiring R
M : Type v
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
ι : Type w
inst✝³ : DecidableEq ι
inst✝² : Fintype ι
κ : Type u_1
inst✝¹ : DecidableEq κ
inst✝ : Fintype κ
b : Basis ι R M
c : Basis κ R M
f g h : M →ₗ[R] M
⊢ (trace R M) (f * (g * h)) = (trace R M) (h * (f * g))
state_after: no goals
Theorem: Finset.Nat.antidiagonal_succ_succ'
File: Mathlib/Data/Finset/NatAntidiagonal.lean

tactic: simp
state_before: n : ℕ
⊢ (n + 2, 0) ∉
    map ({ toFun := Nat.succ, inj' := Nat.succ_injective }.prodMap { toFun := Nat.succ, inj' := Nat.succ_injective })
      (antidiagonal n)
state_after: no goals

tactic: simp
state_before: n : ℕ
⊢ (0, n + 2) ∉
    cons (n + 2, 0)
      (map ({ toFun := Nat.succ, inj' := Nat.succ_injective }.prodMap { toFun := Nat.succ, inj' := Nat.succ_injective })
        (antidiagonal n))
      ⋯
state_after: no goals

tactic: simp_rw [antidiagonal_succ (n + 1), antidiagonal_succ', Finset.map_cons, map_map]
state_before: n : ℕ
⊢ antidiagonal (n + 2) =
    cons (0, n + 2)
      (cons (n + 2, 0)
        (map
          ({ toFun := Nat.succ, inj' := Nat.succ_injective }.prodMap { toFun := Nat.succ, inj' := Nat.succ_injective })
          (antidiagonal n))
        ⋯)
      ⋯
state_after: n : ℕ
⊢ cons (0, n + 1 + 1)
      (cons (({ toFun := Nat.succ, inj' := Nat.succ_injective }.prodMap (Embedding.refl ℕ)) (n + 1, 0))
        (map
          (((Embedding.refl ℕ).prodMap { toFun := Nat.succ, inj' := Nat.succ_injective }).trans
            ({ toFun := Nat.succ, inj' := Nat.succ_injective }.prodMap (Embedding.refl ℕ)))
          (antidiagonal n))
        ⋯)
      ⋯ =
    cons (0, n + 2)
      (cons (n + 2, 0)
        (map
          ({ toFun := Nat.succ, inj' := Nat.succ_injective }.prodMap { toFun := Nat.succ, inj' := Nat.succ_injective })
          (antidiagonal n))
        ⋯)
      ⋯

tactic: rfl
state_before: n : ℕ
⊢ cons (0, n + 1 + 1)
      (cons (({ toFun := Nat.succ, inj' := Nat.succ_injective }.prodMap (Embedding.refl ℕ)) (n + 1, 0))
        (map
          (((Embedding.refl ℕ).prodMap { toFun := Nat.succ, inj' := Nat.succ_injective }).trans
            ({ toFun := Nat.succ, inj' := Nat.succ_injective }.prodMap (Embedding.refl ℕ)))
          (antidiagonal n))
        ⋯)
      ⋯ =
    cons (0, n + 2)
      (cons (n + 2, 0)
        (map
          ({ toFun := Nat.succ, inj' := Nat.succ_injective }.prodMap { toFun := Nat.succ, inj' := Nat.succ_injective })
          (antidiagonal n))
        ⋯)
      ⋯
state_after: no goals
Theorem: Uniform.continuousAt_iff'_left
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: rw [ContinuousAt, tendsto_nhds_left]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝¹ : UniformSpace α
inst✝ : TopologicalSpace β
f : β → α
b : β
⊢ ContinuousAt f b ↔ Tendsto (fun x => (f x, f b)) (𝓝 b) (𝓤 α)
state_after: no goals
Theorem: Nat.mem_properDivisors_iff_exists
File: Mathlib/NumberTheory/Divisors.lean

tactic: refine ⟨fun h ↦ ⟨n / m, one_lt_div_of_mem_properDivisors h, ?_⟩, ?_⟩
state_before: n✝ m n : ℕ
hn : n ≠ 0
⊢ m ∈ n.properDivisors ↔ ∃ k > 1, n = m * k
state_after: case refine_1
n✝ m n : ℕ
hn : n ≠ 0
h : m ∈ n.properDivisors
⊢ n = m * (n / m)

case refine_2
n✝ m n : ℕ
hn : n ≠ 0
⊢ (∃ k > 1, n = m * k) → m ∈ n.properDivisors

tactic: exact (Nat.mul_div_cancel' (mem_properDivisors.mp h).1).symm
state_before: case refine_1
n✝ m n : ℕ
hn : n ≠ 0
h : m ∈ n.properDivisors
⊢ n = m * (n / m)
state_after: no goals

tactic: rintro ⟨k, hk, rfl⟩
state_before: case refine_2
n✝ m n : ℕ
hn : n ≠ 0
⊢ (∃ k > 1, n = m * k) → m ∈ n.properDivisors
state_after: case refine_2.intro.intro
n m k : ℕ
hk : k > 1
hn : m * k ≠ 0
⊢ m ∈ (m * k).properDivisors

tactic: rw [mul_ne_zero_iff] at hn
state_before: case refine_2.intro.intro
n m k : ℕ
hk : k > 1
hn : m * k ≠ 0
⊢ m ∈ (m * k).properDivisors
state_after: case refine_2.intro.intro
n m k : ℕ
hk : k > 1
hn : m ≠ 0 ∧ k ≠ 0
⊢ m ∈ (m * k).properDivisors

tactic: exact mem_properDivisors.mpr ⟨⟨k, rfl⟩, lt_mul_of_one_lt_right (Nat.pos_of_ne_zero hn.1) hk⟩
state_before: case refine_2.intro.intro
n m k : ℕ
hk : k > 1
hn : m ≠ 0 ∧ k ≠ 0
⊢ m ∈ (m * k).properDivisors
state_after: no goals
Theorem: FractionalIdeal.spanSingleton_mul_coeIdeal_eq_coeIdeal
File: Mathlib/RingTheory/FractionalIdeal/Operations.lean

tactic: rw [← mk'_mul_coeIdeal_eq_coeIdeal K (IsLocalization.sec R₁⁰ z).2.prop,
  IsLocalization.mk'_sec K z]
state_before: R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_3
inst✝³ : CommRing R₁
K : Type u_4
inst✝² : Field K
inst✝¹ : Algebra R₁ K
inst✝ : IsFractionRing R₁ K
I J : Ideal R₁
z : K
⊢ spanSingleton R₁⁰ z * ↑I = ↑J ↔ Ideal.span {(sec R₁⁰ z).1} * I = Ideal.span {↑(sec R₁⁰ z).2} * J
state_after: no goals
Theorem: Monotone.seq_le_seq
File: Mathlib/Order/Iterate.lean

tactic: induction' n with n ihn
state_before: α : Type u_1
inst✝ : Preorder α
f : α → α
x y : ℕ → α
hf : Monotone f
n : ℕ
h₀ : x 0 ≤ y 0
hx : ∀ (k : ℕ), k < n → x (k + 1) ≤ f (x k)
hy : ∀ (k : ℕ), k < n → f (y k) ≤ y (k + 1)
⊢ x n ≤ y n
state_after: case zero
α : Type u_1
inst✝ : Preorder α
f : α → α
x y : ℕ → α
hf : Monotone f
h₀ : x 0 ≤ y 0
hx : ∀ (k : ℕ), k < 0 → x (k + 1) ≤ f (x k)
hy : ∀ (k : ℕ), k < 0 → f (y k) ≤ y (k + 1)
⊢ x 0 ≤ y 0

case succ
α : Type u_1
inst✝ : Preorder α
f : α → α
x y : ℕ → α
hf : Monotone f
h₀ : x 0 ≤ y 0
n : ℕ
ihn : (∀ (k : ℕ), k < n → x (k + 1) ≤ f (x k)) → (∀ (k : ℕ), k < n → f (y k) ≤ y (k + 1)) → x n ≤ y n
hx : ∀ (k : ℕ), k < n + 1 → x (k + 1) ≤ f (x k)
hy : ∀ (k : ℕ), k < n + 1 → f (y k) ≤ y (k + 1)
⊢ x (n + 1) ≤ y (n + 1)

tactic: exact h₀
state_before: case zero
α : Type u_1
inst✝ : Preorder α
f : α → α
x y : ℕ → α
hf : Monotone f
h₀ : x 0 ≤ y 0
hx : ∀ (k : ℕ), k < 0 → x (k + 1) ≤ f (x k)
hy : ∀ (k : ℕ), k < 0 → f (y k) ≤ y (k + 1)
⊢ x 0 ≤ y 0
state_after: no goals

tactic: refine (hx _ n.lt_succ_self).trans ((hf <| ihn ?_ ?_).trans (hy _ n.lt_succ_self))
state_before: case succ
α : Type u_1
inst✝ : Preorder α
f : α → α
x y : ℕ → α
hf : Monotone f
h₀ : x 0 ≤ y 0
n : ℕ
ihn : (∀ (k : ℕ), k < n → x (k + 1) ≤ f (x k)) → (∀ (k : ℕ), k < n → f (y k) ≤ y (k + 1)) → x n ≤ y n
hx : ∀ (k : ℕ), k < n + 1 → x (k + 1) ≤ f (x k)
hy : ∀ (k : ℕ), k < n + 1 → f (y k) ≤ y (k + 1)
⊢ x (n + 1) ≤ y (n + 1)
state_after: case succ.refine_1
α : Type u_1
inst✝ : Preorder α
f : α → α
x y : ℕ → α
hf : Monotone f
h₀ : x 0 ≤ y 0
n : ℕ
ihn : (∀ (k : ℕ), k < n → x (k + 1) ≤ f (x k)) → (∀ (k : ℕ), k < n → f (y k) ≤ y (k + 1)) → x n ≤ y n
hx : ∀ (k : ℕ), k < n + 1 → x (k + 1) ≤ f (x k)
hy : ∀ (k : ℕ), k < n + 1 → f (y k) ≤ y (k + 1)
⊢ ∀ (k : ℕ), k < n → x (k + 1) ≤ f (x k)

case succ.refine_2
α : Type u_1
inst✝ : Preorder α
f : α → α
x y : ℕ → α
hf : Monotone f
h₀ : x 0 ≤ y 0
n : ℕ
ihn : (∀ (k : ℕ), k < n → x (k + 1) ≤ f (x k)) → (∀ (k : ℕ), k < n → f (y k) ≤ y (k + 1)) → x n ≤ y n
hx : ∀ (k : ℕ), k < n + 1 → x (k + 1) ≤ f (x k)
hy : ∀ (k : ℕ), k < n + 1 → f (y k) ≤ y (k + 1)
⊢ ∀ (k : ℕ), k < n → f (y k) ≤ y (k + 1)

tactic: exact fun k hk => hx _ (hk.trans n.lt_succ_self)
state_before: case succ.refine_1
α : Type u_1
inst✝ : Preorder α
f : α → α
x y : ℕ → α
hf : Monotone f
h₀ : x 0 ≤ y 0
n : ℕ
ihn : (∀ (k : ℕ), k < n → x (k + 1) ≤ f (x k)) → (∀ (k : ℕ), k < n → f (y k) ≤ y (k + 1)) → x n ≤ y n
hx : ∀ (k : ℕ), k < n + 1 → x (k + 1) ≤ f (x k)
hy : ∀ (k : ℕ), k < n + 1 → f (y k) ≤ y (k + 1)
⊢ ∀ (k : ℕ), k < n → x (k + 1) ≤ f (x k)
state_after: no goals

tactic: exact fun k hk => hy _ (hk.trans n.lt_succ_self)
state_before: case succ.refine_2
α : Type u_1
inst✝ : Preorder α
f : α → α
x y : ℕ → α
hf : Monotone f
h₀ : x 0 ≤ y 0
n : ℕ
ihn : (∀ (k : ℕ), k < n → x (k + 1) ≤ f (x k)) → (∀ (k : ℕ), k < n → f (y k) ≤ y (k + 1)) → x n ≤ y n
hx : ∀ (k : ℕ), k < n + 1 → x (k + 1) ≤ f (x k)
hy : ∀ (k : ℕ), k < n + 1 → f (y k) ≤ y (k + 1)
⊢ ∀ (k : ℕ), k < n → f (y k) ≤ y (k + 1)
state_after: no goals
Theorem: WeierstrassCurve.Jacobian.Y_eq_of_equiv
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

tactic: rcases h with ⟨u, rfl⟩
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P Q : Fin 3 → R
h : P ≈ Q
⊢ P y * Q z ^ 3 = Q y * P z ^ 3
state_after: case intro
R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
Q : Fin 3 → R
u : Rˣ
⊢ (fun m => m • Q) u y * Q z ^ 3 = Q y * (fun m => m • Q) u z ^ 3

tactic: simp only [Units.smul_def, smul_fin3_ext]
state_before: case intro
R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
Q : Fin 3 → R
u : Rˣ
⊢ (fun m => m • Q) u y * Q z ^ 3 = Q y * (fun m => m • Q) u z ^ 3
state_after: case intro
R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
Q : Fin 3 → R
u : Rˣ
⊢ ↑u ^ 3 * Q y * Q z ^ 3 = Q y * (↑u * Q z) ^ 3

tactic: ring1
state_before: case intro
R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
Q : Fin 3 → R
u : Rˣ
⊢ ↑u ^ 3 * Q y * Q z ^ 3 = Q y * (↑u * Q z) ^ 3
state_after: no goals
Theorem: DFinsupp.equivFunOnFintype_single
File: Mathlib/Data/DFinsupp/Basic.lean

tactic: ext x
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
s : Finset ι
x : (i : ↑↑s) → β ↑i
i✝ : ι
inst✝ : Fintype ι
i : ι
m : β i
⊢ equivFunOnFintype (single i m) = Pi.single i m
state_after: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
s : Finset ι
x✝ : (i : ↑↑s) → β ↑i
i✝ : ι
inst✝ : Fintype ι
i : ι
m : β i
x : ι
⊢ equivFunOnFintype (single i m) x = Pi.single i m x

tactic: dsimp [Pi.single, Function.update]
state_before: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
s : Finset ι
x✝ : (i : ↑↑s) → β ↑i
i✝ : ι
inst✝ : Fintype ι
i : ι
m : β i
x : ι
⊢ equivFunOnFintype (single i m) x = Pi.single i m x
state_after: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
s : Finset ι
x✝ : (i : ↑↑s) → β ↑i
i✝ : ι
inst✝ : Fintype ι
i : ι
m : β i
x : ι
⊢ (single i m) x = if h : x = i then ⋯ ▸ m else 0

tactic: simp [DFinsupp.single_eq_pi_single, @eq_comm _ i]
state_before: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
s : Finset ι
x✝ : (i : ↑↑s) → β ↑i
i✝ : ι
inst✝ : Fintype ι
i : ι
m : β i
x : ι
⊢ (single i m) x = if h : x = i then ⋯ ▸ m else 0
state_after: no goals