ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: LaurentSeries.coeff_zero_of_lt_valuation
File: Mathlib/RingTheory/LaurentSeries.lean

Proof steps:
state_before: R : Type u_1
K : Type u_2
inst✝ : Field K
n D : ℤ
f : LaurentSeries K
H : Valued.v f ≤ ↑(Multiplicative.ofAdd (-D))
⊢ n < D → f.coeff n = 0
state_after: R : Type u_1
K : Type u_2
inst✝ : Field K
n D : ℤ
f : LaurentSeries K
H : Valued.v f ≤ ↑(Multiplicative.ofAdd (-D))
hnd : n < D
⊢ f.coeff n = 0
tactic: intro hnd
state_before: R : Type u_1
K : Type u_2
inst✝ : Field K
n D : ℤ
f : LaurentSeries K
H : Valued.v f ≤ ↑(Multiplicative.ofAdd (-D))
hnd : n < D
⊢ f.coeff n = 0
state_after: case pos
R : Type u_1
K : Type u_2
inst✝ : Field K
n D : ℤ
f : LaurentSeries K
H : Valued.v f ≤ ↑(Multiplicative.ofAdd (-D))
hnd : n < D
h_n_ord : n < HahnSeries.order f
⊢ f.coeff n = 0

case neg
R : Type u_1
K : Type u_2
inst✝ : Field K
n D : ℤ
f : LaurentSeries K
H : Valued.v f ≤ ↑(Multiplicative.ofAdd (-D))
hnd : n < D
h_n_ord : ¬n < HahnSeries.order f
⊢ f.coeff n = 0
tactic: by_cases h_n_ord : n < f.order
state_before: case neg
R : Type u_1
K : Type u_2
inst✝ : Field K
n D : ℤ
f : LaurentSeries K
H : Valued.v f ≤ ↑(Multiplicative.ofAdd (-D))
hnd : n < D
h_n_ord : ¬n < HahnSeries.order f
⊢ f.coeff n = 0
state_after: case neg
R : Type u_1
K : Type u_2
inst✝ : Field K
n D : ℤ
f : LaurentSeries K
H : Valued.v f ≤ ↑(Multiplicative.ofAdd (-D))
hnd : n < D
h_n_ord : HahnSeries.order f ≤ n
⊢ f.coeff n = 0
tactic: rw [not_lt] at h_n_ord
state_before: case neg
R : Type u_1
K : Type u_2
inst✝ : Field K
n D : ℤ
f : LaurentSeries K
H : Valued.v f ≤ ↑(Multiplicative.ofAdd (-D))
hnd : n < D
h_n_ord : HahnSeries.order f ≤ n
⊢ f.coeff n = 0
state_after: case neg
R : Type u_1
K : Type u_2
inst✝ : Field K
n D : ℤ
f : LaurentSeries K
H : Valued.v f ≤ ↑(Multiplicative.ofAdd (-D))
hnd : n < D
h_n_ord : HahnSeries.order f ≤ n
F : K⟦X⟧ := f.powerSeriesPart
hF : F = f.powerSeriesPart
⊢ f.coeff n = 0
tactic: set F := powerSeriesPart f with hF
state_before: case neg
R : Type u_1
K : Type u_2
inst✝ : Field K
n D : ℤ
f : LaurentSeries K
H : Valued.v f ≤ ↑(Multiplicative.ofAdd (-D))
hnd : n < D
h_n_ord : HahnSeries.order f ≤ n
F : K⟦X⟧ := f.powerSeriesPart
hF : F = f.powerSeriesPart
⊢ f.coeff n = 0
state_after: case pos
R : Type u_1
K : Type u_2
inst✝ : Field K
n D : ℤ
f : LaurentSeries K
H : Valued.v f ≤ ↑(Multiplicative.ofAdd (-D))
hnd : n < D
h_n_ord : HahnSeries.order f ≤ n
F : K⟦X⟧ := f.powerSeriesPart
hF : F = f.powerSeriesPart
ord_nonpos : HahnSeries.order f ≤ 0
⊢ f.coeff n = 0

case neg
R : Type u_1
K : Type u_2
inst✝ : Field K
n D : ℤ
f : LaurentSeries K
H : Valued.v f ≤ ↑(Multiplicative.ofAdd (-D))
hnd : n < D
h_n_ord : HahnSeries.order f ≤ n
F : K⟦X⟧ := f.powerSeriesPart
hF : F = f.powerSeriesPart
ord_nonpos : ¬HahnSeries.order f ≤ 0
⊢ f.coeff n = 0
tactic: by_cases ord_nonpos : f.order ≤ 0
Theorem: MeasureTheory.levyProkhorovEDist_le_max_measure_univ
File: Mathlib/MeasureTheory/Measure/LevyProkhorovMetric.lean

Proof steps:
state_before: ι : Type u_1
Ω : Type u_2
inst✝¹ : MeasurableSpace Ω
inst✝ : PseudoEMetricSpace Ω
μ ν : Measure Ω
⊢ levyProkhorovEDist μ ν ≤ max (μ univ) (ν univ)
state_after: no goals
tactic: refine sInf_le fun B _ ↦ ⟨?_, ?_⟩ <;> apply le_add_left <;> simp [measure_mono]
Theorem: sdiff_eq_sdiff_iff_inf_eq_inf
File: Mathlib/Order/BooleanAlgebra.lean

Proof steps:
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
h : y \ x = y \ z
⊢ y ⊓ x ⊓ y \ x = y ⊓ z ⊓ y \ x
state_after: no goals
tactic: rw [inf_inf_sdiff, h, inf_inf_sdiff]
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
h : y \ x = y \ z
⊢ y ⊓ x ⊔ y \ x = y ⊓ z ⊔ y \ x
state_after: no goals
tactic: rw [sup_inf_sdiff, h, sup_inf_sdiff]
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
h : y ⊓ x = y ⊓ z
⊢ y \ x = y \ z
state_after: no goals
tactic: rw [← sdiff_inf_self_right, ← sdiff_inf_self_right z y, inf_comm, h, inf_comm]
Theorem: Polynomial.reflect_neg
File: Mathlib/Algebra/Polynomial/Reverse.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Ring R
f : R[X]
N : ℕ
⊢ reflect N (-f) = -reflect N f
state_after: no goals
tactic: rw [neg_eq_neg_one_mul, ← C_1, ← C_neg, reflect_C_mul, C_neg, C_1, ← neg_eq_neg_one_mul]
Theorem: Finset.max_eq_bot
File: Mathlib/Data/Finset/Lattice.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s : Finset α
h : s.max = ⊥
H : s.Nonempty
⊢ s = ∅
state_after: case intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s : Finset α
h : s.max = ⊥
H : s.Nonempty
a : α
ha : s.max = ↑a
⊢ s = ∅
tactic: obtain ⟨a, ha⟩ := max_of_nonempty H
state_before: case intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s : Finset α
h : s.max = ⊥
H : s.Nonempty
a : α
ha : s.max = ↑a
⊢ s = ∅
state_after: case intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s : Finset α
h : s.max = ⊥
H : s.Nonempty
a : α
ha : ⊥ = ↑a
⊢ s = ∅
tactic: rw [h] at ha
state_before: case intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s : Finset α
h : s.max = ⊥
H : s.Nonempty
a : α
ha : ⊥ = ↑a
⊢ s = ∅
state_after: no goals
tactic: cases ha
Theorem: List.erase_cons_subperm_cons_erase
File: .lake/packages/batteries/Batteries/Data/List/Perm.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
a b : α
l : List α
⊢ (a :: l).erase b <+~ a :: l.erase b
state_after: no goals
tactic: if h : a = b then
    rw [h, erase_cons_head]; apply subperm_cons_erase
  else
    have : ¬(a == b) = true := by simp only [beq_false_of_ne h, not_false_eq_true]
    rw [erase_cons_tail _ this]
Theorem: CategoryTheory.OplaxFunctor.bicategory_homCategory_comp_app
File: Mathlib/CategoryTheory/Bicategory/FunctorBicategory.lean

Proof steps:
state_before: B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G H I a b c : OplaxFunctor B C
f g : a ⟶ b
h i : b ⟶ c
η : f ⟶ g
θ : h ⟶ i
⊢ (fun {F G H} η x x_1 Γ => OplaxNatTrans.whiskerLeft η Γ) f h i θ ≫
      (fun {F G H} x x_1 Γ η => OplaxNatTrans.whiskerRight Γ η) f g η i =
    (fun {F G H} x x_1 Γ η => OplaxNatTrans.whiskerRight Γ η) f g η h ≫
      (fun {F G H} η x x_1 Γ => OplaxNatTrans.whiskerLeft η Γ) g h i θ
state_after: case w
B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G H I a b c : OplaxFunctor B C
f g : a ⟶ b
h i : b ⟶ c
η : f ⟶ g
θ : h ⟶ i
b✝ : B
⊢ ((fun {F G H} η x x_1 Γ => OplaxNatTrans.whiskerLeft η Γ) f h i θ ≫
          (fun {F G H} x x_1 Γ η => OplaxNatTrans.whiskerRight Γ η) f g η i).app
      b✝ =
    ((fun {F G H} x x_1 Γ η => OplaxNatTrans.whiskerRight Γ η) f g η h ≫
          (fun {F G H} η x x_1 Γ => OplaxNatTrans.whiskerLeft η Γ) g h i θ).app
      b✝
tactic: ext
state_before: case w
B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G H I a b c : OplaxFunctor B C
f g : a ⟶ b
h i : b ⟶ c
η : f ⟶ g
θ : h ⟶ i
b✝ : B
⊢ ((fun {F G H} η x x_1 Γ => OplaxNatTrans.whiskerLeft η Γ) f h i θ ≫
          (fun {F G H} x x_1 Γ η => OplaxNatTrans.whiskerRight Γ η) f g η i).app
      b✝ =
    ((fun {F G H} x x_1 Γ η => OplaxNatTrans.whiskerRight Γ η) f g η h ≫
          (fun {F G H} η x x_1 Γ => OplaxNatTrans.whiskerLeft η Γ) g h i θ).app
      b✝
state_after: no goals
tactic: exact whisker_exchange _ _
Theorem: SimpleGraph.isTuranMaximal_of_iso
File: Mathlib/Combinatorics/SimpleGraph/Turan.lean

Proof steps:
state_before: V : Type u_1
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n r : ℕ
f : G ≃g turanGraph n r
hr : 0 < r
⊢ G.IsTuranMaximal r
state_after: case intro.intro
V : Type u_1
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n r : ℕ
f : G ≃g turanGraph n r
hr : 0 < r
J : SimpleGraph V
w✝ : DecidableRel J.Adj
j : J.IsTuranMaximal r
⊢ G.IsTuranMaximal r
tactic: obtain ⟨J, _, j⟩ := exists_isTuranMaximal (V := V) hr
state_before: case intro.intro
V : Type u_1
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n r : ℕ
f : G ≃g turanGraph n r
hr : 0 < r
J : SimpleGraph V
w✝ : DecidableRel J.Adj
j : J.IsTuranMaximal r
⊢ G.IsTuranMaximal r
state_after: case intro.intro.intro
V : Type u_1
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n r : ℕ
f : G ≃g turanGraph n r
hr : 0 < r
J : SimpleGraph V
w✝ : DecidableRel J.Adj
j : J.IsTuranMaximal r
g : J ≃g turanGraph (Fintype.card V) r
⊢ G.IsTuranMaximal r
tactic: obtain ⟨g⟩ := j.nonempty_iso_turanGraph
state_before: case intro.intro.intro
V : Type u_1
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n r : ℕ
f : G ≃g turanGraph n r
hr : 0 < r
J : SimpleGraph V
w✝ : DecidableRel J.Adj
j : J.IsTuranMaximal r
g : J ≃g turanGraph (Fintype.card V) r
⊢ G.IsTuranMaximal r
state_after: case intro.intro.intro
V : Type u_1
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n r : ℕ
f : G ≃g turanGraph n r
hr : 0 < r
J : SimpleGraph V
w✝ : DecidableRel J.Adj
j : J.IsTuranMaximal r
g : J ≃g turanGraph n r
⊢ G.IsTuranMaximal r
tactic: rw [f.card_eq, Fintype.card_fin] at g
state_before: case intro.intro.intro
V : Type u_1
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n r : ℕ
f : G ≃g turanGraph n r
hr : 0 < r
J : SimpleGraph V
w✝ : DecidableRel J.Adj
j : J.IsTuranMaximal r
g : J ≃g turanGraph n r
⊢ G.IsTuranMaximal r
state_after: no goals
tactic: use (turanGraph_cliqueFree (n := n) hr).comap f,
    fun H _ cf ↦ (f.symm.comp g).card_edgeFinset_eq ▸ j.2 H cf
Theorem: Submodule.sub_mem_orthogonal_of_inner_left
File: Mathlib/Analysis/InnerProductSpace/Orthogonal.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
x y : E
h : ∀ (v : ↥K), ⟪x, ↑v⟫_𝕜 = ⟪y, ↑v⟫_𝕜
⊢ x - y ∈ Kᗮ
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
x y : E
h : ∀ (v : ↥K), ⟪x, ↑v⟫_𝕜 = ⟪y, ↑v⟫_𝕜
⊢ ∀ u ∈ K, ⟪x - y, u⟫_𝕜 = 0
tactic: rw [mem_orthogonal']
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
x y : E
h : ∀ (v : ↥K), ⟪x, ↑v⟫_𝕜 = ⟪y, ↑v⟫_𝕜
⊢ ∀ u ∈ K, ⟪x - y, u⟫_𝕜 = 0
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
x y : E
h : ∀ (v : ↥K), ⟪x, ↑v⟫_𝕜 = ⟪y, ↑v⟫_𝕜
u : E
hu : u ∈ K
⊢ ⟪x - y, u⟫_𝕜 = 0
tactic: intro u hu
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
x y : E
h : ∀ (v : ↥K), ⟪x, ↑v⟫_𝕜 = ⟪y, ↑v⟫_𝕜
u : E
hu : u ∈ K
⊢ ⟪x - y, u⟫_𝕜 = 0
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
x y : E
h : ∀ (v : ↥K), ⟪x, ↑v⟫_𝕜 = ⟪y, ↑v⟫_𝕜
u : E
hu : u ∈ K
⊢ ⟪x, u⟫_𝕜 = ⟪y, u⟫_𝕜
tactic: rw [inner_sub_left, sub_eq_zero]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
x y : E
h : ∀ (v : ↥K), ⟪x, ↑v⟫_𝕜 = ⟪y, ↑v⟫_𝕜
u : E
hu : u ∈ K
⊢ ⟪x, u⟫_𝕜 = ⟪y, u⟫_𝕜
state_after: no goals
tactic: exact h ⟨u, hu⟩
Theorem: Multiset.countP_add
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
p : α → Prop
inst✝ : DecidablePred p
s t : Multiset α
⊢ countP p (s + t) = countP p s + countP p t
state_after: no goals
tactic: simp [countP_eq_card_filter]
Theorem: AddLECancellable.injective_left
File: Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Mul α
i : IsSymmOp α α fun x x_1 => x * x_1
inst✝ : PartialOrder α
a : α
ha : MulLECancellable a
b c : α
h : (fun x => x * a) b = (fun x => x * a) c
⊢ (fun x => a * x) b = (fun x => a * x) c
state_after: α : Type u_1
β : Type u_2
inst✝¹ : Mul α
i : IsSymmOp α α fun x x_1 => x * x_1
inst✝ : PartialOrder α
a : α
ha : MulLECancellable a
b c : α
h : (fun x => x * a) b = (fun x => x * a) c
⊢ a * b = a * c
tactic: dsimp
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Mul α
i : IsSymmOp α α fun x x_1 => x * x_1
inst✝ : PartialOrder α
a : α
ha : MulLECancellable a
b c : α
h : (fun x => x * a) b = (fun x => x * a) c
⊢ a * b = a * c
state_after: no goals
tactic: rwa [i.symm_op a, i.symm_op a]
Theorem: Nat.sum_divisors_filter_squarefree
File: Mathlib/Data/Nat/Squarefree.lean

Proof steps:
state_before: s : Finset ℕ
m n✝ p n : ℕ
h0 : n ≠ 0
α : Type u_1
inst✝ : AddCommMonoid α
f : ℕ → α
⊢ ∑ i ∈ filter Squarefree n.divisors, f i = ∑ i ∈ (normalizedFactors n).toFinset.powerset, f i.val.prod
state_after: s : Finset ℕ
m n✝ p n : ℕ
h0 : n ≠ 0
α : Type u_1
inst✝ : AddCommMonoid α
f : ℕ → α
⊢ (Multiset.map (f ∘ fun x => x.val.prod) (normalizedFactors n).toFinset.powerset.val).sum =
    (Multiset.map (fun i => f i.val.prod) (normalizedFactors n).toFinset.powerset.val).sum
tactic: rw [Finset.sum_eq_multiset_sum, divisors_filter_squarefree h0, Multiset.map_map,
    Finset.sum_eq_multiset_sum]
state_before: s : Finset ℕ
m n✝ p n : ℕ
h0 : n ≠ 0
α : Type u_1
inst✝ : AddCommMonoid α
f : ℕ → α
⊢ (Multiset.map (f ∘ fun x => x.val.prod) (normalizedFactors n).toFinset.powerset.val).sum =
    (Multiset.map (fun i => f i.val.prod) (normalizedFactors n).toFinset.powerset.val).sum
state_after: no goals
tactic: rfl
Theorem: Zsqrtd.sqLe_smul
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

Proof steps:
state_before: d✝ : ℤ
c d x y n : ℕ
xy : SqLe x c y d
⊢ SqLe (n * x) c (n * y) d
state_after: no goals
tactic: simpa [SqLe, mul_left_comm, mul_assoc] using Nat.mul_le_mul_left (n * n) xy
Theorem: CochainComplex.HomComplex.Cocycle.ofHom_homOf_eq_self
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
z : Cocycle F G 0
⊢ ofHom z.homOf = z
state_after: no goals
tactic: aesop_cat
Theorem: Ideal.cotangentEquivIdeal_symm_apply
File: Mathlib/RingTheory/Ideal/Cotangent.lean

Proof steps:
state_before: R : Type u
S : Type v
S' : Type w
inst✝⁶ : CommRing R
inst✝⁵ : CommSemiring S
inst✝⁴ : Algebra S R
inst✝³ : CommSemiring S'
inst✝² : Algebra S' R
inst✝¹ : Algebra S S'
inst✝ : IsScalarTower S S' R
I : Ideal R
x : R
hx : x ∈ I
⊢ I.cotangentEquivIdeal.symm ⟨(Submodule.mkQ (I ^ 2)) x, ⋯⟩ = I.toCotangent ⟨x, hx⟩
state_after: case a
R : Type u
S : Type v
S' : Type w
inst✝⁶ : CommRing R
inst✝⁵ : CommSemiring S
inst✝⁴ : Algebra S R
inst✝³ : CommSemiring S'
inst✝² : Algebra S' R
inst✝¹ : Algebra S S'
inst✝ : IsScalarTower S S' R
I : Ideal R
x : R
hx : x ∈ I
⊢ I.cotangentEquivIdeal (I.cotangentEquivIdeal.symm ⟨(Submodule.mkQ (I ^ 2)) x, ⋯⟩) =
    I.cotangentEquivIdeal (I.toCotangent ⟨x, hx⟩)
tactic: apply I.cotangentEquivIdeal.injective
state_before: case a
R : Type u
S : Type v
S' : Type w
inst✝⁶ : CommRing R
inst✝⁵ : CommSemiring S
inst✝⁴ : Algebra S R
inst✝³ : CommSemiring S'
inst✝² : Algebra S' R
inst✝¹ : Algebra S S'
inst✝ : IsScalarTower S S' R
I : Ideal R
x : R
hx : x ∈ I
⊢ I.cotangentEquivIdeal (I.cotangentEquivIdeal.symm ⟨(Submodule.mkQ (I ^ 2)) x, ⋯⟩) =
    I.cotangentEquivIdeal (I.toCotangent ⟨x, hx⟩)
state_after: case a
R : Type u
S : Type v
S' : Type w
inst✝⁶ : CommRing R
inst✝⁵ : CommSemiring S
inst✝⁴ : Algebra S R
inst✝³ : CommSemiring S'
inst✝² : Algebra S' R
inst✝¹ : Algebra S S'
inst✝ : IsScalarTower S S' R
I : Ideal R
x : R
hx : x ∈ I
⊢ ⟨(Submodule.mkQ (I ^ 2)) x, ⋯⟩ = I.cotangentEquivIdeal (I.toCotangent ⟨x, hx⟩)
tactic: rw [I.cotangentEquivIdeal.apply_symm_apply]
state_before: case a
R : Type u
S : Type v
S' : Type w
inst✝⁶ : CommRing R
inst✝⁵ : CommSemiring S
inst✝⁴ : Algebra S R
inst✝³ : CommSemiring S'
inst✝² : Algebra S' R
inst✝¹ : Algebra S S'
inst✝ : IsScalarTower S S' R
I : Ideal R
x : R
hx : x ∈ I
⊢ ⟨(Submodule.mkQ (I ^ 2)) x, ⋯⟩ = I.cotangentEquivIdeal (I.toCotangent ⟨x, hx⟩)
state_after: case a.a
R : Type u
S : Type v
S' : Type w
inst✝⁶ : CommRing R
inst✝⁵ : CommSemiring S
inst✝⁴ : Algebra S R
inst✝³ : CommSemiring S'
inst✝² : Algebra S' R
inst✝¹ : Algebra S S'
inst✝ : IsScalarTower S S' R
I : Ideal R
x : R
hx : x ∈ I
⊢ ↑⟨(Submodule.mkQ (I ^ 2)) x, ⋯⟩ = ↑(I.cotangentEquivIdeal (I.toCotangent ⟨x, hx⟩))
tactic: ext
state_before: case a.a
R : Type u
S : Type v
S' : Type w
inst✝⁶ : CommRing R
inst✝⁵ : CommSemiring S
inst✝⁴ : Algebra S R
inst✝³ : CommSemiring S'
inst✝² : Algebra S' R
inst✝¹ : Algebra S S'
inst✝ : IsScalarTower S S' R
I : Ideal R
x : R
hx : x ∈ I
⊢ ↑⟨(Submodule.mkQ (I ^ 2)) x, ⋯⟩ = ↑(I.cotangentEquivIdeal (I.toCotangent ⟨x, hx⟩))
state_after: no goals
tactic: rfl
Theorem: Disjoint.le_symmDiff_sup_symmDiff_right
File: Mathlib/Order/SymmDiff.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : BooleanAlgebra α
a b c d : α
h : Disjoint b c
⊢ a ≤ a ∆ b ⊔ a ∆ c
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : BooleanAlgebra α
a b c d : α
h : Disjoint b c
⊢ a ≤ b ∆ a ⊔ c ∆ a
tactic: simp_rw [symmDiff_comm a]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : BooleanAlgebra α
a b c d : α
h : Disjoint b c
⊢ a ≤ b ∆ a ⊔ c ∆ a
state_after: no goals
tactic: exact h.le_symmDiff_sup_symmDiff_left
Theorem: MonoidAlgebra.support_mul_single
File: Mathlib/Algebra/MonoidAlgebra/Support.lean

Proof steps:
state_before: k : Type u₁
G : Type u₂
inst✝² : Semiring k
inst✝¹ : Mul G
inst✝ : IsRightCancelMul G
f : MonoidAlgebra k G
r : k
hr : ∀ (y : k), y * r = 0 ↔ y = 0
x : G
⊢ (f * single x r).support = map (mulRightEmbedding x) f.support
state_after: no goals
tactic: classical
    ext
    simp only [support_mul_single_eq_image f hr (IsRightRegular.all x),
      mem_image, mem_map, mulRightEmbedding_apply]
Theorem: invOf_two_add_invOf_two
File: Mathlib/Algebra/Ring/Invertible.lean

Proof steps:
state_before: α : Type u
inst✝¹ : NonAssocSemiring α
inst✝ : Invertible 2
⊢ ⅟2 + ⅟2 = 1
state_after: no goals
tactic: rw [← two_mul, mul_invOf_self]
Theorem: CategoryTheory.Pretriangulated.Triangle.isZero₂_of_isZero₁₃
File: Mathlib/CategoryTheory/Triangulated/Pretriangulated.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : Preadditive C
inst✝ : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive
hC : Pretriangulated C
T : Triangle C
hT : T ∈ distinguishedTriangles
h₁ : IsZero T.obj₁
h₃ : IsZero T.obj₃
⊢ IsZero T.obj₂
state_after: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : Preadditive C
inst✝ : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive
hC : Pretriangulated C
T : Triangle C
hT : T ∈ distinguishedTriangles
h₁ : IsZero T.obj₁
h₃ : IsZero T.obj₃
⊢ T.mor₁ = 0 ∧ T.mor₂ = 0
tactic: rw [T.isZero₂_iff hT]
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : Preadditive C
inst✝ : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive
hC : Pretriangulated C
T : Triangle C
hT : T ∈ distinguishedTriangles
h₁ : IsZero T.obj₁
h₃ : IsZero T.obj₃
⊢ T.mor₁ = 0 ∧ T.mor₂ = 0
state_after: no goals
tactic: exact ⟨h₁.eq_of_src _ _, h₃.eq_of_tgt _ _⟩
Theorem: PMF.toOuterMeasure_map_apply
File: Mathlib/Probability/ProbabilityMassFunction/Constructions.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : α → β
p : PMF α
b : β
s : Set β
⊢ (map f p).toOuterMeasure s = p.toOuterMeasure (f ⁻¹' s)
state_after: no goals
tactic: simp [map, Set.indicator, toOuterMeasure_apply p (f ⁻¹' s)]
Theorem: Mathlib.Tactic.Ring.div_pf
File: Mathlib/Tactic/Ring/Basic.lean

Proof steps:
state_before: u✝ : Lean.Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : Lean.Level
α : Q(Type u)
sα : Q(CommSemiring «$α»)
R✝ : Type u_1
inst✝¹ : CommSemiring R✝
a✝ a' a₁ a₂ a₃ b✝ b' b₁ b₂ b₃ c✝ c₁ c₂ : R✝
R : Type u_2
inst✝ : DivisionRing R
a b c d : R
x✝¹ : b⁻¹ = c
x✝ : a * c = d
⊢ a / b = d
state_after: u✝ : Lean.Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : Lean.Level
α : Q(Type u)
sα : Q(CommSemiring «$α»)
R✝ : Type u_1
inst✝¹ : CommSemiring R✝
a✝ a' a₁ a₂ a₃ b✝ b' b₁ b₂ b₃ c c₁ c₂ : R✝
R : Type u_2
inst✝ : DivisionRing R
a b : R
⊢ a / b = a * b⁻¹
tactic: subst_vars
state_before: u✝ : Lean.Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : Lean.Level
α : Q(Type u)
sα : Q(CommSemiring «$α»)
R✝ : Type u_1
inst✝¹ : CommSemiring R✝
a✝ a' a₁ a₂ a₃ b✝ b' b₁ b₂ b₃ c c₁ c₂ : R✝
R : Type u_2
inst✝ : DivisionRing R
a b : R
⊢ a / b = a * b⁻¹
state_after: no goals
tactic: simp [div_eq_mul_inv]
Theorem: div_pos_iff_of_pos_right
File: Mathlib/Algebra/Order/Field/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
hb : 0 < b
⊢ 0 < a / b ↔ 0 < a
state_after: no goals
tactic: simp only [div_eq_mul_inv, mul_pos_iff_of_pos_right (inv_pos (α := α) |>.2 hb)]
Theorem: Prod.openSegment_subset
File: Mathlib/Analysis/Convex/Segment.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y : E × F
⊢ openSegment 𝕜 x y ⊆ openSegment 𝕜 x.1 y.1 ×ˢ openSegment 𝕜 x.2 y.2
state_after: case intro.intro.intro.intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y z : E × F
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
hz : a • x + b • y = z
⊢ z ∈ openSegment 𝕜 x.1 y.1 ×ˢ openSegment 𝕜 x.2 y.2
tactic: rintro z ⟨a, b, ha, hb, hab, hz⟩
state_before: case intro.intro.intro.intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y z : E × F
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
hz : a • x + b • y = z
⊢ z ∈ openSegment 𝕜 x.1 y.1 ×ˢ openSegment 𝕜 x.2 y.2
state_after: no goals
tactic: exact ⟨⟨a, b, ha, hb, hab, congr_arg Prod.fst hz⟩, a, b, ha, hb, hab, congr_arg Prod.snd hz⟩
Theorem: LazyList.append_bind
File: .lake/packages/batteries/Batteries/Data/LazyList.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
xs : LazyList α
ys : Thunk (LazyList α)
f : α → LazyList β
⊢ (xs.append ys).bind f = (xs.bind f).append { fn := fun x => ys.get.bind f }
state_after: no goals
tactic: match xs with
  | LazyList.nil =>
    simp only [append, Thunk.get, LazyList.bind]
  | LazyList.cons x xs =>
    simp only [append, Thunk.get, LazyList.bind]
    have := append_bind xs.get ys f
    simp only [Thunk.get] at this
    rw [this, append_assoc]
Theorem: Subgroup.closure_le_normalClosure
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
s✝ s : Set G
⊢ closure s ≤ normalClosure s
state_after: no goals
tactic: simp only [subset_normalClosure, closure_le]
Theorem: List.disjoint_append_left
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α✝ : Type u_1
l₁ l₂ l : List α✝
⊢ (l₁ ++ l₂).Disjoint l ↔ l₁.Disjoint l ∧ l₂.Disjoint l
state_after: no goals
tactic: simp [Disjoint, or_imp, forall_and]