ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.ShortComplex.FunctorEquivalence.counitIso_inv_app_app_τ₃
File: Mathlib/Algebra/Homology/ShortComplex/FunctorEquivalence.lean

Proof steps:
state_before: J : Type u_1
C : Type u_2
inst✝² : Category.{?u.66473, u_1} J
inst✝¹ : Category.{?u.66477, u_2} C
inst✝ : HasZeroMorphisms C
x✝¹ : J ⥤ ShortComplex C
x✝ : J
⊢ (Iso.refl (((inverse J C ⋙ functor J C).obj x✝¹).obj x✝).X₁).hom ≫ (((𝟭 (J ⥤ ShortComplex C)).obj x✝¹).obj x✝).f =
    (((inverse J C ⋙ functor J C).obj x✝¹).obj x✝).f ≫ (Iso.refl (((inverse J C ⋙ functor J C).obj x✝¹).obj x✝).X₂).hom
state_after: no goals
tactic: aesop_cat
state_before: J : Type u_1
C : Type u_2
inst✝² : Category.{?u.66473, u_1} J
inst✝¹ : Category.{?u.66477, u_2} C
inst✝ : HasZeroMorphisms C
x✝¹ : J ⥤ ShortComplex C
x✝ : J
⊢ (Iso.refl (((inverse J C ⋙ functor J C).obj x✝¹).obj x✝).X₂).hom ≫ (((𝟭 (J ⥤ ShortComplex C)).obj x✝¹).obj x✝).g =
    (((inverse J C ⋙ functor J C).obj x✝¹).obj x✝).g ≫ (Iso.refl (((inverse J C ⋙ functor J C).obj x✝¹).obj x✝).X₃).hom
state_after: no goals
tactic: aesop_cat
state_before: J : Type u_1
C : Type u_2
inst✝² : Category.{?u.66473, u_1} J
inst✝¹ : Category.{?u.66477, u_2} C
inst✝ : HasZeroMorphisms C
x✝ : J ⥤ ShortComplex C
⊢ ∀ {X Y : J} (f : X ⟶ Y),
    ((inverse J C ⋙ functor J C).obj x✝).map f ≫
        ((fun x =>
              isoMk (Iso.refl (((inverse J C ⋙ functor J C).obj x✝).obj x).X₁)
                (Iso.refl (((inverse J C ⋙ functor J C).obj x✝).obj x).X₂)
                (Iso.refl (((inverse J C ⋙ functor J C).obj x✝).obj x).X₃) ⋯ ⋯)
            Y).hom =
      ((fun x =>
              isoMk (Iso.refl (((inverse J C ⋙ functor J C).obj x✝).obj x).X₁)
                (Iso.refl (((inverse J C ⋙ functor J C).obj x✝).obj x).X₂)
                (Iso.refl (((inverse J C ⋙ functor J C).obj x✝).obj x).X₃) ⋯ ⋯)
            X).hom ≫
        ((𝟭 (J ⥤ ShortComplex C)).obj x✝).map f
state_after: no goals
tactic: aesop_cat
state_before: J : Type u_1
C : Type u_2
inst✝² : Category.{?u.66473, u_1} J
inst✝¹ : Category.{?u.66477, u_2} C
inst✝ : HasZeroMorphisms C
⊢ ∀ {X Y : J ⥤ ShortComplex C} (f : X ⟶ Y),
    (inverse J C ⋙ functor J C).map f ≫
        ((fun x =>
              NatIso.ofComponents
                (fun x_1 =>
                  isoMk (Iso.refl (((inverse J C ⋙ functor J C).obj x).obj x_1).X₁)
                    (Iso.refl (((inverse J C ⋙ functor J C).obj x).obj x_1).X₂)
                    (Iso.refl (((inverse J C ⋙ functor J C).obj x).obj x_1).X₃) ⋯ ⋯)
                ⋯)
            Y).hom =
      ((fun x =>
              NatIso.ofComponents
                (fun x_1 =>
                  isoMk (Iso.refl (((inverse J C ⋙ functor J C).obj x).obj x_1).X₁)
                    (Iso.refl (((inverse J C ⋙ functor J C).obj x).obj x_1).X₂)
                    (Iso.refl (((inverse J C ⋙ functor J C).obj x).obj x_1).X₃) ⋯ ⋯)
                ⋯)
            X).hom ≫
        (𝟭 (J ⥤ ShortComplex C)).map f
state_after: no goals
tactic: aesop_cat
Theorem: CategoryTheory.Functor.triangle
File: Mathlib/CategoryTheory/Whiskering.lean

Proof steps:
state_before: A : Type u₁
inst✝³ : Category.{v₁, u₁} A
B : Type u₂
inst✝² : Category.{v₂, u₂} B
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : A ⥤ B
G : B ⥤ C
⊢ (F.associator (𝟭 B) G).hom ≫ whiskerLeft F G.leftUnitor.hom = whiskerRight F.rightUnitor.hom G
state_after: no goals
tactic: aesop_cat
Theorem: eq_of_norm_le_re_inner_eq_norm_sq
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
hle : ‖x‖ ≤ ‖y‖
h : re ⟪x, y⟫_𝕜 = ‖y‖ ^ 2
⊢ x = y
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
hle : ‖x‖ ≤ ‖y‖
h : re ⟪x, y⟫_𝕜 = ‖y‖ ^ 2
⊢ re ⟪x - y, x - y⟫_𝕜 ≤ 0
tactic: suffices H : re ⟪x - y, x - y⟫ ≤ 0 by rwa [inner_self_nonpos, sub_eq_zero] at H
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
hle : ‖x‖ ≤ ‖y‖
h : re ⟪x, y⟫_𝕜 = ‖y‖ ^ 2
⊢ re ⟪x - y, x - y⟫_𝕜 ≤ 0
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
hle : ‖x‖ ≤ ‖y‖
h : re ⟪x, y⟫_𝕜 = ‖y‖ ^ 2
H₁ : ‖x‖ ^ 2 ≤ ‖y‖ ^ 2
⊢ re ⟪x - y, x - y⟫_𝕜 ≤ 0
tactic: have H₁ : ‖x‖ ^ 2 ≤ ‖y‖ ^ 2 := by gcongr
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
hle : ‖x‖ ≤ ‖y‖
h : re ⟪x, y⟫_𝕜 = ‖y‖ ^ 2
H₁ : ‖x‖ ^ 2 ≤ ‖y‖ ^ 2
⊢ re ⟪x - y, x - y⟫_𝕜 ≤ 0
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
hle : ‖x‖ ≤ ‖y‖
h : re ⟪x, y⟫_𝕜 = ‖y‖ ^ 2
H₁ : ‖x‖ ^ 2 ≤ ‖y‖ ^ 2
H₂ : re ⟪y, x⟫_𝕜 = ‖y‖ ^ 2
⊢ re ⟪x - y, x - y⟫_𝕜 ≤ 0
tactic: have H₂ : re ⟪y, x⟫ = ‖y‖ ^ 2 := by rwa [← inner_conj_symm, conj_re]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
hle : ‖x‖ ≤ ‖y‖
h : re ⟪x, y⟫_𝕜 = ‖y‖ ^ 2
H₁ : ‖x‖ ^ 2 ≤ ‖y‖ ^ 2
H₂ : re ⟪y, x⟫_𝕜 = ‖y‖ ^ 2
⊢ re ⟪x - y, x - y⟫_𝕜 ≤ 0
state_after: no goals
tactic: simpa [inner_sub_left, inner_sub_right, ← norm_sq_eq_inner, h, H₂] using H₁
Theorem: Convex.helly_theorem_set'
File: Mathlib/Analysis/Convex/Radon.lean

Proof steps:
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
inst✝³ : LinearOrderedField 𝕜
inst✝² : AddCommGroup E
inst✝¹ : Module 𝕜 E
inst✝ : FiniteDimensional 𝕜 E
F : Finset (Set E)
h_convex : ∀ X ∈ F, Convex 𝕜 X
h_inter : ∀ G ⊆ F, G.card ≤ finrank 𝕜 E + 1 → (⋂₀ ↑G).Nonempty
⊢ (⋂₀ ↑F).Nonempty
state_after: no goals
tactic: classical -- for DecidableEq, required for the family version
  rw [show ⋂₀ F = ⋂ X ∈ F, (X : Set E) by ext; simp]
  apply helly_theorem' h_convex
  intro G hG_ss hG_card
  rw [show ⋂ X ∈ G, X = ⋂₀ G by ext; simp]
  exact h_inter G hG_ss hG_card
Theorem: Matrix.toLin_kronecker
File: Mathlib/LinearAlgebra/TensorProduct/Matrix.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
M' : Type u_5
N' : Type u_6
ι : Type u_7
κ : Type u_8
τ : Type u_9
ι' : Type u_10
κ' : Type u_11
inst✝¹⁸ : DecidableEq ι
inst✝¹⁷ : DecidableEq κ
inst✝¹⁶ : DecidableEq τ
inst✝¹⁵ : Fintype ι
inst✝¹⁴ : Fintype κ
inst✝¹³ : Fintype τ
inst✝¹² : Finite ι'
inst✝¹¹ : Finite κ'
inst✝¹⁰ : CommRing R
inst✝⁹ : AddCommGroup M
inst✝⁸ : AddCommGroup N
inst✝⁷ : AddCommGroup P
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup N'
inst✝⁴ : Module R M
inst✝³ : Module R N
inst✝² : Module R P
inst✝¹ : Module R M'
inst✝ : Module R N'
bM : Basis ι R M
bN : Basis κ R N
bP : Basis τ R P
bM' : Basis ι' R M'
bN' : Basis κ' R N'
A : Matrix ι' ι R
B : Matrix κ' κ R
⊢ (toLin (bM.tensorProduct bN) (bM'.tensorProduct bN')) (kroneckerMap (fun x x_1 => x * x_1) A B) =
    TensorProduct.map ((toLin bM bM') A) ((toLin bN bN') B)
state_after: no goals
tactic: rw [← LinearEquiv.eq_symm_apply, toLin_symm, TensorProduct.toMatrix_map, toMatrix_toLin,
    toMatrix_toLin]
Theorem: intervalIntegral.sum_integral_adjacent_intervals
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

Proof steps:
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a✝ b c d : ℝ
f g : ℝ → E
μ : Measure ℝ
a : ℕ → ℝ
n : ℕ
hint : ∀ k < n, IntervalIntegrable f μ (a k) (a (k + 1))
⊢ ∑ k ∈ Finset.range n, ∫ (x : ℝ) in a k..a (k + 1), f x ∂μ = ∫ (x : ℝ) in a 0 ..a n, f x ∂μ
state_after: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a✝ b c d : ℝ
f g : ℝ → E
μ : Measure ℝ
a : ℕ → ℝ
n : ℕ
hint : ∀ k < n, IntervalIntegrable f μ (a k) (a (k + 1))
⊢ ∑ k ∈ Finset.Ico 0 n, ∫ (x : ℝ) in a k..a (k + 1), f x ∂μ = ∫ (x : ℝ) in a 0 ..a n, f x ∂μ
tactic: rw [← Nat.Ico_zero_eq_range]
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a✝ b c d : ℝ
f g : ℝ → E
μ : Measure ℝ
a : ℕ → ℝ
n : ℕ
hint : ∀ k < n, IntervalIntegrable f μ (a k) (a (k + 1))
⊢ ∑ k ∈ Finset.Ico 0 n, ∫ (x : ℝ) in a k..a (k + 1), f x ∂μ = ∫ (x : ℝ) in a 0 ..a n, f x ∂μ
state_after: no goals
tactic: exact sum_integral_adjacent_intervals_Ico (zero_le n) fun k hk => hint k hk.2
Theorem: CategoryTheory.Presieve.isSheaf_iff_preservesFiniteProducts
File: Mathlib/CategoryTheory/Sites/Coherent/ExtensiveSheaves.lean

Proof steps:
state_before: C : Type u_1
inst✝³ : Category.{u_3, u_1} C
D : Type u_2
inst✝² : Category.{?u.9434, u_2} D
inst✝¹ : FinitaryPreExtensive C
inst✝ : FinitaryExtensive C
F : Cᵒᵖ ⥤ Type w
⊢ IsSheaf (extensiveTopology C) F ↔ Nonempty (PreservesFiniteProducts F)
state_after: case refine_1
C : Type u_1
inst✝³ : Category.{u_3, u_1} C
D : Type u_2
inst✝² : Category.{?u.9434, u_2} D
inst✝¹ : FinitaryPreExtensive C
inst✝ : FinitaryExtensive C
F : Cᵒᵖ ⥤ Type w
hF : IsSheaf (extensiveTopology C) F
α : Type
x✝ : Fintype α
K : Discrete α ⥤ Cᵒᵖ
⊢ PreservesLimit K F

case refine_2
C : Type u_1
inst✝³ : Category.{u_3, u_1} C
D : Type u_2
inst✝² : Category.{?u.9434, u_2} D
inst✝¹ : FinitaryPreExtensive C
inst✝ : FinitaryExtensive C
F : Cᵒᵖ ⥤ Type w
hF : Nonempty (PreservesFiniteProducts F)
⊢ IsSheaf (extensiveTopology C) F
tactic: refine ⟨fun hF ↦ ⟨⟨fun α _ ↦ ⟨fun {K} ↦ ?_⟩⟩⟩, fun hF ↦ ?_⟩
Theorem: InnerProductSpace.Core.ofReal_normSq_eq_inner_self
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝² : _root_.RCLike 𝕜
inst✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
c : Core 𝕜 F
x : F
⊢ ↑(normSq x) = ⟪x, x⟫_𝕜
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝² : _root_.RCLike 𝕜
inst✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
c : Core 𝕜 F
x : F
⊢ re ↑(normSq x) = re ⟪x, x⟫_𝕜 ∧ im ↑(normSq x) = im ⟪x, x⟫_𝕜
tactic: rw [ext_iff]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝² : _root_.RCLike 𝕜
inst✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
c : Core 𝕜 F
x : F
⊢ re ↑(normSq x) = re ⟪x, x⟫_𝕜 ∧ im ↑(normSq x) = im ⟪x, x⟫_𝕜
state_after: no goals
tactic: exact ⟨by simp only [ofReal_re]; rfl, by simp only [inner_self_im, ofReal_im]⟩
Theorem: Multiset.prod_nat_mod
File: Mathlib/Algebra/BigOperators/Group/Multiset.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s : Multiset ℕ
n : ℕ
⊢ s.prod % n = (map (fun x => x % n) s).prod % n
state_after: no goals
tactic: induction s using Multiset.induction <;> simp [Nat.mul_mod, *]
Theorem: measurable_sub_const'
File: Mathlib/MeasureTheory/Group/Arithmetic.lean

Proof steps:
state_before: α : Type u_1
G : Type u_2
inst✝² : DivInvMonoid G
inst✝¹ : MeasurableSpace G
inst✝ : MeasurableMul G
g : G
⊢ Measurable fun h => h / g
state_after: no goals
tactic: simp_rw [div_eq_mul_inv, measurable_mul_const]
Theorem: FintypeCat.equivEquivIso_symm_apply_symm_apply
File: Mathlib/CategoryTheory/FintypeCat.lean

Proof steps:
state_before: A B : FintypeCat
⊢ Function.LeftInverse (fun i => { toFun := i.hom, invFun := i.inv, left_inv := ⋯, right_inv := ⋯ }) fun e =>
    { hom := ⇑e, inv := ⇑e.symm, hom_inv_id := ⋯, inv_hom_id := ⋯ }
state_after: no goals
tactic: aesop_cat
state_before: A B : FintypeCat
⊢ Function.RightInverse (fun i => { toFun := i.hom, invFun := i.inv, left_inv := ⋯, right_inv := ⋯ }) fun e =>
    { hom := ⇑e, inv := ⇑e.symm, hom_inv_id := ⋯, inv_hom_id := ⋯ }
state_after: no goals
tactic: aesop_cat
Theorem: Ideal.not_isPrime_iff
File: Mathlib/RingTheory/Ideal/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝ : Semiring α
I✝ : Ideal α
a b : α
I : Ideal α
⊢ ¬I.IsPrime ↔ I = ⊤ ∨ ∃ x, ∃ (_ : x ∉ I), ∃ y, ∃ (_ : y ∉ I), x * y ∈ I
state_after: α : Type u
β : Type v
inst✝ : Semiring α
I✝ : Ideal α
a b : α
I : Ideal α
⊢ (I = ⊤ ∨ ∃ x x_1, ∃ (_ : x * x_1 ∈ I), x ∉ I ∧ x_1 ∉ I) ↔ I = ⊤ ∨ ∃ x, ∃ (_ : x ∉ I), ∃ y, ∃ (_ : y ∉ I), x * y ∈ I
tactic: simp_rw [Ideal.isPrime_iff, not_and_or, Ne, Classical.not_not, not_forall, not_or]
state_before: α : Type u
β : Type v
inst✝ : Semiring α
I✝ : Ideal α
a b : α
I : Ideal α
⊢ (I = ⊤ ∨ ∃ x x_1, ∃ (_ : x * x_1 ∈ I), x ∉ I ∧ x_1 ∉ I) ↔ I = ⊤ ∨ ∃ x, ∃ (_ : x ∉ I), ∃ y, ∃ (_ : y ∉ I), x * y ∈ I
state_after: no goals
tactic: exact
    or_congr Iff.rfl
      ⟨fun ⟨x, y, hxy, hx, hy⟩ => ⟨x, hx, y, hy, hxy⟩, fun ⟨x, hx, y, hy, hxy⟩ =>
        ⟨x, y, hxy, hx, hy⟩⟩
Theorem: CategoryTheory.shift_shiftFunctorCompIsoId_inv_app
File: Mathlib/CategoryTheory/Shift/Basic.lean

Proof steps:
state_before: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddGroup A
inst✝ : HasShift C A
X✝ Y : C
f : X✝ ⟶ Y
n m : A
h : n + m = 0
X : C
⊢ m + n = 0
state_after: no goals
tactic: rw [← neg_eq_of_add_eq_zero_left h, add_right_neg]
state_before: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddGroup A
inst✝ : HasShift C A
X✝ Y : C
f : X✝ ⟶ Y
n m : A
h : n + m = 0
X : C
⊢ (shiftFunctor C n).map ((shiftFunctorCompIsoId C n m h).inv.app X) =
    (shiftFunctorCompIsoId C m n ⋯).inv.app ((shiftFunctor C n).obj X)
state_after: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddGroup A
inst✝ : HasShift C A
X✝ Y : C
f : X✝ ⟶ Y
n m : A
h : n + m = 0
X : C
⊢ 𝟙 ((shiftFunctor C n).obj ((𝟭 C).obj X)) = 𝟙 ((𝟭 C).obj ((shiftFunctor C n).obj X))
tactic: rw [← cancel_mono (((shiftFunctorCompIsoId C n m h).hom.app X)⟦n⟧'),
    ← Functor.map_comp, Iso.inv_hom_id_app, Functor.map_id,
    shift_shiftFunctorCompIsoId_hom_app, Iso.inv_hom_id_app]
state_before: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddGroup A
inst✝ : HasShift C A
X✝ Y : C
f : X✝ ⟶ Y
n m : A
h : n + m = 0
X : C
⊢ 𝟙 ((shiftFunctor C n).obj ((𝟭 C).obj X)) = 𝟙 ((𝟭 C).obj ((shiftFunctor C n).obj X))
state_after: no goals
tactic: rfl
Theorem: WeierstrassCurve.Jacobian.map_addZ
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

Proof steps:
state_before: R : Type u
inst✝² : CommRing R
W' : Jacobian R
F : Type v
inst✝¹ : Field F
W : Jacobian F
S : Type u_1
inst✝ : CommRing S
f : R →+* S
P Q : Fin 3 → R
⊢ addZ (⇑f ∘ P) (⇑f ∘ Q) = f (addZ P Q)
state_after: no goals
tactic: simp [addZ]
Theorem: ZFSet.eq_empty
File: Mathlib/SetTheory/ZFC/Basic.lean

Proof steps:
state_before: x : ZFSet
⊢ x = ∅ ↔ ∀ (y : ZFSet), y ∉ x
state_after: x : ZFSet
⊢ (∀ (z : ZFSet), z ∈ x ↔ z ∈ ∅) ↔ ∀ (y : ZFSet), y ∉ x
tactic: rw [ZFSet.ext_iff]
state_before: x : ZFSet
⊢ (∀ (z : ZFSet), z ∈ x ↔ z ∈ ∅) ↔ ∀ (y : ZFSet), y ∉ x
state_after: no goals
tactic: simp
Theorem: SimpleGraph.Walk.mem_darts_reverse
File: Mathlib/Combinatorics/SimpleGraph/Walk.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
d : G.Dart
p : G.Walk u v
⊢ d ∈ p.reverse.darts ↔ d.symm ∈ p.darts
state_after: no goals
tactic: simp
Theorem: Matroid.mapEmbedding_indep_iff
File: Mathlib/Data/Matroid/Map.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
f✝ : α → β
E I✝ s : Set α
M : Matroid α
N : Matroid β
f : α ↪ β
I : Set β
⊢ (M.mapEmbedding f).Indep I ↔ M.Indep (⇑f ⁻¹' I) ∧ I ⊆ range ⇑f
state_after: α : Type u_1
β : Type u_2
f✝ : α → β
E I✝ s : Set α
M : Matroid α
N : Matroid β
f : α ↪ β
I : Set β
⊢ (∃ I₀, M.Indep I₀ ∧ I = ⇑f '' I₀) ↔ M.Indep (⇑f ⁻¹' I) ∧ I ⊆ range ⇑f
tactic: rw [mapEmbedding, map_indep_iff]
state_before: α : Type u_1
β : Type u_2
f✝ : α → β
E I✝ s : Set α
M : Matroid α
N : Matroid β
f : α ↪ β
I : Set β
⊢ (∃ I₀, M.Indep I₀ ∧ I = ⇑f '' I₀) ↔ M.Indep (⇑f ⁻¹' I) ∧ I ⊆ range ⇑f
state_after: α : Type u_1
β : Type u_2
f✝ : α → β
E I✝ s : Set α
M : Matroid α
N : Matroid β
f : α ↪ β
I : Set β
⊢ (∃ I₀, M.Indep I₀ ∧ I = ⇑f '' I₀) → M.Indep (⇑f ⁻¹' I) ∧ I ⊆ range ⇑f
tactic: refine ⟨?_, fun ⟨h,h'⟩ ↦ ⟨f ⁻¹' I, h, by rwa [eq_comm, image_preimage_eq_iff]⟩⟩
state_before: α : Type u_1
β : Type u_2
f✝ : α → β
E I✝ s : Set α
M : Matroid α
N : Matroid β
f : α ↪ β
I : Set β
⊢ (∃ I₀, M.Indep I₀ ∧ I = ⇑f '' I₀) → M.Indep (⇑f ⁻¹' I) ∧ I ⊆ range ⇑f
state_after: case intro.intro
α : Type u_1
β : Type u_2
f✝ : α → β
E I✝ s : Set α
M : Matroid α
N : Matroid β
f : α ↪ β
I : Set α
hI : M.Indep I
⊢ M.Indep (⇑f ⁻¹' (⇑f '' I)) ∧ ⇑f '' I ⊆ range ⇑f
tactic: rintro ⟨I, hI, rfl⟩
state_before: case intro.intro
α : Type u_1
β : Type u_2
f✝ : α → β
E I✝ s : Set α
M : Matroid α
N : Matroid β
f : α ↪ β
I : Set α
hI : M.Indep I
⊢ M.Indep (⇑f ⁻¹' (⇑f '' I)) ∧ ⇑f '' I ⊆ range ⇑f
state_after: case intro.intro
α : Type u_1
β : Type u_2
f✝ : α → β
E I✝ s : Set α
M : Matroid α
N : Matroid β
f : α ↪ β
I : Set α
hI : M.Indep I
⊢ M.Indep I ∧ ⇑f '' I ⊆ range ⇑f
tactic: rw [preimage_image_eq _ f.injective]
state_before: case intro.intro
α : Type u_1
β : Type u_2
f✝ : α → β
E I✝ s : Set α
M : Matroid α
N : Matroid β
f : α ↪ β
I : Set α
hI : M.Indep I
⊢ M.Indep I ∧ ⇑f '' I ⊆ range ⇑f
state_after: no goals
tactic: exact ⟨hI, image_subset_range _ _⟩
Theorem: Rat.addSubmonoid_closure_range_pow
File: Mathlib/Data/Rat/Star.lean

Proof steps:
state_before: n : ℕ
hn₀ : n ≠ 0
hn : Even n
⊢ closure (range fun x => x ^ n) = nonneg ℚ
state_after: case h.e'_2.h.e'_3
n : ℕ
hn₀ : n ≠ 0
hn : Even n
⊢ (range fun x => x ^ n) = ⇑NNRat.coeHom '' range fun x => x ^ n

case h.e'_3
n : ℕ
hn₀ : n ≠ 0
hn : Even n
⊢ nonneg ℚ = map NNRat.coeHom (closure (range fun x => x ^ n))
tactic: convert (AddMonoidHom.map_mclosure NNRat.coeHom <| range fun x ↦ x ^ n).symm
Theorem: AlgebraicGeometry.LocallyRingedSpace.basicOpen_zero
File: Mathlib/Geometry/RingedSpace/LocallyRingedSpace.lean

Proof steps:
state_before: X✝ X : LocallyRingedSpace
U : Opens ↑↑X.toPresheafedSpace
⊢ X.toRingedSpace.basicOpen 0 = ⊥
state_after: case h.h
X✝ X : LocallyRingedSpace
U : Opens ↑↑X.toPresheafedSpace
x : ↑↑X.toRingedSpace.toPresheafedSpace
⊢ x ∈ ↑(X.toRingedSpace.basicOpen 0) ↔ x ∈ ↑⊥
tactic: ext x
state_before: case h.h
X✝ X : LocallyRingedSpace
U : Opens ↑↑X.toPresheafedSpace
x : ↑↑X.toRingedSpace.toPresheafedSpace
⊢ x ∈ ↑(X.toRingedSpace.basicOpen 0) ↔ x ∈ ↑⊥
state_after: case h.h
X✝ X : LocallyRingedSpace
U : Opens ↑↑X.toPresheafedSpace
x : ↑↑X.toRingedSpace.toPresheafedSpace
⊢ ∀ (x_1 : x ∈ U), ¬IsUnit ((X.toRingedSpace.presheaf.germ ⟨x, ⋯⟩) 0)
tactic: simp only [RingedSpace.basicOpen, Opens.coe_mk, Set.mem_image, Set.mem_setOf_eq, Subtype.exists,
    exists_and_right, exists_eq_right, Opens.coe_bot, Set.mem_empty_iff_false,
    iff_false, not_exists]
state_before: case h.h
X✝ X : LocallyRingedSpace
U : Opens ↑↑X.toPresheafedSpace
x : ↑↑X.toRingedSpace.toPresheafedSpace
⊢ ∀ (x_1 : x ∈ U), ¬IsUnit ((X.toRingedSpace.presheaf.germ ⟨x, ⋯⟩) 0)
state_after: case h.h
X✝ X : LocallyRingedSpace
U : Opens ↑↑X.toPresheafedSpace
x : ↑↑X.toRingedSpace.toPresheafedSpace
hx : x ∈ U
⊢ ¬IsUnit ((X.toRingedSpace.presheaf.germ ⟨x, ⋯⟩) 0)
tactic: intros hx
state_before: case h.h
X✝ X : LocallyRingedSpace
U : Opens ↑↑X.toPresheafedSpace
x : ↑↑X.toRingedSpace.toPresheafedSpace
hx : x ∈ U
⊢ ¬IsUnit ((X.toRingedSpace.presheaf.germ ⟨x, ⋯⟩) 0)
state_after: case h.h
X✝ X : LocallyRingedSpace
U : Opens ↑↑X.toPresheafedSpace
x : ↑↑X.toRingedSpace.toPresheafedSpace
hx : x ∈ U
⊢ ¬0 = 1
tactic: rw [map_zero, isUnit_zero_iff]
state_before: case h.h
X✝ X : LocallyRingedSpace
U : Opens ↑↑X.toPresheafedSpace
x : ↑↑X.toRingedSpace.toPresheafedSpace
hx : x ∈ U
⊢ ¬0 = 1
state_after: case h.h
X✝ X : LocallyRingedSpace
U : Opens ↑↑X.toPresheafedSpace
x : ↑↑X.toRingedSpace.toPresheafedSpace
hx : x ∈ U
⊢ 0 ≠ 1
tactic: change (0 : X.presheaf.stalk x) ≠ (1 : X.presheaf.stalk x)
state_before: case h.h
X✝ X : LocallyRingedSpace
U : Opens ↑↑X.toPresheafedSpace
x : ↑↑X.toRingedSpace.toPresheafedSpace
hx : x ∈ U
⊢ 0 ≠ 1
state_after: no goals
tactic: exact zero_ne_one
Theorem: tendsto_multiset_prod
File: Mathlib/Topology/Algebra/Monoid.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : CommMonoid M
inst✝ : ContinuousMul M
f : ι → α → M
x : Filter α
a : ι → M
s : Multiset ι
⊢ (∀ i ∈ s, Tendsto (f i) x (𝓝 (a i))) →
    Tendsto (fun b => (Multiset.map (fun c => f c b) s).prod) x (𝓝 (Multiset.map a s).prod)
state_after: case mk
ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : CommMonoid M
inst✝ : ContinuousMul M
f : ι → α → M
x : Filter α
a : ι → M
s : Multiset ι
l : List ι
⊢ (∀ i ∈ Quot.mk Setoid.r l, Tendsto (f i) x (𝓝 (a i))) →
    Tendsto (fun b => (Multiset.map (fun c => f c b) (Quot.mk Setoid.r l)).prod) x
      (𝓝 (Multiset.map a (Quot.mk Setoid.r l)).prod)
tactic: rcases s with ⟨l⟩
state_before: case mk
ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : CommMonoid M
inst✝ : ContinuousMul M
f : ι → α → M
x : Filter α
a : ι → M
s : Multiset ι
l : List ι
⊢ (∀ i ∈ Quot.mk Setoid.r l, Tendsto (f i) x (𝓝 (a i))) →
    Tendsto (fun b => (Multiset.map (fun c => f c b) (Quot.mk Setoid.r l)).prod) x
      (𝓝 (Multiset.map a (Quot.mk Setoid.r l)).prod)
state_after: no goals
tactic: simpa using tendsto_list_prod l
Theorem: circleIntegrable_zero_radius
File: Mathlib/MeasureTheory/Integral/CircleIntegral.lean

Proof steps:
state_before: E : Type u_1
inst✝ : NormedAddCommGroup E
f : ℂ → E
c : ℂ
⊢ CircleIntegrable f c 0
state_after: no goals
tactic: simp [CircleIntegrable]
Theorem: NumberField.mixedEmbedding.convexBodyLT_neg_mem
File: Mathlib/NumberTheory/NumberField/CanonicalEmbedding/ConvexBody.lean

Proof steps:
state_before: K : Type u_1
inst✝ : Field K
f : InfinitePlace K → ℝ≥0
x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
hx : x ∈ convexBodyLT K f
⊢ -x ∈ convexBodyLT K f
state_after: K : Type u_1
inst✝ : Field K
f : InfinitePlace K → ℝ≥0
x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
hx :
  (∀ (a : InfinitePlace K) (b : a.IsReal), |x.1 ⟨a, b⟩| < ↑(f a)) ∧
    ∀ (a : InfinitePlace K) (b : a.IsComplex), Complex.abs (x.2 ⟨a, b⟩) < ↑(f a)
⊢ (∀ (a : InfinitePlace K) (b : a.IsReal), |x.1 ⟨a, b⟩| < ↑(f a)) ∧
    ∀ (a : InfinitePlace K) (b : a.IsComplex), Complex.abs (x.2 ⟨a, b⟩) < ↑(f a)
tactic: simp only [Set.mem_prod, Prod.fst_neg, Set.mem_pi, Set.mem_univ, Pi.neg_apply,
    mem_ball_zero_iff, norm_neg, Real.norm_eq_abs, forall_true_left, Subtype.forall,
    Prod.snd_neg, Complex.norm_eq_abs] at hx ⊢
state_before: K : Type u_1
inst✝ : Field K
f : InfinitePlace K → ℝ≥0
x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
hx :
  (∀ (a : InfinitePlace K) (b : a.IsReal), |x.1 ⟨a, b⟩| < ↑(f a)) ∧
    ∀ (a : InfinitePlace K) (b : a.IsComplex), Complex.abs (x.2 ⟨a, b⟩) < ↑(f a)
⊢ (∀ (a : InfinitePlace K) (b : a.IsReal), |x.1 ⟨a, b⟩| < ↑(f a)) ∧
    ∀ (a : InfinitePlace K) (b : a.IsComplex), Complex.abs (x.2 ⟨a, b⟩) < ↑(f a)
state_after: no goals
tactic: exact hx
Theorem: CategoryTheory.NatTrans.CommShift.comm
File: Mathlib/CategoryTheory/Shift/CommShift.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
E : Type u_3
J : Type u_4
inst✝¹⁵ : Category.{u_7, u_1} C
inst✝¹⁴ : Category.{u_6, u_2} D
inst✝¹³ : Category.{?u.101305, u_3} E
inst✝¹² : Category.{?u.101309, u_4} J
F₁ F₂ F₃ : C ⥤ D
τ : F₁ ⟶ F₂
τ' : F₂ ⟶ F₃
e : F₁ ≅ F₂
G G' : D ⥤ E
τ'' : G ⟶ G'
H : E ⥤ J
A : Type u_5
inst✝¹¹ : AddMonoid A
inst✝¹⁰ : HasShift C A
inst✝⁹ : HasShift D A
inst✝⁸ : HasShift E A
inst✝⁷ : HasShift J A
inst✝⁶ : F₁.CommShift A
inst✝⁵ : F₂.CommShift A
inst✝⁴ : F₃.CommShift A
inst✝³ : G.CommShift A
inst✝² : G'.CommShift A
inst✝¹ : H.CommShift A
inst✝ : CommShift τ A
a : A
⊢ (F₁.commShiftIso a).hom ≫ whiskerRight τ (shiftFunctor D a) =
    whiskerLeft (shiftFunctor C a) τ ≫ (F₂.commShiftIso a).hom
state_after: no goals
tactic: apply comm'