1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Finset.Icc_eq_image_powerset
File: Mathlib/Data/Finset/Interval.lean

tactic: ext u
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s t : Finset α
h : s ⊆ t
⊢ Icc s t = image (fun x => s ∪ x) (t \ s).powerset
state_after: case a
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s t : Finset α
h : s ⊆ t
u : Finset α
⊢ u ∈ Icc s t ↔ u ∈ image (fun x => s ∪ x) (t \ s).powerset

tactic: simp_rw [mem_Icc, mem_image, mem_powerset]
state_before: case a
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s t : Finset α
h : s ⊆ t
u : Finset α
⊢ u ∈ Icc s t ↔ u ∈ image (fun x => s ∪ x) (t \ s).powerset
state_after: case a
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s t : Finset α
h : s ⊆ t
u : Finset α
⊢ s ≤ u ∧ u ≤ t ↔ ∃ a ⊆ t \ s, s ∪ a = u

tactic: constructor
state_before: case a
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s t : Finset α
h : s ⊆ t
u : Finset α
⊢ s ≤ u ∧ u ≤ t ↔ ∃ a ⊆ t \ s, s ∪ a = u
state_after: case a.mp
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s t : Finset α
h : s ⊆ t
u : Finset α
⊢ s ≤ u ∧ u ≤ t → ∃ a ⊆ t \ s, s ∪ a = u

case a.mpr
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s t : Finset α
h : s ⊆ t
u : Finset α
⊢ (∃ a ⊆ t \ s, s ∪ a = u) → s ≤ u ∧ u ≤ t

tactic: rintro ⟨hs, ht⟩
state_before: case a.mp
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s t : Finset α
h : s ⊆ t
u : Finset α
⊢ s ≤ u ∧ u ≤ t → ∃ a ⊆ t \ s, s ∪ a = u
state_after: case a.mp.intro
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s t : Finset α
h : s ⊆ t
u : Finset α
hs : s ≤ u
ht : u ≤ t
⊢ ∃ a ⊆ t \ s, s ∪ a = u

tactic: exact ⟨u \ s, sdiff_le_sdiff_right ht, sup_sdiff_cancel_right hs⟩
state_before: case a.mp.intro
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s t : Finset α
h : s ⊆ t
u : Finset α
hs : s ≤ u
ht : u ≤ t
⊢ ∃ a ⊆ t \ s, s ∪ a = u
state_after: no goals

tactic: rintro ⟨v, hv, rfl⟩
state_before: case a.mpr
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s t : Finset α
h : s ⊆ t
u : Finset α
⊢ (∃ a ⊆ t \ s, s ∪ a = u) → s ≤ u ∧ u ≤ t
state_after: case a.mpr.intro.intro
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s t : Finset α
h : s ⊆ t
v : Finset α
hv : v ⊆ t \ s
⊢ s ≤ s ∪ v ∧ s ∪ v ≤ t

tactic: exact ⟨le_sup_left, union_subset h <| hv.trans sdiff_subset⟩
state_before: case a.mpr.intro.intro
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s t : Finset α
h : s ⊆ t
v : Finset α
hv : v ⊆ t \ s
⊢ s ≤ s ∪ v ∧ s ∪ v ≤ t
state_after: no goals
Theorem: QuadraticForm.polar_prod
File: Mathlib/LinearAlgebra/QuadraticForm/Prod.lean

tactic: dsimp [polar]
state_before: ι : Type u_1
R : Type u_2
M₁ : Type u_3
M₂ : Type u_4
N₁ : Type u_5
N₂ : Type u_6
Mᵢ : ι → Type u_7
Nᵢ : ι → Type u_8
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M₁
inst✝² : AddCommGroup M₂
inst✝¹ : Module R M₁
inst✝ : Module R M₂
Q₁ : QuadraticForm R M₁
Q₂ : QuadraticForm R M₂
x y : M₁ × M₂
⊢ polar (⇑(Q₁.prod Q₂)) x y = polar (⇑Q₁) x.1 y.1 + polar (⇑Q₂) x.2 y.2
state_after: ι : Type u_1
R : Type u_2
M₁ : Type u_3
M₂ : Type u_4
N₁ : Type u_5
N₂ : Type u_6
Mᵢ : ι → Type u_7
Nᵢ : ι → Type u_8
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M₁
inst✝² : AddCommGroup M₂
inst✝¹ : Module R M₁
inst✝ : Module R M₂
Q₁ : QuadraticForm R M₁
Q₂ : QuadraticForm R M₂
x y : M₁ × M₂
⊢ Q₁ (x.1 + y.1) + Q₂ (x.2 + y.2) - (Q₁ x.1 + Q₂ x.2) - (Q₁ y.1 + Q₂ y.2) =
    Q₁ (x.1 + y.1) - Q₁ x.1 - Q₁ y.1 + (Q₂ (x.2 + y.2) - Q₂ x.2 - Q₂ y.2)

tactic: abel
state_before: ι : Type u_1
R : Type u_2
M₁ : Type u_3
M₂ : Type u_4
N₁ : Type u_5
N₂ : Type u_6
Mᵢ : ι → Type u_7
Nᵢ : ι → Type u_8
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M₁
inst✝² : AddCommGroup M₂
inst✝¹ : Module R M₁
inst✝ : Module R M₂
Q₁ : QuadraticForm R M₁
Q₂ : QuadraticForm R M₂
x y : M₁ × M₂
⊢ Q₁ (x.1 + y.1) + Q₂ (x.2 + y.2) - (Q₁ x.1 + Q₂ x.2) - (Q₁ y.1 + Q₂ y.2) =
    Q₁ (x.1 + y.1) - Q₁ x.1 - Q₁ y.1 + (Q₂ (x.2 + y.2) - Q₂ x.2 - Q₂ y.2)
state_after: no goals
Theorem: nhdsWithin_Iic_eq'
File: Mathlib/Topology/Order/Basic.lean

tactic: simp only [nhdsWithin_Iic_eq'', biInf_inf ha, inf_principal, Ioi_inter_Iic]
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : Preorder α
inst✝ : OrderTopology α
a : α
ha : ∃ l, l < a
⊢ 𝓝[≤] a = ⨅ l, ⨅ (_ : l < a), 𝓟 (Ioc l a)
state_after: no goals
Theorem: IsSubmonoid.finset_prod_mem
File: Mathlib/Deprecated/Submonoid.lean

tactic: simpa
state_before: M✝ : Type u_1
inst✝² : Monoid M✝
s✝ : Set M✝
A✝ : Type u_2
inst✝¹ : AddMonoid A✝
t : Set A✝
M : Type u_3
A : Type u_4
inst✝ : CommMonoid M
s : Set M
hs : IsSubmonoid s
f : A → M
m : Multiset A
hm : m.Nodup
x✝ : ∀ b ∈ { val := m, nodup := hm }, f b ∈ s
⊢ ∀ a ∈ Multiset.map (fun b => f b) { val := m, nodup := hm }.val, a ∈ s
state_after: no goals
Theorem: MonoidHom.compAddChar_injective_right
File: Mathlib/Algebra/Group/AddChar.lean

tactic: rintro ψ χ h
state_before: A : Type u_1
B : Type u_2
M : Type u_3
N : Type u_4
inst✝³ : AddMonoid A
inst✝² : AddMonoid B
inst✝¹ : Monoid M
inst✝ : Monoid N
ψ : AddChar A M
f : M →* N
hf : Injective ⇑f
⊢ Injective fun ψ => f.compAddChar ψ
state_after: A : Type u_1
B : Type u_2
M : Type u_3
N : Type u_4
inst✝³ : AddMonoid A
inst✝² : AddMonoid B
inst✝¹ : Monoid M
inst✝ : Monoid N
ψ✝ : AddChar A M
f : M →* N
hf : Injective ⇑f
ψ χ : AddChar B M
h : (fun ψ => f.compAddChar ψ) ψ = (fun ψ => f.compAddChar ψ) χ
⊢ ψ = χ

tactic: rw [DFunLike.ext'_iff] at h ⊢
state_before: A : Type u_1
B : Type u_2
M : Type u_3
N : Type u_4
inst✝³ : AddMonoid A
inst✝² : AddMonoid B
inst✝¹ : Monoid M
inst✝ : Monoid N
ψ✝ : AddChar A M
f : M →* N
hf : Injective ⇑f
ψ χ : AddChar B M
h : (fun ψ => f.compAddChar ψ) ψ = (fun ψ => f.compAddChar ψ) χ
⊢ ψ = χ
state_after: A : Type u_1
B : Type u_2
M : Type u_3
N : Type u_4
inst✝³ : AddMonoid A
inst✝² : AddMonoid B
inst✝¹ : Monoid M
inst✝ : Monoid N
ψ✝ : AddChar A M
f : M →* N
hf : Injective ⇑f
ψ χ : AddChar B M
h : ⇑((fun ψ => f.compAddChar ψ) ψ) = ⇑((fun ψ => f.compAddChar ψ) χ)
⊢ ⇑ψ = ⇑χ

tactic: exact hf.comp_left h
state_before: A : Type u_1
B : Type u_2
M : Type u_3
N : Type u_4
inst✝³ : AddMonoid A
inst✝² : AddMonoid B
inst✝¹ : Monoid M
inst✝ : Monoid N
ψ✝ : AddChar A M
f : M →* N
hf : Injective ⇑f
ψ χ : AddChar B M
h : ⇑((fun ψ => f.compAddChar ψ) ψ) = ⇑((fun ψ => f.compAddChar ψ) χ)
⊢ ⇑ψ = ⇑χ
state_after: no goals
Theorem: List.rotate_eq_nil_iff
File: Mathlib/Data/List/Rotate.lean

tactic: induction' n with n hn generalizing l
state_before: α : Type u
l : List α
n : ℕ
⊢ l.rotate n = [] ↔ l = []
state_after: case zero
α : Type u
l : List α
⊢ l.rotate 0 = [] ↔ l = []

case succ
α : Type u
n : ℕ
hn : ∀ {l : List α}, l.rotate n = [] ↔ l = []
l : List α
⊢ l.rotate (n + 1) = [] ↔ l = []

tactic: simp
state_before: case zero
α : Type u
l : List α
⊢ l.rotate 0 = [] ↔ l = []
state_after: no goals

tactic: cases' l with hd tl
state_before: case succ
α : Type u
n : ℕ
hn : ∀ {l : List α}, l.rotate n = [] ↔ l = []
l : List α
⊢ l.rotate (n + 1) = [] ↔ l = []
state_after: case succ.nil
α : Type u
n : ℕ
hn : ∀ {l : List α}, l.rotate n = [] ↔ l = []
⊢ [].rotate (n + 1) = [] ↔ [] = []

case succ.cons
α : Type u
n : ℕ
hn : ∀ {l : List α}, l.rotate n = [] ↔ l = []
hd : α
tl : List α
⊢ (hd :: tl).rotate (n + 1) = [] ↔ hd :: tl = []

tactic: simp
state_before: case succ.nil
α : Type u
n : ℕ
hn : ∀ {l : List α}, l.rotate n = [] ↔ l = []
⊢ [].rotate (n + 1) = [] ↔ [] = []
state_after: no goals

tactic: simp [rotate_cons_succ, hn]
state_before: case succ.cons
α : Type u
n : ℕ
hn : ∀ {l : List α}, l.rotate n = [] ↔ l = []
hd : α
tl : List α
⊢ (hd :: tl).rotate (n + 1) = [] ↔ hd :: tl = []
state_after: no goals
Theorem: HomologicalComplex.single_map_f_self
File: Mathlib/Algebra/Homology/Single.lean

tactic: dsimp [single]
state_before: V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
A B : V
f : A ⟶ B
⊢ ((single V c j).map f).f j = (singleObjXSelf c j A).hom ≫ f ≫ (singleObjXSelf c j B).inv
state_after: V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
A B : V
f : A ⟶ B
⊢ (if h : j = j then eqToHom ⋯ ≫ f ≫ eqToHom ⋯ else 0) = (singleObjXSelf c j A).hom ≫ f ≫ (singleObjXSelf c j B).inv

tactic: rw [dif_pos rfl]
state_before: V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
A B : V
f : A ⟶ B
⊢ (if h : j = j then eqToHom ⋯ ≫ f ≫ eqToHom ⋯ else 0) = (singleObjXSelf c j A).hom ≫ f ≫ (singleObjXSelf c j B).inv
state_after: V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
A B : V
f : A ⟶ B
⊢ eqToHom ⋯ ≫ f ≫ eqToHom ⋯ = (singleObjXSelf c j A).hom ≫ f ≫ (singleObjXSelf c j B).inv

tactic: rfl
state_before: V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
A B : V
f : A ⟶ B
⊢ eqToHom ⋯ ≫ f ≫ eqToHom ⋯ = (singleObjXSelf c j A).hom ≫ f ≫ (singleObjXSelf c j B).inv
state_after: no goals
Theorem: summable_riemannZetaSummand
File: Mathlib/NumberTheory/EulerProduct/DirichletLSeries.lean

tactic: simp only [riemannZetaSummandHom, MonoidWithZeroHom.coe_mk, ZeroHom.coe_mk]
state_before: s : ℂ
hs : 1 < s.re
⊢ Summable fun n => ‖(riemannZetaSummandHom ⋯) n‖
state_after: s : ℂ
hs : 1 < s.re
⊢ Summable fun n => ‖↑n ^ (-s)‖

tactic: convert Real.summable_nat_rpow_inv.mpr hs with n
state_before: s : ℂ
hs : 1 < s.re
⊢ Summable fun n => ‖↑n ^ (-s)‖
state_after: case h.e'_5.h
s : ℂ
hs : 1 < s.re
n : ℕ
⊢ ‖↑n ^ (-s)‖ = (↑n ^ s.re)⁻¹

tactic: rw [← ofReal_natCast, Complex.norm_eq_abs,
  abs_cpow_eq_rpow_re_of_nonneg (Nat.cast_nonneg n) <| re_neg_ne_zero_of_one_lt_re hs,
  neg_re, Real.rpow_neg <| Nat.cast_nonneg n]
state_before: case h.e'_5.h
s : ℂ
hs : 1 < s.re
n : ℕ
⊢ ‖↑n ^ (-s)‖ = (↑n ^ s.re)⁻¹
state_after: no goals
Theorem: Polynomial.X_sub_C_dvd_derivative_of_X_sub_C_dvd_divByMonic
File: Mathlib/Algebra/Polynomial/FieldDivision.lean

tactic: have key := divByMonic_add_X_sub_C_mul_derivate_divByMonic_eq_derivative f a
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]
K : Type u_1
inst✝ : Field K
f : K[X]
a : K
hf : X - C a ∣ f /ₘ (X - C a)
⊢ X - C a ∣ derivative f
state_after: R : Type u
S : Type v
k : Type y
A : Type z
a✝ b : R
n : ℕ
inst✝¹ : Field R
p q : R[X]
K : Type u_1
inst✝ : Field K
f : K[X]
a : K
hf : X - C a ∣ f /ₘ (X - C a)
key : f /ₘ (X - C a) + (X - C a) * derivative (f /ₘ (X - C a)) = derivative f
⊢ X - C a ∣ derivative f

tactic: have ⟨u,hu⟩ := hf
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]
K : Type u_1
inst✝ : Field K
f : K[X]
a : K
hf : X - C a ∣ f /ₘ (X - C a)
key : f /ₘ (X - C a) + (X - C a) * derivative (f /ₘ (X - C a)) = derivative f
⊢ X - C a ∣ derivative f
state_after: R : Type u
S : Type v
k : Type y
A : Type z
a✝ b : R
n : ℕ
inst✝¹ : Field R
p q : R[X]
K : Type u_1
inst✝ : Field K
f : K[X]
a : K
hf : X - C a ∣ f /ₘ (X - C a)
key : f /ₘ (X - C a) + (X - C a) * derivative (f /ₘ (X - C a)) = derivative f
u : K[X]
hu : f /ₘ (X - C a) = (X - C a) * u
⊢ X - C a ∣ derivative f

tactic: rw [← key, hu, ← mul_add (X - C a) u _]
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]
K : Type u_1
inst✝ : Field K
f : K[X]
a : K
hf : X - C a ∣ f /ₘ (X - C a)
key : f /ₘ (X - C a) + (X - C a) * derivative (f /ₘ (X - C a)) = derivative f
u : K[X]
hu : f /ₘ (X - C a) = (X - C a) * u
⊢ X - C a ∣ derivative f
state_after: R : Type u
S : Type v
k : Type y
A : Type z
a✝ b : R
n : ℕ
inst✝¹ : Field R
p q : R[X]
K : Type u_1
inst✝ : Field K
f : K[X]
a : K
hf : X - C a ∣ f /ₘ (X - C a)
key : f /ₘ (X - C a) + (X - C a) * derivative (f /ₘ (X - C a)) = derivative f
u : K[X]
hu : f /ₘ (X - C a) = (X - C a) * u
⊢ X - C a ∣ (X - C a) * (u + derivative ((X - C a) * u))

tactic: use (u + derivative ((X - C a) * u))
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]
K : Type u_1
inst✝ : Field K
f : K[X]
a : K
hf : X - C a ∣ f /ₘ (X - C a)
key : f /ₘ (X - C a) + (X - C a) * derivative (f /ₘ (X - C a)) = derivative f
u : K[X]
hu : f /ₘ (X - C a) = (X - C a) * u
⊢ X - C a ∣ (X - C a) * (u + derivative ((X - C a) * u))
state_after: no goals
Theorem: thickenedIndicatorAux_one
File: Mathlib/Topology/MetricSpace/ThickenedIndicator.lean

tactic: simp [thickenedIndicatorAux, infEdist_zero_of_mem x_in_E, tsub_zero]
state_before: α : Type u_1
inst✝ : PseudoEMetricSpace α
δ : ℝ
E : Set α
x : α
x_in_E : x ∈ E
⊢ thickenedIndicatorAux δ E x = 1
state_after: no goals
Theorem: Filter.tendsto_iSup
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [Tendsto, map_iSup, iSup_le_iff]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l : Filter α
f : α → β
x : ι → Filter α
y : Filter β
⊢ Tendsto f (⨆ i, x i) y ↔ ∀ (i : ι), Tendsto f (x i) y
state_after: no goals
Theorem: LowerSet.compl_sSup
File: Mathlib/Order/UpperLower/Basic.lean

tactic: simp only [coe_compl, coe_sSup, compl_iUnion₂, UpperSet.coe_iSup₂]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝ : LE α
s t : LowerSet α
a : α
S : Set (LowerSet α)
⊢ ↑(sSup S).compl = ↑(⨆ s ∈ S, s.compl)
state_after: no goals
Theorem: Set.forall_in_swap
File: Mathlib/Data/Set/Basic.lean

tactic: tauto
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
p : α → β → Prop
⊢ (∀ a ∈ s, ∀ (b : β), p a b) ↔ ∀ (b : β), ∀ a ∈ s, p a b
state_after: no goals
Theorem: tendsto_nhds_top_mono
File: Mathlib/Topology/Order/Basic.lean

tactic: simp only [nhds_top_order, tendsto_iInf, tendsto_principal] at hf ⊢
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace β
inst✝² : Preorder β
inst✝¹ : OrderTop β
inst✝ : OrderTopology β
l : Filter α
f g : α → β
hf : Tendsto f l (𝓝 ⊤)
hg : f ≤ᶠ[l] g
⊢ Tendsto g l (𝓝 ⊤)
state_after: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace β
inst✝² : Preorder β
inst✝¹ : OrderTop β
inst✝ : OrderTopology β
l : Filter α
f g : α → β
hg : f ≤ᶠ[l] g
hf : ∀ i < ⊤, ∀ᶠ (a : α) in l, f a ∈ Ioi i
⊢ ∀ i < ⊤, ∀ᶠ (a : α) in l, g a ∈ Ioi i

tactic: intro x hx
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace β
inst✝² : Preorder β
inst✝¹ : OrderTop β
inst✝ : OrderTopology β
l : Filter α
f g : α → β
hg : f ≤ᶠ[l] g
hf : ∀ i < ⊤, ∀ᶠ (a : α) in l, f a ∈ Ioi i
⊢ ∀ i < ⊤, ∀ᶠ (a : α) in l, g a ∈ Ioi i
state_after: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace β
inst✝² : Preorder β
inst✝¹ : OrderTop β
inst✝ : OrderTopology β
l : Filter α
f g : α → β
hg : f ≤ᶠ[l] g
hf : ∀ i < ⊤, ∀ᶠ (a : α) in l, f a ∈ Ioi i
x : β
hx : x < ⊤
⊢ ∀ᶠ (a : α) in l, g a ∈ Ioi x

tactic: filter_upwards [hf x hx, hg] with _ using lt_of_lt_of_le
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace β
inst✝² : Preorder β
inst✝¹ : OrderTop β
inst✝ : OrderTopology β
l : Filter α
f g : α → β
hg : f ≤ᶠ[l] g
hf : ∀ i < ⊤, ∀ᶠ (a : α) in l, f a ∈ Ioi i
x : β
hx : x < ⊤
⊢ ∀ᶠ (a : α) in l, g a ∈ Ioi x
state_after: no goals
Theorem: CategoryTheory.ShortComplex.RightHomologyData.homologyIso_rightHomologyData
File: Mathlib/Algebra/Homology/ShortComplex/Homology.lean

tactic: ext
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
inst✝ : S.HasHomology
⊢ S.rightHomologyData.homologyIso = S.rightHomologyIso.symm
state_after: case w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
inst✝ : S.HasHomology
⊢ S.rightHomologyData.homologyIso.hom = S.rightHomologyIso.symm.hom

tactic: dsimp [homologyIso, rightHomologyIso]
state_before: case w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
inst✝ : S.HasHomology
⊢ S.rightHomologyData.homologyIso.hom = S.rightHomologyIso.symm.hom
state_after: case w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
inst✝ : S.HasHomology
⊢ S.rightHomologyIso.inv ≫ rightHomologyMap' (𝟙 S) S.rightHomologyData S.rightHomologyData = S.rightHomologyIso.inv

tactic: erw [rightHomologyMap'_id, comp_id]
state_before: case w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
inst✝ : S.HasHomology
⊢ S.rightHomologyIso.inv ≫ rightHomologyMap' (𝟙 S) S.rightHomologyData S.rightHomologyData = S.rightHomologyIso.inv
state_after: no goals
Theorem: partialSups_disjointed
File: Mathlib/Order/Disjointed.lean

tactic: ext n
state_before: α : Type u_1
β : Type u_2
inst✝ : GeneralizedBooleanAlgebra α
f : ℕ → α
⊢ partialSups (disjointed f) = partialSups f
state_after: case h.h
α : Type u_1
β : Type u_2
inst✝ : GeneralizedBooleanAlgebra α
f : ℕ → α
n : ℕ
⊢ (partialSups (disjointed f)) n = (partialSups f) n

tactic: induction' n with k ih
state_before: case h.h
α : Type u_1
β : Type u_2
inst✝ : GeneralizedBooleanAlgebra α
f : ℕ → α
n : ℕ
⊢ (partialSups (disjointed f)) n = (partialSups f) n
state_after: case h.h.zero
α : Type u_1
β : Type u_2
inst✝ : GeneralizedBooleanAlgebra α
f : ℕ → α
⊢ (partialSups (disjointed f)) 0 = (partialSups f) 0

case h.h.succ
α : Type u_1
β : Type u_2
inst✝ : GeneralizedBooleanAlgebra α
f : ℕ → α
k : ℕ
ih : (partialSups (disjointed f)) k = (partialSups f) k
⊢ (partialSups (disjointed f)) (k + 1) = (partialSups f) (k + 1)

tactic: rw [partialSups_zero, partialSups_zero, disjointed_zero]
state_before: case h.h.zero
α : Type u_1
β : Type u_2
inst✝ : GeneralizedBooleanAlgebra α
f : ℕ → α
⊢ (partialSups (disjointed f)) 0 = (partialSups f) 0
state_after: no goals

tactic: rw [partialSups_succ, partialSups_succ, disjointed_succ, ih, sup_sdiff_self_right]
state_before: case h.h.succ
α : Type u_1
β : Type u_2
inst✝ : GeneralizedBooleanAlgebra α
f : ℕ → α
k : ℕ
ih : (partialSups (disjointed f)) k = (partialSups f) k
⊢ (partialSups (disjointed f)) (k + 1) = (partialSups f) (k + 1)
state_after: no goals
Theorem: Nat.factors_unique
File: Mathlib/Data/Nat/Factors.lean

tactic: refine perm_of_prod_eq_prod ?_ ?_ ?_
state_before: n : ℕ
l : List ℕ
h₁ : l.prod = n
h₂ : ∀ p ∈ l, Prime p
⊢ l ~ n.factors
state_after: case refine_1
n : ℕ
l : List ℕ
h₁ : l.prod = n
h₂ : ∀ p ∈ l, Prime p
⊢ l.prod = n.factors.prod

case refine_2
n : ℕ
l : List ℕ
h₁ : l.prod = n
h₂ : ∀ p ∈ l, Prime p
⊢ ∀ p ∈ l, _root_.Prime p

case refine_3
n : ℕ
l : List ℕ
h₁ : l.prod = n
h₂ : ∀ p ∈ l, Prime p
⊢ ∀ p ∈ n.factors, _root_.Prime p

tactic: rw [h₁]
state_before: case refine_1
n : ℕ
l : List ℕ
h₁ : l.prod = n
h₂ : ∀ p ∈ l, Prime p
⊢ l.prod = n.factors.prod
state_after: case refine_1
n : ℕ
l : List ℕ
h₁ : l.prod = n
h₂ : ∀ p ∈ l, Prime p
⊢ n = n.factors.prod

tactic: refine (prod_factors ?_).symm
state_before: case refine_1
n : ℕ
l : List ℕ
h₁ : l.prod = n
h₂ : ∀ p ∈ l, Prime p
⊢ n = n.factors.prod
state_after: case refine_1
n : ℕ
l : List ℕ
h₁ : l.prod = n
h₂ : ∀ p ∈ l, Prime p
⊢ n ≠ 0

tactic: rintro rfl
state_before: case refine_1
n : ℕ
l : List ℕ
h₁ : l.prod = n
h₂ : ∀ p ∈ l, Prime p
⊢ n ≠ 0
state_after: case refine_1
l : List ℕ
h₂ : ∀ p ∈ l, Prime p
h₁ : l.prod = 0
⊢ False

tactic: rw [prod_eq_zero_iff] at h₁
state_before: case refine_1
l : List ℕ
h₂ : ∀ p ∈ l, Prime p
h₁ : l.prod = 0
⊢ False
state_after: case refine_1
l : List ℕ
h₂ : ∀ p ∈ l, Prime p
h₁ : 0 ∈ l
⊢ False

tactic: exact Prime.ne_zero (h₂ 0 h₁) rfl
state_before: case refine_1
l : List ℕ
h₂ : ∀ p ∈ l, Prime p
h₁ : 0 ∈ l
⊢ False
state_after: no goals

tactic: simp_rw [← prime_iff]
state_before: case refine_2
n : ℕ
l : List ℕ
h₁ : l.prod = n
h₂ : ∀ p ∈ l, Prime p
⊢ ∀ p ∈ l, _root_.Prime p
state_after: case refine_2
n : ℕ
l : List ℕ
h₁ : l.prod = n
h₂ : ∀ p ∈ l, Prime p
⊢ ∀ p ∈ l, Prime p

tactic: exact h₂
state_before: case refine_2
n : ℕ
l : List ℕ
h₁ : l.prod = n
h₂ : ∀ p ∈ l, Prime p
⊢ ∀ p ∈ l, Prime p
state_after: no goals

tactic: simp_rw [← prime_iff]
state_before: case refine_3
n : ℕ
l : List ℕ
h₁ : l.prod = n
h₂ : ∀ p ∈ l, Prime p
⊢ ∀ p ∈ n.factors, _root_.Prime p
state_after: case refine_3
n : ℕ
l : List ℕ
h₁ : l.prod = n
h₂ : ∀ p ∈ l, Prime p
⊢ ∀ p ∈ n.factors, Prime p

tactic: exact fun p => prime_of_mem_factors
state_before: case refine_3
n : ℕ
l : List ℕ
h₁ : l.prod = n
h₂ : ∀ p ∈ l, Prime p
⊢ ∀ p ∈ n.factors, Prime p
state_after: no goals
Theorem: Sum.noMaxOrder_iff
File: Mathlib/Data/Sum/Order.lean

tactic: obtain ⟨b | b, h⟩ := exists_gt (inl a : Sum α β)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : LT α
inst✝ : LT β
x✝ : NoMaxOrder (α ⊕ β)
a : α
⊢ ∃ b, a < b
state_after: case intro.inl
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : LT α
inst✝ : LT β
x✝ : NoMaxOrder (α ⊕ β)
a b : α
h : inl a < inl b
⊢ ∃ b, a < b

case intro.inr
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : LT α
inst✝ : LT β
x✝ : NoMaxOrder (α ⊕ β)
a : α
b : β
h : inl a < inr b
⊢ ∃ b, a < b

tactic: exact ⟨b, inl_lt_inl_iff.1 h⟩
state_before: case intro.inl
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : LT α
inst✝ : LT β
x✝ : NoMaxOrder (α ⊕ β)
a b : α
h : inl a < inl b
⊢ ∃ b, a < b
state_after: no goals

tactic: exact (not_inl_lt_inr h).elim
state_before: case intro.inr
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : LT α
inst✝ : LT β
x✝ : NoMaxOrder (α ⊕ β)
a : α
b : β
h : inl a < inr b
⊢ ∃ b, a < b
state_after: no goals

tactic: obtain ⟨b | b, h⟩ := exists_gt (inr a : Sum α β)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : LT α
inst✝ : LT β
x✝ : NoMaxOrder (α ⊕ β)
a : β
⊢ ∃ b, a < b
state_after: case intro.inl
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : LT α
inst✝ : LT β
x✝ : NoMaxOrder (α ⊕ β)
a : β
b : α
h : inr a < inl b
⊢ ∃ b, a < b

case intro.inr
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : LT α
inst✝ : LT β
x✝ : NoMaxOrder (α ⊕ β)
a b : β
h : inr a < inr b
⊢ ∃ b, a < b

tactic: exact (not_inr_lt_inl h).elim
state_before: case intro.inl
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : LT α
inst✝ : LT β
x✝ : NoMaxOrder (α ⊕ β)
a : β
b : α
h : inr a < inl b
⊢ ∃ b, a < b
state_after: no goals

tactic: exact ⟨b, inr_lt_inr_iff.1 h⟩
state_before: case intro.inr
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : LT α
inst✝ : LT β
x✝ : NoMaxOrder (α ⊕ β)
a b : β
h : inr a < inr b
⊢ ∃ b, a < b
state_after: no goals
Theorem: Complex.oangle
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean

tactic: simp [oangle]
state_before: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
w z : ℂ
⊢ Complex.orientation.oangle w z = ↑((starRingEnd ℂ) w * z).arg
state_after: no goals
Theorem: finsuppTensorFinsuppRid_self
File: Mathlib/LinearAlgebra/DirectSum/Finsupp.lean

tactic: rw [finsuppTensorFinsupp', finsuppTensorFinsuppLid, finsuppTensorFinsuppRid,
  TensorProduct.lid_eq_rid]
state_before: R : Type u_1
S : Type u_2
M : Type u_3
N : Type u_4
ι : Type u_5
κ : Type u_6
inst✝⁸ : CommSemiring R
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
inst✝³ : Semiring S
inst✝² : Algebra R S
inst✝¹ : Module S M
inst✝ : IsScalarTower R S M
⊢ finsuppTensorFinsuppRid R R ι κ = finsuppTensorFinsupp' R ι κ
state_after: no goals