ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: MeasureTheory.LocallyIntegrable.integrableOn_nhds_isCompact
File: Mathlib/MeasureTheory/Function/LocallyIntegrable.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
R : Type u_5
inst✝⁵ : MeasurableSpace X
inst✝⁴ : TopologicalSpace X
inst✝³ : MeasurableSpace Y
inst✝² : TopologicalSpace Y
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
f g : X → E
μ : Measure X
s : Set X
hf : LocallyIntegrable f μ
k : Set X
hk : IsCompact k
⊢ ∃ u, IsOpen u ∧ k ⊆ u ∧ IntegrableOn f u μ
state_after: case refine_1
X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
R : Type u_5
inst✝⁵ : MeasurableSpace X
inst✝⁴ : TopologicalSpace X
inst✝³ : MeasurableSpace Y
inst✝² : TopologicalSpace Y
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
f g : X → E
μ : Measure X
s : Set X
hf : LocallyIntegrable f μ
k : Set X
hk : IsCompact k
⊢ ∃ u, IsOpen u ∧ ∅ ⊆ u ∧ IntegrableOn f u μ

case refine_2
X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
R : Type u_5
inst✝⁵ : MeasurableSpace X
inst✝⁴ : TopologicalSpace X
inst✝³ : MeasurableSpace Y
inst✝² : TopologicalSpace Y
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
f g : X → E
μ : Measure X
s : Set X
hf : LocallyIntegrable f μ
k : Set X
hk : IsCompact k
⊢ ∀ ⦃s t : Set X⦄, s ⊆ t → (∃ u, IsOpen u ∧ t ⊆ u ∧ IntegrableOn f u μ) → ∃ u, IsOpen u ∧ s ⊆ u ∧ IntegrableOn f u μ

case refine_3
X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
R : Type u_5
inst✝⁵ : MeasurableSpace X
inst✝⁴ : TopologicalSpace X
inst✝³ : MeasurableSpace Y
inst✝² : TopologicalSpace Y
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
f g : X → E
μ : Measure X
s : Set X
hf : LocallyIntegrable f μ
k : Set X
hk : IsCompact k
⊢ ∀ ⦃s t : Set X⦄,
    (∃ u, IsOpen u ∧ s ⊆ u ∧ IntegrableOn f u μ) →
      (∃ u, IsOpen u ∧ t ⊆ u ∧ IntegrableOn f u μ) → ∃ u, IsOpen u ∧ s ∪ t ⊆ u ∧ IntegrableOn f u μ

case refine_4
X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
R : Type u_5
inst✝⁵ : MeasurableSpace X
inst✝⁴ : TopologicalSpace X
inst✝³ : MeasurableSpace Y
inst✝² : TopologicalSpace Y
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
f g : X → E
μ : Measure X
s : Set X
hf : LocallyIntegrable f μ
k : Set X
hk : IsCompact k
⊢ ∀ x ∈ k, ∃ t ∈ 𝓝[k] x, ∃ u, IsOpen u ∧ t ⊆ u ∧ IntegrableOn f u μ
tactic: refine IsCompact.induction_on hk ?_ ?_ ?_ ?_
Theorem: CategoryTheory.Bicategory.associator_naturality_left
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

Proof steps:
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f f' : a ⟶ b
η : f ⟶ f'
g : b ⟶ c
h : c ⟶ d
⊢ η ▷ g ▷ h ≫ (α_ f' g h).hom = (α_ f g h).hom ≫ η ▷ (g ≫ h)
state_after: no goals
tactic: simp
Theorem: LinearPMap.domRestrict_le
File: Mathlib/LinearAlgebra/LinearPMap.lean

Proof steps:
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
S : Submodule R E
⊢ (f.domRestrict S).domain ≤ f.domain
state_after: no goals
tactic: simp
Theorem: MvPolynomial.support_monomial
File: Mathlib/Algebra/MvPolynomial/Basic.lean

Proof steps:
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
h : Decidable (a = 0)
⊢ ((monomial s) a).support = if a = 0 then ∅ else {s}
state_after: no goals
tactic: rfl
Theorem: IsCyclic.image_range_card
File: Mathlib/GroupTheory/SpecificGroups/Cyclic.lean

Proof steps:
state_before: α : Type u
a : α
inst✝² : Group α
inst✝¹ : DecidableEq α
inst✝ : Fintype α
ha : ∀ (x : α), x ∈ zpowers a
⊢ image (fun i => a ^ i) (range (Fintype.card α)) = univ
state_after: no goals
tactic: rw [← orderOf_eq_card_of_forall_mem_zpowers ha, IsCyclic.image_range_orderOf ha]
Theorem: inf_symmDiff_distrib_left
File: Mathlib/Order/SymmDiff.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedBooleanAlgebra α
a b c d : α
⊢ a ⊓ b ∆ c = (a ⊓ b) ∆ (a ⊓ c)
state_after: no goals
tactic: rw [symmDiff_eq_sup_sdiff_inf, inf_sdiff_distrib_left, inf_sup_left, inf_inf_distrib_left,
    symmDiff_eq_sup_sdiff_inf]
Theorem: List.prod_induction
File: Mathlib/Algebra/BigOperators/Group/List.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l l₁ l₂ : List M
a : M
p : M → Prop
hom : ∀ (a b : M), p a → p b → p (a * b)
unit : p 1
base : ∀ x ∈ l, p x
⊢ p l.prod
state_after: case nil
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l l₁ l₂ : List M
a : M
p : M → Prop
hom : ∀ (a b : M), p a → p b → p (a * b)
unit : p 1
base : ∀ x ∈ [], p x
⊢ p [].prod

case cons
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l✝ l₁ l₂ : List M
a✝ : M
p : M → Prop
hom : ∀ (a b : M), p a → p b → p (a * b)
unit : p 1
a : M
l : List M
ih : (∀ x ∈ l, p x) → p l.prod
base : ∀ x ∈ a :: l, p x
⊢ p (a :: l).prod
tactic: induction' l with a l ih
state_before: case cons
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l✝ l₁ l₂ : List M
a✝ : M
p : M → Prop
hom : ∀ (a b : M), p a → p b → p (a * b)
unit : p 1
a : M
l : List M
ih : (∀ x ∈ l, p x) → p l.prod
base : ∀ x ∈ a :: l, p x
⊢ p (a :: l).prod
state_after: case cons
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l✝ l₁ l₂ : List M
a✝ : M
p : M → Prop
hom : ∀ (a b : M), p a → p b → p (a * b)
unit : p 1
a : M
l : List M
ih : (∀ x ∈ l, p x) → p l.prod
base : ∀ x ∈ a :: l, p x
⊢ p (a * l.prod)
tactic: rw [List.prod_cons]
state_before: case cons
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l✝ l₁ l₂ : List M
a✝ : M
p : M → Prop
hom : ∀ (a b : M), p a → p b → p (a * b)
unit : p 1
a : M
l : List M
ih : (∀ x ∈ l, p x) → p l.prod
base : ∀ x ∈ a :: l, p x
⊢ p (a * l.prod)
state_after: case cons
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l✝ l₁ l₂ : List M
a✝ : M
p : M → Prop
hom : ∀ (a b : M), p a → p b → p (a * b)
unit : p 1
a : M
l : List M
ih : (∀ x ∈ l, p x) → p l.prod
base : p a ∧ ∀ a ∈ l, p a
⊢ p (a * l.prod)
tactic: simp only [Bool.not_eq_true, List.mem_cons, forall_eq_or_imp] at base
state_before: case cons
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l✝ l₁ l₂ : List M
a✝ : M
p : M → Prop
hom : ∀ (a b : M), p a → p b → p (a * b)
unit : p 1
a : M
l : List M
ih : (∀ x ∈ l, p x) → p l.prod
base : p a ∧ ∀ a ∈ l, p a
⊢ p (a * l.prod)
state_after: no goals
tactic: exact hom _ _ (base.1) (ih base.2)
Theorem: isClosed_nonneg
File: Mathlib/Analysis/Normed/Order/Lattice.lean

Proof steps:
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: have : {x : α | 0 ≤ x} = negPart ⁻¹' {0} := by ext; simp [negPart_eq_zero]
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: rw [this]
state_before: α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
this : {x | 0 ≤ x} = negPart ⁻¹' {0}
⊢ IsClosed (negPart ⁻¹' {0})
state_after: no goals
tactic: exact isClosed_singleton.preimage continuous_negPart
Theorem: SpectrumRestricts.of_spectrum_eq
File: Mathlib/Algebra/Algebra/Quasispectrum.lean

Proof steps:
state_before: R✝ : Type u_1
A✝ : Type u_2
inst✝¹¹ : CommSemiring R✝
inst✝¹⁰ : NonUnitalRing A✝
inst✝⁹ : Module R✝ A✝
inst✝⁸ : IsScalarTower R✝ A✝ A✝
inst✝⁷ : SMulCommClass R✝ A✝ A✝
R : Type u_3
S : Type u_4
A : Type u_5
inst✝⁶ : Semifield R
inst✝⁵ : Semifield S
inst✝⁴ : Ring A
inst✝³ : Algebra R S
inst✝² : Algebra R A
inst✝¹ : Algebra S A
a✝ : A
f✝ : S → R
inst✝ : IsScalarTower R S A
h✝ : SpectrumRestricts a✝ f✝
a b : A
f : S → R
ha : SpectrumRestricts a f
h : spectrum S a = spectrum S b
⊢ Set.RightInvOn f (⇑(algebraMap R S)) (quasispectrum S b)
state_after: R✝ : Type u_1
A✝ : Type u_2
inst✝¹¹ : CommSemiring R✝
inst✝¹⁰ : NonUnitalRing A✝
inst✝⁹ : Module R✝ A✝
inst✝⁸ : IsScalarTower R✝ A✝ A✝
inst✝⁷ : SMulCommClass R✝ A✝ A✝
R : Type u_3
S : Type u_4
A : Type u_5
inst✝⁶ : Semifield R
inst✝⁵ : Semifield S
inst✝⁴ : Ring A
inst✝³ : Algebra R S
inst✝² : Algebra R A
inst✝¹ : Algebra S A
a✝ : A
f✝ : S → R
inst✝ : IsScalarTower R S A
h✝ : SpectrumRestricts a✝ f✝
a b : A
f : S → R
ha : SpectrumRestricts a f
h : spectrum S a = spectrum S b
⊢ Set.RightInvOn f (⇑(algebraMap R S)) (quasispectrum S a)
tactic: rw [quasispectrum_eq_spectrum_union_zero, ← h, ← quasispectrum_eq_spectrum_union_zero]
state_before: R✝ : Type u_1
A✝ : Type u_2
inst✝¹¹ : CommSemiring R✝
inst✝¹⁰ : NonUnitalRing A✝
inst✝⁹ : Module R✝ A✝
inst✝⁸ : IsScalarTower R✝ A✝ A✝
inst✝⁷ : SMulCommClass R✝ A✝ A✝
R : Type u_3
S : Type u_4
A : Type u_5
inst✝⁶ : Semifield R
inst✝⁵ : Semifield S
inst✝⁴ : Ring A
inst✝³ : Algebra R S
inst✝² : Algebra R A
inst✝¹ : Algebra S A
a✝ : A
f✝ : S → R
inst✝ : IsScalarTower R S A
h✝ : SpectrumRestricts a✝ f✝
a b : A
f : S → R
ha : SpectrumRestricts a f
h : spectrum S a = spectrum S b
⊢ Set.RightInvOn f (⇑(algebraMap R S)) (quasispectrum S a)
state_after: no goals
tactic: exact QuasispectrumRestricts.rightInvOn ha
Theorem: Ring.choose_zero_pos
File: Mathlib/RingTheory/Binomial.lean

Proof steps:
state_before: R✝ : Type u_1
inst✝⁶ : NonAssocRing R✝
inst✝⁵ : Pow R✝ ℕ
inst✝⁴ : BinomialRing R✝
R : Type u_2
inst✝³ : NonAssocRing R
inst✝² : Pow R ℕ
inst✝¹ : NatPowAssoc R
inst✝ : BinomialRing R
k : ℕ
h_pos : 0 < k
⊢ choose 0 k = 0
state_after: no goals
tactic: rw [← Nat.succ_pred_eq_of_pos h_pos, choose_zero_succ]
Theorem: char_dvd_card_solutions_of_fintype_sum_lt
File: Mathlib/FieldTheory/ChevalleyWarning.lean

Proof steps:
state_before: K : Type u_1
σ : Type u_2
ι : Type u_3
inst✝⁶ : Fintype K
inst✝⁵ : Field K
inst✝⁴ : Fintype σ
inst✝³ : DecidableEq σ
inst✝² : DecidableEq K
p : ℕ
inst✝¹ : CharP K p
inst✝ : Fintype ι
f : ι → MvPolynomial σ K
h : ∑ i : ι, (f i).totalDegree < Fintype.card σ
⊢ p ∣ Fintype.card { x // ∀ (i : ι), (eval x) (f i) = 0 }
state_after: no goals
tactic: simpa using char_dvd_card_solutions_of_sum_lt p h
Theorem: CategoryTheory.InjectiveResolution.self_ι
File: Mathlib/CategoryTheory/Preadditive/InjectiveResolution.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroObject C
inst✝¹ : HasZeroMorphisms C
Z : C
I : InjectiveResolution Z
inst✝ : Injective Z
n : ℕ
⊢ Injective (((single₀ C).obj Z).X n)
state_after: case zero
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroObject C
inst✝¹ : HasZeroMorphisms C
Z : C
I : InjectiveResolution Z
inst✝ : Injective Z
⊢ Injective (((single₀ C).obj Z).X 0)

case succ
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroObject C
inst✝¹ : HasZeroMorphisms C
Z : C
I : InjectiveResolution Z
inst✝ : Injective Z
n✝ : ℕ
⊢ Injective (((single₀ C).obj Z).X (n✝ + 1))
tactic: cases n
Theorem: SimpleGraph.Dart.edge_fiber
File: Mathlib/Combinatorics/SimpleGraph/DegreeSum.lean

Proof steps:
state_before: V : Type u
G : SimpleGraph V
inst✝³ : Fintype V
inst✝² : DecidableRel G.Adj
inst✝¹ : Fintype (Sym2 V)
inst✝ : DecidableEq V
d d' : G.Dart
⊢ d' ∈ filter (fun d' => d'.edge = d.edge) univ ↔ d' ∈ {d, d.symm}
state_after: no goals
tactic: simpa using dart_edge_eq_iff d' d
Theorem: CategoryTheory.Limits.PreservesCokernel.iso_inv
File: Mathlib/CategoryTheory/Limits/Preserves/Shapes/Kernels.lean

Proof steps:
state_before: C : Type u₁
inst✝⁷ : Category.{v₁, u₁} C
inst✝⁶ : HasZeroMorphisms C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
inst✝⁴ : HasZeroMorphisms D
G : C ⥤ D
inst✝³ : G.PreservesZeroMorphisms
X Y Z : C
f : X ⟶ Y
h : Y ⟶ Z
w : f ≫ h = 0
inst✝² : HasCokernel f
inst✝¹ : HasCokernel (G.map f)
inst✝ : PreservesColimit (parallelPair f 0) G
⊢ (iso G f).inv = cokernelComparison f G
state_after: C : Type u₁
inst✝⁷ : Category.{v₁, u₁} C
inst✝⁶ : HasZeroMorphisms C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
inst✝⁴ : HasZeroMorphisms D
G : C ⥤ D
inst✝³ : G.PreservesZeroMorphisms
X Y Z : C
f : X ⟶ Y
h : Y ⟶ Z
w : f ≫ h = 0
inst✝² : HasCokernel f
inst✝¹ : HasCokernel (G.map f)
inst✝ : PreservesColimit (parallelPair f 0) G
⊢ cokernel.π (G.map f) ≫ (iso G f).inv = cokernel.π (G.map f) ≫ cokernelComparison f G
tactic: rw [← cancel_epi (cokernel.π _)]
state_before: C : Type u₁
inst✝⁷ : Category.{v₁, u₁} C
inst✝⁶ : HasZeroMorphisms C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
inst✝⁴ : HasZeroMorphisms D
G : C ⥤ D
inst✝³ : G.PreservesZeroMorphisms
X Y Z : C
f : X ⟶ Y
h : Y ⟶ Z
w : f ≫ h = 0
inst✝² : HasCokernel f
inst✝¹ : HasCokernel (G.map f)
inst✝ : PreservesColimit (parallelPair f 0) G
⊢ cokernel.π (G.map f) ≫ (iso G f).inv = cokernel.π (G.map f) ≫ cokernelComparison f G
state_after: no goals
tactic: simp [PreservesCokernel.iso]
Theorem: irrational_mul_rat_iff
File: Mathlib/Data/Real/Irrational.lean

Proof steps:
state_before: q : ℚ
m : ℤ
n : ℕ
x : ℝ
⊢ Irrational (x * ↑q) ↔ q ≠ 0 ∧ Irrational x
state_after: no goals
tactic: rw [mul_comm, irrational_rat_mul_iff]
Theorem: Multiset.length_ndinsert_of_not_mem
File: Mathlib/Data/Multiset/FinsetOps.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
s✝ : Multiset α
a : α
s : Multiset α
h : a ∉ s
⊢ card (ndinsert a s) = card s + 1
state_after: no goals
tactic: simp [h]
Theorem: Nat.mul_le_of_le_div
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n k✝ : ℕ
p q : ℕ → Prop
k x y : ℕ
h : x ≤ y / k
⊢ x * k ≤ y
state_after: no goals
tactic: if hk : k = 0 then
    rw [hk, Nat.mul_zero]; exact zero_le _
  else
    rwa [← le_div_iff_mul_le (Nat.pos_iff_ne_zero.2 hk)]
Theorem: BddBelow.image2
File: Mathlib/Order/Bounds/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β → γ
s : Set α
t : Set β
a : α
b : β
h₀✝ : ∀ (b : β), Monotone (swap f b)
h₁✝ : ∀ (a : α), Monotone (f a)
h₀ : ∀ (b : β), Monotone (swap f b)
h₁ : ∀ (a : α), Monotone (f a)
⊢ BddBelow s → BddBelow t → BddBelow (image2 f s t)
state_after: case intro.intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β → γ
s : Set α
t : Set β
a✝ : α
b✝ : β
h₀✝ : ∀ (b : β), Monotone (swap f b)
h₁✝ : ∀ (a : α), Monotone (f a)
h₀ : ∀ (b : β), Monotone (swap f b)
h₁ : ∀ (a : α), Monotone (f a)
a : α
ha : a ∈ lowerBounds s
b : β
hb : b ∈ lowerBounds t
⊢ BddBelow (image2 f s t)
tactic: rintro ⟨a, ha⟩ ⟨b, hb⟩
state_before: case intro.intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β → γ
s : Set α
t : Set β
a✝ : α
b✝ : β
h₀✝ : ∀ (b : β), Monotone (swap f b)
h₁✝ : ∀ (a : α), Monotone (f a)
h₀ : ∀ (b : β), Monotone (swap f b)
h₁ : ∀ (a : α), Monotone (f a)
a : α
ha : a ∈ lowerBounds s
b : β
hb : b ∈ lowerBounds t
⊢ BddBelow (image2 f s t)
state_after: no goals
tactic: exact ⟨f a b, mem_lowerBounds_image2 h₀ h₁ ha hb⟩
Theorem: SimpleGraph.Subgraph.Connected.induce_verts
File: Mathlib/Combinatorics/SimpleGraph/Connectivity/Subgraph.lean

Proof steps:
state_before: V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
H : G.Subgraph
h : H.Connected
⊢ (SimpleGraph.induce H.verts G).Connected
state_after: V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
H : G.Subgraph
h : H.Connected
⊢ (⊤.induce H.verts).Connected
tactic: rw [connected_induce_iff]
state_before: V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
H : G.Subgraph
h : H.Connected
⊢ (⊤.induce H.verts).Connected
state_after: no goals
tactic: exact h.mono le_induce_top_verts (by exact rfl)
Theorem: EReal.toReal_mul
File: Mathlib/Data/Real/EReal.lean

Proof steps:
state_before: x y : EReal
⊢ (x * y).toReal = x.toReal * y.toReal
state_after: no goals
tactic: induction x, y using induction₂_symm with
  | top_zero | zero_bot | top_top | top_bot | bot_bot => simp
  | symm h => rwa [mul_comm, EReal.mul_comm]
  | coe_coe => norm_cast
  | top_pos _ h => simp [top_mul_coe_of_pos h]
  | top_neg _ h => simp [top_mul_coe_of_neg h]
  | pos_bot _ h => simp [coe_mul_bot_of_pos h]
  | neg_bot _ h => simp [coe_mul_bot_of_neg h]
Theorem: PNat.factorMultiset_ofPrime
File: Mathlib/Data/PNat/Factors.lean

Proof steps:
state_before: p : Nat.Primes
⊢ (↑p).factorMultiset = PrimeMultiset.ofPrime p
state_after: case a
p : Nat.Primes
⊢ factorMultisetEquiv.symm (↑p).factorMultiset = factorMultisetEquiv.symm (PrimeMultiset.ofPrime p)
tactic: apply factorMultisetEquiv.symm.injective
state_before: case a
p : Nat.Primes
⊢ factorMultisetEquiv.symm (↑p).factorMultiset = factorMultisetEquiv.symm (PrimeMultiset.ofPrime p)
state_after: case a
p : Nat.Primes
⊢ (↑p).factorMultiset.prod = (PrimeMultiset.ofPrime p).prod
tactic: change (p : ℕ+).factorMultiset.prod = (PrimeMultiset.ofPrime p).prod
state_before: case a
p : Nat.Primes
⊢ (↑p).factorMultiset.prod = (PrimeMultiset.ofPrime p).prod
state_after: no goals
tactic: rw [(p : ℕ+).prod_factorMultiset, PrimeMultiset.prod_ofPrime]
Theorem: CategoryTheory.image_ι_op_comp_imageUnopOp_hom
File: Mathlib/CategoryTheory/Abelian/Opposite.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
X Y : C
f : X ⟶ Y
A B : Cᵒᵖ
g : A ⟶ B
⊢ (image.ι g.unop).op ≫ (imageUnopOp g).hom = factorThruImage g
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
X Y : C
f : X ⟶ Y
A B : Cᵒᵖ
g : A ⟶ B
⊢ (((((kernel.lift (cokernel.π g.unop) (cokernel.π (cokernel.π g.unop).op).unop ⋯ ≫
                  (Abelian.imageIsoImage g.unop).hom) ≫
                image.ι g.unop).op ≫
            (cokernelIsoOfEq ⋯).hom) ≫
          cokernel.desc ((cokernelUnopOp g).hom ≫ kernel.ι g ≫ eqToHom ⋯) (cokernel.π (kernel.ι g ≫ eqToHom ⋯)) ⋯) ≫
        cokernel.desc (kernel.ι g ≫ eqToHom ⋯) (inv (eqToHom ⋯) ≫ cokernel.π (kernel.ι g)) ⋯) ≫
      cokernel.desc (kernel.ι g) (factorThruImage g) ⋯ =
    factorThruImage g
tactic: simp only [imageUnopOp, Iso.trans, Iso.symm, Iso.op, cokernelOpOp_inv, cokernelEpiComp_hom,
    cokernelCompIsIso_hom, Abelian.coimageIsoImage'_hom, ← Category.assoc, ← op_comp]
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
X Y : C
f : X ⟶ Y
A B : Cᵒᵖ
g : A ⟶ B
⊢ (((((kernel.lift (cokernel.π g.unop) (cokernel.π (cokernel.π g.unop).op).unop ⋯ ≫
                  (Abelian.imageIsoImage g.unop).hom) ≫
                image.ι g.unop).op ≫
            (cokernelIsoOfEq ⋯).hom) ≫
          cokernel.desc ((cokernelUnopOp g).hom ≫ kernel.ι g ≫ eqToHom ⋯) (cokernel.π (kernel.ι g ≫ eqToHom ⋯)) ⋯) ≫
        cokernel.desc (kernel.ι g ≫ eqToHom ⋯) (inv (eqToHom ⋯) ≫ cokernel.π (kernel.ι g)) ⋯) ≫
      cokernel.desc (kernel.ι g) (factorThruImage g) ⋯ =
    factorThruImage g
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
X Y : C
f : X ⟶ Y
A B : Cᵒᵖ
g : A ⟶ B
⊢ inv (eqToHom ⋯) ≫ factorThruImage g = factorThruImage g
tactic: simp only [Category.assoc, Abelian.imageIsoImage_hom_comp_image_ι, kernel.lift_ι,
    Quiver.Hom.op_unop, cokernelIsoOfEq_hom_comp_desc_assoc, cokernel.π_desc_assoc,
    cokernel.π_desc]
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
X Y : C
f : X ⟶ Y
A B : Cᵒᵖ
g : A ⟶ B
⊢ inv (eqToHom ⋯) ≫ factorThruImage g = factorThruImage g
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
X Y : C
f : X ⟶ Y
A B : Cᵒᵖ
g : A ⟶ B
⊢ inv (𝟙 A) ≫ factorThruImage g = factorThruImage g
tactic: simp only [eqToHom_refl]
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
X Y : C
f : X ⟶ Y
A B : Cᵒᵖ
g : A ⟶ B
⊢ inv (𝟙 A) ≫ factorThruImage g = factorThruImage g
state_after: no goals
tactic: erw [IsIso.inv_id, Category.id_comp]
Theorem: descPochhammer_succ_right
File: Mathlib/RingTheory/Polynomial/Pochhammer.lean

Proof steps:
state_before: R : Type u
inst✝ : Ring R
n : ℕ
⊢ descPochhammer R (n + 1) = descPochhammer R n * (X - ↑n)
state_after: R : Type u
inst✝ : Ring R
n : ℕ
⊢ descPochhammer ℤ (n + 1) = descPochhammer ℤ n * (X - ↑n)
tactic: suffices h : descPochhammer ℤ (n + 1) = descPochhammer ℤ n * (X - (n : ℤ[X])) by
    apply_fun Polynomial.map (algebraMap ℤ R) at h
    simpa [descPochhammer_map, Polynomial.map_mul, Polynomial.map_add, map_X,
      Polynomial.map_intCast] using h
state_before: R : Type u
inst✝ : Ring R
n : ℕ
⊢ descPochhammer ℤ (n + 1) = descPochhammer ℤ n * (X - ↑n)
state_after: case zero
R : Type u
inst✝ : Ring R
⊢ descPochhammer ℤ (0 + 1) = descPochhammer ℤ 0 * (X - ↑0)

case succ
R : Type u
inst✝ : Ring R
n : ℕ
ih : descPochhammer ℤ (n + 1) = descPochhammer ℤ n * (X - ↑n)
⊢ descPochhammer ℤ (n + 1 + 1) = descPochhammer ℤ (n + 1) * (X - ↑(n + 1))
tactic: induction' n with n ih
Theorem: IsMulFreimanIso.threeGPFree_congr
File: Mathlib/Combinatorics/Additive/AP/Three/Defs.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
inst✝¹ : CommMonoid α
inst✝ : CommMonoid β
s A : Set α
t B : Set β
f : α → β
a✝ : α
hf : IsMulFreimanIso 2 s t f
hs : ThreeGPFree s
a : β
hfa : a ∈ t
b : β
hfb : b ∈ t
c : β
hfc : c ∈ t
habc : a * c = b * b
⊢ a = b
state_after: case intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
inst✝¹ : CommMonoid α
inst✝ : CommMonoid β
s A : Set α
t B : Set β
f : α → β
a✝ : α
hf : IsMulFreimanIso 2 s t f
hs : ThreeGPFree s
b : β
hfb : b ∈ t
c : β
hfc : c ∈ t
a : α
ha : a ∈ s
hfa : f a ∈ t
habc : f a * c = b * b
⊢ f a = b
tactic: obtain ⟨a, ha, rfl⟩ := hf.bijOn.surjOn hfa
state_before: case intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
inst✝¹ : CommMonoid α
inst✝ : CommMonoid β
s A : Set α
t B : Set β
f : α → β
a✝ : α
hf : IsMulFreimanIso 2 s t f
hs : ThreeGPFree s
b : β
hfb : b ∈ t
c : β
hfc : c ∈ t
a : α
ha : a ∈ s
hfa : f a ∈ t
habc : f a * c = b * b
⊢ f a = b
state_after: case intro.intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
inst✝¹ : CommMonoid α
inst✝ : CommMonoid β
s A : Set α
t B : Set β
f : α → β
a✝ : α
hf : IsMulFreimanIso 2 s t f
hs : ThreeGPFree s
c : β
hfc : c ∈ t
a : α
ha : a ∈ s
hfa : f a ∈ t
b : α
hb : b ∈ s
hfb : f b ∈ t
habc : f a * c = f b * f b
⊢ f a = f b
tactic: obtain ⟨b, hb, rfl⟩ := hf.bijOn.surjOn hfb
state_before: case intro.intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
inst✝¹ : CommMonoid α
inst✝ : CommMonoid β
s A : Set α
t B : Set β
f : α → β
a✝ : α
hf : IsMulFreimanIso 2 s t f
hs : ThreeGPFree s
c : β
hfc : c ∈ t
a : α
ha : a ∈ s
hfa : f a ∈ t
b : α
hb : b ∈ s
hfb : f b ∈ t
habc : f a * c = f b * f b
⊢ f a = f b
state_after: case intro.intro.intro.intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
inst✝¹ : CommMonoid α
inst✝ : CommMonoid β
s A : Set α
t B : Set β
f : α → β
a✝ : α
hf : IsMulFreimanIso 2 s t f
hs : ThreeGPFree s
a : α
ha : a ∈ s
hfa : f a ∈ t
b : α
hb : b ∈ s
hfb : f b ∈ t
c : α
hc : c ∈ s
hfc : f c ∈ t
habc : f a * f c = f b * f b
⊢ f a = f b
tactic: obtain ⟨c, hc, rfl⟩ := hf.bijOn.surjOn hfc
state_before: case intro.intro.intro.intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
inst✝¹ : CommMonoid α
inst✝ : CommMonoid β
s A : Set α
t B : Set β
f : α → β
a✝ : α
hf : IsMulFreimanIso 2 s t f
hs : ThreeGPFree s
a : α
ha : a ∈ s
hfa : f a ∈ t
b : α
hb : b ∈ s
hfb : f b ∈ t
c : α
hc : c ∈ s
hfc : f c ∈ t
habc : f a * f c = f b * f b
⊢ f a = f b
state_after: no goals
tactic: exact congr_arg f $ hs ha hb hc $ (hf.mul_eq_mul ha hc hb hb).1 habc