ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: EuclideanGeometry.oangle_swap₁₂_sign
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
⊢ -(∡ p₁ p₂ p₃).sign = (∡ p₂ p₁ p₃).sign
state_after: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
⊢ (o.oangle (p₁ -ᵥ p₂) (p₁ -ᵥ p₂ + -1 • (p₃ -ᵥ p₂))).sign = -(o.oangle (p₁ -ᵥ p₂) (p₃ -ᵥ p₂)).sign
tactic: rw [eq_comm, oangle, oangle, ← o.oangle_neg_neg, neg_vsub_eq_vsub_rev, neg_vsub_eq_vsub_rev, ←
    vsub_sub_vsub_cancel_left p₁ p₃ p₂, ← neg_vsub_eq_vsub_rev p₃ p₂, sub_eq_add_neg,
    neg_vsub_eq_vsub_rev p₂ p₁, add_comm, ← @neg_one_smul ℝ]
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
⊢ (o.oangle (p₁ -ᵥ p₂) (p₁ -ᵥ p₂ + -1 • (p₃ -ᵥ p₂))).sign = -(o.oangle (p₁ -ᵥ p₂) (p₃ -ᵥ p₂)).sign
state_after: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
⊢ (o.oangle (p₁ -ᵥ p₂) (1 • (p₁ -ᵥ p₂) + -1 • (p₃ -ᵥ p₂))).sign = -(o.oangle (p₁ -ᵥ p₂) (p₃ -ᵥ p₂)).sign
tactic: nth_rw 2 [← one_smul ℝ (p₁ -ᵥ p₂)]
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
⊢ (o.oangle (p₁ -ᵥ p₂) (1 • (p₁ -ᵥ p₂) + -1 • (p₃ -ᵥ p₂))).sign = -(o.oangle (p₁ -ᵥ p₂) (p₃ -ᵥ p₂)).sign
state_after: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
⊢ SignType.sign (-1) * (o.oangle (p₁ -ᵥ p₂) (p₃ -ᵥ p₂)).sign = -(o.oangle (p₁ -ᵥ p₂) (p₃ -ᵥ p₂)).sign
tactic: rw [o.oangle_sign_smul_add_smul_right]
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
⊢ SignType.sign (-1) * (o.oangle (p₁ -ᵥ p₂) (p₃ -ᵥ p₂)).sign = -(o.oangle (p₁ -ᵥ p₂) (p₃ -ᵥ p₂)).sign
state_after: no goals
tactic: simp
Theorem: Multiset.Ico_filter_le_of_right_le
File: Mathlib/Order/Interval/Multiset.lean

Proof steps:
state_before: α : Type u_1
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a b c : α
inst✝ : DecidablePred fun x => b ≤ x
⊢ filter (fun x => b ≤ x) (Ico a b) = ∅
state_after: α : Type u_1
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a b c : α
inst✝ : DecidablePred fun x => b ≤ x
⊢ ∅.val = ∅
tactic: rw [Ico, ← Finset.filter_val, Finset.Ico_filter_le_of_right_le]
state_before: α : Type u_1
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a b c : α
inst✝ : DecidablePred fun x => b ≤ x
⊢ ∅.val = ∅
state_after: no goals
tactic: rfl
Theorem: Finset.cast_card_inter
File: Mathlib/Data/Finset/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
R : Type u_3
s t u : Finset α
f : α → β
n : ℕ
inst✝¹ : DecidableEq α
inst✝ : AddGroupWithOne R
⊢ ↑(s ∩ t).card = ↑s.card + ↑t.card - ↑(s ∪ t).card
state_after: no goals
tactic: rw [eq_sub_iff_add_eq, ← cast_add, card_inter_add_card_union, cast_add]
Theorem: List.length_rotate'
File: Mathlib/Data/List/Rotate.lean

Proof steps:
state_before: α : Type u
x✝ : ℕ
⊢ ([].rotate' x✝).length = [].length
state_after: no goals
tactic: simp
state_before: α : Type u
a : α
l : List α
n : ℕ
⊢ ((a :: l).rotate' (n + 1)).length = (a :: l).length
state_after: α : Type u
a : α
l : List α
n : ℕ
⊢ (l ++ [a]).length = (a :: l).length
tactic: rw [List.rotate', length_rotate' (l ++ [a]) n]
state_before: α : Type u
a : α
l : List α
n : ℕ
⊢ (l ++ [a]).length = (a :: l).length
state_after: no goals
tactic: simp
Theorem: ContinuousLinearEquiv.comp_hasFDerivAt_iff'
File: Mathlib/Analysis/Calculus/FDeriv/Equiv.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f'✝ f₀' f₁' g' e : E →L[𝕜] F
x✝ : E
s t : Set E
L L₁ L₂ : Filter E
iso : E ≃L[𝕜] F
f : G → E
x : G
f' : G →L[𝕜] F
⊢ HasFDerivAt (⇑iso ∘ f) f' x ↔ HasFDerivAt f ((↑iso.symm).comp f') x
state_after: no goals
tactic: simp_rw [← hasFDerivWithinAt_univ, iso.comp_hasFDerivWithinAt_iff']
Theorem: Nat.fib_succ_eq_sum_choose
File: Mathlib/Data/Nat/Fib/Basic.lean

Proof steps:
state_before: n : ℕ
h1 : fib (n + 1) = ∑ p ∈ Finset.antidiagonal n, p.1.choose p.2
h2 : fib (n.succ + 1) = ∑ p ∈ Finset.antidiagonal n.succ, p.1.choose p.2
⊢ fib (n.succ.succ + 1) = ∑ p ∈ Finset.antidiagonal n.succ.succ, p.1.choose p.2
state_after: n : ℕ
h1 : fib (n + 1) = ∑ p ∈ Finset.antidiagonal n, p.1.choose p.2
h2 : fib (n.succ + 1) = ∑ p ∈ Finset.antidiagonal n.succ, p.1.choose p.2
⊢ ∑ p ∈ Finset.antidiagonal n, p.1.choose p.2 +
      ∑
        p ∈
          Finset.cons (n + 1, 0)
            (Finset.map ((Function.Embedding.refl ℕ).prodMap { toFun := succ, inj' := succ_injective })
              (Finset.antidiagonal n))
            ⋯,
        p.1.choose p.2 =
    ∑
      p ∈
        Finset.cons (0, n + 2)
          (Finset.cons (n + 2, 0)
            (Finset.map ({ toFun := succ, inj' := succ_injective }.prodMap { toFun := succ, inj' := succ_injective })
              (Finset.antidiagonal n))
            ⋯)
          ⋯,
      p.1.choose p.2
tactic: rw [fib_add_two, h1, h2, Finset.Nat.antidiagonal_succ_succ', Finset.Nat.antidiagonal_succ']
state_before: n : ℕ
h1 : fib (n + 1) = ∑ p ∈ Finset.antidiagonal n, p.1.choose p.2
h2 : fib (n.succ + 1) = ∑ p ∈ Finset.antidiagonal n.succ, p.1.choose p.2
⊢ ∑ p ∈ Finset.antidiagonal n, p.1.choose p.2 +
      ∑
        p ∈
          Finset.cons (n + 1, 0)
            (Finset.map ((Function.Embedding.refl ℕ).prodMap { toFun := succ, inj' := succ_injective })
              (Finset.antidiagonal n))
            ⋯,
        p.1.choose p.2 =
    ∑
      p ∈
        Finset.cons (0, n + 2)
          (Finset.cons (n + 2, 0)
            (Finset.map ({ toFun := succ, inj' := succ_injective }.prodMap { toFun := succ, inj' := succ_injective })
              (Finset.antidiagonal n))
            ⋯)
          ⋯,
      p.1.choose p.2
state_after: no goals
tactic: simp [choose_succ_succ, Finset.sum_add_distrib, add_left_comm]
Theorem: HomologicalComplex.homotopyCofiber.inrX_d
File: Mathlib/Algebra/Homology/HomotopyCofiber.lean

Proof steps:
state_before: C : Type u_1
inst✝³ : Category.{u_3, u_1} C
inst✝² : Preadditive C
ι : Type u_2
c : ComplexShape ι
F G K : HomologicalComplex C c
φ : F ⟶ G
inst✝¹ : HasHomotopyCofiber φ
inst✝ : DecidableRel c.Rel
i j : ι
⊢ inrX φ i ≫ d φ i j = G.d i j ≫ inrX φ j
state_after: case pos
C : Type u_1
inst✝³ : Category.{u_3, u_1} C
inst✝² : Preadditive C
ι : Type u_2
c : ComplexShape ι
F G K : HomologicalComplex C c
φ : F ⟶ G
inst✝¹ : HasHomotopyCofiber φ
inst✝ : DecidableRel c.Rel
i j : ι
hij : c.Rel i j
⊢ inrX φ i ≫ d φ i j = G.d i j ≫ inrX φ j

case neg
C : Type u_1
inst✝³ : Category.{u_3, u_1} C
inst✝² : Preadditive C
ι : Type u_2
c : ComplexShape ι
F G K : HomologicalComplex C c
φ : F ⟶ G
inst✝¹ : HasHomotopyCofiber φ
inst✝ : DecidableRel c.Rel
i j : ι
hij : ¬c.Rel i j
⊢ inrX φ i ≫ d φ i j = G.d i j ≫ inrX φ j
tactic: by_cases hij : c.Rel i j
Theorem: Polynomial.monic_C_mul_of_mul_leadingCoeff_eq_one
File: Mathlib/Algebra/Polynomial/Monic.lean

Proof steps:
state_before: R : Type u
S : Type v
a b✝ : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
b : R
hp : b * p.leadingCoeff = 1
⊢ (C b * p).Monic
state_after: R : Type u
S : Type v
a b✝ : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
b : R
hp : b * p.leadingCoeff = 1
⊢ (C b * p).leadingCoeff = 1
tactic: unfold Monic
state_before: R : Type u
S : Type v
a b✝ : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
b : R
hp : b * p.leadingCoeff = 1
⊢ (C b * p).leadingCoeff = 1
state_after: R : Type u
S : Type v
a b✝ : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
b : R
hp : b * p.leadingCoeff = 1
a✝ : Nontrivial R
⊢ (C b * p).leadingCoeff = 1
tactic: nontriviality
state_before: R : Type u
S : Type v
a b✝ : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
b : R
hp : b * p.leadingCoeff = 1
a✝ : Nontrivial R
⊢ (C b * p).leadingCoeff = 1
state_after: no goals
tactic: rw [leadingCoeff_mul' _] <;> simp [leadingCoeff_C b, hp]
Theorem: HilbertBasis.repr_self
File: Mathlib/Analysis/InnerProductSpace/l2Space.lean

Proof steps:
state_before: ι : Type u_1
𝕜 : Type u_2
inst✝⁴ : RCLike 𝕜
E : Type u_3
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
cplt : CompleteSpace E
G : ι → Type u_4
inst✝¹ : (i : ι) → NormedAddCommGroup (G i)
inst✝ : (i : ι) → InnerProductSpace 𝕜 (G i)
b : HilbertBasis ι 𝕜 E
i : ι
⊢ b.repr ((fun i => b.repr.symm (lp.single 2 i 1)) i) = lp.single 2 i 1
state_after: no goals
tactic: simp only [LinearIsometryEquiv.apply_symm_apply]
Theorem: PresheafOfModules.colimitCoconeιApp_naturality
File: Mathlib/Algebra/Category/ModuleCat/Presheaf/Colimits.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
R : Cᵒᵖ ⥤ RingCat
J : Type u₂
inst✝² : Category.{v₂, u₂} J
F : J ⥤ PresheafOfModules R
inst✝¹ : {X Y : Cᵒᵖ} → (f : X ⟶ Y) → PreservesColimit (F ⋙ evaluation R Y) (ModuleCat.restrictScalars (R.map f))
inst✝ : ∀ (X : Cᵒᵖ), HasColimit (F ⋙ evaluation R X)
i j : J
f : i ⟶ j
⊢ F.map f ≫ colimitCoconeιApp F j = colimitCoconeιApp F i
state_after: case w
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
R : Cᵒᵖ ⥤ RingCat
J : Type u₂
inst✝² : Category.{v₂, u₂} J
F : J ⥤ PresheafOfModules R
inst✝¹ : {X Y : Cᵒᵖ} → (f : X ⟶ Y) → PreservesColimit (F ⋙ evaluation R Y) (ModuleCat.restrictScalars (R.map f))
inst✝ : ∀ (X : Cᵒᵖ), HasColimit (F ⋙ evaluation R X)
i j : J
f : i ⟶ j
X : Cᵒᵖ
⊢ Hom.app (F.map f ≫ colimitCoconeιApp F j) X = Hom.app (colimitCoconeιApp F i) X
tactic: ext1 X
state_before: case w
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
R : Cᵒᵖ ⥤ RingCat
J : Type u₂
inst✝² : Category.{v₂, u₂} J
F : J ⥤ PresheafOfModules R
inst✝¹ : {X Y : Cᵒᵖ} → (f : X ⟶ Y) → PreservesColimit (F ⋙ evaluation R Y) (ModuleCat.restrictScalars (R.map f))
inst✝ : ∀ (X : Cᵒᵖ), HasColimit (F ⋙ evaluation R X)
i j : J
f : i ⟶ j
X : Cᵒᵖ
⊢ Hom.app (F.map f ≫ colimitCoconeιApp F j) X = Hom.app (colimitCoconeιApp F i) X
state_after: no goals
tactic: exact colimit.w (F ⋙ evaluation R X) f
Theorem: Cardinal.cantorFunction_injective
File: Mathlib/Data/Real/Cardinality.lean

Proof steps:
state_before: c : ℝ
f g : ℕ → Bool
n : ℕ
h1 : 0 < c
h2 : c < 1 / 2
⊢ Function.Injective (cantorFunction c)
state_after: c : ℝ
f✝ g✝ : ℕ → Bool
n : ℕ
h1 : 0 < c
h2 : c < 1 / 2
f g : ℕ → Bool
hfg : cantorFunction c f = cantorFunction c g
⊢ f = g
tactic: intro f g hfg
Theorem: Equiv.subtypeSubtypeEquivSubtypeExists_apply_coe
File: Mathlib/Logic/Equiv/Basic.lean

Proof steps:
state_before: α : Sort ?u.60325
p : α → Prop
q : Subtype p → Prop
a : Subtype q
⊢ q ⟨↑↑a, ⋯⟩
state_after: case mk.mk
α : Sort ?u.60325
p : α → Prop
q : Subtype p → Prop
a : α
hap : p a
haq : q ⟨a, hap⟩
⊢ q ⟨↑↑⟨⟨a, hap⟩, haq⟩, ⋯⟩
tactic: rcases a with ⟨⟨a, hap⟩, haq⟩
state_before: case mk.mk
α : Sort ?u.60325
p : α → Prop
q : Subtype p → Prop
a : α
hap : p a
haq : q ⟨a, hap⟩
⊢ q ⟨↑↑⟨⟨a, hap⟩, haq⟩, ⋯⟩
state_after: no goals
tactic: exact haq
Theorem: upperClosure_prod
File: Mathlib/Order/UpperLower/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
s : Set α
t : Set β
⊢ upperClosure (s ×ˢ t) = upperClosure s ×ˢ upperClosure t
state_after: case a.h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
s : Set α
t : Set β
x✝ : α × β
⊢ x✝ ∈ ↑(upperClosure (s ×ˢ t)) ↔ x✝ ∈ ↑(upperClosure s ×ˢ upperClosure t)
tactic: ext
state_before: case a.h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
s : Set α
t : Set β
x✝ : α × β
⊢ x✝ ∈ ↑(upperClosure (s ×ˢ t)) ↔ x✝ ∈ ↑(upperClosure s ×ˢ upperClosure t)
state_after: no goals
tactic: simp [Prod.le_def, @and_and_and_comm _ (_ ∈ t)]
Theorem: FractionalIdeal.mem_singleton_mul
File: Mathlib/RingTheory/FractionalIdeal/Operations.lean

Proof steps:
state_before: R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_3
inst✝³ : CommRing R₁
K : Type u_4
inst✝² : Field K
inst✝¹ : Algebra R₁ K
inst✝ : IsFractionRing R₁ K
x y : P
I : FractionalIdeal S P
⊢ y ∈ spanSingleton S x * I ↔ ∃ y' ∈ I, y = x * y'
state_after: case mp
R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_3
inst✝³ : CommRing R₁
K : Type u_4
inst✝² : Field K
inst✝¹ : Algebra R₁ K
inst✝ : IsFractionRing R₁ K
x y : P
I : FractionalIdeal S P
⊢ y ∈ spanSingleton S x * I → ∃ y' ∈ I, y = x * y'

case mpr
R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_3
inst✝³ : CommRing R₁
K : Type u_4
inst✝² : Field K
inst✝¹ : Algebra R₁ K
inst✝ : IsFractionRing R₁ K
x y : P
I : FractionalIdeal S P
⊢ (∃ y' ∈ I, y = x * y') → y ∈ spanSingleton S x * I
tactic: constructor
Theorem: Multiset.gcd_ndinsert
File: Mathlib/Algebra/GCDMonoid/Multiset.lean

Proof steps:
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
inst✝ : DecidableEq α
a : α
s : Multiset α
⊢ (ndinsert a s).gcd = GCDMonoid.gcd a s.gcd
state_after: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
inst✝ : DecidableEq α
a : α
s : Multiset α
⊢ ∀ (a_1 : α), a_1 ∈ ndinsert a s ↔ a_1 ∈ a ::ₘ s
tactic: rw [← gcd_dedup, dedup_ext.2, gcd_dedup, gcd_cons]
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
inst✝ : DecidableEq α
a : α
s : Multiset α
⊢ ∀ (a_1 : α), a_1 ∈ ndinsert a s ↔ a_1 ∈ a ::ₘ s
state_after: no goals
tactic: simp
Theorem: Surreal.Multiplication.ih24_neg
File: Mathlib/SetTheory/Surreal/Multiplication.lean

Proof steps:
state_before: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
⊢ IH24 x₁ x₂ y → IH24 (-x₂) (-x₁) y ∧ IH24 x₁ x₂ (-y)
state_after: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
⊢ (∀ ⦃z : PGame⦄, (z.IsOption x₁ → P24 z x₂ y) ∧ (z.IsOption x₂ → P24 x₁ z y) ∧ (z.IsOption y → P24 x₁ x₂ z)) →
    (∀ ⦃z : PGame⦄,
        ((-z).IsOption x₂ → P24 z (-x₁) y) ∧ ((-z).IsOption x₁ → P24 (-x₂) z y) ∧ (z.IsOption y → P24 (-x₂) (-x₁) z)) ∧
      ∀ ⦃z : PGame⦄, (z.IsOption x₁ → P24 z x₂ y) ∧ (z.IsOption x₂ → P24 x₁ z y) ∧ ((-z).IsOption y → P24 x₁ x₂ z)
tactic: simp_rw [IH24, ← P24_neg_right, isOption_neg]
state_before: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
⊢ (∀ ⦃z : PGame⦄, (z.IsOption x₁ → P24 z x₂ y) ∧ (z.IsOption x₂ → P24 x₁ z y) ∧ (z.IsOption y → P24 x₁ x₂ z)) →
    (∀ ⦃z : PGame⦄,
        ((-z).IsOption x₂ → P24 z (-x₁) y) ∧ ((-z).IsOption x₁ → P24 (-x₂) z y) ∧ (z.IsOption y → P24 (-x₂) (-x₁) z)) ∧
      ∀ ⦃z : PGame⦄, (z.IsOption x₁ → P24 z x₂ y) ∧ (z.IsOption x₂ → P24 x₁ z y) ∧ ((-z).IsOption y → P24 x₁ x₂ z)
state_after: case refine_1
x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
h : ∀ ⦃z : PGame⦄, (z.IsOption x₁ → P24 z x₂ y) ∧ (z.IsOption x₂ → P24 x₁ z y) ∧ (z.IsOption y → P24 x₁ x₂ z)
z : PGame
⊢ (-z).IsOption x₂ → P24 z (-x₁) y

case refine_2
x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
h : ∀ ⦃z : PGame⦄, (z.IsOption x₁ → P24 z x₂ y) ∧ (z.IsOption x₂ → P24 x₁ z y) ∧ (z.IsOption y → P24 x₁ x₂ z)
z : PGame
⊢ (-z).IsOption x₁ → P24 (-x₂) z y

case refine_3
x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
h : ∀ ⦃z : PGame⦄, (z.IsOption x₁ → P24 z x₂ y) ∧ (z.IsOption x₂ → P24 x₁ z y) ∧ (z.IsOption y → P24 x₁ x₂ z)
z : PGame
⊢ z.IsOption y → P24 (-x₂) (-x₁) z
tactic: refine fun h ↦ ⟨fun z ↦ ⟨?_, ?_, ?_⟩,
    fun z ↦ ⟨(@h z).1, (@h z).2.1, P24_neg_right.2 ∘ (@h <| -z).2.2⟩⟩
state_before: case refine_1
x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
h : ∀ ⦃z : PGame⦄, (z.IsOption x₁ → P24 z x₂ y) ∧ (z.IsOption x₂ → P24 x₁ z y) ∧ (z.IsOption y → P24 x₁ x₂ z)
z : PGame
⊢ (-z).IsOption x₂ → P24 z (-x₁) y

case refine_2
x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
h : ∀ ⦃z : PGame⦄, (z.IsOption x₁ → P24 z x₂ y) ∧ (z.IsOption x₂ → P24 x₁ z y) ∧ (z.IsOption y → P24 x₁ x₂ z)
z : PGame
⊢ (-z).IsOption x₁ → P24 (-x₂) z y

case refine_3
x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
h : ∀ ⦃z : PGame⦄, (z.IsOption x₁ → P24 z x₂ y) ∧ (z.IsOption x₂ → P24 x₁ z y) ∧ (z.IsOption y → P24 x₁ x₂ z)
z : PGame
⊢ z.IsOption y → P24 (-x₂) (-x₁) z
state_after: no goals
tactic: all_goals
    rw [P24_neg_left]
    simp only [neg_neg]
    first | exact (@h <| -z).2.1 | exact (@h <| -z).1 | exact (@h z).2.2
Theorem: AlgebraicTopology.DoldKan.natTransP_app
File: Mathlib/AlgebraicTopology/DoldKan/Projections.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.72014, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
q : ℕ
x✝¹ x✝ : SimplicialObject C
f : x✝¹ ⟶ x✝
⊢ (alternatingFaceMapComplex C).map f ≫ (fun X => P q) x✝ = (fun X => P q) x✝¹ ≫ (alternatingFaceMapComplex C).map f
state_after: case zero
C : Type u_1
inst✝¹ : Category.{?u.72014, u_1} C
inst✝ : Preadditive C
X x✝¹ x✝ : SimplicialObject C
f : x✝¹ ⟶ x✝
⊢ (alternatingFaceMapComplex C).map f ≫ (fun X => P 0) x✝ = (fun X => P 0) x✝¹ ≫ (alternatingFaceMapComplex C).map f

case succ
C : Type u_1
inst✝¹ : Category.{?u.72014, u_1} C
inst✝ : Preadditive C
X x✝¹ x✝ : SimplicialObject C
f : x✝¹ ⟶ x✝
q : ℕ
hq : (alternatingFaceMapComplex C).map f ≫ (fun X => P q) x✝ = (fun X => P q) x✝¹ ≫ (alternatingFaceMapComplex C).map f
⊢ (alternatingFaceMapComplex C).map f ≫ (fun X => P (q + 1)) x✝ =
    (fun X => P (q + 1)) x✝¹ ≫ (alternatingFaceMapComplex C).map f
tactic: induction' q with q hq
Theorem: IsOfFinOrder.natCard_powers_le_orderOf
File: Mathlib/GroupTheory/OrderOfElement.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n m : ℕ
ha : IsOfFinOrder a
⊢ Nat.card ↑↑(powers a) ≤ orderOf a
state_after: no goals
tactic: classical
  simpa [ha.powers_eq_image_range_orderOf, Finset.card_range, Nat.Iio_eq_range]
    using Finset.card_image_le (s := Finset.range (orderOf a))
Theorem: Batteries.LTCmp.cmp_iff_gt
File: .lake/packages/batteries/Batteries/Classes/Order.lean

Proof steps:
state_before: α : Type u_1
cmp : α → α → Ordering
x y : α
inst✝¹ : LT α
inst✝ : LTCmp cmp
⊢ cmp x y = Ordering.gt ↔ y < x
state_after: no goals
tactic: rw [OrientedCmp.cmp_eq_gt, LTCmp.cmp_iff_lt]
Theorem: LinearMap.polar_zero
File: Mathlib/Analysis/LocallyConvex/Polar.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : NormedCommRing 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜
⊢ B.polar {0} = Set.univ
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : NormedCommRing 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜
y : F
x : E
hx : x ∈ {0}
⊢ ‖(B x) y‖ ≤ 1
tactic: refine Set.eq_univ_iff_forall.mpr fun y x hx => ?_
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : NormedCommRing 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜
y : F
x : E
hx : x ∈ {0}
⊢ ‖(B x) y‖ ≤ 1
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : NormedCommRing 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜
y : F
x : E
hx : x ∈ {0}
⊢ 0 ≤ 1
tactic: rw [Set.mem_singleton_iff.mp hx, map_zero, LinearMap.zero_apply, norm_zero]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : NormedCommRing 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜
y : F
x : E
hx : x ∈ {0}
⊢ 0 ≤ 1
state_after: no goals
tactic: exact zero_le_one
Theorem: CategoryTheory.Limits.colimitUncurryIsoColimitCompColim_ι_hom
File: Mathlib/CategoryTheory/Limits/Fubini.lean

Proof steps:
state_before: J K : Type v
inst✝⁵ : SmallCategory J
inst✝⁴ : SmallCategory K
C : Type u
inst✝³ : Category.{v, u} C
F : J ⥤ K ⥤ C
inst✝² : HasColimitsOfShape K C
inst✝¹ : HasColimit (uncurry.obj F)
inst✝ : HasColimit (F ⋙ colim)
j : J
k : K
⊢ colimit.ι (uncurry.obj F) (j, k) ≫ (colimitUncurryIsoColimitCompColim F).hom =
    colimit.ι (F.obj j) k ≫ colimit.ι (F ⋙ colim) j
state_after: J K : Type v
inst✝⁵ : SmallCategory J
inst✝⁴ : SmallCategory K
C : Type u
inst✝³ : Category.{v, u} C
F : J ⥤ K ⥤ C
inst✝² : HasColimitsOfShape K C
inst✝¹ : HasColimit (uncurry.obj F)
inst✝ : HasColimit (F ⋙ colim)
j : J
k : K
⊢ (colimit.ι (uncurry.obj F) (j, k) ≫ (colimitUncurryIsoColimitCompColim F).hom) ≫
      (colimitUncurryIsoColimitCompColim F).inv =
    (colimit.ι (F.obj j) k ≫ colimit.ι (F ⋙ colim) j) ≫ (colimitUncurryIsoColimitCompColim F).inv
tactic: rw [← cancel_mono (colimitUncurryIsoColimitCompColim F).inv]
state_before: J K : Type v
inst✝⁵ : SmallCategory J
inst✝⁴ : SmallCategory K
C : Type u
inst✝³ : Category.{v, u} C
F : J ⥤ K ⥤ C
inst✝² : HasColimitsOfShape K C
inst✝¹ : HasColimit (uncurry.obj F)
inst✝ : HasColimit (F ⋙ colim)
j : J
k : K
⊢ (colimit.ι (uncurry.obj F) (j, k) ≫ (colimitUncurryIsoColimitCompColim F).hom) ≫
      (colimitUncurryIsoColimitCompColim F).inv =
    (colimit.ι (F.obj j) k ≫ colimit.ι (F ⋙ colim) j) ≫ (colimitUncurryIsoColimitCompColim F).inv
state_after: no goals
tactic: simp
Theorem: map_div_rev
File: Mathlib/Algebra/Order/Hom/Basic.lean

Proof steps:
state_before: ι : Type u_1
F : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
inst✝³ : FunLike F α β
inst✝² : Group α
inst✝¹ : OrderedAddCommMonoid β
inst✝ : GroupSeminormClass F α β
f : F
x y : α
⊢ f (x / y) = f (y / x)
state_after: no goals
tactic: rw [← inv_div, map_inv_eq_map]
Theorem: gcd_dvd_iff_exists
File: Mathlib/RingTheory/PrincipalIdealDomain.lean

Proof steps:
state_before: R : Type u
M : Type v
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : IsBezout R
inst✝ : GCDMonoid R
a b z : R
⊢ gcd a b ∣ z ↔ ∃ x y, z = a * x + b * y
state_after: no goals
tactic: simp_rw [mul_comm a, mul_comm b, @eq_comm _ z, ← Ideal.mem_span_pair, ← span_gcd,
    Ideal.mem_span_singleton]
Theorem: Turing.TM2.stmts_trans
File: Mathlib/Computability/TuringMachine.lean

Proof steps:
state_before: K : Type u_1
inst✝ : DecidableEq K
Γ : K → Type u_2
Λ : Type u_3
σ : Type u_4
M : Λ → Stmt₂
S : Finset Λ
q₁ q₂ : Stmt₂
h₁ : q₁ ∈ stmts₁ q₂
⊢ some q₂ ∈ stmts M S → some q₁ ∈ stmts M S
state_after: K : Type u_1
inst✝ : DecidableEq K
Γ : K → Type u_2
Λ : Type u_3
σ : Type u_4
M : Λ → Stmt₂
S : Finset Λ
q₁ q₂ : Stmt₂
h₁ : q₁ ∈ stmts₁ q₂
⊢ ∀ x ∈ S, q₂ ∈ stmts₁ (M x) → ∃ a ∈ S, q₁ ∈ stmts₁ (M a)
tactic: simp only [stmts, Finset.mem_insertNone, Finset.mem_biUnion, Option.mem_def, Option.some.injEq,
    forall_eq', exists_imp, and_imp]
state_before: K : Type u_1
inst✝ : DecidableEq K
Γ : K → Type u_2
Λ : Type u_3
σ : Type u_4
M : Λ → Stmt₂
S : Finset Λ
q₁ q₂ : Stmt₂
h₁ : q₁ ∈ stmts₁ q₂
⊢ ∀ x ∈ S, q₂ ∈ stmts₁ (M x) → ∃ a ∈ S, q₁ ∈ stmts₁ (M a)
state_after: no goals
tactic: exact fun l ls h₂ ↦ ⟨_, ls, stmts₁_trans h₂ h₁⟩
Theorem: Int.nonneg_of_normalize_eq_self
File: Mathlib/Algebra/GCDMonoid/Nat.lean

Proof steps:
state_before: z : ℤ
hz : normalize z = z
⊢ |z| = z
state_after: no goals
tactic: rw [abs_eq_normalize, hz]