1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Multiset.lt_replicate_succ
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [lt_iff_cons_le]
state_before: α : Type u_1
β : Type v
γ : Type u_2
m : Multiset α
x : α
n : ℕ
⊢ m < replicate (n + 1) x ↔ m ≤ replicate n x
state_after: α : Type u_1
β : Type v
γ : Type u_2
m : Multiset α
x : α
n : ℕ
⊢ (∃ a, a ::ₘ m ≤ replicate (n + 1) x) ↔ m ≤ replicate n x

tactic: constructor
state_before: α : Type u_1
β : Type v
γ : Type u_2
m : Multiset α
x : α
n : ℕ
⊢ (∃ a, a ::ₘ m ≤ replicate (n + 1) x) ↔ m ≤ replicate n x
state_after: case mp
α : Type u_1
β : Type v
γ : Type u_2
m : Multiset α
x : α
n : ℕ
⊢ (∃ a, a ::ₘ m ≤ replicate (n + 1) x) → m ≤ replicate n x

case mpr
α : Type u_1
β : Type v
γ : Type u_2
m : Multiset α
x : α
n : ℕ
⊢ m ≤ replicate n x → ∃ a, a ::ₘ m ≤ replicate (n + 1) x

tactic: rintro ⟨x', hx'⟩
state_before: case mp
α : Type u_1
β : Type v
γ : Type u_2
m : Multiset α
x : α
n : ℕ
⊢ (∃ a, a ::ₘ m ≤ replicate (n + 1) x) → m ≤ replicate n x
state_after: case mp.intro
α : Type u_1
β : Type v
γ : Type u_2
m : Multiset α
x : α
n : ℕ
x' : α
hx' : x' ::ₘ m ≤ replicate (n + 1) x
⊢ m ≤ replicate n x

tactic: have := eq_of_mem_replicate (mem_of_le hx' (mem_cons_self _ _))
state_before: case mp.intro
α : Type u_1
β : Type v
γ : Type u_2
m : Multiset α
x : α
n : ℕ
x' : α
hx' : x' ::ₘ m ≤ replicate (n + 1) x
⊢ m ≤ replicate n x
state_after: case mp.intro
α : Type u_1
β : Type v
γ : Type u_2
m : Multiset α
x : α
n : ℕ
x' : α
hx' : x' ::ₘ m ≤ replicate (n + 1) x
this : x' = x
⊢ m ≤ replicate n x

tactic: rwa [this, replicate_succ, cons_le_cons_iff] at hx'
state_before: case mp.intro
α : Type u_1
β : Type v
γ : Type u_2
m : Multiset α
x : α
n : ℕ
x' : α
hx' : x' ::ₘ m ≤ replicate (n + 1) x
this : x' = x
⊢ m ≤ replicate n x
state_after: no goals

tactic: intro h
state_before: case mpr
α : Type u_1
β : Type v
γ : Type u_2
m : Multiset α
x : α
n : ℕ
⊢ m ≤ replicate n x → ∃ a, a ::ₘ m ≤ replicate (n + 1) x
state_after: case mpr
α : Type u_1
β : Type v
γ : Type u_2
m : Multiset α
x : α
n : ℕ
h : m ≤ replicate n x
⊢ ∃ a, a ::ₘ m ≤ replicate (n + 1) x

tactic: rw [replicate_succ]
state_before: case mpr
α : Type u_1
β : Type v
γ : Type u_2
m : Multiset α
x : α
n : ℕ
h : m ≤ replicate n x
⊢ ∃ a, a ::ₘ m ≤ replicate (n + 1) x
state_after: case mpr
α : Type u_1
β : Type v
γ : Type u_2
m : Multiset α
x : α
n : ℕ
h : m ≤ replicate n x
⊢ ∃ a, a ::ₘ m ≤ x ::ₘ replicate n x

tactic: exact ⟨x, cons_le_cons _ h⟩
state_before: case mpr
α : Type u_1
β : Type v
γ : Type u_2
m : Multiset α
x : α
n : ℕ
h : m ≤ replicate n x
⊢ ∃ a, a ::ₘ m ≤ x ::ₘ replicate n x
state_after: no goals
Theorem: MonoidAlgebra.prod_single
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

tactic: rw [prod_cons has, ih, single_mul_single, prod_cons has, prod_cons has]
state_before: k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
ι : Type ui
inst✝¹ : CommSemiring k
inst✝ : CommMonoid G
s✝ : Finset ι
a✝ : ι → G
b : ι → k
a : ι
s : Finset ι
has : a ∉ s
ih : ∏ i ∈ s, single (a✝ i) (b i) = single (∏ i ∈ s, a✝ i) (∏ i ∈ s, b i)
⊢ ∏ i ∈ Finset.cons a s has, single (a✝ i) (b i) =
    single (∏ i ∈ Finset.cons a s has, a✝ i) (∏ i ∈ Finset.cons a s has, b i)
state_after: no goals
Theorem: CategoryTheory.Sieve.arrows_ext
File: Mathlib/CategoryTheory/Sites/Sieves.lean

tactic: rintro ⟨_, _⟩ ⟨_, _⟩ rfl
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f : Y ⟶ X
S R : Sieve X
⊢ ∀ {R S : Sieve X}, R.arrows = S.arrows → R = S
state_after: case mk.mk
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f : Y ⟶ X
S R : Sieve X
arrows✝ : Presieve X
downward_closed✝¹ : ∀ {Y Z : C} {f : Y ⟶ X}, arrows✝ f → ∀ (g : Z ⟶ Y), arrows✝ (g ≫ f)
downward_closed✝ :
  ∀ {Y Z : C} {f : Y ⟶ X},
    { arrows := arrows✝, downward_closed := downward_closed✝¹ }.arrows f →
      ∀ (g : Z ⟶ Y), { arrows := arrows✝, downward_closed := downward_closed✝¹ }.arrows (g ≫ f)
⊢ { arrows := arrows✝, downward_closed := downward_closed✝¹ } =
    { arrows := { arrows := arrows✝, downward_closed := downward_closed✝¹ }.arrows,
      downward_closed := downward_closed✝ }

tactic: rfl
state_before: case mk.mk
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f : Y ⟶ X
S R : Sieve X
arrows✝ : Presieve X
downward_closed✝¹ : ∀ {Y Z : C} {f : Y ⟶ X}, arrows✝ f → ∀ (g : Z ⟶ Y), arrows✝ (g ≫ f)
downward_closed✝ :
  ∀ {Y Z : C} {f : Y ⟶ X},
    { arrows := arrows✝, downward_closed := downward_closed✝¹ }.arrows f →
      ∀ (g : Z ⟶ Y), { arrows := arrows✝, downward_closed := downward_closed✝¹ }.arrows (g ≫ f)
⊢ { arrows := arrows✝, downward_closed := downward_closed✝¹ } =
    { arrows := { arrows := arrows✝, downward_closed := downward_closed✝¹ }.arrows,
      downward_closed := downward_closed✝ }
state_after: no goals
Theorem: Nat.pow_sub_lt_descFactorial'
File: Mathlib/Data/Nat/Factorial/Basic.lean

tactic: rw [descFactorial_succ, Nat.pow_succ, Nat.pow_one, descFactorial_one]
state_before: n : ℕ
h : 0 + 2 ≤ n
⊢ (n - (0 + 1)) ^ (0 + 2) < n.descFactorial (0 + 2)
state_after: n : ℕ
h : 0 + 2 ≤ n
⊢ (n - (0 + 1)) * (n - (0 + 1)) < (n - 1) * n

tactic: exact Nat.mul_lt_mul_of_pos_left (by omega) (Nat.sub_pos_of_lt h)
state_before: n : ℕ
h : 0 + 2 ≤ n
⊢ (n - (0 + 1)) * (n - (0 + 1)) < (n - 1) * n
state_after: no goals

tactic: omega
state_before: n : ℕ
h : 0 + 2 ≤ n
⊢ n - (0 + 1) < n
state_after: no goals

tactic: rw [descFactorial_succ, Nat.pow_succ, Nat.mul_comm]
state_before: n k : ℕ
h : k + 1 + 2 ≤ n
⊢ (n - (k + 1 + 1)) ^ (k + 1 + 2) < n.descFactorial (k + 1 + 2)
state_after: n k : ℕ
h : k + 1 + 2 ≤ n
⊢ (n - (k + 1 + 1)) * (n - (k + 1 + 1)) ^ (k + 2) < (n - (k + 2)) * n.descFactorial (k + 2)

tactic: refine Nat.mul_lt_mul_of_pos_left ?_ (Nat.sub_pos_of_lt h)
state_before: n k : ℕ
h : k + 1 + 2 ≤ n
⊢ (n - (k + 1 + 1)) * (n - (k + 1 + 1)) ^ (k + 2) < (n - (k + 2)) * n.descFactorial (k + 2)
state_after: n k : ℕ
h : k + 1 + 2 ≤ n
⊢ (n - (k + 1 + 1)) ^ (k + 2) < n.descFactorial (k + 2)

tactic: refine Nat.lt_of_le_of_lt (Nat.pow_le_pow_left (Nat.sub_le_sub_right n.le_succ _) _) ?_
state_before: n k : ℕ
h : k + 1 + 2 ≤ n
⊢ (n - (k + 1 + 1)) ^ (k + 2) < n.descFactorial (k + 2)
state_after: n k : ℕ
h : k + 1 + 2 ≤ n
⊢ (n.succ - (k + 1 + 1)) ^ (k + 2) < n.descFactorial (k + 2)

tactic: rw [succ_sub_succ]
state_before: n k : ℕ
h : k + 1 + 2 ≤ n
⊢ (n.succ - (k + 1 + 1)) ^ (k + 2) < n.descFactorial (k + 2)
state_after: n k : ℕ
h : k + 1 + 2 ≤ n
⊢ (n - (k + 1)) ^ (k + 2) < n.descFactorial (k + 2)

tactic: exact pow_sub_lt_descFactorial' (Nat.le_trans (le_succ _) h)
state_before: n k : ℕ
h : k + 1 + 2 ≤ n
⊢ (n - (k + 1)) ^ (k + 2) < n.descFactorial (k + 2)
state_after: no goals
Theorem: RingQuot.mkAlgHom_rel
File: Mathlib/Algebra/RingQuot.lean

tactic: simp [mkAlgHom_def, mkRingHom_def, Quot.sound (Rel.of w)]
state_before: R : Type uR
inst✝⁴ : Semiring R
S : Type uS
inst✝³ : CommSemiring S
T : Type uT
A : Type uA
inst✝² : Semiring A
inst✝¹ : Algebra S A
r : R → R → Prop
inst✝ : Semiring T
s : A → A → Prop
x y : A
w : s x y
⊢ (mkAlgHom S s) x = (mkAlgHom S s) y
state_after: no goals
Theorem: CategoryTheory.Limits.diagonalObjPullbackFstIso_inv_fst_snd
File: Mathlib/CategoryTheory/Limits/Shapes/Diagonal.lean

tactic: delta diagonalObjPullbackFstIso
state_before: C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
X✝ Y✝ Z✝ : C
inst✝⁴ : HasPullbacks C
S T : C
f✝ : X✝ ⟶ T
g✝ : Y✝ ⟶ T
i : T ⟶ S
inst✝³ : HasPullback i i
inst✝² : HasPullback f✝ g✝
inst✝¹ : HasPullback (f✝ ≫ i) (g✝ ≫ i)
inst✝ : HasPullback (diagonal i) (map (f✝ ≫ i) (g✝ ≫ i) i i f✝ g✝ (𝟙 S) ⋯ ⋯)
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ (diagonalObjPullbackFstIso f g).inv ≫ fst ≫ snd = fst ≫ fst
state_after: C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
X✝ Y✝ Z✝ : C
inst✝⁴ : HasPullbacks C
S T : C
f✝ : X✝ ⟶ T
g✝ : Y✝ ⟶ T
i : T ⟶ S
inst✝³ : HasPullback i i
inst✝² : HasPullback f✝ g✝
inst✝¹ : HasPullback (f✝ ≫ i) (g✝ ≫ i)
inst✝ : HasPullback (diagonal i) (map (f✝ ≫ i) (g✝ ≫ i) i i f✝ g✝ (𝟙 S) ⋯ ⋯)
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ (pullbackRightPullbackFstIso f g fst ≪≫
          congrHom ⋯ ⋯ ≪≫ pullbackAssoc f g g g ≪≫ pullbackSymmetry f (fst ≫ g) ≪≫ congrHom ⋯ ⋯).inv ≫
      fst ≫ snd =
    fst ≫ fst

tactic: simp
state_before: C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
X✝ Y✝ Z✝ : C
inst✝⁴ : HasPullbacks C
S T : C
f✝ : X✝ ⟶ T
g✝ : Y✝ ⟶ T
i : T ⟶ S
inst✝³ : HasPullback i i
inst✝² : HasPullback f✝ g✝
inst✝¹ : HasPullback (f✝ ≫ i) (g✝ ≫ i)
inst✝ : HasPullback (diagonal i) (map (f✝ ≫ i) (g✝ ≫ i) i i f✝ g✝ (𝟙 S) ⋯ ⋯)
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ (pullbackRightPullbackFstIso f g fst ≪≫
          congrHom ⋯ ⋯ ≪≫ pullbackAssoc f g g g ≪≫ pullbackSymmetry f (fst ≫ g) ≪≫ congrHom ⋯ ⋯).inv ≫
      fst ≫ snd =
    fst ≫ fst
state_after: no goals
Theorem: UpperSet.compl_iInf
File: Mathlib/Order/UpperLower/Basic.lean

tactic: simp only [coe_compl, coe_iInf, compl_iUnion, LowerSet.coe_iInf]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝ : LE α
s t : UpperSet α
a : α
f : ι → UpperSet α
⊢ ↑(⨅ i, f i).compl = ↑(⨅ i, (f i).compl)
state_after: no goals
Theorem: Set.offDiag_insert
File: Mathlib/Data/Set/Prod.lean

tactic: rw [insert_eq, union_comm, offDiag_union, offDiag_singleton, union_empty, union_right_comm]
state_before: α : Type u_1
s t : Set α
x : α × α
a : α
ha : a ∉ s
⊢ (insert a s).offDiag = s.offDiag ∪ {a} ×ˢ s ∪ s ×ˢ {a}
state_after: α : Type u_1
s t : Set α
x : α × α
a : α
ha : a ∉ s
⊢ Disjoint s {a}

tactic: rw [disjoint_left]
state_before: α : Type u_1
s t : Set α
x : α × α
a : α
ha : a ∉ s
⊢ Disjoint s {a}
state_after: α : Type u_1
s t : Set α
x : α × α
a : α
ha : a ∉ s
⊢ ∀ ⦃a_1 : α⦄, a_1 ∈ s → a_1 ∉ {a}

tactic: rintro b hb (rfl : b = a)
state_before: α : Type u_1
s t : Set α
x : α × α
a : α
ha : a ∉ s
⊢ ∀ ⦃a_1 : α⦄, a_1 ∈ s → a_1 ∉ {a}
state_after: α : Type u_1
s t : Set α
x : α × α
b : α
hb : b ∈ s
ha : b ∉ s
⊢ False

tactic: exact ha hb
state_before: α : Type u_1
s t : Set α
x : α × α
b : α
hb : b ∈ s
ha : b ∉ s
⊢ False
state_after: no goals
Theorem: Ordinal.mul_omega_opow_opow
File: Mathlib/SetTheory/Ordinal/Principal.lean

tactic: by_cases b0 : b = 0
state_before: a b : Ordinal.{u_1}
a0 : 0 < a
h : a < ω ^ ω ^ b
⊢ a * ω ^ ω ^ b = ω ^ ω ^ b
state_after: case pos
a b : Ordinal.{u_1}
a0 : 0 < a
h : a < ω ^ ω ^ b
b0 : b = 0
⊢ a * ω ^ ω ^ b = ω ^ ω ^ b

case neg
a b : Ordinal.{u_1}
a0 : 0 < a
h : a < ω ^ ω ^ b
b0 : ¬b = 0
⊢ a * ω ^ ω ^ b = ω ^ ω ^ b

tactic: refine
  le_antisymm ?_
    (by simpa only [one_mul] using mul_le_mul_right' (one_le_iff_pos.2 a0) (omega^omega^b))
state_before: case neg
a b : Ordinal.{u_1}
a0 : 0 < a
h : a < ω ^ ω ^ b
b0 : ¬b = 0
⊢ a * ω ^ ω ^ b = ω ^ ω ^ b
state_after: case neg
a b : Ordinal.{u_1}
a0 : 0 < a
h : a < ω ^ ω ^ b
b0 : ¬b = 0
⊢ a * ω ^ ω ^ b ≤ ω ^ ω ^ b

tactic: rcases (lt_opow_of_limit omega_ne_zero (opow_isLimit_left omega_isLimit b0)).1 h with ⟨x, xb, ax⟩
state_before: case neg
a b : Ordinal.{u_1}
a0 : 0 < a
h : a < ω ^ ω ^ b
b0 : ¬b = 0
⊢ a * ω ^ ω ^ b ≤ ω ^ ω ^ b
state_after: case neg.intro.intro
a b : Ordinal.{u_1}
a0 : 0 < a
h : a < ω ^ ω ^ b
b0 : ¬b = 0
x : Ordinal.{u_1}
xb : x < ω ^ b
ax : a < ω ^ x
⊢ a * ω ^ ω ^ b ≤ ω ^ ω ^ b

tactic: apply (mul_le_mul_right' (le_of_lt ax) _).trans
state_before: case neg.intro.intro
a b : Ordinal.{u_1}
a0 : 0 < a
h : a < ω ^ ω ^ b
b0 : ¬b = 0
x : Ordinal.{u_1}
xb : x < ω ^ b
ax : a < ω ^ x
⊢ a * ω ^ ω ^ b ≤ ω ^ ω ^ b
state_after: case neg.intro.intro
a b : Ordinal.{u_1}
a0 : 0 < a
h : a < ω ^ ω ^ b
b0 : ¬b = 0
x : Ordinal.{u_1}
xb : x < ω ^ b
ax : a < ω ^ x
⊢ ω ^ x * ω ^ ω ^ b ≤ ω ^ ω ^ b

tactic: rw [← opow_add, add_omega_opow xb]
state_before: case neg.intro.intro
a b : Ordinal.{u_1}
a0 : 0 < a
h : a < ω ^ ω ^ b
b0 : ¬b = 0
x : Ordinal.{u_1}
xb : x < ω ^ b
ax : a < ω ^ x
⊢ ω ^ x * ω ^ ω ^ b ≤ ω ^ ω ^ b
state_after: no goals

tactic: rw [b0, opow_zero, opow_one] at h ⊢
state_before: case pos
a b : Ordinal.{u_1}
a0 : 0 < a
h : a < ω ^ ω ^ b
b0 : b = 0
⊢ a * ω ^ ω ^ b = ω ^ ω ^ b
state_after: case pos
a b : Ordinal.{u_1}
a0 : 0 < a
h : a < ω
b0 : b = 0
⊢ a * ω = ω

tactic: exact mul_omega a0 h
state_before: case pos
a b : Ordinal.{u_1}
a0 : 0 < a
h : a < ω
b0 : b = 0
⊢ a * ω = ω
state_after: no goals

tactic: simpa only [one_mul] using mul_le_mul_right' (one_le_iff_pos.2 a0) (omega^omega^b)
state_before: a b : Ordinal.{u_1}
a0 : 0 < a
h : a < ω ^ ω ^ b
b0 : ¬b = 0
⊢ ω ^ ω ^ b ≤ a * ω ^ ω ^ b
state_after: no goals
Theorem: CliffordAlgebra.EquivEven.ι_eq_v_add_smul_e0
File: Mathlib/LinearAlgebra/CliffordAlgebra/EvenEquiv.lean

tactic: rw [e0, v, LinearMap.comp_apply, LinearMap.inl_apply, ← LinearMap.map_smul, Prod.smul_mk,
  smul_zero, smul_eq_mul, mul_one, ← LinearMap.map_add, Prod.mk_add_mk, zero_add, add_zero]
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
m : M
r : R
⊢ (ι (Q' Q)) (m, r) = (v Q) m + r • e0 Q
state_after: no goals
Theorem: Real.abs_rpow_le_exp_log_mul
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: refine (abs_rpow_le_abs_rpow x y).trans ?_
state_before: x✝ y✝ z x y : ℝ
⊢ |x ^ y| ≤ rexp (log x * y)
state_after: x✝ y✝ z x y : ℝ
⊢ |x| ^ y ≤ rexp (log x * y)

tactic: by_cases hx : x = 0
state_before: x✝ y✝ z x y : ℝ
⊢ |x| ^ y ≤ rexp (log x * y)
state_after: case pos
x✝ y✝ z x y : ℝ
hx : x = 0
⊢ |x| ^ y ≤ rexp (log x * y)

case neg
x✝ y✝ z x y : ℝ
hx : ¬x = 0
⊢ |x| ^ y ≤ rexp (log x * y)

tactic: by_cases hy : y = 0 <;> simp [hx, hy, zero_le_one]
state_before: case pos
x✝ y✝ z x y : ℝ
hx : x = 0
⊢ |x| ^ y ≤ rexp (log x * y)
state_after: no goals

tactic: rw [rpow_def_of_pos (abs_pos.2 hx), log_abs]
state_before: case neg
x✝ y✝ z x y : ℝ
hx : ¬x = 0
⊢ |x| ^ y ≤ rexp (log x * y)
state_after: no goals
Theorem: equicontinuousWithinAt_univ
File: Mathlib/Topology/UniformSpace/Equicontinuity.lean

tactic: rw [EquicontinuousWithinAt, EquicontinuousAt, nhdsWithin_univ]
state_before: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
F : ι → X → α
x₀ : X
⊢ EquicontinuousWithinAt F univ x₀ ↔ EquicontinuousAt F x₀
state_after: no goals
Theorem: Order.pred_lt_pred_iff_of_not_isMin
File: Mathlib/Order/SuccPred/Basic.lean

tactic: rw [pred_lt_iff_of_not_isMin ha, le_pred_iff_of_not_isMin hb]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : PredOrder α
a b : α
ha : ¬IsMin a
hb : ¬IsMin b
⊢ pred a < pred b ↔ a < b
state_after: no goals
Theorem: InnerProductSpace.ext_inner_right_basis
File: Mathlib/Analysis/InnerProductSpace/Dual.lean

tactic: refine ext_inner_left_basis b fun i => ?_
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝² : RCLike 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
ι : Type u_3
x y : E
b : Basis ι 𝕜 E
h : ∀ (i : ι), ⟪x, b i⟫_𝕜 = ⟪y, b i⟫_𝕜
⊢ x = y
state_after: 𝕜 : Type u_1
E : Type u_2
inst✝² : RCLike 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
ι : Type u_3
x y : E
b : Basis ι 𝕜 E
h : ∀ (i : ι), ⟪x, b i⟫_𝕜 = ⟪y, b i⟫_𝕜
i : ι
⊢ ⟪b i, x⟫_𝕜 = ⟪b i, y⟫_𝕜

tactic: rw [← inner_conj_symm]
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝² : RCLike 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
ι : Type u_3
x y : E
b : Basis ι 𝕜 E
h : ∀ (i : ι), ⟪x, b i⟫_𝕜 = ⟪y, b i⟫_𝕜
i : ι
⊢ ⟪b i, x⟫_𝕜 = ⟪b i, y⟫_𝕜
state_after: 𝕜 : Type u_1
E : Type u_2
inst✝² : RCLike 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
ι : Type u_3
x y : E
b : Basis ι 𝕜 E
h : ∀ (i : ι), ⟪x, b i⟫_𝕜 = ⟪y, b i⟫_𝕜
i : ι
⊢ (starRingEnd 𝕜) ⟪x, b i⟫_𝕜 = ⟪b i, y⟫_𝕜

tactic: conv_rhs => rw [← inner_conj_symm]
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝² : RCLike 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
ι : Type u_3
x y : E
b : Basis ι 𝕜 E
h : ∀ (i : ι), ⟪x, b i⟫_𝕜 = ⟪y, b i⟫_𝕜
i : ι
⊢ (starRingEnd 𝕜) ⟪x, b i⟫_𝕜 = ⟪b i, y⟫_𝕜
state_after: 𝕜 : Type u_1
E : Type u_2
inst✝² : RCLike 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
ι : Type u_3
x y : E
b : Basis ι 𝕜 E
h : ∀ (i : ι), ⟪x, b i⟫_𝕜 = ⟪y, b i⟫_𝕜
i : ι
⊢ (starRingEnd 𝕜) ⟪x, b i⟫_𝕜 = (starRingEnd 𝕜) ⟪y, b i⟫_𝕜

tactic: exact congr_arg conj (h i)
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝² : RCLike 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
ι : Type u_3
x y : E
b : Basis ι 𝕜 E
h : ∀ (i : ι), ⟪x, b i⟫_𝕜 = ⟪y, b i⟫_𝕜
i : ι
⊢ (starRingEnd 𝕜) ⟪x, b i⟫_𝕜 = (starRingEnd 𝕜) ⟪y, b i⟫_𝕜
state_after: no goals
Theorem: Algebra.TensorProduct.includeLeftRingHom_comp_algebraMap
File: Mathlib/RingTheory/TensorProduct/Basic.lean

tactic: ext
state_before: R : Type uR
S : Type uS
A : Type uA
B : Type uB
C : Type uC
D : Type uD
E : Type uE
F : Type uF
inst✝⁸ : CommSemiring R
inst✝⁷ : Semiring A
inst✝⁶ : Algebra R A
inst✝⁵ : Semiring B
inst✝⁴ : Algebra R B
inst✝³ : Semiring C
inst✝² : Algebra R C
inst✝¹ : CommSemiring S
inst✝ : Algebra S A
⊢ includeLeftRingHom.comp (algebraMap R A) = includeRight.comp (algebraMap R B)
state_after: case a
R : Type uR
S : Type uS
A : Type uA
B : Type uB
C : Type uC
D : Type uD
E : Type uE
F : Type uF
inst✝⁸ : CommSemiring R
inst✝⁷ : Semiring A
inst✝⁶ : Algebra R A
inst✝⁵ : Semiring B
inst✝⁴ : Algebra R B
inst✝³ : Semiring C
inst✝² : Algebra R C
inst✝¹ : CommSemiring S
inst✝ : Algebra S A
x✝ : R
⊢ (includeLeftRingHom.comp (algebraMap R A)) x✝ = (includeRight.comp (algebraMap R B)) x✝

tactic: simp
state_before: case a
R : Type uR
S : Type uS
A : Type uA
B : Type uB
C : Type uC
D : Type uD
E : Type uE
F : Type uF
inst✝⁸ : CommSemiring R
inst✝⁷ : Semiring A
inst✝⁶ : Algebra R A
inst✝⁵ : Semiring B
inst✝⁴ : Algebra R B
inst✝³ : Semiring C
inst✝² : Algebra R C
inst✝¹ : CommSemiring S
inst✝ : Algebra S A
x✝ : R
⊢ (includeLeftRingHom.comp (algebraMap R A)) x✝ = (includeRight.comp (algebraMap R B)) x✝
state_after: no goals
Theorem: NonUnitalSubsemiring.mem_map_equiv
File: Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean

tactic: convert @Set.mem_image_equiv _ _ (↑K) f.toEquiv x
state_before: R : Type u
S : Type v
T : Type w
inst✝² : NonUnitalNonAssocSemiring R
M : Subsemigroup R
inst✝¹ : NonUnitalNonAssocSemiring S
inst✝ : NonUnitalNonAssocSemiring T
f : R ≃+* S
K : NonUnitalSubsemiring R
x : S
⊢ x ∈ map (↑f) K ↔ f.symm x ∈ K
state_after: no goals
Theorem: Batteries.BinomialHeap.Imp.Heap.findMin_val
File: .lake/packages/batteries/Batteries/Data/BinomialHeap/Lemmas.lean

tactic: rw [findMin, headD]
state_before: α : Type u_1
s✝ : Heap α
le : α → α → Bool
k : Heap α → Heap α
res : FindMin α
r : Nat
a : α
c : HeapNode α
s : Heap α
⊢ (findMin le k (cons r a c s) res).val = headD le res.val (cons r a c s)
state_after: α : Type u_1
s✝ : Heap α
le : α → α → Bool
k : Heap α → Heap α
res : FindMin α
r : Nat
a : α
c : HeapNode α
s : Heap α
⊢ (findMin le (k ∘ cons r a c) s
        (if le res.val a = true then res else { before := k, val := a, node := c, next := s })).val =
    headD le (if le res.val a = true then res.val else a) s

tactic: split <;> apply findMin_val
state_before: α : Type u_1
s✝ : Heap α
le : α → α → Bool
k : Heap α → Heap α
res : FindMin α
r : Nat
a : α
c : HeapNode α
s : Heap α
⊢ (findMin le (k ∘ cons r a c) s
        (if le res.val a = true then res else { before := k, val := a, node := c, next := s })).val =
    headD le (if le res.val a = true then res.val else a) s
state_after: no goals
Theorem: CategoryTheory.GradedObject.ι_mapBifunctorMapObjDesc
File: Mathlib/CategoryTheory/GradedObject/Bifunctor.lean

tactic: apply ι_descMapObj
state_before: C₁ : Type u_1
C₂ : Type u_2
C₃ : Type u_3
inst✝³ : Category.{u_9, u_1} C₁
inst✝² : Category.{u_8, u_2} C₂
inst✝¹ : Category.{u_7, u_3} C₃
F : C₁ ⥤ C₂ ⥤ C₃
I : Type u_4
J : Type u_5
K : Type u_6
p : I × J → K
X : GradedObject I C₁
Y : GradedObject J C₂
A : C₃
k : K
inst✝ : (((mapBifunctor F I J).obj X).obj Y).HasMap p
f : (i : I) → (j : J) → p (i, j) = k → ((F.obj (X i)).obj (Y j) ⟶ A)
i : I
j : J
hij : p (i, j) = k
⊢ ιMapBifunctorMapObj F p X Y i j k hij ≫ mapBifunctorMapObjDesc f = f i j hij
state_after: no goals
Theorem: Batteries.RBNode.Ordered.lowerBound?_exists
File: .lake/packages/batteries/Batteries/Data/RBMap/Lemmas.lean

tactic: conv => enter [2, 1, x]; rw [Ne, ← Ordering.swap_inj]
state_before: α : Type u_1
cmp : α → α → Ordering
cut : α → Ordering
t : RBNode α
inst✝¹ : TransCmp cmp
inst✝ : IsCut cmp cut
h : Ordered cmp t
⊢ (∃ x, lowerBound? cut t = some x) ↔ ∃ x, x ∈ t ∧ cut x ≠ Ordering.lt
state_after: α : Type u_1
cmp : α → α → Ordering
cut : α → Ordering
t : RBNode α
inst✝¹ : TransCmp cmp
inst✝ : IsCut cmp cut
h : Ordered cmp t
⊢ (∃ x, lowerBound? cut t = some x) ↔ ∃ x, x ∈ t ∧ ¬(cut x).swap = Ordering.lt.swap

tactic: rw [← reverse_reverse t, lowerBound?_reverse]
state_before: α : Type u_1
cmp : α → α → Ordering
cut : α → Ordering
t : RBNode α
inst✝¹ : TransCmp cmp
inst✝ : IsCut cmp cut
h : Ordered cmp t
⊢ (∃ x, lowerBound? cut t = some x) ↔ ∃ x, x ∈ t ∧ ¬(cut x).swap = Ordering.lt.swap
state_after: α : Type u_1
cmp : α → α → Ordering
cut : α → Ordering
t : RBNode α
inst✝¹ : TransCmp cmp
inst✝ : IsCut cmp cut
h : Ordered cmp t
⊢ (∃ x, upperBound? (fun x => (cut x).swap) t.reverse = some x) ↔
    ∃ x, x ∈ t.reverse.reverse ∧ ¬(cut x).swap = Ordering.lt.swap
Theorem: nonZeroDivisorsLeft_eq_right
File: Mathlib/Algebra/GroupWithZero/NonZeroDivisors.lean

tactic: ext x
state_before: M₀✝ : Type u_1
inst✝¹ : MonoidWithZero M₀✝
M₀ : Type u_2
inst✝ : CommMonoidWithZero M₀
⊢ nonZeroDivisorsLeft M₀ = nonZeroDivisorsRight M₀
state_after: case h
M₀✝ : Type u_1
inst✝¹ : MonoidWithZero M₀✝
M₀ : Type u_2
inst✝ : CommMonoidWithZero M₀
x : M₀
⊢ x ∈ nonZeroDivisorsLeft M₀ ↔ x ∈ nonZeroDivisorsRight M₀

tactic: simp [mul_comm x]
state_before: case h
M₀✝ : Type u_1
inst✝¹ : MonoidWithZero M₀✝
M₀ : Type u_2
inst✝ : CommMonoidWithZero M₀
x : M₀
⊢ x ∈ nonZeroDivisorsLeft M₀ ↔ x ∈ nonZeroDivisorsRight M₀
state_after: no goals
Theorem: RatFunc.intDegree_C
File: Mathlib/FieldTheory/RatFunc/Degree.lean

tactic: rw [intDegree, num_C, natDegree_C, denom_C, natDegree_one, sub_self]
state_before: K : Type u
inst✝ : Field K
k : K
⊢ (C k).intDegree = 0
state_after: no goals
Theorem: isClosed_nonneg
File: Mathlib/Analysis/Normed/Order/Lattice.lean

tactic: have : {x : α | 0 ≤ x} = negPart ⁻¹' {0} := by ext; simp [negPart_eq_zero]
state_before: α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
⊢ IsClosed {x | 0 ≤ x}
state_after: α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
this : {x | 0 ≤ x} = negPart ⁻¹' {0}
⊢ IsClosed {x | 0 ≤ x}

tactic: rw [this]
state_before: α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
this : {x | 0 ≤ x} = negPart ⁻¹' {0}
⊢ IsClosed {x | 0 ≤ x}
state_after: α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
this : {x | 0 ≤ x} = negPart ⁻¹' {0}
⊢ IsClosed (negPart ⁻¹' {0})

tactic: exact isClosed_singleton.preimage continuous_negPart
state_before: α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
this : {x | 0 ≤ x} = negPart ⁻¹' {0}
⊢ IsClosed (negPart ⁻¹' {0})
state_after: no goals

tactic: ext
state_before: α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
⊢ {x | 0 ≤ x} = negPart ⁻¹' {0}
state_after: case h
α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
x✝ : α
⊢ x✝ ∈ {x | 0 ≤ x} ↔ x✝ ∈ negPart ⁻¹' {0}

tactic: simp [negPart_eq_zero]
state_before: case h
α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
x✝ : α
⊢ x✝ ∈ {x | 0 ≤ x} ↔ x✝ ∈ negPart ⁻¹' {0}
state_after: no goals
Theorem: ENNReal.add_iSup
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: rw [add_comm, iSup_add]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s✝ : Set ℝ≥0∞
ι : Sort u_4
s : ι → ℝ≥0∞
inst✝ : Nonempty ι
⊢ a + iSup s = ⨆ b, a + s b
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s✝ : Set ℝ≥0∞
ι : Sort u_4
s : ι → ℝ≥0∞
inst✝ : Nonempty ι
⊢ ⨆ b, s b + a = ⨆ b, a + s b

tactic: simp [add_comm]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s✝ : Set ℝ≥0∞
ι : Sort u_4
s : ι → ℝ≥0∞
inst✝ : Nonempty ι
⊢ ⨆ b, s b + a = ⨆ b, a + s b
state_after: no goals