1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: AlgebraicGeometry.PresheafedSpace.map_comp_c_app
File: Mathlib/Geometry/RingedSpace/PresheafedSpace/HasColimits.lean

tactic: rw [F.map_comp]
state_before: J : Type u'
inst✝¹ : Category.{v', u'} J
C : Type u
inst✝ : Category.{v, u} C
F : J ⥤ PresheafedSpace C
j₁ j₂ j₃ : J
f : j₁ ⟶ j₂
g : j₂ ⟶ j₃
U : Opens ↑↑(F.obj j₃)
⊢ (F.map f).base ≫ (F.map g).base = (F.map (f ≫ g)).base
state_after: J : Type u'
inst✝¹ : Category.{v', u'} J
C : Type u
inst✝ : Category.{v, u} C
F : J ⥤ PresheafedSpace C
j₁ j₂ j₃ : J
f : j₁ ⟶ j₂
g : j₂ ⟶ j₃
U : Opens ↑↑(F.obj j₃)
⊢ (F.map f).base ≫ (F.map g).base = (F.map f ≫ F.map g).base

tactic: rfl
state_before: J : Type u'
inst✝¹ : Category.{v', u'} J
C : Type u
inst✝ : Category.{v, u} C
F : J ⥤ PresheafedSpace C
j₁ j₂ j₃ : J
f : j₁ ⟶ j₂
g : j₂ ⟶ j₃
U : Opens ↑↑(F.obj j₃)
⊢ (F.map f).base ≫ (F.map g).base = (F.map f ≫ F.map g).base
state_after: no goals

tactic: cases U
state_before: J : Type u'
inst✝¹ : Category.{v', u'} J
C : Type u
inst✝ : Category.{v, u} C
F : J ⥤ PresheafedSpace C
j₁ j₂ j₃ : J
f : j₁ ⟶ j₂
g : j₂ ⟶ j₃
U : Opens ↑↑(F.obj j₃)
⊢ (F.map (f ≫ g)).c.app { unop := U } =
    (F.map g).c.app { unop := U } ≫
      (pushforwardMap (F.map g).base (F.map f).c).app { unop := U } ≫
        (Pushforward.comp (F.obj j₁).presheaf (F.map f).base (F.map g).base).inv.app { unop := U } ≫
          (pushforwardEq ⋯ (F.obj j₁).presheaf).hom.app { unop := U }
state_after: case mk
J : Type u'
inst✝¹ : Category.{v', u'} J
C : Type u
inst✝ : Category.{v, u} C
F : J ⥤ PresheafedSpace C
j₁ j₂ j₃ : J
f : j₁ ⟶ j₂
g : j₂ ⟶ j₃
carrier✝ : Set ↑↑(F.obj j₃)
is_open'✝ : IsOpen carrier✝
⊢ (F.map (f ≫ g)).c.app { unop := { carrier := carrier✝, is_open' := is_open'✝ } } =
    (F.map g).c.app { unop := { carrier := carrier✝, is_open' := is_open'✝ } } ≫
      (pushforwardMap (F.map g).base (F.map f).c).app { unop := { carrier := carrier✝, is_open' := is_open'✝ } } ≫
        (Pushforward.comp (F.obj j₁).presheaf (F.map f).base (F.map g).base).inv.app
            { unop := { carrier := carrier✝, is_open' := is_open'✝ } } ≫
          (pushforwardEq ⋯ (F.obj j₁).presheaf).hom.app { unop := { carrier := carrier✝, is_open' := is_open'✝ } }

tactic: simp [PresheafedSpace.congr_app (F.map_comp f g)]
state_before: case mk
J : Type u'
inst✝¹ : Category.{v', u'} J
C : Type u
inst✝ : Category.{v, u} C
F : J ⥤ PresheafedSpace C
j₁ j₂ j₃ : J
f : j₁ ⟶ j₂
g : j₂ ⟶ j₃
carrier✝ : Set ↑↑(F.obj j₃)
is_open'✝ : IsOpen carrier✝
⊢ (F.map (f ≫ g)).c.app { unop := { carrier := carrier✝, is_open' := is_open'✝ } } =
    (F.map g).c.app { unop := { carrier := carrier✝, is_open' := is_open'✝ } } ≫
      (pushforwardMap (F.map g).base (F.map f).c).app { unop := { carrier := carrier✝, is_open' := is_open'✝ } } ≫
        (Pushforward.comp (F.obj j₁).presheaf (F.map f).base (F.map g).base).inv.app
            { unop := { carrier := carrier✝, is_open' := is_open'✝ } } ≫
          (pushforwardEq ⋯ (F.obj j₁).presheaf).hom.app { unop := { carrier := carrier✝, is_open' := is_open'✝ } }
state_after: no goals
Theorem: Complex.Gammaℝ_mul_Gammaℝ_add_one
File: Mathlib/Analysis/SpecialFunctions/Gamma/Deligne.lean

tactic: simp only [Gammaℝ_def, Gammaℂ_def]
state_before: s : ℂ
⊢ s.Gammaℝ * (s + 1).Gammaℝ = s.Gammaℂ
state_after: s : ℂ
⊢ ↑π ^ (-s / 2) * Gamma (s / 2) * (↑π ^ (-(s + 1) / 2) * Gamma ((s + 1) / 2)) = 2 * (2 * ↑π) ^ (-s) * Gamma s

tactic: calc
_ = (π ^ (-s / 2) * π ^ (-(s + 1) / 2)) * (Gamma (s / 2) * Gamma (s / 2 + 1 / 2)) := by ring_nf
_ = 2 ^ (1 - s) * (π ^ (-1 / 2 - s) * π ^ (1 / 2 : ℂ)) * Gamma s := by
  rw [← cpow_add _ _ (ofReal_ne_zero.mpr pi_ne_zero), Complex.Gamma_mul_Gamma_add_half,
    sqrt_eq_rpow, ofReal_cpow pi_pos.le, ofReal_div, ofReal_one, ofReal_ofNat]
  ring_nf
_ = 2 * ((2 : ℝ) ^ (-s) * π ^ (-s)) * Gamma s := by
  rw [sub_eq_add_neg, cpow_add _ _ two_ne_zero, cpow_one,
    ← cpow_add _ _ (ofReal_ne_zero.mpr pi_ne_zero), ofReal_ofNat]
  ring_nf
_ = 2 * (2 * π) ^ (-s) * Gamma s := by
  rw [← mul_cpow_ofReal_nonneg two_pos.le pi_pos.le, ofReal_ofNat]
state_before: s : ℂ
⊢ ↑π ^ (-s / 2) * Gamma (s / 2) * (↑π ^ (-(s + 1) / 2) * Gamma ((s + 1) / 2)) = 2 * (2 * ↑π) ^ (-s) * Gamma s
state_after: no goals

tactic: ring_nf
state_before: s : ℂ
⊢ ↑π ^ (-s / 2) * Gamma (s / 2) * (↑π ^ (-(s + 1) / 2) * Gamma ((s + 1) / 2)) =
    ↑π ^ (-s / 2) * ↑π ^ (-(s + 1) / 2) * (Gamma (s / 2) * Gamma (s / 2 + 1 / 2))
state_after: no goals

tactic: rw [← cpow_add _ _ (ofReal_ne_zero.mpr pi_ne_zero), Complex.Gamma_mul_Gamma_add_half,
  sqrt_eq_rpow, ofReal_cpow pi_pos.le, ofReal_div, ofReal_one, ofReal_ofNat]
state_before: s : ℂ
⊢ ↑π ^ (-s / 2) * ↑π ^ (-(s + 1) / 2) * (Gamma (s / 2) * Gamma (s / 2 + 1 / 2)) =
    2 ^ (1 - s) * (↑π ^ (-1 / 2 - s) * ↑π ^ (1 / 2)) * Gamma s
state_after: s : ℂ
⊢ ↑π ^ (-s / 2 + -(s + 1) / 2) * (Gamma (2 * (s / 2)) * 2 ^ (1 - 2 * (s / 2)) * ↑π ^ (1 / 2)) =
    2 ^ (1 - s) * (↑π ^ (-1 / 2 - s) * ↑π ^ (1 / 2)) * Gamma s

tactic: ring_nf
state_before: s : ℂ
⊢ ↑π ^ (-s / 2 + -(s + 1) / 2) * (Gamma (2 * (s / 2)) * 2 ^ (1 - 2 * (s / 2)) * ↑π ^ (1 / 2)) =
    2 ^ (1 - s) * (↑π ^ (-1 / 2 - s) * ↑π ^ (1 / 2)) * Gamma s
state_after: no goals

tactic: rw [sub_eq_add_neg, cpow_add _ _ two_ne_zero, cpow_one,
  ← cpow_add _ _ (ofReal_ne_zero.mpr pi_ne_zero), ofReal_ofNat]
state_before: s : ℂ
⊢ 2 ^ (1 - s) * (↑π ^ (-1 / 2 - s) * ↑π ^ (1 / 2)) * Gamma s = 2 * (↑2 ^ (-s) * ↑π ^ (-s)) * Gamma s
state_after: s : ℂ
⊢ 2 * 2 ^ (-s) * ↑π ^ (-1 / 2 - s + 1 / 2) * Gamma s = 2 * (2 ^ (-s) * ↑π ^ (-s)) * Gamma s

tactic: ring_nf
state_before: s : ℂ
⊢ 2 * 2 ^ (-s) * ↑π ^ (-1 / 2 - s + 1 / 2) * Gamma s = 2 * (2 ^ (-s) * ↑π ^ (-s)) * Gamma s
state_after: no goals

tactic: rw [← mul_cpow_ofReal_nonneg two_pos.le pi_pos.le, ofReal_ofNat]
state_before: s : ℂ
⊢ 2 * (↑2 ^ (-s) * ↑π ^ (-s)) * Gamma s = 2 * (2 * ↑π) ^ (-s) * Gamma s
state_after: no goals
Theorem: MeasureTheory.L1.ofReal_norm_sub_eq_lintegral
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: simp_rw [ofReal_norm_eq_lintegral, ← edist_eq_coe_nnnorm]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f g : ↥(Lp β 1 μ)
⊢ ENNReal.ofReal ‖f - g‖ = ∫⁻ (x : α), ↑‖↑↑f x - ↑↑g x‖₊ ∂μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f g : ↥(Lp β 1 μ)
⊢ ∫⁻ (x : α), edist (↑↑(f - g) x) 0 ∂μ = ∫⁻ (x : α), edist (↑↑f x - ↑↑g x) 0 ∂μ

tactic: apply lintegral_congr_ae
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f g : ↥(Lp β 1 μ)
⊢ ∫⁻ (x : α), edist (↑↑(f - g) x) 0 ∂μ = ∫⁻ (x : α), edist (↑↑f x - ↑↑g x) 0 ∂μ
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f g : ↥(Lp β 1 μ)
⊢ (fun a => edist (↑↑(f - g) a) 0) =ᶠ[ae μ] fun a => edist (↑↑f a - ↑↑g a) 0

tactic: filter_upwards [Lp.coeFn_sub f g] with _ ha
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f g : ↥(Lp β 1 μ)
⊢ (fun a => edist (↑↑(f - g) a) 0) =ᶠ[ae μ] fun a => edist (↑↑f a - ↑↑g a) 0
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f g : ↥(Lp β 1 μ)
a✝ : α
ha : ↑↑(f - g) a✝ = (↑↑f - ↑↑g) a✝
⊢ edist (↑↑(f - g) a✝) 0 = edist (↑↑f a✝ - ↑↑g a✝) 0

tactic: simp only [ha, Pi.sub_apply]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f g : ↥(Lp β 1 μ)
a✝ : α
ha : ↑↑(f - g) a✝ = (↑↑f - ↑↑g) a✝
⊢ edist (↑↑(f - g) a✝) 0 = edist (↑↑f a✝ - ↑↑g a✝) 0
state_after: no goals
Theorem: CliffordAlgebraQuaternion.toQuaternion_star
File: Mathlib/LinearAlgebra/CliffordAlgebra/Equivs.lean

tactic: simp only [CliffordAlgebra.star_def']
state_before: R : Type u_1
inst✝ : CommRing R
c₁ c₂ : R
c : CliffordAlgebra (Q c₁ c₂)
⊢ toQuaternion (star c) = star (toQuaternion c)
state_after: R : Type u_1
inst✝ : CommRing R
c₁ c₂ : R
c : CliffordAlgebra (Q c₁ c₂)
⊢ toQuaternion (involute (reverse c)) = star (toQuaternion c)

tactic: induction c using CliffordAlgebra.induction with
| algebraMap r =>
  simp only [reverse.commutes, AlgHom.commutes, QuaternionAlgebra.coe_algebraMap,
    QuaternionAlgebra.star_coe]
| ι x =>
  rw [reverse_ι, involute_ι, toQuaternion_ι, AlgHom.map_neg, toQuaternion_ι,
    QuaternionAlgebra.neg_mk, star_mk, neg_zero]
| mul x₁ x₂ hx₁ hx₂ => simp only [reverse.map_mul, AlgHom.map_mul, hx₁, hx₂, star_mul]
| add x₁ x₂ hx₁ hx₂ => simp only [reverse.map_add, AlgHom.map_add, hx₁, hx₂, star_add]
state_before: R : Type u_1
inst✝ : CommRing R
c₁ c₂ : R
c : CliffordAlgebra (Q c₁ c₂)
⊢ toQuaternion (involute (reverse c)) = star (toQuaternion c)
state_after: no goals

tactic: simp only [reverse.commutes, AlgHom.commutes, QuaternionAlgebra.coe_algebraMap,
  QuaternionAlgebra.star_coe]
state_before: case algebraMap
R : Type u_1
inst✝ : CommRing R
c₁ c₂ r : R
⊢ toQuaternion (involute (reverse ((algebraMap R (CliffordAlgebra (Q c₁ c₂))) r))) =
    star (toQuaternion ((algebraMap R (CliffordAlgebra (Q c₁ c₂))) r))
state_after: no goals

tactic: rw [reverse_ι, involute_ι, toQuaternion_ι, AlgHom.map_neg, toQuaternion_ι,
  QuaternionAlgebra.neg_mk, star_mk, neg_zero]
state_before: case ι
R : Type u_1
inst✝ : CommRing R
c₁ c₂ : R
x : R × R
⊢ toQuaternion (involute (reverse ((ι (Q c₁ c₂)) x))) = star (toQuaternion ((ι (Q c₁ c₂)) x))
state_after: no goals

tactic: simp only [reverse.map_mul, AlgHom.map_mul, hx₁, hx₂, star_mul]
state_before: case mul
R : Type u_1
inst✝ : CommRing R
c₁ c₂ : R
x₁ x₂ : CliffordAlgebra (Q c₁ c₂)
hx₁ : toQuaternion (involute (reverse x₁)) = star (toQuaternion x₁)
hx₂ : toQuaternion (involute (reverse x₂)) = star (toQuaternion x₂)
⊢ toQuaternion (involute (reverse (x₁ * x₂))) = star (toQuaternion (x₁ * x₂))
state_after: no goals

tactic: simp only [reverse.map_add, AlgHom.map_add, hx₁, hx₂, star_add]
state_before: case add
R : Type u_1
inst✝ : CommRing R
c₁ c₂ : R
x₁ x₂ : CliffordAlgebra (Q c₁ c₂)
hx₁ : toQuaternion (involute (reverse x₁)) = star (toQuaternion x₁)
hx₂ : toQuaternion (involute (reverse x₂)) = star (toQuaternion x₂)
⊢ toQuaternion (involute (reverse (x₁ + x₂))) = star (toQuaternion (x₁ + x₂))
state_after: no goals
Theorem: Matrix.blockTriangular_blockDiagonal
File: Mathlib/LinearAlgebra/Matrix/Block.lean

tactic: rintro ⟨i, i'⟩ ⟨j, j'⟩ h
state_before: α : Type u_1
β : Type u_2
m : Type u_3
n : Type u_4
o : Type u_5
m' : α → Type u_6
n' : α → Type u_7
R : Type v
inst✝² : CommRing R
M N : Matrix m m R
b : m → α
inst✝¹ : Preorder α
inst✝ : DecidableEq α
d : α → Matrix m m R
⊢ (blockDiagonal d).BlockTriangular Prod.snd
state_after: case mk.mk
α : Type u_1
β : Type u_2
m : Type u_3
n : Type u_4
o : Type u_5
m' : α → Type u_6
n' : α → Type u_7
R : Type v
inst✝² : CommRing R
M N : Matrix m m R
b : m → α
inst✝¹ : Preorder α
inst✝ : DecidableEq α
d : α → Matrix m m R
i : m
i' : α
j : m
j' : α
h : (j, j').2 < (i, i').2
⊢ blockDiagonal d (i, i') (j, j') = 0

tactic: rw [blockDiagonal'_eq_blockDiagonal, blockTriangular_blockDiagonal']
state_before: case mk.mk
α : Type u_1
β : Type u_2
m : Type u_3
n : Type u_4
o : Type u_5
m' : α → Type u_6
n' : α → Type u_7
R : Type v
inst✝² : CommRing R
M N : Matrix m m R
b : m → α
inst✝¹ : Preorder α
inst✝ : DecidableEq α
d : α → Matrix m m R
i : m
i' : α
j : m
j' : α
h : (j, j').2 < (i, i').2
⊢ blockDiagonal d (i, i') (j, j') = 0
state_after: case mk.mk.a
α : Type u_1
β : Type u_2
m : Type u_3
n : Type u_4
o : Type u_5
m' : α → Type u_6
n' : α → Type u_7
R : Type v
inst✝² : CommRing R
M N : Matrix m m R
b : m → α
inst✝¹ : Preorder α
inst✝ : DecidableEq α
d : α → Matrix m m R
i : m
i' : α
j : m
j' : α
h : (j, j').2 < (i, i').2
⊢ ⟨j', j⟩.fst < ⟨i', i⟩.fst

tactic: exact h
state_before: case mk.mk.a
α : Type u_1
β : Type u_2
m : Type u_3
n : Type u_4
o : Type u_5
m' : α → Type u_6
n' : α → Type u_7
R : Type v
inst✝² : CommRing R
M N : Matrix m m R
b : m → α
inst✝¹ : Preorder α
inst✝ : DecidableEq α
d : α → Matrix m m R
i : m
i' : α
j : m
j' : α
h : (j, j').2 < (i, i').2
⊢ ⟨j', j⟩.fst < ⟨i', i⟩.fst
state_after: no goals
Theorem: Pretrivialization.symm_proj_apply
File: Mathlib/Topology/FiberBundle/Trivialization.lean

tactic: rw [e.symm_apply hz, cast_eq_iff_heq, e.mk_proj_snd' hz, e.symm_apply_apply (e.mem_source.mpr hz)]
state_before: ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
proj : Z → B
e✝ : Pretrivialization F proj
x : Z
e' : Pretrivialization F TotalSpace.proj
x' : TotalSpace F E
b : B
y : E b
inst✝ : (x : B) → Zero (E x)
e : Pretrivialization F TotalSpace.proj
z : TotalSpace F E
hz : z.proj ∈ e.baseSet
⊢ e.symm z.proj (↑e z).2 = z.snd
state_after: no goals
Theorem: le_sdiff_sup
File: Mathlib/Order/Heyting/Basic.lean

tactic: rw [sup_comm, ← sdiff_le_iff]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
⊢ a ≤ a \ b ⊔ b
state_after: no goals
Theorem: CompositionSeries.eq_snoc_eraseLast
File: Mathlib/Order/JordanHolder.lean

tactic: ext x
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
h : 0 < s.length
⊢ s = (eraseLast s).snoc (last s) ⋯
state_after: case h
X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
h : 0 < s.length
x : X
⊢ x ∈ s ↔ x ∈ (eraseLast s).snoc (last s) ⋯

tactic: simp only [mem_snoc, mem_eraseLast h, ne_eq]
state_before: case h
X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
h : 0 < s.length
x : X
⊢ x ∈ s ↔ x ∈ (eraseLast s).snoc (last s) ⋯
state_after: case h
X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
h : 0 < s.length
x : X
⊢ x ∈ s ↔ ¬x = last s ∧ x ∈ s ∨ x = last s

tactic: by_cases h : x = s.last <;> simp [*, s.last_mem]
state_before: case h
X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
h : 0 < s.length
x : X
⊢ x ∈ s ↔ ¬x = last s ∧ x ∈ s ∨ x = last s
state_after: no goals
Theorem: Equiv.Perm.signBijAux_mem
File: Mathlib/GroupTheory/Perm/Sign.lean

tactic: unfold signBijAux
state_before: α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a₁ a₂ : Fin n
ha : ⟨a₁, a₂⟩ ∈ finPairsLT n
⊢ f.signBijAux ⟨a₁, a₂⟩ ∈ finPairsLT n
state_after: α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a₁ a₂ : Fin n
ha : ⟨a₁, a₂⟩ ∈ finPairsLT n
⊢ (if x : f ⟨a₁, a₂⟩.snd < f ⟨a₁, a₂⟩.fst then ⟨f ⟨a₁, a₂⟩.fst, f ⟨a₁, a₂⟩.snd⟩ else ⟨f ⟨a₁, a₂⟩.snd, f ⟨a₁, a₂⟩.fst⟩) ∈
    finPairsLT n

tactic: split_ifs with h
state_before: α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a₁ a₂ : Fin n
ha : ⟨a₁, a₂⟩ ∈ finPairsLT n
⊢ (if x : f ⟨a₁, a₂⟩.snd < f ⟨a₁, a₂⟩.fst then ⟨f ⟨a₁, a₂⟩.fst, f ⟨a₁, a₂⟩.snd⟩ else ⟨f ⟨a₁, a₂⟩.snd, f ⟨a₁, a₂⟩.fst⟩) ∈
    finPairsLT n
state_after: case pos
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a₁ a₂ : Fin n
ha : ⟨a₁, a₂⟩ ∈ finPairsLT n
h : f ⟨a₁, a₂⟩.snd < f ⟨a₁, a₂⟩.fst
⊢ ⟨f ⟨a₁, a₂⟩.fst, f ⟨a₁, a₂⟩.snd⟩ ∈ finPairsLT n

case neg
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a₁ a₂ : Fin n
ha : ⟨a₁, a₂⟩ ∈ finPairsLT n
h : ¬f ⟨a₁, a₂⟩.snd < f ⟨a₁, a₂⟩.fst
⊢ ⟨f ⟨a₁, a₂⟩.snd, f ⟨a₁, a₂⟩.fst⟩ ∈ finPairsLT n

tactic: exact mem_finPairsLT.2 h
state_before: case pos
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a₁ a₂ : Fin n
ha : ⟨a₁, a₂⟩ ∈ finPairsLT n
h : f ⟨a₁, a₂⟩.snd < f ⟨a₁, a₂⟩.fst
⊢ ⟨f ⟨a₁, a₂⟩.fst, f ⟨a₁, a₂⟩.snd⟩ ∈ finPairsLT n
state_after: no goals

tactic: exact mem_finPairsLT.2
  ((le_of_not_gt h).lt_of_ne fun h => (mem_finPairsLT.1 ha).ne (f.injective h.symm))
state_before: case neg
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a₁ a₂ : Fin n
ha : ⟨a₁, a₂⟩ ∈ finPairsLT n
h : ¬f ⟨a₁, a₂⟩.snd < f ⟨a₁, a₂⟩.fst
⊢ ⟨f ⟨a₁, a₂⟩.snd, f ⟨a₁, a₂⟩.fst⟩ ∈ finPairsLT n
state_after: no goals
Theorem: Fin.mem_find_iff
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: rintro ⟨hpi, hj⟩
state_before: m n : ℕ
p : Fin n → Prop
inst✝ : DecidablePred p
i : Fin n
⊢ (p i ∧ ∀ (j : Fin n), p j → i ≤ j) → i ∈ find p
state_after: case intro
m n : ℕ
p : Fin n → Prop
inst✝ : DecidablePred p
i : Fin n
hpi : p i
hj : ∀ (j : Fin n), p j → i ≤ j
⊢ i ∈ find p

tactic: cases hfp : Fin.find p
state_before: case intro
m n : ℕ
p : Fin n → Prop
inst✝ : DecidablePred p
i : Fin n
hpi : p i
hj : ∀ (j : Fin n), p j → i ≤ j
⊢ i ∈ find p
state_after: case intro.none
m n : ℕ
p : Fin n → Prop
inst✝ : DecidablePred p
i : Fin n
hpi : p i
hj : ∀ (j : Fin n), p j → i ≤ j
hfp : find p = none
⊢ i ∈ none

case intro.some
m n : ℕ
p : Fin n → Prop
inst✝ : DecidablePred p
i : Fin n
hpi : p i
hj : ∀ (j : Fin n), p j → i ≤ j
val✝ : Fin n
hfp : find p = some val✝
⊢ i ∈ some val✝

tactic: rw [find_eq_none_iff] at hfp
state_before: case intro.none
m n : ℕ
p : Fin n → Prop
inst✝ : DecidablePred p
i : Fin n
hpi : p i
hj : ∀ (j : Fin n), p j → i ≤ j
hfp : find p = none
⊢ i ∈ none
state_after: case intro.none
m n : ℕ
p : Fin n → Prop
inst✝ : DecidablePred p
i : Fin n
hpi : p i
hj : ∀ (j : Fin n), p j → i ≤ j
hfp : ∀ (i : Fin n), ¬p i
⊢ i ∈ none

tactic: exact (hfp _ hpi).elim
state_before: case intro.none
m n : ℕ
p : Fin n → Prop
inst✝ : DecidablePred p
i : Fin n
hpi : p i
hj : ∀ (j : Fin n), p j → i ≤ j
hfp : ∀ (i : Fin n), ¬p i
⊢ i ∈ none
state_after: no goals

tactic: exact Option.some_inj.2 (le_antisymm (find_min' hfp hpi) (hj _ (find_spec _ hfp)))
state_before: case intro.some
m n : ℕ
p : Fin n → Prop
inst✝ : DecidablePred p
i : Fin n
hpi : p i
hj : ∀ (j : Fin n), p j → i ≤ j
val✝ : Fin n
hfp : find p = some val✝
⊢ i ∈ some val✝
state_after: no goals
Theorem: HomologicalComplex.i_cyclesMk
File: Mathlib/Algebra/Homology/ConcreteCategory.lean

tactic: subst hj
state_before: C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : ConcreteCategory C
inst✝³ : HasForget₂ C Ab
inst✝² : Abelian C
inst✝¹ : (forget₂ C Ab).Additive
inst✝ : (forget₂ C Ab).PreservesHomology
ι : Type u_1
c : ComplexShape ι
K : HomologicalComplex C c
i : ι
x : ↑((forget₂ C Ab).obj (K.X i))
j : ι
hj : c.next i = j
hx : ((forget₂ C Ab).map (K.d i j)) x = 0
⊢ ((forget₂ C Ab).map (K.iCycles i)) (K.cyclesMk x j hj hx) = x
state_after: C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : ConcreteCategory C
inst✝³ : HasForget₂ C Ab
inst✝² : Abelian C
inst✝¹ : (forget₂ C Ab).Additive
inst✝ : (forget₂ C Ab).PreservesHomology
ι : Type u_1
c : ComplexShape ι
K : HomologicalComplex C c
i : ι
x : ↑((forget₂ C Ab).obj (K.X i))
hx : ((forget₂ C Ab).map (K.d i (c.next i))) x = 0
⊢ ((forget₂ C Ab).map (K.iCycles i)) (K.cyclesMk x (c.next i) ⋯ hx) = x

tactic: apply (K.sc i).i_cyclesMk
state_before: C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : ConcreteCategory C
inst✝³ : HasForget₂ C Ab
inst✝² : Abelian C
inst✝¹ : (forget₂ C Ab).Additive
inst✝ : (forget₂ C Ab).PreservesHomology
ι : Type u_1
c : ComplexShape ι
K : HomologicalComplex C c
i : ι
x : ↑((forget₂ C Ab).obj (K.X i))
hx : ((forget₂ C Ab).map (K.d i (c.next i))) x = 0
⊢ ((forget₂ C Ab).map (K.iCycles i)) (K.cyclesMk x (c.next i) ⋯ hx) = x
state_after: no goals
Theorem: FirstOrder.Language.card_mk₂
File: Mathlib/ModelTheory/Basic.lean

tactic: simp [card_eq_card_functions_add_card_relations, add_assoc]
state_before: L : Language
L' : Language
c f₁ f₂ : Type u
r₁ r₂ : Type v
⊢ (Language.mk₂ c f₁ f₂ r₁ r₂).card =
    lift.{v, u} #c + lift.{v, u} #f₁ + lift.{v, u} #f₂ + lift.{u, v} #r₁ + lift.{u, v} #r₂
state_after: no goals
Theorem: Batteries.BinomialHeap.Imp.HeapNode.WF.toHeap
File: .lake/packages/batteries/Batteries/Data/BinomialHeap/Basic.lean

tactic: rw [← h'.rank_eq] at h
state_before: α : Type u_1
le : α → α → Bool
a✝ : α
n✝ : Nat
s✝ : HeapNode α
h✝ : WF le a✝ s✝ n✝
res : Heap α
a : α
c s : HeapNode α
n : Nat
left✝ : ∀ [inst : TotalBLE le], le a✝ a = true
h : WF le a c n
h' : WF le a✝ s n
hr : Heap.WF le (node a c s).rank res
⊢ WF le a c ((node a c s).rank - 1)
state_after: α : Type u_1
le : α → α → Bool
a✝ : α
n✝ : Nat
s✝ : HeapNode α
h✝ : WF le a✝ s✝ n✝
res : Heap α
a : α
c s : HeapNode α
n : Nat
left✝ : ∀ [inst : TotalBLE le], le a✝ a = true
h : WF le a c s.rank
h' : WF le a✝ s n
hr : Heap.WF le (node a c s).rank res
⊢ WF le a c ((node a c s).rank - 1)

tactic: exact h
state_before: α : Type u_1
le : α → α → Bool
a✝ : α
n✝ : Nat
s✝ : HeapNode α
h✝ : WF le a✝ s✝ n✝
res : Heap α
a : α
c s : HeapNode α
n : Nat
left✝ : ∀ [inst : TotalBLE le], le a✝ a = true
h : WF le a c s.rank
h' : WF le a✝ s n
hr : Heap.WF le (node a c s).rank res
⊢ WF le a c ((node a c s).rank - 1)
state_after: no goals
Theorem: Matroid.Indep.indep_restriction
File: Mathlib/Data/Matroid/Restrict.lean

tactic: obtain ⟨R, -, rfl⟩ := hNM
state_before: α : Type u_1
M : Matroid α
R I J X Y : Set α
N : Matroid α
hI : M.Indep I
hNM : N ≤r M
hIN : I ⊆ N.E
⊢ N.Indep I
state_after: case intro.intro
α : Type u_1
M : Matroid α
R✝ I J X Y : Set α
hI : M.Indep I
R : Set α
hIN : I ⊆ (M ↾ R).E
⊢ (M ↾ R).Indep I

tactic: simpa [hI]
state_before: case intro.intro
α : Type u_1
M : Matroid α
R✝ I J X Y : Set α
hI : M.Indep I
R : Set α
hIN : I ⊆ (M ↾ R).E
⊢ (M ↾ R).Indep I
state_after: no goals
Theorem: SimpleGraph.mem_incidenceSet
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: simp [incidenceSet]
state_before: ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v✝ w✝ : V
e : Sym2 V
v w : V
⊢ s(v, w) ∈ G.incidenceSet v ↔ G.Adj v w
state_after: no goals
Theorem: Finset.SupIndep.le_sup_iff
File: Mathlib/Order/SupIndep.lean

tactic: refine ⟨fun h => ?_, le_sup⟩
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝¹ : Lattice α
inst✝ : OrderBot α
s t : Finset ι
f : ι → α
i : ι
hs : s.SupIndep f
hts : t ⊆ s
hi : i ∈ s
hf : ∀ (i : ι), f i ≠ ⊥
⊢ f i ≤ t.sup f ↔ i ∈ t
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝¹ : Lattice α
inst✝ : OrderBot α
s t : Finset ι
f : ι → α
i : ι
hs : s.SupIndep f
hts : t ⊆ s
hi : i ∈ s
hf : ∀ (i : ι), f i ≠ ⊥
h : f i ≤ t.sup f
⊢ i ∈ t

tactic: by_contra hit
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝¹ : Lattice α
inst✝ : OrderBot α
s t : Finset ι
f : ι → α
i : ι
hs : s.SupIndep f
hts : t ⊆ s
hi : i ∈ s
hf : ∀ (i : ι), f i ≠ ⊥
h : f i ≤ t.sup f
⊢ i ∈ t
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝¹ : Lattice α
inst✝ : OrderBot α
s t : Finset ι
f : ι → α
i : ι
hs : s.SupIndep f
hts : t ⊆ s
hi : i ∈ s
hf : ∀ (i : ι), f i ≠ ⊥
h : f i ≤ t.sup f
hit : i ∉ t
⊢ False

tactic: exact hf i (disjoint_self.1 <| (hs hts hi hit).mono_right h)
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝¹ : Lattice α
inst✝ : OrderBot α
s t : Finset ι
f : ι → α
i : ι
hs : s.SupIndep f
hts : t ⊆ s
hi : i ∈ s
hf : ∀ (i : ι), f i ≠ ⊥
h : f i ≤ t.sup f
hit : i ∉ t
⊢ False
state_after: no goals
Theorem: Finset.iSup_singleton
File: Mathlib/Data/Finset/Lattice.lean

tactic: simp
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : CompleteLattice β
a : α
s : α → β
⊢ ⨆ x ∈ {a}, s x = s a
state_after: no goals
Theorem: Polynomial.hasseDeriv_zero'
File: Mathlib/Algebra/Polynomial/HasseDeriv.lean

tactic: simp only [hasseDeriv_apply, tsub_zero, Nat.choose_zero_right, Nat.cast_one, one_mul,
  sum_monomial_eq]
state_before: R : Type u_1
inst✝ : Semiring R
k : ℕ
f : R[X]
⊢ (hasseDeriv 0) f = f
state_after: no goals
Theorem: Order.succ_le_succ_iff
File: Mathlib/Order/SuccPred/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : SuccOrder α
a b : α
inst✝ : NoMaxOrder α
⊢ succ a ≤ succ b ↔ a ≤ b
state_after: no goals