1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: List.Sublist.sym2
File: Mathlib/Data/List/Sym.lean

tactic: induction h with
| slnil => apply slnil
| cons a h ih =>
  simp only [List.sym2]
  exact Sublist.append (nil_sublist _) ih
| cons₂ a h ih =>
  simp only [List.sym2, map_cons, cons_append]
  exact cons₂ _ (append (Sublist.map _ h) ih)
state_before: α : Type u_1
xs ys : List α
h : xs <+ ys
⊢ xs.sym2 <+ ys.sym2
state_after: no goals

tactic: apply slnil
state_before: case slnil
α : Type u_1
xs ys : List α
⊢ [].sym2 <+ [].sym2
state_after: no goals

tactic: simp only [List.sym2]
state_before: case cons
α : Type u_1
xs ys l₁✝ l₂✝ : List α
a : α
h : l₁✝ <+ l₂✝
ih : l₁✝.sym2 <+ l₂✝.sym2
⊢ l₁✝.sym2 <+ (a :: l₂✝).sym2
state_after: case cons
α : Type u_1
xs ys l₁✝ l₂✝ : List α
a : α
h : l₁✝ <+ l₂✝
ih : l₁✝.sym2 <+ l₂✝.sym2
⊢ l₁✝.sym2 <+ List.map (fun y => s(a, y)) (a :: l₂✝) ++ l₂✝.sym2

tactic: exact Sublist.append (nil_sublist _) ih
state_before: case cons
α : Type u_1
xs ys l₁✝ l₂✝ : List α
a : α
h : l₁✝ <+ l₂✝
ih : l₁✝.sym2 <+ l₂✝.sym2
⊢ l₁✝.sym2 <+ List.map (fun y => s(a, y)) (a :: l₂✝) ++ l₂✝.sym2
state_after: no goals

tactic: simp only [List.sym2, map_cons, cons_append]
state_before: case cons₂
α : Type u_1
xs ys l₁✝ l₂✝ : List α
a : α
h : l₁✝ <+ l₂✝
ih : l₁✝.sym2 <+ l₂✝.sym2
⊢ (a :: l₁✝).sym2 <+ (a :: l₂✝).sym2
state_after: case cons₂
α : Type u_1
xs ys l₁✝ l₂✝ : List α
a : α
h : l₁✝ <+ l₂✝
ih : l₁✝.sym2 <+ l₂✝.sym2
⊢ s(a, a) :: (List.map (fun y => s(a, y)) l₁✝ ++ l₁✝.sym2) <+ s(a, a) :: (List.map (fun y => s(a, y)) l₂✝ ++ l₂✝.sym2)

tactic: exact cons₂ _ (append (Sublist.map _ h) ih)
state_before: case cons₂
α : Type u_1
xs ys l₁✝ l₂✝ : List α
a : α
h : l₁✝ <+ l₂✝
ih : l₁✝.sym2 <+ l₂✝.sym2
⊢ s(a, a) :: (List.map (fun y => s(a, y)) l₁✝ ++ l₁✝.sym2) <+ s(a, a) :: (List.map (fun y => s(a, y)) l₂✝ ++ l₂✝.sym2)
state_after: no goals
Theorem: ENNReal.sub_half
File: Mathlib/Data/ENNReal/Inv.lean

tactic: lift a to ℝ≥0 using h
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
h : a ≠ ⊤
⊢ a - a / 2 = a / 2
state_after: case intro
b c d : ℝ≥0∞
r p q a : ℝ≥0
⊢ ↑a - ↑a / 2 = ↑a / 2

tactic: exact sub_eq_of_add_eq (mul_ne_top coe_ne_top <| by simp) (ENNReal.add_halves a)
state_before: case intro
b c d : ℝ≥0∞
r p q a : ℝ≥0
⊢ ↑a - ↑a / 2 = ↑a / 2
state_after: no goals

tactic: simp
state_before: b c d : ℝ≥0∞
r p q a : ℝ≥0
⊢ 2⁻¹ ≠ ⊤
state_after: no goals
Theorem: Matrix.invOf_fromBlocks₂₂_eq
File: Mathlib/LinearAlgebra/Matrix/SchurComplement.lean

tactic: letI := fromBlocks₂₂Invertible A B C D
state_before: l : Type u_1
m : Type u_2
n : Type u_3
α : Type u_4
inst✝⁹ : Fintype l
inst✝⁸ : Fintype m
inst✝⁷ : Fintype n
inst✝⁶ : DecidableEq l
inst✝⁵ : DecidableEq m
inst✝⁴ : DecidableEq n
inst✝³ : CommRing α
A : Matrix m m α
B : Matrix m n α
C : Matrix n m α
D : Matrix n n α
inst✝² : Invertible D
inst✝¹ : Invertible (A - B * ⅟D * C)
inst✝ : Invertible (fromBlocks A B C D)
⊢ ⅟(fromBlocks A B C D) =
    fromBlocks (⅟(A - B * ⅟D * C)) (-(⅟(A - B * ⅟D * C) * B * ⅟D)) (-(⅟D * C * ⅟(A - B * ⅟D * C)))
      (⅟D + ⅟D * C * ⅟(A - B * ⅟D * C) * B * ⅟D)
state_after: l : Type u_1
m : Type u_2
n : Type u_3
α : Type u_4
inst✝⁹ : Fintype l
inst✝⁸ : Fintype m
inst✝⁷ : Fintype n
inst✝⁶ : DecidableEq l
inst✝⁵ : DecidableEq m
inst✝⁴ : DecidableEq n
inst✝³ : CommRing α
A : Matrix m m α
B : Matrix m n α
C : Matrix n m α
D : Matrix n n α
inst✝² : Invertible D
inst✝¹ : Invertible (A - B * ⅟D * C)
inst✝ : Invertible (fromBlocks A B C D)
this : Invertible (fromBlocks A B C D) := A.fromBlocks₂₂Invertible B C D
⊢ ⅟(fromBlocks A B C D) =
    fromBlocks (⅟(A - B * ⅟D * C)) (-(⅟(A - B * ⅟D * C) * B * ⅟D)) (-(⅟D * C * ⅟(A - B * ⅟D * C)))
      (⅟D + ⅟D * C * ⅟(A - B * ⅟D * C) * B * ⅟D)

tactic: convert (rfl : ⅟ (fromBlocks A B C D) = _)
state_before: l : Type u_1
m : Type u_2
n : Type u_3
α : Type u_4
inst✝⁹ : Fintype l
inst✝⁸ : Fintype m
inst✝⁷ : Fintype n
inst✝⁶ : DecidableEq l
inst✝⁵ : DecidableEq m
inst✝⁴ : DecidableEq n
inst✝³ : CommRing α
A : Matrix m m α
B : Matrix m n α
C : Matrix n m α
D : Matrix n n α
inst✝² : Invertible D
inst✝¹ : Invertible (A - B * ⅟D * C)
inst✝ : Invertible (fromBlocks A B C D)
this : Invertible (fromBlocks A B C D) := A.fromBlocks₂₂Invertible B C D
⊢ ⅟(fromBlocks A B C D) =
    fromBlocks (⅟(A - B * ⅟D * C)) (-(⅟(A - B * ⅟D * C) * B * ⅟D)) (-(⅟D * C * ⅟(A - B * ⅟D * C)))
      (⅟D + ⅟D * C * ⅟(A - B * ⅟D * C) * B * ⅟D)
state_after: no goals
Theorem: ContinuousAffineMap.decomp
File: Mathlib/Analysis/NormedSpace/ContinuousAffineMap.lean

tactic: rcases f with ⟨f, h⟩
state_before: 𝕜 : Type u_1
R : Type u_2
V : Type u_3
W : Type u_4
W₂ : Type u_5
P : Type u_6
Q : Type u_7
Q₂ : Type u_8
inst✝¹⁶ : NormedAddCommGroup V
inst✝¹⁵ : MetricSpace P
inst✝¹⁴ : NormedAddTorsor V P
inst✝¹³ : NormedAddCommGroup W
inst✝¹² : MetricSpace Q
inst✝¹¹ : NormedAddTorsor W Q
inst✝¹⁰ : NormedAddCommGroup W₂
inst✝⁹ : MetricSpace Q₂
inst✝⁸ : NormedAddTorsor W₂ Q₂
inst✝⁷ : NormedField R
inst✝⁶ : NormedSpace R V
inst✝⁵ : NormedSpace R W
inst✝⁴ : NormedSpace R W₂
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedSpace 𝕜 V
inst✝¹ : NormedSpace 𝕜 W
inst✝ : NormedSpace 𝕜 W₂
f : V →ᴬ[R] W
⊢ ⇑f = ⇑f.contLinear + Function.const V (f 0)
state_after: case mk
𝕜 : Type u_1
R : Type u_2
V : Type u_3
W : Type u_4
W₂ : Type u_5
P : Type u_6
Q : Type u_7
Q₂ : Type u_8
inst✝¹⁶ : NormedAddCommGroup V
inst✝¹⁵ : MetricSpace P
inst✝¹⁴ : NormedAddTorsor V P
inst✝¹³ : NormedAddCommGroup W
inst✝¹² : MetricSpace Q
inst✝¹¹ : NormedAddTorsor W Q
inst✝¹⁰ : NormedAddCommGroup W₂
inst✝⁹ : MetricSpace Q₂
inst✝⁸ : NormedAddTorsor W₂ Q₂
inst✝⁷ : NormedField R
inst✝⁶ : NormedSpace R V
inst✝⁵ : NormedSpace R W
inst✝⁴ : NormedSpace R W₂
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedSpace 𝕜 V
inst✝¹ : NormedSpace 𝕜 W
inst✝ : NormedSpace 𝕜 W₂
f : V →ᵃ[R] W
h : Continuous f.toFun
⊢ ⇑{ toAffineMap := f, cont := h } =
    ⇑{ toAffineMap := f, cont := h }.contLinear + Function.const V ({ toAffineMap := f, cont := h } 0)

tactic: rw [coe_mk_const_linear_eq_linear, coe_mk, f.decomp, Pi.add_apply, LinearMap.map_zero, zero_add,
  ← Function.const_def]
state_before: case mk
𝕜 : Type u_1
R : Type u_2
V : Type u_3
W : Type u_4
W₂ : Type u_5
P : Type u_6
Q : Type u_7
Q₂ : Type u_8
inst✝¹⁶ : NormedAddCommGroup V
inst✝¹⁵ : MetricSpace P
inst✝¹⁴ : NormedAddTorsor V P
inst✝¹³ : NormedAddCommGroup W
inst✝¹² : MetricSpace Q
inst✝¹¹ : NormedAddTorsor W Q
inst✝¹⁰ : NormedAddCommGroup W₂
inst✝⁹ : MetricSpace Q₂
inst✝⁸ : NormedAddTorsor W₂ Q₂
inst✝⁷ : NormedField R
inst✝⁶ : NormedSpace R V
inst✝⁵ : NormedSpace R W
inst✝⁴ : NormedSpace R W₂
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedSpace 𝕜 V
inst✝¹ : NormedSpace 𝕜 W
inst✝ : NormedSpace 𝕜 W₂
f : V →ᵃ[R] W
h : Continuous f.toFun
⊢ ⇑{ toAffineMap := f, cont := h } =
    ⇑{ toAffineMap := f, cont := h }.contLinear + Function.const V ({ toAffineMap := f, cont := h } 0)
state_after: no goals
Theorem: mem_span_gramSchmidt
File: Mathlib/Analysis/InnerProductSpace/GramSchmidtOrtho.lean

tactic: rw [gramSchmidt_def' 𝕜 f i]
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝⁵ : RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : InnerProductSpace 𝕜 E
ι : Type u_3
inst✝² : LinearOrder ι
inst✝¹ : LocallyFiniteOrderBot ι
inst✝ : IsWellOrder ι fun x x_1 => x < x_1
f : ι → E
i j : ι
hij : i ≤ j
⊢ f i ∈ span 𝕜 (gramSchmidt 𝕜 f '' Set.Iic j)
state_after: 𝕜 : Type u_1
E : Type u_2
inst✝⁵ : RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : InnerProductSpace 𝕜 E
ι : Type u_3
inst✝² : LinearOrder ι
inst✝¹ : LocallyFiniteOrderBot ι
inst✝ : IsWellOrder ι fun x x_1 => x < x_1
f : ι → E
i j : ι
hij : i ≤ j
⊢ gramSchmidt 𝕜 f i + ∑ i_1 ∈ Finset.Iio i, ↑((orthogonalProjection (span 𝕜 {gramSchmidt 𝕜 f i_1})) (f i)) ∈
    span 𝕜 (gramSchmidt 𝕜 f '' Set.Iic j)

tactic: simp_rw [orthogonalProjection_singleton]
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝⁵ : RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : InnerProductSpace 𝕜 E
ι : Type u_3
inst✝² : LinearOrder ι
inst✝¹ : LocallyFiniteOrderBot ι
inst✝ : IsWellOrder ι fun x x_1 => x < x_1
f : ι → E
i j : ι
hij : i ≤ j
⊢ gramSchmidt 𝕜 f i + ∑ i_1 ∈ Finset.Iio i, ↑((orthogonalProjection (span 𝕜 {gramSchmidt 𝕜 f i_1})) (f i)) ∈
    span 𝕜 (gramSchmidt 𝕜 f '' Set.Iic j)
state_after: 𝕜 : Type u_1
E : Type u_2
inst✝⁵ : RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : InnerProductSpace 𝕜 E
ι : Type u_3
inst✝² : LinearOrder ι
inst✝¹ : LocallyFiniteOrderBot ι
inst✝ : IsWellOrder ι fun x x_1 => x < x_1
f : ι → E
i j : ι
hij : i ≤ j
⊢ gramSchmidt 𝕜 f i +
      ∑ x ∈ Finset.Iio i, (⟪gramSchmidt 𝕜 f x, f i⟫_𝕜 / ↑(‖gramSchmidt 𝕜 f x‖ ^ 2)) • gramSchmidt 𝕜 f x ∈
    span 𝕜 (gramSchmidt 𝕜 f '' Set.Iic j)

tactic: exact Submodule.add_mem _ (subset_span <| mem_image_of_mem _ hij)
  (Submodule.sum_mem _ fun k hk => smul_mem (span 𝕜 (gramSchmidt 𝕜 f '' Set.Iic j)) _ <|
    subset_span <| mem_image_of_mem (gramSchmidt 𝕜 f) <| (Finset.mem_Iio.1 hk).le.trans hij)
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝⁵ : RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : InnerProductSpace 𝕜 E
ι : Type u_3
inst✝² : LinearOrder ι
inst✝¹ : LocallyFiniteOrderBot ι
inst✝ : IsWellOrder ι fun x x_1 => x < x_1
f : ι → E
i j : ι
hij : i ≤ j
⊢ gramSchmidt 𝕜 f i +
      ∑ x ∈ Finset.Iio i, (⟪gramSchmidt 𝕜 f x, f i⟫_𝕜 / ↑(‖gramSchmidt 𝕜 f x‖ ^ 2)) • gramSchmidt 𝕜 f x ∈
    span 𝕜 (gramSchmidt 𝕜 f '' Set.Iic j)
state_after: no goals
Theorem: WeierstrassCurve.Affine.equation_add_iff
File: Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean

tactic: rw [Equation, negAddY, addPolynomial, linePolynomial, polynomial]
state_before: R : Type u
inst✝ : CommRing R
W : Affine R
x₁ x₂ y₁ L : R
⊢ W.Equation (W.addX x₁ x₂ L) (W.negAddY x₁ x₂ y₁ L) ↔ eval (W.addX x₁ x₂ L) (W.addPolynomial x₁ y₁ L) = 0
state_after: R : Type u
inst✝ : CommRing R
W : Affine R
x₁ x₂ y₁ L : R
⊢ evalEval (W.addX x₁ x₂ L) (L * (W.addX x₁ x₂ L - x₁) + y₁)
        (Y ^ 2 + C (C W.a₁ * X + C W.a₃) * Y - C (X ^ 3 + C W.a₂ * X ^ 2 + C W.a₄ * X + C W.a₆)) =
      0 ↔
    eval (W.addX x₁ x₂ L)
        (eval (C L * (X - C x₁) + C y₁)
          (Y ^ 2 + C (C W.a₁ * X + C W.a₃) * Y - C (X ^ 3 + C W.a₂ * X ^ 2 + C W.a₄ * X + C W.a₆))) =
      0

tactic: eval_simp
state_before: R : Type u
inst✝ : CommRing R
W : Affine R
x₁ x₂ y₁ L : R
⊢ evalEval (W.addX x₁ x₂ L) (L * (W.addX x₁ x₂ L - x₁) + y₁)
        (Y ^ 2 + C (C W.a₁ * X + C W.a₃) * Y - C (X ^ 3 + C W.a₂ * X ^ 2 + C W.a₄ * X + C W.a₆)) =
      0 ↔
    eval (W.addX x₁ x₂ L)
        (eval (C L * (X - C x₁) + C y₁)
          (Y ^ 2 + C (C W.a₁ * X + C W.a₃) * Y - C (X ^ 3 + C W.a₂ * X ^ 2 + C W.a₄ * X + C W.a₆))) =
      0
state_after: no goals
Theorem: GaussianInt.toComplex_def₂
File: Mathlib/NumberTheory/Zsqrtd/GaussianInt.lean

tactic: apply Complex.ext <;> simp [toComplex_def]
state_before: x : ℤ[i]
⊢ toComplex x = { re := ↑x.re, im := ↑x.im }
state_after: no goals
Theorem: MvPolynomial.degreeOf_C
File: Mathlib/Algebra/MvPolynomial/Degrees.lean

tactic: classical simp [degreeOf_def, degrees_C]
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
a : R
x : σ
⊢ degreeOf x (C a) = 0
state_after: no goals

tactic: simp [degreeOf_def, degrees_C]
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
a : R
x : σ
⊢ degreeOf x (C a) = 0
state_after: no goals
Theorem: SimpleGraph.isClique_map_finset_iff
File: Mathlib/Combinatorics/SimpleGraph/Clique.lean

tactic: obtain (ht | ht) := le_or_lt t.card 1
state_before: α : Type u_1
β : Type u_2
G H : SimpleGraph α
s t✝ : Set α
a b : α
inst✝ : DecidableEq β
f : α ↪ β
t : Finset β
⊢ (SimpleGraph.map f G).IsClique ↑t ↔ t.card ≤ 1 ∨ ∃ s, G.IsClique ↑s ∧ map f s = t
state_after: case inl
α : Type u_1
β : Type u_2
G H : SimpleGraph α
s t✝ : Set α
a b : α
inst✝ : DecidableEq β
f : α ↪ β
t : Finset β
ht : t.card ≤ 1
⊢ (SimpleGraph.map f G).IsClique ↑t ↔ t.card ≤ 1 ∨ ∃ s, G.IsClique ↑s ∧ map f s = t

case inr
α : Type u_1
β : Type u_2
G H : SimpleGraph α
s t✝ : Set α
a b : α
inst✝ : DecidableEq β
f : α ↪ β
t : Finset β
ht : 1 < t.card
⊢ (SimpleGraph.map f G).IsClique ↑t ↔ t.card ≤ 1 ∨ ∃ s, G.IsClique ↑s ∧ map f s = t

tactic: rw [isClique_map_finset_iff_of_nontrivial, ← not_lt]
state_before: case inr
α : Type u_1
β : Type u_2
G H : SimpleGraph α
s t✝ : Set α
a b : α
inst✝ : DecidableEq β
f : α ↪ β
t : Finset β
ht : 1 < t.card
⊢ (SimpleGraph.map f G).IsClique ↑t ↔ t.card ≤ 1 ∨ ∃ s, G.IsClique ↑s ∧ map f s = t
state_after: case inr
α : Type u_1
β : Type u_2
G H : SimpleGraph α
s t✝ : Set α
a b : α
inst✝ : DecidableEq β
f : α ↪ β
t : Finset β
ht : 1 < t.card
⊢ (∃ s, G.IsClique ↑s ∧ map f s = t) ↔ ¬1 < t.card ∨ ∃ s, G.IsClique ↑s ∧ map f s = t

case inr
α : Type u_1
β : Type u_2
G H : SimpleGraph α
s t✝ : Set α
a b : α
inst✝ : DecidableEq β
f : α ↪ β
t : Finset β
ht : 1 < t.card
⊢ t.Nontrivial

tactic: exact Finset.one_lt_card_iff_nontrivial.mp ht
state_before: case inr
α : Type u_1
β : Type u_2
G H : SimpleGraph α
s t✝ : Set α
a b : α
inst✝ : DecidableEq β
f : α ↪ β
t : Finset β
ht : 1 < t.card
⊢ t.Nontrivial
state_after: no goals

tactic: simp only [ht, true_or, iff_true]
state_before: case inl
α : Type u_1
β : Type u_2
G H : SimpleGraph α
s t✝ : Set α
a b : α
inst✝ : DecidableEq β
f : α ↪ β
t : Finset β
ht : t.card ≤ 1
⊢ (SimpleGraph.map f G).IsClique ↑t ↔ t.card ≤ 1 ∨ ∃ s, G.IsClique ↑s ∧ map f s = t
state_after: case inl
α : Type u_1
β : Type u_2
G H : SimpleGraph α
s t✝ : Set α
a b : α
inst✝ : DecidableEq β
f : α ↪ β
t : Finset β
ht : t.card ≤ 1
⊢ (SimpleGraph.map f G).IsClique ↑t

tactic: exact IsClique.of_subsingleton <| card_le_one.1 ht
state_before: case inl
α : Type u_1
β : Type u_2
G H : SimpleGraph α
s t✝ : Set α
a b : α
inst✝ : DecidableEq β
f : α ↪ β
t : Finset β
ht : t.card ≤ 1
⊢ (SimpleGraph.map f G).IsClique ↑t
state_after: no goals

tactic: simp [ht, Finset.map_eq_image]
state_before: case inr
α : Type u_1
β : Type u_2
G H : SimpleGraph α
s t✝ : Set α
a b : α
inst✝ : DecidableEq β
f : α ↪ β
t : Finset β
ht : 1 < t.card
⊢ (∃ s, G.IsClique ↑s ∧ map f s = t) ↔ ¬1 < t.card ∨ ∃ s, G.IsClique ↑s ∧ map f s = t
state_after: no goals
Theorem: Stream'.iterate_eq
File: Mathlib/Data/Stream/Init.lean

tactic: rw [← Stream'.eta (iterate f a)]
state_before: α : Type u
β : Type v
δ : Type w
f : α → α
a : α
⊢ iterate f a = a :: iterate f (f a)
state_after: α : Type u
β : Type v
δ : Type w
f : α → α
a : α
⊢ (iterate f a).head :: (iterate f a).tail = a :: iterate f (f a)

tactic: rw [tail_iterate]
state_before: α : Type u
β : Type v
δ : Type w
f : α → α
a : α
⊢ (iterate f a).head :: (iterate f a).tail = a :: iterate f (f a)
state_after: α : Type u
β : Type v
δ : Type w
f : α → α
a : α
⊢ (iterate f a).head :: iterate f (f a) = a :: iterate f (f a)

tactic: rfl
state_before: α : Type u
β : Type v
δ : Type w
f : α → α
a : α
⊢ (iterate f a).head :: iterate f (f a) = a :: iterate f (f a)
state_after: no goals
Theorem: Int.eq_pow_of_mul_eq_pow_bit1_left
File: Mathlib/RingTheory/Int/Basic.lean

tactic: obtain ⟨d, hd⟩ := exists_associated_pow_of_mul_eq_pow' hab h
state_before: a b c : ℤ
hab : IsCoprime a b
k : ℕ
h : a * b = c ^ bit1 k
⊢ ∃ d, a = d ^ bit1 k
state_after: case intro
a b c : ℤ
hab : IsCoprime a b
k : ℕ
h : a * b = c ^ bit1 k
d : ℤ
hd : Associated (d ^ bit1 k) a
⊢ ∃ d, a = d ^ bit1 k

tactic: replace hd := hd.symm
state_before: case intro
a b c : ℤ
hab : IsCoprime a b
k : ℕ
h : a * b = c ^ bit1 k
d : ℤ
hd : Associated (d ^ bit1 k) a
⊢ ∃ d, a = d ^ bit1 k
state_after: case intro
a b c : ℤ
hab : IsCoprime a b
k : ℕ
h : a * b = c ^ bit1 k
d : ℤ
hd : Associated a (d ^ bit1 k)
⊢ ∃ d, a = d ^ bit1 k

tactic: rw [associated_iff_natAbs, natAbs_eq_natAbs_iff, ← neg_pow_bit1] at hd
state_before: case intro
a b c : ℤ
hab : IsCoprime a b
k : ℕ
h : a * b = c ^ bit1 k
d : ℤ
hd : Associated a (d ^ bit1 k)
⊢ ∃ d, a = d ^ bit1 k
state_after: case intro
a b c : ℤ
hab : IsCoprime a b
k : ℕ
h : a * b = c ^ bit1 k
d : ℤ
hd : a = d ^ bit1 k ∨ a = (-d) ^ bit1 k
⊢ ∃ d, a = d ^ bit1 k

tactic: obtain rfl | rfl := hd <;> exact ⟨_, rfl⟩
state_before: case intro
a b c : ℤ
hab : IsCoprime a b
k : ℕ
h : a * b = c ^ bit1 k
d : ℤ
hd : a = d ^ bit1 k ∨ a = (-d) ^ bit1 k
⊢ ∃ d, a = d ^ bit1 k
state_after: no goals
Theorem: MultilinearMap.linearDeriv_apply
File: Mathlib/LinearAlgebra/Multilinear/Basic.lean

tactic: unfold linearDeriv
state_before: R : Type uR
S : Type uS
ι : Type uι
n : ℕ
M : Fin n.succ → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝¹² : Semiring R
inst✝¹¹ : (i : Fin n.succ) → AddCommMonoid (M i)
inst✝¹⁰ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁹ : AddCommMonoid M₂
inst✝⁸ : AddCommMonoid M₃
inst✝⁷ : AddCommMonoid M'
inst✝⁶ : (i : Fin n.succ) → Module R (M i)
inst✝⁵ : (i : ι) → Module R (M₁ i)
inst✝⁴ : Module R M₂
inst✝³ : Module R M₃
inst✝² : Module R M'
f✝ f' : MultilinearMap R M₁ M₂
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
f : MultilinearMap R M₁ M₂
x y : (i : ι) → M₁ i
⊢ (f.linearDeriv x) y = ∑ i : ι, f (update x i (y i))
state_after: R : Type uR
S : Type uS
ι : Type uι
n : ℕ
M : Fin n.succ → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝¹² : Semiring R
inst✝¹¹ : (i : Fin n.succ) → AddCommMonoid (M i)
inst✝¹⁰ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁹ : AddCommMonoid M₂
inst✝⁸ : AddCommMonoid M₃
inst✝⁷ : AddCommMonoid M'
inst✝⁶ : (i : Fin n.succ) → Module R (M i)
inst✝⁵ : (i : ι) → Module R (M₁ i)
inst✝⁴ : Module R M₂
inst✝³ : Module R M₃
inst✝² : Module R M'
f✝ f' : MultilinearMap R M₁ M₂
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
f : MultilinearMap R M₁ M₂
x y : (i : ι) → M₁ i
⊢ (∑ i : ι, f.toLinearMap x i ∘ₗ LinearMap.proj i) y = ∑ i : ι, f (update x i (y i))

tactic: simp only [LinearMap.coeFn_sum, LinearMap.coe_comp, LinearMap.coe_proj, Finset.sum_apply,
  Function.comp_apply, Function.eval, toLinearMap_apply]
state_before: R : Type uR
S : Type uS
ι : Type uι
n : ℕ
M : Fin n.succ → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝¹² : Semiring R
inst✝¹¹ : (i : Fin n.succ) → AddCommMonoid (M i)
inst✝¹⁰ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁹ : AddCommMonoid M₂
inst✝⁸ : AddCommMonoid M₃
inst✝⁷ : AddCommMonoid M'
inst✝⁶ : (i : Fin n.succ) → Module R (M i)
inst✝⁵ : (i : ι) → Module R (M₁ i)
inst✝⁴ : Module R M₂
inst✝³ : Module R M₃
inst✝² : Module R M'
f✝ f' : MultilinearMap R M₁ M₂
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
f : MultilinearMap R M₁ M₂
x y : (i : ι) → M₁ i
⊢ (∑ i : ι, f.toLinearMap x i ∘ₗ LinearMap.proj i) y = ∑ i : ι, f (update x i (y i))
state_after: no goals
Theorem: Set.Finite.isOpen_sInter
File: Mathlib/Topology/Basic.lean

tactic: rw [sInter_empty]
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s✝ s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
s : Set (Set X)
hs : s.Finite
x✝ : ∀ t ∈ ∅, IsOpen t
⊢ IsOpen (⋂₀ ∅)
state_after: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s✝ s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
s : Set (Set X)
hs : s.Finite
x✝ : ∀ t ∈ ∅, IsOpen t
⊢ IsOpen univ

tactic: exact isOpen_univ
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s✝ s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
s : Set (Set X)
hs : s.Finite
x✝ : ∀ t ∈ ∅, IsOpen t
⊢ IsOpen univ
state_after: no goals

tactic: simp only [sInter_insert, forall_mem_insert] at h ⊢
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s✝¹ s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
s : Set (Set X)
hs : s.Finite
a✝ : Set X
s✝ : Set (Set X)
x✝¹ : a✝ ∉ s✝
x✝ : s✝.Finite
ih : (∀ t ∈ s✝, IsOpen t) → IsOpen (⋂₀ s✝)
h : ∀ t ∈ insert a✝ s✝, IsOpen t
⊢ IsOpen (⋂₀ insert a✝ s✝)
state_after: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s✝¹ s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
s : Set (Set X)
hs : s.Finite
a✝ : Set X
s✝ : Set (Set X)
x✝¹ : a✝ ∉ s✝
x✝ : s✝.Finite
ih : (∀ t ∈ s✝, IsOpen t) → IsOpen (⋂₀ s✝)
h : IsOpen a✝ ∧ ∀ x ∈ s✝, IsOpen x
⊢ IsOpen (a✝ ∩ ⋂₀ s✝)

tactic: exact h.1.inter (ih h.2)
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s✝¹ s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
s : Set (Set X)
hs : s.Finite
a✝ : Set X
s✝ : Set (Set X)
x✝¹ : a✝ ∉ s✝
x✝ : s✝.Finite
ih : (∀ t ∈ s✝, IsOpen t) → IsOpen (⋂₀ s✝)
h : IsOpen a✝ ∧ ∀ x ∈ s✝, IsOpen x
⊢ IsOpen (a✝ ∩ ⋂₀ s✝)
state_after: no goals
Theorem: Real.arctan_inv_of_pos
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean

tactic: rw [← arctan_tan (x := _ - _), tan_pi_div_two_sub, tan_arctan]
state_before: x : ℝ
h : 0 < x
⊢ arctan x⁻¹ = π / 2 - arctan x
state_after: case hx₁
x : ℝ
h : 0 < x
⊢ -(π / 2) < π / 2 - arctan x

case hx₂
x : ℝ
h : 0 < x
⊢ π / 2 - arctan x < π / 2

tactic: norm_num
state_before: case hx₁
x : ℝ
h : 0 < x
⊢ -(π / 2) < π / 2 - arctan x
state_after: case hx₁
x : ℝ
h : 0 < x
⊢ arctan x < π

tactic: exact (arctan_lt_pi_div_two x).trans (half_lt_self_iff.mpr pi_pos)
state_before: case hx₁
x : ℝ
h : 0 < x
⊢ arctan x < π
state_after: no goals

tactic: rw [sub_lt_self_iff, ← arctan_zero]
state_before: case hx₂
x : ℝ
h : 0 < x
⊢ π / 2 - arctan x < π / 2
state_after: case hx₂
x : ℝ
h : 0 < x
⊢ arctan 0 < arctan x

tactic: exact tanOrderIso.symm.strictMono h
state_before: case hx₂
x : ℝ
h : 0 < x
⊢ arctan 0 < arctan x
state_after: no goals
Theorem: Real.Angle.sin_coe_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [sin_coe, Real.sin_pi]
state_before: ⊢ (↑π).sin = 0
state_after: no goals
Theorem: Finset.sum_smul_sum
File: Mathlib/Algebra/Module/BigOperators.lean

tactic: rw [Finset.sum_product, Finset.sum_smul, Finset.sum_congr rfl]
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
R : Type u_5
M : Type u_6
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
r s✝ : R
x y : M
f : α → R
g : β → M
s : Finset α
t : Finset β
⊢ (∑ i ∈ s, f i) • ∑ i ∈ t, g i = ∑ p ∈ s ×ˢ t, f p.1 • g p.2
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
R : Type u_5
M : Type u_6
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
r s✝ : R
x y : M
f : α → R
g : β → M
s : Finset α
t : Finset β
⊢ ∀ x ∈ s, f x • ∑ i ∈ t, g i = ∑ y ∈ t, f (x, y).1 • g (x, y).2

tactic: intros
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
R : Type u_5
M : Type u_6
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
r s✝ : R
x y : M
f : α → R
g : β → M
s : Finset α
t : Finset β
⊢ ∀ x ∈ s, f x • ∑ i ∈ t, g i = ∑ y ∈ t, f (x, y).1 • g (x, y).2
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
R : Type u_5
M : Type u_6
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
r s✝ : R
x y : M
f : α → R
g : β → M
s : Finset α
t : Finset β
x✝ : α
a✝ : x✝ ∈ s
⊢ f x✝ • ∑ i ∈ t, g i = ∑ y ∈ t, f (x✝, y).1 • g (x✝, y).2

tactic: rw [Finset.smul_sum]
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
R : Type u_5
M : Type u_6
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
r s✝ : R
x y : M
f : α → R
g : β → M
s : Finset α
t : Finset β
x✝ : α
a✝ : x✝ ∈ s
⊢ f x✝ • ∑ i ∈ t, g i = ∑ y ∈ t, f (x✝, y).1 • g (x✝, y).2
state_after: no goals
Theorem: Asymptotics.IsEquivalent.add_isLittleO
File: Mathlib/Analysis/Asymptotics/AsymptoticEquivalent.lean

tactic: simpa only [IsEquivalent, add_sub_right_comm] using huv.add hwv
state_before: α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
huv : u ~[l] v
hwv : w =o[l] v
⊢ u + w ~[l] v
state_after: no goals