1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: IsOpen.isGδ
File: Mathlib/Topology/GDelta.lean

tactic: simp [h]
state_before: X : Type u_1
Y : Type u_2
ι : Type u_3
ι' : Sort u_4
inst✝ : TopologicalSpace X
s : Set X
h : IsOpen s
⊢ ∀ t ∈ {s}, IsOpen t
state_after: no goals
Theorem: norm_sub_eq_norm_add
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [← mul_self_inj_of_nonneg (norm_nonneg _) (norm_nonneg _)]
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
v w : E
h : ⟪v, w⟫_𝕜 = 0
⊢ ‖w - v‖ = ‖w + v‖
state_after: 𝕜 : 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
v w : E
h : ⟪v, w⟫_𝕜 = 0
⊢ ‖w - v‖ * ‖w - v‖ = ‖w + v‖ * ‖w + v‖

tactic: simp only [h, ← @inner_self_eq_norm_mul_norm 𝕜, sub_neg_eq_add, sub_zero, map_sub, zero_re',
  zero_sub, add_zero, map_add, inner_add_right, inner_sub_left, inner_sub_right, inner_re_symm,
  zero_add]
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
v w : E
h : ⟪v, w⟫_𝕜 = 0
⊢ ‖w - v‖ * ‖w - v‖ = ‖w + v‖ * ‖w + v‖
state_after: no goals
Theorem: PiTensorProduct.liftIsometry_symm_apply
File: Mathlib/Analysis/NormedSpace/PiTensorProduct/InjectiveSeminorm.lean

tactic: ext m
state_before: ι : Type uι
inst✝⁵ : Fintype ι
𝕜 : Type u𝕜
inst✝⁴ : NontriviallyNormedField 𝕜
E : ι → Type uE
inst✝³ : (i : ι) → SeminormedAddCommGroup (E i)
inst✝² : (i : ι) → NormedSpace 𝕜 (E i)
F : Type uF
inst✝¹ : SeminormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
l : (⨂[𝕜] (i : ι), E i) →L[𝕜] F
⊢ (liftIsometry 𝕜 E F).symm l = l.compContinuousMultilinearMap (tprodL 𝕜)
state_after: case H
ι : Type uι
inst✝⁵ : Fintype ι
𝕜 : Type u𝕜
inst✝⁴ : NontriviallyNormedField 𝕜
E : ι → Type uE
inst✝³ : (i : ι) → SeminormedAddCommGroup (E i)
inst✝² : (i : ι) → NormedSpace 𝕜 (E i)
F : Type uF
inst✝¹ : SeminormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
l : (⨂[𝕜] (i : ι), E i) →L[𝕜] F
m : (i : ι) → E i
⊢ ((liftIsometry 𝕜 E F).symm l) m = (l.compContinuousMultilinearMap (tprodL 𝕜)) m

tactic: change (liftEquiv 𝕜 E F).symm l m = _
state_before: case H
ι : Type uι
inst✝⁵ : Fintype ι
𝕜 : Type u𝕜
inst✝⁴ : NontriviallyNormedField 𝕜
E : ι → Type uE
inst✝³ : (i : ι) → SeminormedAddCommGroup (E i)
inst✝² : (i : ι) → NormedSpace 𝕜 (E i)
F : Type uF
inst✝¹ : SeminormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
l : (⨂[𝕜] (i : ι), E i) →L[𝕜] F
m : (i : ι) → E i
⊢ ((liftIsometry 𝕜 E F).symm l) m = (l.compContinuousMultilinearMap (tprodL 𝕜)) m
state_after: case H
ι : Type uι
inst✝⁵ : Fintype ι
𝕜 : Type u𝕜
inst✝⁴ : NontriviallyNormedField 𝕜
E : ι → Type uE
inst✝³ : (i : ι) → SeminormedAddCommGroup (E i)
inst✝² : (i : ι) → NormedSpace 𝕜 (E i)
F : Type uF
inst✝¹ : SeminormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
l : (⨂[𝕜] (i : ι), E i) →L[𝕜] F
m : (i : ι) → E i
⊢ ((liftEquiv 𝕜 E F).symm l) m = (l.compContinuousMultilinearMap (tprodL 𝕜)) m

tactic: simp only [liftEquiv_symm_apply, lift_symm, MultilinearMap.coe_mkContinuous,
  LinearMap.compMultilinearMap_apply, ContinuousLinearMap.coe_coe,
  ContinuousLinearMap.compContinuousMultilinearMap_coe, Function.comp_apply, tprodL_toFun]
state_before: case H
ι : Type uι
inst✝⁵ : Fintype ι
𝕜 : Type u𝕜
inst✝⁴ : NontriviallyNormedField 𝕜
E : ι → Type uE
inst✝³ : (i : ι) → SeminormedAddCommGroup (E i)
inst✝² : (i : ι) → NormedSpace 𝕜 (E i)
F : Type uF
inst✝¹ : SeminormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
l : (⨂[𝕜] (i : ι), E i) →L[𝕜] F
m : (i : ι) → E i
⊢ ((liftEquiv 𝕜 E F).symm l) m = (l.compContinuousMultilinearMap (tprodL 𝕜)) m
state_after: no goals
Theorem: adjoinRootXPowSubCEquiv_symm_eq_root
File: Mathlib/FieldTheory/KummerExtension.lean

tactic: apply (adjoinRootXPowSubCEquiv hζ H hα).injective
state_before: K : Type u
inst✝³ : Field K
n : ℕ
hζ : (primitiveRoots n K).Nonempty
hn : 0 < n
a : K
H : Irreducible (X ^ n - C a)
L : Type u_1
inst✝² : Field L
inst✝¹ : Algebra K L
inst✝ : IsSplittingField K L (X ^ n - C a)
α : L
hα : α ^ n = (algebraMap K L) a
⊢ (adjoinRootXPowSubCEquiv hζ H hα).symm α = root (X ^ n - C a)
state_after: case a
K : Type u
inst✝³ : Field K
n : ℕ
hζ : (primitiveRoots n K).Nonempty
hn : 0 < n
a : K
H : Irreducible (X ^ n - C a)
L : Type u_1
inst✝² : Field L
inst✝¹ : Algebra K L
inst✝ : IsSplittingField K L (X ^ n - C a)
α : L
hα : α ^ n = (algebraMap K L) a
⊢ (adjoinRootXPowSubCEquiv hζ H hα) ((adjoinRootXPowSubCEquiv hζ H hα).symm α) =
    (adjoinRootXPowSubCEquiv hζ H hα) (root (X ^ n - C a))

tactic: rw [(adjoinRootXPowSubCEquiv hζ H hα).apply_symm_apply, adjoinRootXPowSubCEquiv_root]
state_before: case a
K : Type u
inst✝³ : Field K
n : ℕ
hζ : (primitiveRoots n K).Nonempty
hn : 0 < n
a : K
H : Irreducible (X ^ n - C a)
L : Type u_1
inst✝² : Field L
inst✝¹ : Algebra K L
inst✝ : IsSplittingField K L (X ^ n - C a)
α : L
hα : α ^ n = (algebraMap K L) a
⊢ (adjoinRootXPowSubCEquiv hζ H hα) ((adjoinRootXPowSubCEquiv hζ H hα).symm α) =
    (adjoinRootXPowSubCEquiv hζ H hα) (root (X ^ n - C a))
state_after: no goals
Theorem: Matroid.Basis.of_restriction
File: Mathlib/Data/Matroid/Restrict.lean

tactic: obtain ⟨R, hR, rfl⟩ := hNM
state_before: α : Type u_1
M : Matroid α
R I J X Y : Set α
N : Matroid α
hI : N.Basis I X
hNM : N ≤r M
⊢ M.Basis I X
state_after: case intro.intro
α : Type u_1
M : Matroid α
R✝ I J X Y R : Set α
hR : R ⊆ M.E
hI : (M ↾ R).Basis I X
⊢ M.Basis I X

tactic: exact ((basis_restrict_iff hR).1 hI).1
state_before: case intro.intro
α : Type u_1
M : Matroid α
R✝ I J X Y R : Set α
hR : R ⊆ M.E
hI : (M ↾ R).Basis I X
⊢ M.Basis I X
state_after: no goals
Theorem: Sylow.normalizer_normalizer
File: Mathlib/GroupTheory/Sylow.lean

tactic: have := normal_of_normalizer_normal (P.subtype (le_normalizer.trans le_normalizer))
state_before: G : Type u
α : Type v
β : Type w
inst✝² : Group G
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
⊢ (↑P).normalizer.normalizer = (↑P).normalizer
state_after: G : Type u
α : Type v
β : Type w
inst✝² : Group G
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
this : (↑(P.subtype ⋯)).normalizer.Normal → (↑(P.subtype ⋯)).Normal
⊢ (↑P).normalizer.normalizer = (↑P).normalizer

tactic: simp_rw [← normalizer_eq_top, Sylow.coe_subtype, ← subgroupOf_normalizer_eq le_normalizer, ←
  subgroupOf_normalizer_eq le_rfl, subgroupOf_self] at this
state_before: G : Type u
α : Type v
β : Type w
inst✝² : Group G
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
this : (↑(P.subtype ⋯)).normalizer.Normal → (↑(P.subtype ⋯)).Normal
⊢ (↑P).normalizer.normalizer = (↑P).normalizer
state_after: G : Type u
α : Type v
β : Type w
inst✝² : Group G
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
this : True → (↑P).normalizer.subgroupOf (↑P).normalizer.normalizer = ⊤
⊢ (↑P).normalizer.normalizer = (↑P).normalizer

tactic: rw [← subtype_range (P : Subgroup G).normalizer.normalizer, MonoidHom.range_eq_map,
  ← this trivial]
state_before: G : Type u
α : Type v
β : Type w
inst✝² : Group G
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
this : True → (↑P).normalizer.subgroupOf (↑P).normalizer.normalizer = ⊤
⊢ (↑P).normalizer.normalizer = (↑P).normalizer
state_after: G : Type u
α : Type v
β : Type w
inst✝² : Group G
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
this : True → (↑P).normalizer.subgroupOf (↑P).normalizer.normalizer = ⊤
⊢ Subgroup.map (↑P).normalizer.normalizer.subtype ((↑P).normalizer.subgroupOf (↑P).normalizer.normalizer) =
    (↑P).normalizer

tactic: exact map_comap_eq_self (le_normalizer.trans (ge_of_eq (subtype_range _)))
state_before: G : Type u
α : Type v
β : Type w
inst✝² : Group G
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
this : True → (↑P).normalizer.subgroupOf (↑P).normalizer.normalizer = ⊤
⊢ Subgroup.map (↑P).normalizer.normalizer.subtype ((↑P).normalizer.subgroupOf (↑P).normalizer.normalizer) =
    (↑P).normalizer
state_after: no goals
Theorem: div_self_le_one
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: simp [h]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a✝ b c d e : α
m n : ℤ
a : α
h : a = 0
⊢ a / a ≤ 1
state_after: no goals

tactic: simp [h]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a✝ b c d e : α
m n : ℤ
a : α
h : ¬a = 0
⊢ a / a ≤ 1
state_after: no goals
Theorem: List.prod_nat_mod
File: Mathlib/Algebra/BigOperators/Group/List.lean

tactic: induction' l with a l ih
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
l : List ℕ
n : ℕ
⊢ l.prod % n = (map (fun x => x % n) l).prod % n
state_after: case nil
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
n : ℕ
⊢ [].prod % n = (map (fun x => x % n) []).prod % n

case cons
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
n a : ℕ
l : List ℕ
ih : l.prod % n = (map (fun x => x % n) l).prod % n
⊢ (a :: l).prod % n = (map (fun x => x % n) (a :: l)).prod % n

tactic: simp only [Nat.zero_mod, map_nil]
state_before: case nil
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
n : ℕ
⊢ [].prod % n = (map (fun x => x % n) []).prod % n
state_after: no goals

tactic: simpa only [prod_cons, map_cons, Nat.mod_mul_mod, Nat.mul_mod_mod] using congr((a * $ih) % n)
state_before: case cons
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
n a : ℕ
l : List ℕ
ih : l.prod % n = (map (fun x => x % n) l).prod % n
⊢ (a :: l).prod % n = (map (fun x => x % n) (a :: l)).prod % n
state_after: no goals
Theorem: RatFunc.num_denom_add
File: Mathlib/FieldTheory/RatFunc/Basic.lean

tactic: conv_lhs => rw [← num_div_denom x, ← num_div_denom y]
state_before: K : Type u
inst✝ : Field K
x y : RatFunc K
⊢ x + y =
    (algebraMap K[X] (RatFunc K)) (x.num * y.denom + x.denom * y.num) /
      (algebraMap K[X] (RatFunc K)) (x.denom * y.denom)
state_after: K : Type u
inst✝ : Field K
x y : RatFunc K
⊢ (algebraMap K[X] (RatFunc K)) x.num / (algebraMap K[X] (RatFunc K)) x.denom +
      (algebraMap K[X] (RatFunc K)) y.num / (algebraMap K[X] (RatFunc K)) y.denom =
    (algebraMap K[X] (RatFunc K)) (x.num * y.denom + x.denom * y.num) /
      (algebraMap K[X] (RatFunc K)) (x.denom * y.denom)

tactic: rw [div_add_div, RingHom.map_mul, RingHom.map_add, RingHom.map_mul, RingHom.map_mul]
state_before: K : Type u
inst✝ : Field K
x y : RatFunc K
⊢ (algebraMap K[X] (RatFunc K)) x.num / (algebraMap K[X] (RatFunc K)) x.denom +
      (algebraMap K[X] (RatFunc K)) y.num / (algebraMap K[X] (RatFunc K)) y.denom =
    (algebraMap K[X] (RatFunc K)) (x.num * y.denom + x.denom * y.num) /
      (algebraMap K[X] (RatFunc K)) (x.denom * y.denom)
state_after: case hb
K : Type u
inst✝ : Field K
x y : RatFunc K
⊢ (algebraMap K[X] (RatFunc K)) x.denom ≠ 0

case hd
K : Type u
inst✝ : Field K
x y : RatFunc K
⊢ (algebraMap K[X] (RatFunc K)) y.denom ≠ 0

tactic: exact algebraMap_ne_zero (denom_ne_zero x)
state_before: case hb
K : Type u
inst✝ : Field K
x y : RatFunc K
⊢ (algebraMap K[X] (RatFunc K)) x.denom ≠ 0
state_after: no goals

tactic: exact algebraMap_ne_zero (denom_ne_zero y)
state_before: case hd
K : Type u
inst✝ : Field K
x y : RatFunc K
⊢ (algebraMap K[X] (RatFunc K)) y.denom ≠ 0
state_after: no goals
Theorem: iUnion_Ioc_add_zsmul
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: refine eq_univ_iff_forall.mpr fun b => mem_iUnion.mpr ?_
state_before: α : Type u_1
inst✝¹ : LinearOrderedAddCommGroup α
inst✝ : Archimedean α
p : α
hp : 0 < p
a : α
⊢ ⋃ n, Ioc (a + n • p) (a + (n + 1) • p) = univ
state_after: α : Type u_1
inst✝¹ : LinearOrderedAddCommGroup α
inst✝ : Archimedean α
p : α
hp : 0 < p
a b : α
⊢ ∃ i, b ∈ Ioc (a + i • p) (a + (i + 1) • p)

tactic: rcases sub_toIocDiv_zsmul_mem_Ioc hp a b with ⟨hl, hr⟩
state_before: α : Type u_1
inst✝¹ : LinearOrderedAddCommGroup α
inst✝ : Archimedean α
p : α
hp : 0 < p
a b : α
⊢ ∃ i, b ∈ Ioc (a + i • p) (a + (i + 1) • p)
state_after: case intro
α : Type u_1
inst✝¹ : LinearOrderedAddCommGroup α
inst✝ : Archimedean α
p : α
hp : 0 < p
a b : α
hl : a < b - toIocDiv hp a b • p
hr : b - toIocDiv hp a b • p ≤ a + p
⊢ ∃ i, b ∈ Ioc (a + i • p) (a + (i + 1) • p)

tactic: refine ⟨toIocDiv hp a b, ⟨lt_sub_iff_add_lt.mp hl, ?_⟩⟩
state_before: case intro
α : Type u_1
inst✝¹ : LinearOrderedAddCommGroup α
inst✝ : Archimedean α
p : α
hp : 0 < p
a b : α
hl : a < b - toIocDiv hp a b • p
hr : b - toIocDiv hp a b • p ≤ a + p
⊢ ∃ i, b ∈ Ioc (a + i • p) (a + (i + 1) • p)
state_after: case intro
α : Type u_1
inst✝¹ : LinearOrderedAddCommGroup α
inst✝ : Archimedean α
p : α
hp : 0 < p
a b : α
hl : a < b - toIocDiv hp a b • p
hr : b - toIocDiv hp a b • p ≤ a + p
⊢ b ≤ a + (toIocDiv hp a b + 1) • p

tactic: rw [add_smul, one_smul, ← add_assoc]
state_before: case intro
α : Type u_1
inst✝¹ : LinearOrderedAddCommGroup α
inst✝ : Archimedean α
p : α
hp : 0 < p
a b : α
hl : a < b - toIocDiv hp a b • p
hr : b - toIocDiv hp a b • p ≤ a + p
⊢ b ≤ a + (toIocDiv hp a b + 1) • p
state_after: case intro
α : Type u_1
inst✝¹ : LinearOrderedAddCommGroup α
inst✝ : Archimedean α
p : α
hp : 0 < p
a b : α
hl : a < b - toIocDiv hp a b • p
hr : b - toIocDiv hp a b • p ≤ a + p
⊢ b ≤ a + toIocDiv hp a b • p + p

tactic: convert sub_le_iff_le_add.mp hr using 1
state_before: case intro
α : Type u_1
inst✝¹ : LinearOrderedAddCommGroup α
inst✝ : Archimedean α
p : α
hp : 0 < p
a b : α
hl : a < b - toIocDiv hp a b • p
hr : b - toIocDiv hp a b • p ≤ a + p
⊢ b ≤ a + toIocDiv hp a b • p + p
state_after: case h.e'_4
α : Type u_1
inst✝¹ : LinearOrderedAddCommGroup α
inst✝ : Archimedean α
p : α
hp : 0 < p
a b : α
hl : a < b - toIocDiv hp a b • p
hr : b - toIocDiv hp a b • p ≤ a + p
⊢ a + toIocDiv hp a b • p + p = a + p + toIocDiv hp a b • p

tactic: abel
state_before: case h.e'_4
α : Type u_1
inst✝¹ : LinearOrderedAddCommGroup α
inst✝ : Archimedean α
p : α
hp : 0 < p
a b : α
hl : a < b - toIocDiv hp a b • p
hr : b - toIocDiv hp a b • p ≤ a + p
⊢ a + toIocDiv hp a b • p + p = a + p + toIocDiv hp a b • p
state_after: no goals
Theorem: Finset.not_isDiag_mk_of_mem_offDiag
File: Mathlib/Data/Finset/Sym.lean

tactic: rw [Sym2.isDiag_iff_proj_eq]
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
a✝ b : α
a : α × α
h : a ∈ s.offDiag
⊢ ¬(Sym2.mk a).IsDiag
state_after: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
a✝ b : α
a : α × α
h : a ∈ s.offDiag
⊢ ¬a.1 = a.2

tactic: exact (mem_offDiag.1 h).2.2
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
a✝ b : α
a : α × α
h : a ∈ s.offDiag
⊢ ¬a.1 = a.2
state_after: no goals
Theorem: Quaternion.norm_piLp_equiv_symm_equivTuple
File: Mathlib/Analysis/Quaternion.lean

tactic: rw [norm_eq_sqrt_real_inner, norm_eq_sqrt_real_inner, inner_self, normSq_def', PiLp.inner_apply,
  Fin.sum_univ_four]
state_before: x : ℍ
⊢ ‖(WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x)‖ = ‖x‖
state_after: x : ℍ
⊢ √(⟪(WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 0, (WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 0⟫_ℝ +
            ⟪(WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 1,
              (WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 1⟫_ℝ +
          ⟪(WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 2,
            (WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 2⟫_ℝ +
        ⟪(WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 3,
          (WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 3⟫_ℝ) =
    √(x.re ^ 2 + x.imI ^ 2 + x.imJ ^ 2 + x.imK ^ 2)

tactic: simp_rw [RCLike.inner_apply, starRingEnd_apply, star_trivial, ← sq]
state_before: x : ℍ
⊢ √(⟪(WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 0, (WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 0⟫_ℝ +
            ⟪(WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 1,
              (WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 1⟫_ℝ +
          ⟪(WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 2,
            (WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 2⟫_ℝ +
        ⟪(WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 3,
          (WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 3⟫_ℝ) =
    √(x.re ^ 2 + x.imI ^ 2 + x.imJ ^ 2 + x.imK ^ 2)
state_after: x : ℍ
⊢ √((WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 0 ^ 2 +
            (WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 1 ^ 2 +
          (WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 2 ^ 2 +
        (WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 3 ^ 2) =
    √(x.re ^ 2 + x.imI ^ 2 + x.imJ ^ 2 + x.imK ^ 2)

tactic: rfl
state_before: x : ℍ
⊢ √((WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 0 ^ 2 +
            (WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 1 ^ 2 +
          (WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 2 ^ 2 +
        (WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 3 ^ 2) =
    √(x.re ^ 2 + x.imI ^ 2 + x.imJ ^ 2 + x.imK ^ 2)
state_after: no goals
Theorem: Polynomial.ne_zero_of_degree_ge_degree
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

tactic: rwa [Ne, Polynomial.degree_eq_bot]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
hpq : p.degree ≤ q.degree
hp : p ≠ 0
⊢ p.degree ≠ ⊥
state_after: no goals
Theorem: IsPrimitiveRoot.zmodEquivZPowers_apply_coe_int
File: Mathlib/RingTheory/RootsOfUnity/Basic.lean

tactic: rw [zmodEquivZPowers, AddEquiv.ofBijective_apply]
state_before: M : Type u_1
N : Type u_2
G : Type u_3
R : Type u_4
S : Type u_5
F : Type u_6
inst✝³ : CommMonoid M
inst✝² : CommMonoid N
inst✝¹ : DivisionCommMonoid G
k l : ℕ
inst✝ : CommRing R
ζ : Rˣ
h : IsPrimitiveRoot ζ k
i : ℤ
⊢ h.zmodEquivZPowers ↑i = Additive.ofMul ⟨ζ ^ i, ⋯⟩
state_after: M : Type u_1
N : Type u_2
G : Type u_3
R : Type u_4
S : Type u_5
F : Type u_6
inst✝³ : CommMonoid M
inst✝² : CommMonoid N
inst✝¹ : DivisionCommMonoid G
k l : ℕ
inst✝ : CommRing R
ζ : Rˣ
h : IsPrimitiveRoot ζ k
i : ℤ
⊢ (((Int.castAddHom (ZMod k)).liftOfRightInverse ZMod.cast ⋯)
        ⟨{ toFun := fun i => Additive.ofMul ⟨(fun x => ζ ^ x) i, ⋯⟩, map_zero' := ⋯, map_add' := ⋯ }, ⋯⟩)
      ↑i =
    Additive.ofMul ⟨ζ ^ i, ⋯⟩

tactic: exact AddMonoidHom.liftOfRightInverse_comp_apply _ _ ZMod.intCast_rightInverse _ _
state_before: M : Type u_1
N : Type u_2
G : Type u_3
R : Type u_4
S : Type u_5
F : Type u_6
inst✝³ : CommMonoid M
inst✝² : CommMonoid N
inst✝¹ : DivisionCommMonoid G
k l : ℕ
inst✝ : CommRing R
ζ : Rˣ
h : IsPrimitiveRoot ζ k
i : ℤ
⊢ (((Int.castAddHom (ZMod k)).liftOfRightInverse ZMod.cast ⋯)
        ⟨{ toFun := fun i => Additive.ofMul ⟨(fun x => ζ ^ x) i, ⋯⟩, map_zero' := ⋯, map_add' := ⋯ }, ⋯⟩)
      ↑i =
    Additive.ofMul ⟨ζ ^ i, ⋯⟩
state_after: no goals
Theorem: Finset.card_div_mul_le_card_div_mul_card_mul
File: Mathlib/Combinatorics/Additive/PluenneckeRuzsa.lean

tactic: rw [← div_inv_eq_mul, div_eq_mul_inv]
state_before: α : Type u_1
inst✝¹ : CommGroup α
inst✝ : DecidableEq α
A✝ B✝ C✝ A B C : Finset α
⊢ (A / C).card * B.card ≤ (A / B).card * (B * C).card
state_after: α : Type u_1
inst✝¹ : CommGroup α
inst✝ : DecidableEq α
A✝ B✝ C✝ A B C : Finset α
⊢ (A * C⁻¹).card * B.card ≤ (A / B).card * (B / C⁻¹).card

tactic: exact card_mul_mul_le_card_div_mul_card_div _ _ _
state_before: α : Type u_1
inst✝¹ : CommGroup α
inst✝ : DecidableEq α
A✝ B✝ C✝ A B C : Finset α
⊢ (A * C⁻¹).card * B.card ≤ (A / B).card * (B / C⁻¹).card
state_after: no goals
Theorem: Polynomial.cyclotomic_eval_le_add_one_pow_totient
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Eval.lean

tactic: simp
state_before: q : ℝ
hq' : 1 < q
⊢ eval q (cyclotomic 0 ℝ) ≤ (q + 1) ^ φ 0
state_after: no goals

tactic: simp [add_assoc, add_nonneg, zero_le_one]
state_before: q : ℝ
hq' : 1 < q
⊢ eval q (cyclotomic 1 ℝ) ≤ (q + 1) ^ φ 1
state_after: no goals

tactic: simp
state_before: q : ℝ
hq' : 1 < q
⊢ eval q (cyclotomic 2 ℝ) ≤ (q + 1) ^ φ 2
state_after: no goals
Theorem: Submonoid.leftInvEquiv_symm_mul
File: Mathlib/GroupTheory/Submonoid/Inverses.lean

tactic: convert S.mul_leftInvEquiv hS ((S.leftInvEquiv hS).symm x)
state_before: M : Type u_1
inst✝ : CommMonoid M
S : Submonoid M
hS : S ≤ IsUnit.submonoid M
x : ↥S
⊢ ↑((S.leftInvEquiv hS).symm x) * ↑x = 1
state_after: case h.e'_2.h.e'_6.h.e'_3
M : Type u_1
inst✝ : CommMonoid M
S : Submonoid M
hS : S ≤ IsUnit.submonoid M
x : ↥S
⊢ x = (S.leftInvEquiv hS) ((S.leftInvEquiv hS).symm x)

tactic: simp
state_before: case h.e'_2.h.e'_6.h.e'_3
M : Type u_1
inst✝ : CommMonoid M
S : Submonoid M
hS : S ≤ IsUnit.submonoid M
x : ↥S
⊢ x = (S.leftInvEquiv hS) ((S.leftInvEquiv hS).symm x)
state_after: no goals
Theorem: AffineEquiv.sbtw_map_iff
File: Mathlib/Analysis/Convex/Between.lean

tactic: refine Function.Injective.sbtw_map_iff (?_ : Function.Injective f.toAffineMap)
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x y z : P
f : P ≃ᵃ[R] P'
⊢ Sbtw R (f x) (f y) (f z) ↔ Sbtw R x y z
state_after: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x y z : P
f : P ≃ᵃ[R] P'
⊢ Function.Injective ⇑↑f

tactic: exact f.injective
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x y z : P
f : P ≃ᵃ[R] P'
⊢ Function.Injective ⇑↑f
state_after: no goals
Theorem: LowerSet.mem_map
File: Mathlib/Order/UpperLower/Basic.lean

tactic: rw [← f.symm_symm, ← symm_map, f.symm_symm]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f✝ : α ≃o β
s t : LowerSet α
a : α
b✝ : β
f : α ≃o β
b : β
⊢ b ∈ (map f) s ↔ f.symm b ∈ s
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f✝ : α ≃o β
s t : LowerSet α
a : α
b✝ : β
f : α ≃o β
b : β
⊢ b ∈ (map f.symm).symm s ↔ f.symm b ∈ s

tactic: rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f✝ : α ≃o β
s t : LowerSet α
a : α
b✝ : β
f : α ≃o β
b : β
⊢ b ∈ (map f.symm).symm s ↔ f.symm b ∈ s
state_after: no goals
Theorem: CategoryTheory.Abelian.Pseudoelement.apply_eq_zero_of_comp_eq_zero
File: Mathlib/CategoryTheory/Abelian/Pseudoelements.lean

tactic: simp [over_coe_def, pseudoApply_mk', Over.coe_hom, h]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Abelian C
P Q R : C
f : Q ⟶ R
a : P ⟶ Q
h : a ≫ f = 0
⊢ pseudoApply f (Quot.mk (PseudoEqual Q) (Over.mk a)) = 0
state_after: no goals
Theorem: Bool.not_eq_true_eq_eq_false
File: Mathlib/Init/Data/Bool/Lemmas.lean

tactic: cases a <;> simp
state_before: a : Bool
⊢ ((!a) = true) = (a = false)
state_after: no goals
Theorem: Set.Icc_eq_empty_iff
File: Mathlib/Order/Interval/Set/Basic.lean

tactic: rw [← not_nonempty_iff_eq_empty, not_iff_not, nonempty_Icc]
state_before: α : Type u_1
β : Type u_2
inst✝ : Preorder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ Icc a b = ∅ ↔ ¬a ≤ b
state_after: no goals