1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: CategoryTheory.Localization.homEquiv_map
File: Mathlib/CategoryTheory/Localization/HomEquiv.lean

tactic: simp [homEquiv_apply]
state_before: C : Type u_1
C₁ : Type u_2
C₂ : Type u_3
C₃ : Type u_4
D₁ : Type u_5
D₂ : Type u_6
D₃ : Type u_7
inst✝⁹ : Category.{u_8, u_1} C
inst✝⁸ : Category.{?u.46956, u_2} C₁
inst✝⁷ : Category.{?u.46960, u_3} C₂
inst✝⁶ : Category.{?u.46964, u_4} C₃
inst✝⁵ : Category.{u_10, u_5} D₁
inst✝⁴ : Category.{u_9, u_6} D₂
inst✝³ : Category.{?u.46976, u_7} D₃
W : MorphismProperty C
L₁ : C ⥤ D₁
inst✝² : L₁.IsLocalization W
L₂ : C ⥤ D₂
inst✝¹ : L₂.IsLocalization W
L₃ : C ⥤ D₃
inst✝ : L₃.IsLocalization W
X Y Z : C
f : X ⟶ Y
⊢ (homEquiv W L₁ L₂) (L₁.map f) = L₂.map f
state_after: no goals
Theorem: LieSubmodule.le_normalizer
File: Mathlib/Algebra/Lie/Normalizer.lean

tactic: intro m hm
state_before: R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
⊢ N ≤ N.normalizer
state_after: R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
m : M
hm : m ∈ N
⊢ m ∈ N.normalizer

tactic: rw [mem_normalizer]
state_before: R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
m : M
hm : m ∈ N
⊢ m ∈ N.normalizer
state_after: R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
m : M
hm : m ∈ N
⊢ ∀ (x : L), ⁅x, m⁆ ∈ N

tactic: exact fun x => N.lie_mem hm
state_before: R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
m : M
hm : m ∈ N
⊢ ∀ (x : L), ⁅x, m⁆ ∈ N
state_after: no goals
Theorem: Finset.map_toDual_min
File: Mathlib/Data/Finset/Lattice.lean

tactic: rw [max_eq_sup_withBot, sup_image]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s✝ : Finset α
H : s✝.Nonempty
x : α
s : Finset α
⊢ WithTop.map (⇑toDual) s.min = (image (⇑toDual) s).max
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s✝ : Finset α
H : s✝.Nonempty
x : α
s : Finset α
⊢ WithTop.map (⇑toDual) s.min = s.sup (WithBot.some ∘ ⇑toDual)

tactic: exact congr_fun Option.map_id _
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s✝ : Finset α
H : s✝.Nonempty
x : α
s : Finset α
⊢ WithTop.map (⇑toDual) s.min = s.sup (WithBot.some ∘ ⇑toDual)
state_after: no goals
Theorem: CoxeterSystem.leftInvSeq_eq_reverse_rightInvSeq_reverse
File: Mathlib/GroupTheory/Coxeter/Inversion.lean

tactic: induction' ω with i ω ih
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
⊢ cs.leftInvSeq ω = (cs.rightInvSeq ω.reverse).reverse
state_after: case nil
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
⊢ cs.leftInvSeq [] = (cs.rightInvSeq [].reverse).reverse

case cons
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
i : B
ω : List B
ih : cs.leftInvSeq ω = (cs.rightInvSeq ω.reverse).reverse
⊢ cs.leftInvSeq (i :: ω) = (cs.rightInvSeq (i :: ω).reverse).reverse

tactic: simp
state_before: case nil
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
⊢ cs.leftInvSeq [] = (cs.rightInvSeq [].reverse).reverse
state_after: no goals

tactic: rw [leftInvSeq, reverse_cons, ← concat_eq_append, rightInvSeq_concat, ih]
state_before: case cons
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
i : B
ω : List B
ih : cs.leftInvSeq ω = (cs.rightInvSeq ω.reverse).reverse
⊢ cs.leftInvSeq (i :: ω) = (cs.rightInvSeq (i :: ω).reverse).reverse
state_after: case cons
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
i : B
ω : List B
ih : cs.leftInvSeq ω = (cs.rightInvSeq ω.reverse).reverse
⊢ cs.simple i :: List.map (⇑(MulAut.conj (cs.simple i))) (cs.rightInvSeq ω.reverse).reverse =
    ((List.map (⇑(MulAut.conj (cs.simple i))) (cs.rightInvSeq ω.reverse)).concat (cs.simple i)).reverse

tactic: simp [map_reverse]
state_before: case cons
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
i : B
ω : List B
ih : cs.leftInvSeq ω = (cs.rightInvSeq ω.reverse).reverse
⊢ cs.simple i :: List.map (⇑(MulAut.conj (cs.simple i))) (cs.rightInvSeq ω.reverse).reverse =
    ((List.map (⇑(MulAut.conj (cs.simple i))) (cs.rightInvSeq ω.reverse)).concat (cs.simple i)).reverse
state_after: no goals
Theorem: CategoryTheory.MorphismProperty.RespectsIso.cancel_right_isIso
File: Mathlib/CategoryTheory/MorphismProperty/Basic.lean

tactic: simpa using hP.2 (asIso g).symm (f ≫ g) h
state_before: C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
inst✝¹ : Category.{?u.11773, u_1} D
P : MorphismProperty C
hP : P.RespectsIso
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝ : IsIso g
h : P (f ≫ g)
⊢ P f
state_after: no goals
Theorem: MulAction.zpow_add_period_smul
File: Mathlib/Dynamics/PeriodicPts.lean

tactic: rw [← zpow_mod_period_smul, Int.add_emod_self, zpow_mod_period_smul]
state_before: α : Type v
G : Type u
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u
inst✝¹ : Monoid M
inst✝ : MulAction M α
i : ℤ
g : G
a : α
⊢ g ^ (i + ↑(period g a)) • a = g ^ i • a
state_after: no goals
Theorem: pNilradical_le_nilradical
File: Mathlib/FieldTheory/IsPerfectClosure.lean

tactic: by_cases hp : 1 < p
state_before: R : Type u_1
inst✝ : CommSemiring R
p : ℕ
⊢ pNilradical R p ≤ nilradical R
state_after: case pos
R : Type u_1
inst✝ : CommSemiring R
p : ℕ
hp : 1 < p
⊢ pNilradical R p ≤ nilradical R

case neg
R : Type u_1
inst✝ : CommSemiring R
p : ℕ
hp : ¬1 < p
⊢ pNilradical R p ≤ nilradical R

tactic: simp_rw [pNilradical, if_neg hp, bot_le]
state_before: case neg
R : Type u_1
inst✝ : CommSemiring R
p : ℕ
hp : ¬1 < p
⊢ pNilradical R p ≤ nilradical R
state_after: no goals

tactic: rw [pNilradical, if_pos hp]
state_before: case pos
R : Type u_1
inst✝ : CommSemiring R
p : ℕ
hp : 1 < p
⊢ pNilradical R p ≤ nilradical R
state_after: no goals
Theorem: sub_sq
File: Mathlib/Algebra/Ring/Commute.lean

tactic: rw [sub_eq_add_neg, add_sq, neg_sq, mul_neg, ← sub_eq_add_neg]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : CommRing R
a b : R
⊢ (a - b) ^ 2 = a ^ 2 - 2 * a * b + b ^ 2
state_after: no goals
Theorem: spectrum_diagonal
File: Mathlib/LinearAlgebra/Eigenspace/Matrix.lean

tactic: ext μ
state_before: R : Type u_1
n : Type u_2
M : Type u_3
inst✝² : DecidableEq n
inst✝¹ : Fintype n
inst✝ : Field R
d : n → R
⊢ spectrum R (diagonal d) = Set.range d
state_after: case h
R : Type u_1
n : Type u_2
M : Type u_3
inst✝² : DecidableEq n
inst✝¹ : Fintype n
inst✝ : Field R
d : n → R
μ : R
⊢ μ ∈ spectrum R (diagonal d) ↔ μ ∈ Set.range d

tactic: rw [← AlgEquiv.spectrum_eq (toLinAlgEquiv <| Pi.basisFun R n), ← hasEigenvalue_iff_mem_spectrum]
state_before: case h
R : Type u_1
n : Type u_2
M : Type u_3
inst✝² : DecidableEq n
inst✝¹ : Fintype n
inst✝ : Field R
d : n → R
μ : R
⊢ μ ∈ spectrum R (diagonal d) ↔ μ ∈ Set.range d
state_after: case h
R : Type u_1
n : Type u_2
M : Type u_3
inst✝² : DecidableEq n
inst✝¹ : Fintype n
inst✝ : Field R
d : n → R
μ : R
⊢ HasEigenvalue ((toLinAlgEquiv (Pi.basisFun R n)) (diagonal d)) μ ↔ μ ∈ Set.range d

tactic: exact hasEigenvalue_toLin'_diagonal_iff d
state_before: case h
R : Type u_1
n : Type u_2
M : Type u_3
inst✝² : DecidableEq n
inst✝¹ : Fintype n
inst✝ : Field R
d : n → R
μ : R
⊢ HasEigenvalue ((toLinAlgEquiv (Pi.basisFun R n)) (diagonal d)) μ ↔ μ ∈ Set.range d
state_after: no goals
Theorem: Real.volume_preimage_mul_left
File: Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean

tactic: rw [map_volume_mul_left h]
state_before: ι : Type u_1
inst✝ : Fintype ι
a : ℝ
h : a ≠ 0
s : Set ℝ
⊢ (Measure.map (fun x => a * x) volume) s = ofReal |a⁻¹| * volume s
state_after: ι : Type u_1
inst✝ : Fintype ι
a : ℝ
h : a ≠ 0
s : Set ℝ
⊢ (ofReal |a⁻¹| • volume) s = ofReal |a⁻¹| * volume s

tactic: rfl
state_before: ι : Type u_1
inst✝ : Fintype ι
a : ℝ
h : a ≠ 0
s : Set ℝ
⊢ (ofReal |a⁻¹| • volume) s = ofReal |a⁻¹| * volume s
state_after: no goals
Theorem: Set.preimage_const_mul_Ici_of_neg
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simpa only [mul_comm] using preimage_mul_const_Ici_of_neg a h
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ a c : α
h : c < 0
⊢ (fun x => c * x) ⁻¹' Ici a = Iic (a / c)
state_after: no goals
Theorem: WittVector.matrix_vecEmpty_coeff
File: Mathlib/RingTheory/WittVector/Basic.lean

tactic: rcases i with ⟨_ | _ | _ | _ | i_val, ⟨⟩⟩
state_before: p : ℕ
R✝ : Type u_1
S : Type u_2
T : Type u_3
hp : Fact (Nat.Prime p)
inst✝² : CommRing R✝
inst✝¹ : CommRing S
inst✝ : CommRing T
α : Type u_4
β : Type u_5
x y : 𝕎 R✝
R : Type u_6
i : Fin 0
j : ℕ
⊢ (![] i).coeff j = ![] i j
state_after: no goals
Theorem: multiplicity.Int.natCast_multiplicity
File: Mathlib/RingTheory/Multiplicity.lean

tactic: apply Part.ext'
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Monoid α
inst✝ : Monoid β
a b : ℕ
⊢ multiplicity ↑a ↑b = multiplicity a b
state_after: case a
α : Type u_1
β : Type u_2
inst✝¹ : Monoid α
inst✝ : Monoid β
a b : ℕ
⊢ (multiplicity ↑a ↑b).Dom ↔ (multiplicity a b).Dom

case a
α : Type u_1
β : Type u_2
inst✝¹ : Monoid α
inst✝ : Monoid β
a b : ℕ
⊢ ∀ (h₁ : (multiplicity ↑a ↑b).Dom) (h₂ : (multiplicity a b).Dom),
    (multiplicity ↑a ↑b).get h₁ = (multiplicity a b).get h₂

tactic: rw [← @finite_iff_dom ℕ, @finite_def ℕ, ← @finite_iff_dom ℤ, @finite_def ℤ]
state_before: case a
α : Type u_1
β : Type u_2
inst✝¹ : Monoid α
inst✝ : Monoid β
a b : ℕ
⊢ (multiplicity ↑a ↑b).Dom ↔ (multiplicity a b).Dom
state_after: case a
α : Type u_1
β : Type u_2
inst✝¹ : Monoid α
inst✝ : Monoid β
a b : ℕ
⊢ (∃ n, ¬↑a ^ (n + 1) ∣ ↑b) ↔ ∃ n, ¬a ^ (n + 1) ∣ b

tactic: norm_cast
state_before: case a
α : Type u_1
β : Type u_2
inst✝¹ : Monoid α
inst✝ : Monoid β
a b : ℕ
⊢ (∃ n, ¬↑a ^ (n + 1) ∣ ↑b) ↔ ∃ n, ¬a ^ (n + 1) ∣ b
state_after: no goals

tactic: intro h1 h2
state_before: case a
α : Type u_1
β : Type u_2
inst✝¹ : Monoid α
inst✝ : Monoid β
a b : ℕ
⊢ ∀ (h₁ : (multiplicity ↑a ↑b).Dom) (h₂ : (multiplicity a b).Dom),
    (multiplicity ↑a ↑b).get h₁ = (multiplicity a b).get h₂
state_after: case a
α : Type u_1
β : Type u_2
inst✝¹ : Monoid α
inst✝ : Monoid β
a b : ℕ
h1 : (multiplicity ↑a ↑b).Dom
h2 : (multiplicity a b).Dom
⊢ (multiplicity ↑a ↑b).get h1 = (multiplicity a b).get h2

tactic: apply Nat.find_mono
state_before: case a.a
α : Type u_1
β : Type u_2
inst✝¹ : Monoid α
inst✝ : Monoid β
a b : ℕ
h1 : (multiplicity ↑a ↑b).Dom
h2 : (multiplicity a b).Dom
⊢ (multiplicity a b).get h2 ≤ (multiplicity ↑a ↑b).get h1
state_after: case a.a.h
α : Type u_1
β : Type u_2
inst✝¹ : Monoid α
inst✝ : Monoid β
a b : ℕ
h1 : (multiplicity ↑a ↑b).Dom
h2 : (multiplicity a b).Dom
⊢ ∀ (n : ℕ), ¬↑a ^ (n + 1) ∣ ↑b → ¬a ^ (n + 1) ∣ b

tactic: norm_cast
state_before: case a.a.h
α : Type u_1
β : Type u_2
inst✝¹ : Monoid α
inst✝ : Monoid β
a b : ℕ
h1 : (multiplicity ↑a ↑b).Dom
h2 : (multiplicity a b).Dom
⊢ ∀ (n : ℕ), ¬↑a ^ (n + 1) ∣ ↑b → ¬a ^ (n + 1) ∣ b
state_after: case a.a.h
α : Type u_1
β : Type u_2
inst✝¹ : Monoid α
inst✝ : Monoid β
a b : ℕ
h1 : (multiplicity ↑a ↑b).Dom
h2 : (multiplicity a b).Dom
⊢ ∀ (n : ℕ), ¬a ^ (n + 1) ∣ b → ¬a ^ (n + 1) ∣ b

tactic: simp
state_before: case a.a.h
α : Type u_1
β : Type u_2
inst✝¹ : Monoid α
inst✝ : Monoid β
a b : ℕ
h1 : (multiplicity ↑a ↑b).Dom
h2 : (multiplicity a b).Dom
⊢ ∀ (n : ℕ), ¬a ^ (n + 1) ∣ b → ¬a ^ (n + 1) ∣ b
state_after: no goals
Theorem: Vector.mapAccumr₂_redundant_pair
File: Mathlib/Data/Vector/MapLemmas.lean

tactic: use fun (s₁, s₂) s => s₂ = s ∧ s₁ = s
state_before: α : Type
n : ℕ
β : Type
xs : Vector α n
ys : Vector β n
σ γ : Type
s : σ
f : α → β → σ × σ → (σ × σ) × γ
h :
  ∀ (x : α) (y : β) (s : σ),
    let s' := (f x y (s, s)).1;
    s'.1 = s'.2
⊢ ∃ R,
    R (s, s) s ∧
      ∀ {s : σ × σ} {q : σ} (a : α) (b : β),
        R s q →
          R (f a b s).1 ((f a b (q, q)).1.1, (f a b (q, q)).2).1 ∧
            (f a b s).2 = ((f a b (q, q)).1.1, (f a b (q, q)).2).2
state_after: case h
α : Type
n : ℕ
β : Type
xs : Vector α n
ys : Vector β n
σ γ : Type
s : σ
f : α → β → σ × σ → (σ × σ) × γ
h :
  ∀ (x : α) (y : β) (s : σ),
    let s' := (f x y (s, s)).1;
    s'.1 = s'.2
⊢ (match (s, s) with
    | (s₁, s₂) => s₂ = s ∧ s₁ = s) ∧
    ∀ {s : σ × σ} {q : σ} (a : α) (b : β),
      (match s with
        | (s₁, s₂) => s₂ = q ∧ s₁ = q) →
        (match (f a b s).1 with
          | (s₁, s₂) => s₂ = ((f a b (q, q)).1.1, (f a b (q, q)).2).1 ∧ s₁ = ((f a b (q, q)).1.1, (f a b (q, q)).2).1) ∧
          (f a b s).2 = ((f a b (q, q)).1.1, (f a b (q, q)).2).2

tactic: simp_all
state_before: case h
α : Type
n : ℕ
β : Type
xs : Vector α n
ys : Vector β n
σ γ : Type
s : σ
f : α → β → σ × σ → (σ × σ) × γ
h :
  ∀ (x : α) (y : β) (s : σ),
    let s' := (f x y (s, s)).1;
    s'.1 = s'.2
⊢ (match (s, s) with
    | (s₁, s₂) => s₂ = s ∧ s₁ = s) ∧
    ∀ {s : σ × σ} {q : σ} (a : α) (b : β),
      (match s with
        | (s₁, s₂) => s₂ = q ∧ s₁ = q) →
        (match (f a b s).1 with
          | (s₁, s₂) => s₂ = ((f a b (q, q)).1.1, (f a b (q, q)).2).1 ∧ s₁ = ((f a b (q, q)).1.1, (f a b (q, q)).2).1) ∧
          (f a b s).2 = ((f a b (q, q)).1.1, (f a b (q, q)).2).2
state_after: no goals
Theorem: Nat.testBit_eq_false_of_lt
File: Mathlib/Data/Nat/Bitwise.lean

tactic: simp [testBit, shiftRight_eq_div_pow, Nat.div_eq_of_lt h]
state_before: n i : ℕ
h : n < 2 ^ i
⊢ n.testBit i = false
state_after: no goals
Theorem: EuclideanGeometry.angle_eq_arctan_of_angle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean

tactic: rw [angle, ← inner_eq_zero_iff_angle_eq_pi_div_two, real_inner_comm, ← neg_eq_zero, ←
  inner_neg_left, neg_vsub_eq_vsub_rev] at h
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : ∠ p₁ p₂ p₃ = π / 2
h0 : p₃ ≠ p₂
⊢ ∠ p₂ p₃ p₁ = Real.arctan (dist p₁ p₂ / dist p₃ p₂)
state_after: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : ⟪p₂ -ᵥ p₃, p₁ -ᵥ p₂⟫_ℝ = 0
h0 : p₃ ≠ p₂
⊢ ∠ p₂ p₃ p₁ = Real.arctan (dist p₁ p₂ / dist p₃ p₂)

tactic: rw [ne_comm, ← @vsub_ne_zero V] at h0
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : ⟪p₂ -ᵥ p₃, p₁ -ᵥ p₂⟫_ℝ = 0
h0 : p₃ ≠ p₂
⊢ ∠ p₂ p₃ p₁ = Real.arctan (dist p₁ p₂ / dist p₃ p₂)
state_after: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : ⟪p₂ -ᵥ p₃, p₁ -ᵥ p₂⟫_ℝ = 0
h0 : p₂ -ᵥ p₃ ≠ 0
⊢ ∠ p₂ p₃ p₁ = Real.arctan (dist p₁ p₂ / dist p₃ p₂)

tactic: rw [angle, dist_eq_norm_vsub V p₁ p₂, dist_eq_norm_vsub' V p₃ p₂, ← vsub_add_vsub_cancel p₁ p₂ p₃,
  add_comm, angle_add_eq_arctan_of_inner_eq_zero h h0]
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : ⟪p₂ -ᵥ p₃, p₁ -ᵥ p₂⟫_ℝ = 0
h0 : p₂ -ᵥ p₃ ≠ 0
⊢ ∠ p₂ p₃ p₁ = Real.arctan (dist p₁ p₂ / dist p₃ p₂)
state_after: no goals
Theorem: sqrt_one_add_norm_sq_le
File: Mathlib/Analysis/SpecialFunctions/JapaneseBracket.lean

tactic: rw [sqrt_le_left (by positivity)]
state_before: E : Type u_1
inst✝ : NormedAddCommGroup E
x : E
⊢ √(1 + ‖x‖ ^ 2) ≤ 1 + ‖x‖
state_after: E : Type u_1
inst✝ : NormedAddCommGroup E
x : E
⊢ 1 + ‖x‖ ^ 2 ≤ (1 + ‖x‖) ^ 2

tactic: simp [add_sq]
state_before: E : Type u_1
inst✝ : NormedAddCommGroup E
x : E
⊢ 1 + ‖x‖ ^ 2 ≤ (1 + ‖x‖) ^ 2
state_after: no goals

tactic: positivity
state_before: E : Type u_1
inst✝ : NormedAddCommGroup E
x : E
⊢ 0 ≤ 1 + ‖x‖
state_after: no goals
Theorem: TopologicalSpace.Opens.mapIso_inv_app
File: Mathlib/Topology/Category/TopCat/Opens.lean

tactic: rw [h]
state_before: X Y Z : TopCat
f g : X ⟶ Y
h : f = g
U : Opens ↑Y
⊢ (map g).obj U = (map f).obj U
state_after: no goals
Theorem: ENNReal.exists_inv_two_pow_lt
File: Mathlib/Data/ENNReal/Inv.lean

tactic: rcases exists_inv_nat_lt ha with ⟨n, hn⟩
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ 0
⊢ ∃ n, 2⁻¹ ^ n < a
state_after: case intro
a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ 0
n : ℕ
hn : (↑n)⁻¹ < a
⊢ ∃ n, 2⁻¹ ^ n < a

tactic: refine ⟨n, lt_trans ?_ hn⟩
state_before: case intro
a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ 0
n : ℕ
hn : (↑n)⁻¹ < a
⊢ ∃ n, 2⁻¹ ^ n < a
state_after: case intro
a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ 0
n : ℕ
hn : (↑n)⁻¹ < a
⊢ 2⁻¹ ^ n < (↑n)⁻¹

tactic: rw [← ENNReal.inv_pow, ENNReal.inv_lt_inv]
state_before: case intro
a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ 0
n : ℕ
hn : (↑n)⁻¹ < a
⊢ 2⁻¹ ^ n < (↑n)⁻¹
state_after: case intro
a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ 0
n : ℕ
hn : (↑n)⁻¹ < a
⊢ ↑n < 2 ^ n

tactic: norm_cast
state_before: case intro
a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ 0
n : ℕ
hn : (↑n)⁻¹ < a
⊢ ↑n < 2 ^ n
state_after: case intro
a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ 0
n : ℕ
hn : (↑n)⁻¹ < a
⊢ n < 2 ^ n

tactic: exact n.lt_two_pow
state_before: case intro
a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ 0
n : ℕ
hn : (↑n)⁻¹ < a
⊢ n < 2 ^ n
state_after: no goals
Theorem: Ordnode.Valid'.dual_iff
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: have := Valid'.dual h
state_before: α : Type u_1
inst✝ : Preorder α
t : Ordnode α
o₁ : WithBot α
o₂ : WithTop α
h : Valid' o₂ t.dual o₁
⊢ Valid' o₁ t o₂
state_after: α : Type u_1
inst✝ : Preorder α
t : Ordnode α
o₁ : WithBot α
o₂ : WithTop α
h : Valid' o₂ t.dual o₁
this : Valid' o₁ t.dual.dual o₂
⊢ Valid' o₁ t o₂

tactic: rwa [dual_dual, OrderDual.Preorder.dual_dual] at this
state_before: α : Type u_1
inst✝ : Preorder α
t : Ordnode α
o₁ : WithBot α
o₂ : WithTop α
h : Valid' o₂ t.dual o₁
this : Valid' o₁ t.dual.dual o₂
⊢ Valid' o₁ t o₂
state_after: no goals
Theorem: Polynomial.smeval_sub
File: Mathlib/Algebra/Polynomial/Smeval.lean

tactic: rw [sub_eq_add_neg, smeval_add, smeval_neg, sub_eq_add_neg]
state_before: R : Type u_1
inst✝³ : Ring R
S : Type u_2
inst✝² : AddCommGroup S
inst✝¹ : Pow S ℕ
inst✝ : Module R S
p q : R[X]
x : S
⊢ (p - q).smeval x = p.smeval x - q.smeval x
state_after: no goals
Theorem: algebraicIndependent_of_finite
File: Mathlib/RingTheory/AlgebraicIndependent.lean

tactic: simp
state_before: ι : Type u_1
ι' : Type u_2
R : Type u_3
K : Type u_4
A : Type u_5
A' : Type u_6
A'' : Type u_7
V : Type u
V' : Type u_8
x : ι → A
inst✝⁶ : CommRing R
inst✝⁵ : CommRing A
inst✝⁴ : CommRing A'
inst✝³ : CommRing A''
inst✝² : Algebra R A
inst✝¹ : Algebra R A'
inst✝ : Algebra R A''
a b : R
s : Set A
H : ∀ t ⊆ s, t.Finite → AlgebraicIndependent R Subtype.val
p : MvPolynomial A R
hp : p ∈ supported R s
⊢ p ∈ supported R ↑p.vars
state_after: no goals
Theorem: Equiv.Perm.IsCycleOn.subtypePerm
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: obtain hs | hs := s.subsingleton_or_nontrivial
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
s t : Set α
a b x y : α
hf : f.IsCycleOn s
⊢ (f.subtypePerm ⋯).IsCycleOn _root_.Set.univ
state_after: case inl
ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
s t : Set α
a b x y : α
hf : f.IsCycleOn s
hs : s.Subsingleton
⊢ (f.subtypePerm ⋯).IsCycleOn _root_.Set.univ

case inr
ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
s t : Set α
a b x y : α
hf : f.IsCycleOn s
hs : s.Nontrivial
⊢ (f.subtypePerm ⋯).IsCycleOn _root_.Set.univ

tactic: convert (hf.isCycle_subtypePerm hs).isCycleOn
state_before: case inr
ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
s t : Set α
a b x y : α
hf : f.IsCycleOn s
hs : s.Nontrivial
⊢ (f.subtypePerm ⋯).IsCycleOn _root_.Set.univ
state_after: case h.e'_3
ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
s t : Set α
a b x y : α
hf : f.IsCycleOn s
hs : s.Nontrivial
⊢ _root_.Set.univ = {x | (f.subtypePerm ⋯) x ≠ x}

tactic: rw [eq_comm, Set.eq_univ_iff_forall]
state_before: case h.e'_3
ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
s t : Set α
a b x y : α
hf : f.IsCycleOn s
hs : s.Nontrivial
⊢ _root_.Set.univ = {x | (f.subtypePerm ⋯) x ≠ x}
state_after: case h.e'_3
ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
s t : Set α
a b x y : α
hf : f.IsCycleOn s
hs : s.Nontrivial
⊢ ∀ (x : { x // x ∈ s }), x ∈ {x | (f.subtypePerm ⋯) x ≠ x}

tactic: exact fun x => ne_of_apply_ne ((↑) : s → α) (hf.apply_ne hs x.2)
state_before: case h.e'_3
ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
s t : Set α
a b x y : α
hf : f.IsCycleOn s
hs : s.Nontrivial
⊢ ∀ (x : { x // x ∈ s }), x ∈ {x | (f.subtypePerm ⋯) x ≠ x}
state_after: no goals

tactic: haveI := hs.coe_sort
state_before: case inl
ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
s t : Set α
a b x y : α
hf : f.IsCycleOn s
hs : s.Subsingleton
⊢ (f.subtypePerm ⋯).IsCycleOn _root_.Set.univ
state_after: case inl
ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
s t : Set α
a b x y : α
hf : f.IsCycleOn s
hs : s.Subsingleton
this : Subsingleton ↑s
⊢ (f.subtypePerm ⋯).IsCycleOn _root_.Set.univ

tactic: exact isCycleOn_of_subsingleton _ _
state_before: case inl
ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
s t : Set α
a b x y : α
hf : f.IsCycleOn s
hs : s.Subsingleton
this : Subsingleton ↑s
⊢ (f.subtypePerm ⋯).IsCycleOn _root_.Set.univ
state_after: no goals
Theorem: CategoryTheory.Limits.IsImage.e_isoExt_hom
File: Mathlib/CategoryTheory/Limits/Shapes/Images.lean

tactic: simp
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
F F' : MonoFactorisation f
hF : IsImage F
hF' : IsImage F'
⊢ F.e ≫ (hF.isoExt hF').hom = F'.e
state_after: no goals
Theorem: Real.tanh_neg
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [tanh, neg_div]
state_before: x y : ℝ
⊢ tanh (-x) = -tanh x
state_after: no goals
Theorem: Ring.inverse_mul_cancel_left
File: Mathlib/Algebra/GroupWithZero/Units/Basic.lean

tactic: rw [← mul_assoc, inverse_mul_cancel x h, one_mul]
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : MonoidWithZero M₀
x y : M₀
h : IsUnit x
⊢ inverse x * (x * y) = y
state_after: no goals