1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Int.shiftLeft_coe_nat
File: Mathlib/Data/Int/Bitwise.lean

tactic: unfold_projs
state_before: m n : ℕ
⊢ ↑m <<< ↑n = ↑(m <<< n)
state_after: m n : ℕ
⊢ (match ↑m, ↑n with
    | ofNat m, ofNat n => ↑(Nat.shiftLeft' false m n)
    | ofNat m, -[n+1] => ↑(m.shiftRight n.succ)
    | -[m+1], ofNat n => -[Nat.shiftLeft' true m n+1]
    | -[m+1], -[n+1] => -[m.shiftRight n.succ+1]) =
    ↑(m.shiftLeft n)

tactic: simp
state_before: m n : ℕ
⊢ (match ↑m, ↑n with
    | ofNat m, ofNat n => ↑(Nat.shiftLeft' false m n)
    | ofNat m, -[n+1] => ↑(m.shiftRight n.succ)
    | -[m+1], ofNat n => -[Nat.shiftLeft' true m n+1]
    | -[m+1], -[n+1] => -[m.shiftRight n.succ+1]) =
    ↑(m.shiftLeft n)
state_after: no goals
Theorem: Function.Periodic.add_period
File: Mathlib/Algebra/Periodic.lean

tactic: simp_all [← add_assoc]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝ : AddSemigroup α
h1 : Periodic f c₁
h2 : Periodic f c₂
⊢ Periodic f (c₁ + c₂)
state_after: no goals
Theorem: MulOpposite.semiconjBy_unop
File: Mathlib/Algebra/Group/Opposite.lean

tactic: conv_rhs => rw [← op_unop a, ← op_unop x, ← op_unop y, semiconjBy_op]
state_before: α : Type u_1
inst✝ : Mul α
a x y : αᵐᵒᵖ
⊢ SemiconjBy (unop a) (unop y) (unop x) ↔ SemiconjBy a x y
state_after: no goals
Theorem: Filter.sdiff_liminf
File: Mathlib/Order/LiminfLimsup.lean

tactic: rw [← compl_inj_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝ : CompleteBooleanAlgebra α
f : Filter β
u : β → α
a : α
⊢ a \ liminf u f = limsup (fun b => a \ u b) f
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝ : CompleteBooleanAlgebra α
f : Filter β
u : β → α
a : α
⊢ (a \ liminf u f)ᶜ = (limsup (fun b => a \ u b) f)ᶜ
Theorem: antilipschitzWith_iff_le_mul_nndist
File: Mathlib/Topology/MetricSpace/Antilipschitz.lean

tactic: simp only [AntilipschitzWith, edist_nndist]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
K : ℝ≥0
f : α → β
⊢ AntilipschitzWith K f ↔ ∀ (x y : α), nndist x y ≤ K * nndist (f x) (f y)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
K : ℝ≥0
f : α → β
⊢ (∀ (x y : α), ↑(nndist x y) ≤ ↑K * ↑(nndist (f x) (f y))) ↔ ∀ (x y : α), nndist x y ≤ K * nndist (f x) (f y)

tactic: norm_cast
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
K : ℝ≥0
f : α → β
⊢ (∀ (x y : α), ↑(nndist x y) ≤ ↑K * ↑(nndist (f x) (f y))) ↔ ∀ (x y : α), nndist x y ≤ K * nndist (f x) (f y)
state_after: no goals
Theorem: CategoryTheory.MorphismProperty.monotone_isoClosure
File: Mathlib/CategoryTheory/MorphismProperty/Basic.lean

tactic: intro P Q h X Y f ⟨X', Y', f', hf', ⟨e⟩⟩
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u_1
inst✝ : Category.{?u.10422, u_1} D
⊢ Monotone isoClosure
state_after: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u_1
inst✝ : Category.{?u.10422, u_1} D
P Q : MorphismProperty C
h : P ≤ Q
X Y : C
f : X ⟶ Y
X' Y' : C
f' : X' ⟶ Y'
hf' : P f'
e : Arrow.mk f' ≅ Arrow.mk f
⊢ Q.isoClosure f

tactic: exact ⟨X', Y', f', h _ hf', ⟨e⟩⟩
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u_1
inst✝ : Category.{?u.10422, u_1} D
P Q : MorphismProperty C
h : P ≤ Q
X Y : C
f : X ⟶ Y
X' Y' : C
f' : X' ⟶ Y'
hf' : P f'
e : Arrow.mk f' ≅ Arrow.mk f
⊢ Q.isoClosure f
state_after: no goals
Theorem: Semiquot.pure_isPure
File: Mathlib/Data/Semiquot.lean

tactic: rw [mem_pure] at ab ac
state_before: α : Type u_1
β : Type u_2
a b : α
ab : b ∈ pure a
c : α
ac : c ∈ pure a
⊢ b = c
state_after: α : Type u_1
β : Type u_2
a b : α
ab : b = a
c : α
ac : c = a
⊢ b = c

tactic: rwa [← ac] at ab
state_before: α : Type u_1
β : Type u_2
a b : α
ab : b = a
c : α
ac : c = a
⊢ b = c
state_after: no goals
Theorem: FreeGroup.Red.append_append_left_iff
File: Mathlib/GroupTheory/FreeGroup/Basic.lean

tactic: simp [append_append_left_iff L, cons_cons_iff]
state_before: α : Type u
L✝ L₁ L₂ L₃ L₄ : List (α × Bool)
p : α × Bool
L : List (α × Bool)
⊢ Red (p :: L ++ L₁) (p :: L ++ L₂) ↔ Red L₁ L₂
state_after: no goals
Theorem: CharP.nontrivial_of_char_ne_one
File: Mathlib/Algebra/CharP/Defs.lean

tactic: rwa [CharP.cast_eq_zero_iff _ v, Nat.dvd_one] at h
state_before: R : Type u_1
inst✝ : NonAssocSemiring R
v : ℕ
hv : v ≠ 1
hr : CharP R v
h : ↑1 = 0
⊢ v = 1
state_after: no goals
Theorem: CategoryTheory.Limits.colimitObjIsoColimitCompEvaluation_ι_app_hom
File: Mathlib/CategoryTheory/Limits/FunctorCategory.lean

tactic: dsimp [colimitObjIsoColimitCompEvaluation]
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : HasColimitsOfShape J C
F : J ⥤ K ⥤ C
j : J
k : K
⊢ (colimit.ι F j).app k ≫ (colimitObjIsoColimitCompEvaluation F k).hom = colimit.ι (F ⋙ (evaluation K C).obj k) j
state_after: C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : HasColimitsOfShape J C
F : J ⥤ K ⥤ C
j : J
k : K
⊢ (colimit.ι F j).app k ≫ (preservesColimitIso ((evaluation K C).obj k) F).hom =
    colimit.ι (F ⋙ (evaluation K C).obj k) j

tactic: rw [← Iso.eq_comp_inv]
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : HasColimitsOfShape J C
F : J ⥤ K ⥤ C
j : J
k : K
⊢ (colimit.ι F j).app k ≫ (preservesColimitIso ((evaluation K C).obj k) F).hom =
    colimit.ι (F ⋙ (evaluation K C).obj k) j
state_after: C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : HasColimitsOfShape J C
F : J ⥤ K ⥤ C
j : J
k : K
⊢ (colimit.ι F j).app k =
    colimit.ι (F ⋙ (evaluation K C).obj k) j ≫ (preservesColimitIso ((evaluation K C).obj k) F).inv

tactic: simp
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : HasColimitsOfShape J C
F : J ⥤ K ⥤ C
j : J
k : K
⊢ (colimit.ι F j).app k =
    colimit.ι (F ⋙ (evaluation K C).obj k) j ≫ (preservesColimitIso ((evaluation K C).obj k) F).inv
state_after: no goals
Theorem: Polynomial.root_right_of_root_gcd
File: Mathlib/Algebra/Polynomial/FieldDivision.lean

tactic: cases' EuclideanDomain.gcd_dvd_right f g with p hp
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝² : Field R
p q : R[X]
inst✝¹ : CommSemiring k
inst✝ : DecidableEq R
ϕ : R →+* k
f g : R[X]
α : k
hα : eval₂ ϕ α (EuclideanDomain.gcd f g) = 0
⊢ eval₂ ϕ α g = 0
state_after: case intro
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝² : Field R
p✝ q : R[X]
inst✝¹ : CommSemiring k
inst✝ : DecidableEq R
ϕ : R →+* k
f g : R[X]
α : k
hα : eval₂ ϕ α (EuclideanDomain.gcd f g) = 0
p : R[X]
hp : g = EuclideanDomain.gcd f g * p
⊢ eval₂ ϕ α g = 0

tactic: rw [hp, Polynomial.eval₂_mul, hα, zero_mul]
state_before: case intro
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝² : Field R
p✝ q : R[X]
inst✝¹ : CommSemiring k
inst✝ : DecidableEq R
ϕ : R →+* k
f g : R[X]
α : k
hα : eval₂ ϕ α (EuclideanDomain.gcd f g) = 0
p : R[X]
hp : g = EuclideanDomain.gcd f g * p
⊢ eval₂ ϕ α g = 0
state_after: no goals
Theorem: HahnSeries.orderTop_eq_top_iff
File: Mathlib/RingTheory/HahnSeries/Basic.lean

tactic: constructor
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : Zero R
a b : Γ
r : R
x : HahnSeries Γ R
⊢ x.orderTop = ⊤ ↔ x = 0
state_after: case mp
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : Zero R
a b : Γ
r : R
x : HahnSeries Γ R
⊢ x.orderTop = ⊤ → x = 0

case mpr
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : Zero R
a b : Γ
r : R
x : HahnSeries Γ R
⊢ x = 0 → x.orderTop = ⊤

tactic: contrapose!
state_before: case mp
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : Zero R
a b : Γ
r : R
x : HahnSeries Γ R
⊢ x.orderTop = ⊤ → x = 0
state_after: case mp
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : Zero R
a b : Γ
r : R
x : HahnSeries Γ R
⊢ x ≠ 0 → x.orderTop ≠ ⊤

tactic: exact ne_zero_iff_orderTop.mp
state_before: case mp
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : Zero R
a b : Γ
r : R
x : HahnSeries Γ R
⊢ x ≠ 0 → x.orderTop ≠ ⊤
state_after: no goals

tactic: simp_all only [orderTop_zero, implies_true]
state_before: case mpr
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : Zero R
a b : Γ
r : R
x : HahnSeries Γ R
⊢ x = 0 → x.orderTop = ⊤
state_after: no goals
Theorem: Rat.ofScientific_nonneg
File: Mathlib/Algebra/Order/Ring/Rat.lean

tactic: rw [Rat.ofScientific]
state_before: a b c p q : ℚ
m : ℕ
s : Bool
e : ℕ
⊢ 0 ≤ Rat.ofScientific m s e
state_after: a b c p q : ℚ
m : ℕ
s : Bool
e : ℕ
⊢ 0 ≤ if s = true then normalize (↑m) (10 ^ e) ⋯ else ↑(m * 10 ^ e)

tactic: cases s
state_before: a b c p q : ℚ
m : ℕ
s : Bool
e : ℕ
⊢ 0 ≤ if s = true then normalize (↑m) (10 ^ e) ⋯ else ↑(m * 10 ^ e)
state_after: case false
a b c p q : ℚ
m e : ℕ
⊢ 0 ≤ if false = true then normalize (↑m) (10 ^ e) ⋯ else ↑(m * 10 ^ e)

case true
a b c p q : ℚ
m e : ℕ
⊢ 0 ≤ if true = true then normalize (↑m) (10 ^ e) ⋯ else ↑(m * 10 ^ e)

tactic: rw [if_neg (by decide)]
state_before: case false
a b c p q : ℚ
m e : ℕ
⊢ 0 ≤ if false = true then normalize (↑m) (10 ^ e) ⋯ else ↑(m * 10 ^ e)
state_after: case false
a b c p q : ℚ
m e : ℕ
⊢ 0 ≤ ↑(m * 10 ^ e)

tactic: refine num_nonneg.mp ?_
state_before: case false
a b c p q : ℚ
m e : ℕ
⊢ 0 ≤ ↑(m * 10 ^ e)
state_after: case false
a b c p q : ℚ
m e : ℕ
⊢ 0 ≤ (↑(m * 10 ^ e)).num

tactic: rw [num_natCast]
state_before: case false
a b c p q : ℚ
m e : ℕ
⊢ 0 ≤ (↑(m * 10 ^ e)).num
state_after: case false
a b c p q : ℚ
m e : ℕ
⊢ 0 ≤ ↑(m * 10 ^ e)

tactic: exact Int.natCast_nonneg _
state_before: case false
a b c p q : ℚ
m e : ℕ
⊢ 0 ≤ ↑(m * 10 ^ e)
state_after: no goals

tactic: decide
state_before: a b c p q : ℚ
m e : ℕ
⊢ ¬false = true
state_after: no goals

tactic: rw [if_pos rfl, normalize_eq_mkRat]
state_before: case true
a b c p q : ℚ
m e : ℕ
⊢ 0 ≤ if true = true then normalize (↑m) (10 ^ e) ⋯ else ↑(m * 10 ^ e)
state_after: case true
a b c p q : ℚ
m e : ℕ
⊢ 0 ≤ mkRat (↑m) (10 ^ e)

tactic: exact Rat.mkRat_nonneg (Int.natCast_nonneg _) _
state_before: case true
a b c p q : ℚ
m e : ℕ
⊢ 0 ≤ mkRat (↑m) (10 ^ e)
state_after: no goals
Theorem: Int.ModEq.of_div
File: Mathlib/Data/Int/ModEq.lean

tactic: convert h.mul_left' <;> rwa [Int.mul_ediv_cancel']
state_before: m n a b c d : ℤ
h : a / c ≡ b / c [ZMOD m / c]
ha✝¹ : c ∣ a
ha✝ : c ∣ b
ha : c ∣ m
⊢ a ≡ b [ZMOD m]
state_after: no goals
Theorem: Multiset.mem_sections
File: Mathlib/Data/Multiset/Sections.lean

tactic: induction s using Multiset.induction_on with
| empty => simp
| cons _ _ ih => simp [ih, rel_cons_left, eq_comm]
state_before: α : Type u_1
s : Multiset (Multiset α)
⊢ ∀ {a : Multiset α}, a ∈ s.Sections ↔ Rel (fun s a => a ∈ s) s a
state_after: no goals

tactic: simp
state_before: case empty
α : Type u_1
⊢ ∀ {a : Multiset α}, a ∈ Sections 0 ↔ Rel (fun s a => a ∈ s) 0 a
state_after: no goals

tactic: simp [ih, rel_cons_left, eq_comm]
state_before: case cons
α : Type u_1
a✝ : Multiset α
s✝ : Multiset (Multiset α)
ih : ∀ {a : Multiset α}, a ∈ s✝.Sections ↔ Rel (fun s a => a ∈ s) s✝ a
⊢ ∀ {a : Multiset α}, a ∈ (a✝ ::ₘ s✝).Sections ↔ Rel (fun s a => a ∈ s) (a✝ ::ₘ s✝) a
state_after: no goals
Theorem: Polynomial.map_cyclotomic
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean

tactic: rw [← map_cyclotomic_int n R, ← map_cyclotomic_int n S, map_map]
state_before: n : ℕ
R : Type u_1
S : Type u_2
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
⊢ map f (cyclotomic n R) = cyclotomic n S
state_after: n : ℕ
R : Type u_1
S : Type u_2
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
⊢ map (f.comp (Int.castRingHom R)) (cyclotomic n ℤ) = map (Int.castRingHom S) (cyclotomic n ℤ)

tactic: have : Subsingleton (ℤ →+* S) := inferInstance
state_before: n : ℕ
R : Type u_1
S : Type u_2
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
⊢ map (f.comp (Int.castRingHom R)) (cyclotomic n ℤ) = map (Int.castRingHom S) (cyclotomic n ℤ)
state_after: n : ℕ
R : Type u_1
S : Type u_2
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
this : Subsingleton (ℤ →+* S)
⊢ map (f.comp (Int.castRingHom R)) (cyclotomic n ℤ) = map (Int.castRingHom S) (cyclotomic n ℤ)

tactic: congr!
state_before: n : ℕ
R : Type u_1
S : Type u_2
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
this : Subsingleton (ℤ →+* S)
⊢ map (f.comp (Int.castRingHom R)) (cyclotomic n ℤ) = map (Int.castRingHom S) (cyclotomic n ℤ)
state_after: no goals
Theorem: Real.strictMonoOn_tan
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: rintro x hx y hy hlt
state_before: ⊢ StrictMonoOn tan (Ioo (-(π / 2)) (π / 2))
state_after: x : ℝ
hx : x ∈ Ioo (-(π / 2)) (π / 2)
y : ℝ
hy : y ∈ Ioo (-(π / 2)) (π / 2)
hlt : x < y
⊢ tan x < tan y

tactic: rw [tan_eq_sin_div_cos, tan_eq_sin_div_cos,
  div_lt_div_iff (cos_pos_of_mem_Ioo hx) (cos_pos_of_mem_Ioo hy), mul_comm, ← sub_pos, ← sin_sub]
state_before: x : ℝ
hx : x ∈ Ioo (-(π / 2)) (π / 2)
y : ℝ
hy : y ∈ Ioo (-(π / 2)) (π / 2)
hlt : x < y
⊢ tan x < tan y
state_after: x : ℝ
hx : x ∈ Ioo (-(π / 2)) (π / 2)
y : ℝ
hy : y ∈ Ioo (-(π / 2)) (π / 2)
hlt : x < y
⊢ 0 < sin (y - x)

tactic: exact sin_pos_of_pos_of_lt_pi (sub_pos.2 hlt) <| by linarith [hx.1, hy.2]
state_before: x : ℝ
hx : x ∈ Ioo (-(π / 2)) (π / 2)
y : ℝ
hy : y ∈ Ioo (-(π / 2)) (π / 2)
hlt : x < y
⊢ 0 < sin (y - x)
state_after: no goals

tactic: linarith [hx.1, hy.2]
state_before: x : ℝ
hx : x ∈ Ioo (-(π / 2)) (π / 2)
y : ℝ
hy : y ∈ Ioo (-(π / 2)) (π / 2)
hlt : x < y
⊢ y - x < π
state_after: no goals
Theorem: Matrix.dotProduct_neg
File: Mathlib/Data/Matrix/Basic.lean

tactic: simp [dotProduct]
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : Fintype m
inst✝¹ : Fintype n
inst✝ : NonUnitalNonAssocRing α
u v w : m → α
⊢ v ⬝ᵥ -w = -(v ⬝ᵥ w)
state_after: no goals
Theorem: ContinuousLinearMap.opNorm_lsmul_le
File: Mathlib/Analysis/NormedSpace/OperatorNorm/Mul.lean

tactic: refine ContinuousLinearMap.opNorm_le_bound _ zero_le_one fun x => ?_
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : SeminormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
𝕜' : Type u_3
inst✝³ : NormedField 𝕜'
inst✝² : NormedAlgebra 𝕜 𝕜'
inst✝¹ : NormedSpace 𝕜' E
inst✝ : IsScalarTower 𝕜 𝕜' E
⊢ ‖lsmul 𝕜 𝕜'‖ ≤ 1
state_after: 𝕜 : Type u_1
E : Type u_2
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : SeminormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
𝕜' : Type u_3
inst✝³ : NormedField 𝕜'
inst✝² : NormedAlgebra 𝕜 𝕜'
inst✝¹ : NormedSpace 𝕜' E
inst✝ : IsScalarTower 𝕜 𝕜' E
x : 𝕜'
⊢ ‖(lsmul 𝕜 𝕜') x‖ ≤ 1 * ‖x‖

tactic: simp_rw [one_mul]
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : SeminormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
𝕜' : Type u_3
inst✝³ : NormedField 𝕜'
inst✝² : NormedAlgebra 𝕜 𝕜'
inst✝¹ : NormedSpace 𝕜' E
inst✝ : IsScalarTower 𝕜 𝕜' E
x : 𝕜'
⊢ ‖(lsmul 𝕜 𝕜') x‖ ≤ 1 * ‖x‖
state_after: 𝕜 : Type u_1
E : Type u_2
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : SeminormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
𝕜' : Type u_3
inst✝³ : NormedField 𝕜'
inst✝² : NormedAlgebra 𝕜 𝕜'
inst✝¹ : NormedSpace 𝕜' E
inst✝ : IsScalarTower 𝕜 𝕜' E
x : 𝕜'
⊢ ‖(lsmul 𝕜 𝕜') x‖ ≤ ‖x‖

tactic: exact opNorm_lsmul_apply_le _
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : SeminormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
𝕜' : Type u_3
inst✝³ : NormedField 𝕜'
inst✝² : NormedAlgebra 𝕜 𝕜'
inst✝¹ : NormedSpace 𝕜' E
inst✝ : IsScalarTower 𝕜 𝕜' E
x : 𝕜'
⊢ ‖(lsmul 𝕜 𝕜') x‖ ≤ ‖x‖
state_after: no goals
Theorem: StrictMonoOn.lt_iff_lt
File: Mathlib/Order/Monotone/Basic.lean

tactic: rw [lt_iff_le_not_le, lt_iff_le_not_le, hf.le_iff_le ha hb, hf.le_iff_le hb ha]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝¹ : LinearOrder α
inst✝ : Preorder β
f : α → β
s : Set α
hf : StrictMonoOn f s
a b : α
ha : a ∈ s
hb : b ∈ s
⊢ f a < f b ↔ a < b
state_after: no goals
Theorem: Set.encard_congr
File: Mathlib/Data/Set/Card.lean

tactic: rw [← encard_univ_coe, ← encard_univ_coe t, encard_univ, encard_univ, PartENat.card_congr e]
state_before: α : Type u_1
β : Type u_2
s✝ t✝ s : Set α
t : Set β
f : α → β
e : ↑s ≃ ↑t
⊢ s.encard = t.encard
state_after: no goals
Theorem: List.Nodup.product
File: Mathlib/Data/List/Nodup.lean

tactic: rcases mem_map.1 h₁ with ⟨b₁, _, rfl⟩
state_before: α : Type u
β : Type v
l l₁ l₂✝ : List α
r : α → α → Prop
a b : α
l₂ : List β
d₁ : l₁.Nodup
d₂ : l₂.Nodup
a₁ a₂ : α
n : a₁ ≠ a₂
x : α × β
h₁ : x ∈ map (Prod.mk a₁) l₂
h₂ : x ∈ map (Prod.mk a₂) l₂
⊢ False
state_after: case intro.intro
α : Type u
β : Type v
l l₁ l₂✝ : List α
r : α → α → Prop
a b : α
l₂ : List β
d₁ : l₁.Nodup
d₂ : l₂.Nodup
a₁ a₂ : α
n : a₁ ≠ a₂
b₁ : β
left✝ : b₁ ∈ l₂
h₁ : (a₁, b₁) ∈ map (Prod.mk a₁) l₂
h₂ : (a₁, b₁) ∈ map (Prod.mk a₂) l₂
⊢ False

tactic: rcases mem_map.1 h₂ with ⟨b₂, mb₂, ⟨⟩⟩
state_before: case intro.intro
α : Type u
β : Type v
l l₁ l₂✝ : List α
r : α → α → Prop
a b : α
l₂ : List β
d₁ : l₁.Nodup
d₂ : l₂.Nodup
a₁ a₂ : α
n : a₁ ≠ a₂
b₁ : β
left✝ : b₁ ∈ l₂
h₁ : (a₁, b₁) ∈ map (Prod.mk a₁) l₂
h₂ : (a₁, b₁) ∈ map (Prod.mk a₂) l₂
⊢ False
state_after: case intro.intro.intro.intro.refl
α : Type u
β : Type v
l l₁ l₂✝ : List α
r : α → α → Prop
a b : α
l₂ : List β
d₁ : l₁.Nodup
d₂ : l₂.Nodup
a₁ : α
b₁ : β
left✝ : b₁ ∈ l₂
h₁ : (a₁, b₁) ∈ map (Prod.mk a₁) l₂
n : a₁ ≠ a₁
h₂ : (a₁, b₁) ∈ map (Prod.mk a₁) l₂
mb₂ : b₁ ∈ l₂
⊢ False

tactic: exact n rfl
state_before: case intro.intro.intro.intro.refl
α : Type u
β : Type v
l l₁ l₂✝ : List α
r : α → α → Prop
a b : α
l₂ : List β
d₁ : l₁.Nodup
d₂ : l₂.Nodup
a₁ : α
b₁ : β
left✝ : b₁ ∈ l₂
h₁ : (a₁, b₁) ∈ map (Prod.mk a₁) l₂
n : a₁ ≠ a₁
h₂ : (a₁, b₁) ∈ map (Prod.mk a₁) l₂
mb₂ : b₁ ∈ l₂
⊢ False
state_after: no goals
Theorem: CategoryTheory.Iso.inv_hom_id_eval
File: Mathlib/CategoryTheory/GradedObject.lean

tactic: rw [← GradedObject.categoryOfGradedObjects_comp, e.inv_hom_id,
  GradedObject.categoryOfGradedObjects_id]
state_before: C : Type u_1
D : Type u_2
E : Type u_3
J : Type u_4
inst✝² : Category.{u_5, u_1} C
inst✝¹ : Category.{?u.7355, u_2} D
inst✝ : Category.{?u.7359, u_3} E
X Y : GradedObject J C
e : X ≅ Y
j : J
⊢ e.inv j ≫ e.hom j = 𝟙 (Y j)
state_after: no goals
Theorem: WeierstrassCurve.Affine.map_linePolynomial
File: Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean

tactic: simp only [linePolynomial]
state_before: R : Type u
inst✝¹ : CommRing R
W : Affine R
S : Type v
inst✝ : CommRing S
f : R →+* S
x y L : R
⊢ linePolynomial (f x) (f y) (f L) = Polynomial.map f (linePolynomial x y L)
state_after: R : Type u
inst✝¹ : CommRing R
W : Affine R
S : Type v
inst✝ : CommRing S
f : R →+* S
x y L : R
⊢ C (f L) * (X - C (f x)) + C (f y) = Polynomial.map f (C L * (X - C x) + C y)

tactic: map_simp
state_before: R : Type u
inst✝¹ : CommRing R
W : Affine R
S : Type v
inst✝ : CommRing S
f : R →+* S
x y L : R
⊢ C (f L) * (X - C (f x)) + C (f y) = Polynomial.map f (C L * (X - C x) + C y)
state_after: no goals
Theorem: List.pmap_eq_nil
File: Mathlib/Data/List/Basic.lean

tactic: rw [← length_eq_zero, length_pmap, length_eq_zero]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Prop
f : (a : α) → p a → β
l : List α
H : ∀ (a : α), a ∈ l → p a
⊢ pmap f l H = [] ↔ l = []
state_after: no goals
Theorem: abs_cases
File: Mathlib/Algebra/Order/Group/Abs.lean

tactic: by_cases h : 0 ≤ a
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b c d a : α
⊢ |a| = a ∧ 0 ≤ a ∨ |a| = -a ∧ a < 0
state_after: case pos
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b c d a : α
h : 0 ≤ a
⊢ |a| = a ∧ 0 ≤ a ∨ |a| = -a ∧ a < 0

case neg
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b c d a : α
h : ¬0 ≤ a
⊢ |a| = a ∧ 0 ≤ a ∨ |a| = -a ∧ a < 0

tactic: left
state_before: case pos
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b c d a : α
h : 0 ≤ a
⊢ |a| = a ∧ 0 ≤ a ∨ |a| = -a ∧ a < 0
state_after: case pos.h
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b c d a : α
h : 0 ≤ a
⊢ |a| = a ∧ 0 ≤ a

tactic: exact ⟨abs_eq_self.mpr h, h⟩
state_before: case pos.h
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b c d a : α
h : 0 ≤ a
⊢ |a| = a ∧ 0 ≤ a
state_after: no goals

tactic: right
state_before: case neg
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b c d a : α
h : ¬0 ≤ a
⊢ |a| = a ∧ 0 ≤ a ∨ |a| = -a ∧ a < 0
state_after: case neg.h
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b c d a : α
h : ¬0 ≤ a
⊢ |a| = -a ∧ a < 0

tactic: push_neg at h
state_before: case neg.h
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b c d a : α
h : ¬0 ≤ a
⊢ |a| = -a ∧ a < 0
state_after: case neg.h
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b c d a : α
h : a < 0
⊢ |a| = -a ∧ a < 0

tactic: exact ⟨abs_eq_neg_self.mpr (le_of_lt h), h⟩
state_before: case neg.h
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b c d a : α
h : a < 0
⊢ |a| = -a ∧ a < 0
state_after: no goals
Theorem: covBy_sup_of_inf_covBy_right
File: Mathlib/Order/ModularLattice.lean

tactic: rw [sup_comm, inf_comm]
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsUpperModularLattice α
a b : α
⊢ a ⊓ b ⋖ b → a ⋖ a ⊔ b
state_after: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsUpperModularLattice α
a b : α
⊢ b ⊓ a ⋖ b → a ⋖ b ⊔ a

tactic: exact covBy_sup_of_inf_covBy_left
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsUpperModularLattice α
a b : α
⊢ b ⊓ a ⋖ b → a ⋖ b ⊔ a
state_after: no goals
Theorem: GroupTopology.coinduced_continuous
File: Mathlib/Topology/Algebra/Group/Basic.lean

tactic: rw [continuous_sInf_rng]
state_before: G : Type w
H : Type x
α✝ : Type u
β✝ : Type v
inst✝¹ : Group α✝
α : Type u_1
β : Type u_2
t : TopologicalSpace α
inst✝ : Group β
f : α → β
⊢ Continuous f
state_after: G : Type w
H : Type x
α✝ : Type u
β✝ : Type v
inst✝¹ : Group α✝
α : Type u_1
β : Type u_2
t : TopologicalSpace α
inst✝ : Group β
f : α → β
⊢ ∀ t_1 ∈ toTopologicalSpace '' {b | TopologicalSpace.coinduced f t ≤ b.toTopologicalSpace}, Continuous f

tactic: rintro _ ⟨t', ht', rfl⟩
state_before: G : Type w
H : Type x
α✝ : Type u
β✝ : Type v
inst✝¹ : Group α✝
α : Type u_1
β : Type u_2
t : TopologicalSpace α
inst✝ : Group β
f : α → β
⊢ ∀ t_1 ∈ toTopologicalSpace '' {b | TopologicalSpace.coinduced f t ≤ b.toTopologicalSpace}, Continuous f
state_after: case intro.intro
G : Type w
H : Type x
α✝ : Type u
β✝ : Type v
inst✝¹ : Group α✝
α : Type u_1
β : Type u_2
t : TopologicalSpace α
inst✝ : Group β
f : α → β
t' : GroupTopology β
ht' : t' ∈ {b | TopologicalSpace.coinduced f t ≤ b.toTopologicalSpace}
⊢ Continuous f

tactic: exact continuous_iff_coinduced_le.2 ht'
state_before: case intro.intro
G : Type w
H : Type x
α✝ : Type u
β✝ : Type v
inst✝¹ : Group α✝
α : Type u_1
β : Type u_2
t : TopologicalSpace α
inst✝ : Group β
f : α → β
t' : GroupTopology β
ht' : t' ∈ {b | TopologicalSpace.coinduced f t ≤ b.toTopologicalSpace}
⊢ Continuous f
state_after: no goals
Theorem: Real.logb_lt_logb_iff
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: rw [logb, logb, div_lt_div_right (log_pos hb)]
state_before: b x y : ℝ
hb : 1 < b
hx : 0 < x
hy : 0 < y
⊢ logb b x < logb b y ↔ x < y
state_after: b x y : ℝ
hb : 1 < b
hx : 0 < x
hy : 0 < y
⊢ log x < log y ↔ x < y

tactic: exact log_lt_log_iff hx hy
state_before: b x y : ℝ
hb : 1 < b
hx : 0 < x
hy : 0 < y
⊢ log x < log y ↔ x < y
state_after: no goals