ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: setOf_isPreconnected_subset_of_ordered
File: Mathlib/Topology/Order/IntermediateValue.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁶ : ConditionallyCompleteLinearOrder α
inst✝⁵ : TopologicalSpace α
inst✝⁴ : OrderTopology α
inst✝³ : ConditionallyCompleteLinearOrder β
inst✝² : TopologicalSpace β
inst✝¹ : OrderTopology β
inst✝ : Nonempty γ
⊢ {s | IsPreconnected s} ⊆
    range (uncurry Icc) ∪ range (uncurry Ico) ∪ range (uncurry Ioc) ∪ range (uncurry Ioo) ∪
      (range Ici ∪ range Ioi ∪ range Iic ∪ range Iio ∪ {univ, ∅})
state_after: α : Type u
β : Type v
γ : Type w
inst✝⁶ : ConditionallyCompleteLinearOrder α
inst✝⁵ : TopologicalSpace α
inst✝⁴ : OrderTopology α
inst✝³ : ConditionallyCompleteLinearOrder β
inst✝² : TopologicalSpace β
inst✝¹ : OrderTopology β
inst✝ : Nonempty γ
s : Set α
hs : s ∈ {s | IsPreconnected s}
⊢ s ∈
    range (uncurry Icc) ∪ range (uncurry Ico) ∪ range (uncurry Ioc) ∪ range (uncurry Ioo) ∪
      (range Ici ∪ range Ioi ∪ range Iic ∪ range Iio ∪ {univ, ∅})
tactic: intro s hs
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁶ : ConditionallyCompleteLinearOrder α
inst✝⁵ : TopologicalSpace α
inst✝⁴ : OrderTopology α
inst✝³ : ConditionallyCompleteLinearOrder β
inst✝² : TopologicalSpace β
inst✝¹ : OrderTopology β
inst✝ : Nonempty γ
s : Set α
hs : s ∈ {s | IsPreconnected s}
⊢ s ∈
    range (uncurry Icc) ∪ range (uncurry Ico) ∪ range (uncurry Ioc) ∪ range (uncurry Ioo) ∪
      (range Ici ∪ range Ioi ∪ range Iic ∪ range Iio ∪ {univ, ∅})
state_after: no goals
tactic: rcases hs.mem_intervals with (hs | hs | hs | hs | hs | hs | hs | hs | hs | hs) <;> rw [hs] <;>
    simp only [union_insert, union_singleton, mem_insert_iff, mem_union, mem_range, Prod.exists,
      uncurry_apply_pair, exists_apply_eq_apply, true_or, or_true, exists_apply_eq_apply2]
Theorem: cfcUnits_zpow
File: Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unital.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
p : A → Prop
inst✝¹¹ : Semifield R
inst✝¹⁰ : StarRing R
inst✝⁹ : MetricSpace R
inst✝⁸ : TopologicalSemiring R
inst✝⁷ : ContinuousStar R
inst✝⁶ : HasContinuousInv₀ R
inst✝⁵ : TopologicalSpace A
inst✝⁴ : Ring A
inst✝³ : StarRing A
inst✝² : Algebra R A
inst✝¹ : ContinuousFunctionalCalculus R p
f : R → R
a : A
inst✝ : UniqueContinuousFunctionalCalculus R A
hf' : ∀ x ∈ spectrum R a, f x ≠ 0
n : ℤ
hf : autoParam (ContinuousOn f (spectrum R a)) _auto✝
ha : autoParam (p a) _auto✝
⊢ cfcUnits f a hf' hf ha ^ n = cfcUnits (f ^ n) a ⋯ ⋯ ha
state_after: no goals
tactic: cases n with
  | ofNat _ => simpa using cfcUnits_pow f a hf' _
  | negSucc n =>
    simp only [zpow_negSucc, ← inv_pow]
    ext
    exact cfc_pow (hf := hf.inv₀ hf') _ |>.symm
Theorem: continuousAt_prod_of_discrete_right
File: Mathlib/Topology/ContinuousOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝⁴ : (i : ι) → TopologicalSpace (π i)
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
inst✝ : DiscreteTopology β
f : α × β → γ
x : α × β
⊢ ContinuousAt f x ↔ ContinuousAt (fun x_1 => f (x_1, x.2)) x.1
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝⁴ : (i : ι) → TopologicalSpace (π i)
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
inst✝ : DiscreteTopology β
f : α × β → γ
x : α × β
⊢ ContinuousWithinAt f univ x ↔ ContinuousWithinAt (fun x_1 => f (x_1, x.2)) univ x.1
tactic: simp_rw [← continuousWithinAt_univ]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝⁴ : (i : ι) → TopologicalSpace (π i)
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
inst✝ : DiscreteTopology β
f : α × β → γ
x : α × β
⊢ ContinuousWithinAt f univ x ↔ ContinuousWithinAt (fun x_1 => f (x_1, x.2)) univ x.1
state_after: no goals
tactic: exact continuousWithinAt_prod_of_discrete_right
Theorem: IsPrimitiveRoot.integralPowerBasis_gen
File: Mathlib/NumberTheory/Cyclotomic/Rat.lean

Proof steps:
state_before: p : ℕ+
k : ℕ
K : Type u
inst✝¹ : Field K
inst✝ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
hcycl : IsCyclotomicExtension {p ^ k} ℚ K
hζ : IsPrimitiveRoot ζ ↑(p ^ k)
⊢ (algebraMap (𝓞 K) K) hζ.integralPowerBasis.gen = ↑hζ.toInteger
state_after: p : ℕ+
k : ℕ
K : Type u
inst✝¹ : Field K
inst✝ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
hcycl : IsCyclotomicExtension {p ^ k} ℚ K
hζ : IsPrimitiveRoot ζ ↑(p ^ k)
⊢ (algebraMap (𝓞 K) K) (hζ.adjoinEquivRingOfIntegers ⟨ζ, ⋯⟩) = ↑hζ.toInteger
tactic: rw [integralPowerBasis, PowerBasis.map_gen, adjoin.powerBasis'_gen]
state_before: p : ℕ+
k : ℕ
K : Type u
inst✝¹ : Field K
inst✝ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
hcycl : IsCyclotomicExtension {p ^ k} ℚ K
hζ : IsPrimitiveRoot ζ ↑(p ^ k)
⊢ (algebraMap (𝓞 K) K) (hζ.adjoinEquivRingOfIntegers ⟨ζ, ⋯⟩) = ↑hζ.toInteger
state_after: p : ℕ+
k : ℕ
K : Type u
inst✝¹ : Field K
inst✝ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
hcycl : IsCyclotomicExtension {p ^ k} ℚ K
hζ : IsPrimitiveRoot ζ ↑(p ^ k)
⊢ (algebraMap (↥(adjoin ℤ {ζ})) K) ⟨ζ, ⋯⟩ = ζ
tactic: simp only [adjoinEquivRingOfIntegers_apply, IsIntegralClosure.algebraMap_lift]
state_before: p : ℕ+
k : ℕ
K : Type u
inst✝¹ : Field K
inst✝ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
hcycl : IsCyclotomicExtension {p ^ k} ℚ K
hζ : IsPrimitiveRoot ζ ↑(p ^ k)
⊢ (algebraMap (↥(adjoin ℤ {ζ})) K) ⟨ζ, ⋯⟩ = ζ
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.InjectiveResolution.exact_succ
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
n : ℕ
⊢ (ComplexShape.up ℕ).prev (n + 1) = n
state_after: no goals
tactic: simp
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
Z : C
I : InjectiveResolution Z
n : ℕ
⊢ (ComplexShape.up ℕ).next (n + 1) = n + 2
state_after: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
Z : C
I : InjectiveResolution Z
n : ℕ
⊢ n + 1 + 1 = n + 2
tactic: simp only [CochainComplex.next]
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
Z : C
I : InjectiveResolution Z
n : ℕ
⊢ n + 1 + 1 = n + 2
state_after: no goals
tactic: rfl
Theorem: GenContFract.succ_nth_conv'_eq_squashGCF_nth_conv'
File: Mathlib/Algebra/ContinuedFractions/ConvergentsEquiv.lean

Proof steps:
state_before: K : Type u_1
n : ℕ
g : GenContFract K
s : Stream'.Seq (Pair K)
inst✝ : DivisionRing K
⊢ g.convs' (n + 1) = (g.squashGCF n).convs' n
state_after: no goals
tactic: cases n with
  | zero =>
    cases g_s_head_eq : g.s.get? 0 <;>
      simp [g_s_head_eq, squashGCF, convs', convs'Aux, Stream'.Seq.head]
  | succ =>
    simp only [succ_succ_nth_conv'Aux_eq_succ_nth_conv'Aux_squashSeq, convs',
      squashGCF]
Theorem: Set.Subsingleton.isCornerFree
File: Mathlib/Combinatorics/Additive/Corner/Defs.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
inst✝¹ : AddCommMonoid G
inst✝ : AddCommMonoid H
A B : Set (G × G)
s : Set G
t : Set H
f : G → H
a b c x₁ y₁ x₂ y₂ : G
hA : A.Subsingleton
_x₁ _y₁ _x₂ _y₂ : G
hxyd : IsCorner A _x₁ _y₁ _x₂ _y₂
⊢ _x₁ = _x₂
state_after: no goals
tactic: simpa using hA hxyd.fst_fst_mem hxyd.snd_fst_mem
Theorem: ADEInequality.sumInv_pqr
File: Mathlib/NumberTheory/ADEInequality.lean

Proof steps:
state_before: p q r : ℕ+
⊢ sumInv {p, q, r} = (↑↑p)⁻¹ + (↑↑q)⁻¹ + (↑↑r)⁻¹
state_after: no goals
tactic: simp only [sumInv, add_zero, insert_eq_cons, add_assoc, map_cons, sum_cons,
    map_singleton, sum_singleton]
Theorem: sub_add_add_cancel
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : CommGroup G
a✝ b✝ c✝ d a b c : G
⊢ a / c * (b * c) = a * b
state_after: no goals
tactic: rw [mul_left_comm, div_mul_cancel, mul_comm]
Theorem: Complex.HadamardThreeLines.interpStrip_eq_of_mem_verticalStrip
File: Mathlib/Analysis/Complex/Hadamard.lean

Proof steps:
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ → E
z : ℂ
hz : z ∈ verticalStrip 0 1
⊢ interpStrip f z = ↑(sSupNormIm f 0) ^ (1 - z) * ↑(sSupNormIm f 1) ^ z
state_after: case pos
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ → E
z : ℂ
hz : z ∈ verticalStrip 0 1
h : sSupNormIm f 0 = 0 ∨ sSupNormIm f 1 = 0
⊢ interpStrip f z = ↑(sSupNormIm f 0) ^ (1 - z) * ↑(sSupNormIm f 1) ^ z

case neg
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ → E
z : ℂ
hz : z ∈ verticalStrip 0 1
h : ¬(sSupNormIm f 0 = 0 ∨ sSupNormIm f 1 = 0)
⊢ interpStrip f z = ↑(sSupNormIm f 0) ^ (1 - z) * ↑(sSupNormIm f 1) ^ z
tactic: by_cases h : sSupNormIm f 0 = 0 ∨ sSupNormIm f 1 = 0
Theorem: _private.Mathlib.Analysis.InnerProductSpace.OfNorm.0.InnerProductSpaceable.add_left_aux2'
File: Mathlib/Analysis/InnerProductSpace/OfNorm.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝³ : RCLike 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
x y z : E
⊢ ‖x + y + z‖ * ‖x + y + z‖ - ‖x + y - z‖ * ‖x + y - z‖ =
    ‖x + z‖ * ‖x + z‖ - ‖x - z‖ * ‖x - z‖ + (‖2 • z + y‖ * ‖2 • z + y‖ - ‖y - 2 • z‖ * ‖y - 2 • z‖) / 2
state_after: 𝕜 : Type u_1
inst✝³ : RCLike 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
x y z : E
⊢ (‖2 • x + y‖ * ‖2 • x + y‖ + ‖2 • z + y‖ * ‖2 • z + y‖) / 2 - ‖x - z‖ * ‖x - z‖ -
      ((‖2 • x + y‖ * ‖2 • x + y‖ + ‖y - 2 • z‖ * ‖y - 2 • z‖) / 2 - ‖x + z‖ * ‖x + z‖) =
    ‖x + z‖ * ‖x + z‖ - ‖x - z‖ * ‖x - z‖ + (‖2 • z + y‖ * ‖2 • z + y‖ - ‖y - 2 • z‖ * ‖y - 2 • z‖) / 2
tactic: rw [add_left_aux1, add_left_aux2]
state_before: 𝕜 : Type u_1
inst✝³ : RCLike 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
x y z : E
⊢ (‖2 • x + y‖ * ‖2 • x + y‖ + ‖2 • z + y‖ * ‖2 • z + y‖) / 2 - ‖x - z‖ * ‖x - z‖ -
      ((‖2 • x + y‖ * ‖2 • x + y‖ + ‖y - 2 • z‖ * ‖y - 2 • z‖) / 2 - ‖x + z‖ * ‖x + z‖) =
    ‖x + z‖ * ‖x + z‖ - ‖x - z‖ * ‖x - z‖ + (‖2 • z + y‖ * ‖2 • z + y‖ - ‖y - 2 • z‖ * ‖y - 2 • z‖) / 2
state_after: no goals
tactic: ring
Theorem: CategoryTheory.Pretriangulated.productTriangle.lift_hom₃
File: Mathlib/CategoryTheory/Triangulated/Basic.lean

Proof steps:
state_before: C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasShift C ℤ
T₁ T₂ T₃ : Triangle C
J : Type u_1
T : J → Triangle C
inst✝³ : HasProduct fun j => (T j).obj₁
inst✝² : HasProduct fun j => (T j).obj₂
inst✝¹ : HasProduct fun j => (T j).obj₃
inst✝ : HasProduct fun j => (shiftFunctor C 1).obj (T j).obj₁
T' : Triangle C
φ : (j : J) → T' ⟶ T j
⊢ T'.mor₃ ≫ (shiftFunctor C 1).map (Pi.lift fun j => (φ j).hom₁) =
    (Pi.lift fun j => (φ j).hom₃) ≫ (productTriangle T).mor₃
state_after: C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasShift C ℤ
T₁ T₂ T₃ : Triangle C
J : Type u_1
T : J → Triangle C
inst✝³ : HasProduct fun j => (T j).obj₁
inst✝² : HasProduct fun j => (T j).obj₂
inst✝¹ : HasProduct fun j => (T j).obj₃
inst✝ : HasProduct fun j => (shiftFunctor C 1).obj (T j).obj₁
T' : Triangle C
φ : (j : J) → T' ⟶ T j
⊢ T'.mor₃ ≫ (shiftFunctor C 1).map (Pi.lift fun j => (φ j).hom₁) =
    (Pi.lift fun j => (φ j).hom₃) ≫
      (Pi.map fun j => (T j).mor₃) ≫ inv (piComparison (shiftFunctor C 1) fun j => (T j).obj₁)
tactic: dsimp
state_before: C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasShift C ℤ
T₁ T₂ T₃ : Triangle C
J : Type u_1
T : J → Triangle C
inst✝³ : HasProduct fun j => (T j).obj₁
inst✝² : HasProduct fun j => (T j).obj₂
inst✝¹ : HasProduct fun j => (T j).obj₃
inst✝ : HasProduct fun j => (shiftFunctor C 1).obj (T j).obj₁
T' : Triangle C
φ : (j : J) → T' ⟶ T j
⊢ T'.mor₃ ≫ (shiftFunctor C 1).map (Pi.lift fun j => (φ j).hom₁) =
    (Pi.lift fun j => (φ j).hom₃) ≫
      (Pi.map fun j => (T j).mor₃) ≫ inv (piComparison (shiftFunctor C 1) fun j => (T j).obj₁)
state_after: C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasShift C ℤ
T₁ T₂ T₃ : Triangle C
J : Type u_1
T : J → Triangle C
inst✝³ : HasProduct fun j => (T j).obj₁
inst✝² : HasProduct fun j => (T j).obj₂
inst✝¹ : HasProduct fun j => (T j).obj₃
inst✝ : HasProduct fun j => (shiftFunctor C 1).obj (T j).obj₁
T' : Triangle C
φ : (j : J) → T' ⟶ T j
⊢ (T'.mor₃ ≫
      (shiftFunctor C 1).map (Pi.lift fun j => (φ j).hom₁) ≫ piComparison (shiftFunctor C 1) fun j => (T j).obj₁) =
    (Pi.lift fun j => (φ j).hom₃) ≫ Pi.map fun j => (T j).mor₃
tactic: rw [← cancel_mono (piComparison _ _), assoc, assoc, assoc, IsIso.inv_hom_id, comp_id]
state_before: C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasShift C ℤ
T₁ T₂ T₃ : Triangle C
J : Type u_1
T : J → Triangle C
inst✝³ : HasProduct fun j => (T j).obj₁
inst✝² : HasProduct fun j => (T j).obj₂
inst✝¹ : HasProduct fun j => (T j).obj₃
inst✝ : HasProduct fun j => (shiftFunctor C 1).obj (T j).obj₁
T' : Triangle C
φ : (j : J) → T' ⟶ T j
⊢ (T'.mor₃ ≫
      (shiftFunctor C 1).map (Pi.lift fun j => (φ j).hom₁) ≫ piComparison (shiftFunctor C 1) fun j => (T j).obj₁) =
    (Pi.lift fun j => (φ j).hom₃) ≫ Pi.map fun j => (T j).mor₃
state_after: no goals
tactic: aesop_cat
Theorem: Polynomial.mkDerivation_apply
File: Mathlib/Algebra/Polynomial/Derivation.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid A
inst✝² : Module R A
inst✝¹ : Module R[X] A
inst✝ : IsScalarTower R R[X] A
a : A
f : R[X]
⊢ ((mkDerivation R) a) f = derivative f • a
state_after: no goals
tactic: rfl
Theorem: integral_comp_neg_Ioi
File: Mathlib/MeasureTheory/Measure/Lebesgue/Integral.lean

Proof steps:
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
c : ℝ
f : ℝ → E
⊢ ∫ (x : ℝ) in Ioi c, f (-x) = ∫ (x : ℝ) in Iic (-c), f x
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
c : ℝ
f : ℝ → E
⊢ ∫ (x : ℝ) in Iic (-c), f (- -x) = ∫ (x : ℝ) in Iic (- - -c), f x
tactic: rw [← neg_neg c, ← integral_comp_neg_Iic]
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
c : ℝ
f : ℝ → E
⊢ ∫ (x : ℝ) in Iic (-c), f (- -x) = ∫ (x : ℝ) in Iic (- - -c), f x
state_after: no goals
tactic: simp only [neg_neg]
Theorem: Polynomial.derivative'_apply
File: Mathlib/Algebra/Polynomial/Derivation.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝ : CommSemiring R
f g : R[X]
⊢ { toFun := ⇑derivative, map_add' := ⋯, map_smul' := ⋯ } (f * g) =
    f • { toFun := ⇑derivative, map_add' := ⋯, map_smul' := ⋯ } g +
      g • { toFun := ⇑derivative, map_add' := ⋯, map_smul' := ⋯ } f
state_after: no goals
tactic: simp [mul_comm, add_comm, derivative_mul]
Theorem: max_div_div_left'
File: Mathlib/Algebra/Order/Group/MinMax.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedCommGroup α
a✝ b✝ c✝ a b c : α
⊢ max (a / b) (a / c) = a / min b c
state_after: no goals
tactic: simp only [div_eq_mul_inv, max_mul_mul_left, max_inv_inv']
Theorem: Equiv.ofLeftInverse'_eq_ofInjective
File: Mathlib/Logic/Equiv/Set.lean

Proof steps:
state_before: α✝ : Sort u
β✝ : Sort v
γ : Sort w
α : Type u_1
β : Type u_2
f : α → β
f_inv : β → α
hf : LeftInverse f_inv f
⊢ ofLeftInverse' f f_inv hf = ofInjective f ⋯
state_after: case H.a
α✝ : Sort u
β✝ : Sort v
γ : Sort w
α : Type u_1
β : Type u_2
f : α → β
f_inv : β → α
hf : LeftInverse f_inv f
x✝ : α
⊢ ↑((ofLeftInverse' f f_inv hf) x✝) = ↑((ofInjective f ⋯) x✝)
tactic: ext
state_before: case H.a
α✝ : Sort u
β✝ : Sort v
γ : Sort w
α : Type u_1
β : Type u_2
f : α → β
f_inv : β → α
hf : LeftInverse f_inv f
x✝ : α
⊢ ↑((ofLeftInverse' f f_inv hf) x✝) = ↑((ofInjective f ⋯) x✝)
state_after: no goals
tactic: simp
Theorem: List.bind_append_perm
File: Mathlib/Data/List/Perm.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a : α
l : List α
f g : α → List β
⊢ l.bind f ++ l.bind g ~ l.bind fun x => f x ++ g x
state_after: case nil
α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
f g : α → List β
⊢ [].bind f ++ [].bind g ~ [].bind fun x => f x ++ g x

case cons
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
f g : α → List β
a : α
l : List α
IH : l.bind f ++ l.bind g ~ l.bind fun x => f x ++ g x
⊢ (a :: l).bind f ++ (a :: l).bind g ~ (a :: l).bind fun x => f x ++ g x
tactic: induction' l with a l IH
state_before: case cons
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
f g : α → List β
a : α
l : List α
IH : l.bind f ++ l.bind g ~ l.bind fun x => f x ++ g x
⊢ (a :: l).bind f ++ (a :: l).bind g ~ (a :: l).bind fun x => f x ++ g x
state_after: case cons
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
f g : α → List β
a : α
l : List α
IH : l.bind f ++ l.bind g ~ l.bind fun x => f x ++ g x
⊢ f a ++ (l.bind f ++ (g a ++ l.bind g)) ~ f a ++ (g a ++ l.bind fun x => f x ++ g x)
tactic: simp only [bind_cons, append_assoc]
state_before: case cons
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
f g : α → List β
a : α
l : List α
IH : l.bind f ++ l.bind g ~ l.bind fun x => f x ++ g x
⊢ f a ++ (l.bind f ++ (g a ++ l.bind g)) ~ f a ++ (g a ++ l.bind fun x => f x ++ g x)
state_after: case cons
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
f g : α → List β
a : α
l : List α
IH : l.bind f ++ l.bind g ~ l.bind fun x => f x ++ g x
⊢ l.bind f ++ (g a ++ l.bind g) ~ g a ++ (l.bind f ++ l.bind g)
tactic: refine (Perm.trans ?_ (IH.append_left _)).append_left _
state_before: case cons
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
f g : α → List β
a : α
l : List α
IH : l.bind f ++ l.bind g ~ l.bind fun x => f x ++ g x
⊢ l.bind f ++ (g a ++ l.bind g) ~ g a ++ (l.bind f ++ l.bind g)
state_after: case cons
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
f g : α → List β
a : α
l : List α
IH : l.bind f ++ l.bind g ~ l.bind fun x => f x ++ g x
⊢ l.bind f ++ g a ++ l.bind g ~ g a ++ l.bind f ++ l.bind g
tactic: rw [← append_assoc, ← append_assoc]
state_before: case cons
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
f g : α → List β
a : α
l : List α
IH : l.bind f ++ l.bind g ~ l.bind fun x => f x ++ g x
⊢ l.bind f ++ g a ++ l.bind g ~ g a ++ l.bind f ++ l.bind g
state_after: no goals
tactic: exact perm_append_comm.append_right _
Theorem: Stream'.WSeq.mem_of_mem_tail
File: Mathlib/Data/Seq/WSeq.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
a : α
⊢ a ∈ s.tail → a ∈ s
state_after: α : Type u
β : Type v
γ : Type w
s : WSeq α
a : α
h : a ∈ s.tail
⊢ a ∈ s
tactic: intro h
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
a : α
h : a ∈ s.tail
⊢ a ∈ s
state_after: α : Type u
β : Type v
γ : Type w
s : WSeq α
a : α
h this : a ∈ s.tail
⊢ a ∈ s
tactic: have := h
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
a : α
h this : a ∈ s.tail
⊢ a ∈ s
state_after: case intro
α : Type u
β : Type v
γ : Type w
s : WSeq α
a : α
this : a ∈ s.tail
n : ℕ
e : (fun b => some (some a) = b) ((↑s.tail).get n)
⊢ a ∈ s
tactic: cases' h with n e
state_before: case intro
α : Type u
β : Type v
γ : Type w
s : WSeq α
a : α
this : a ∈ s.tail
n : ℕ
e : (fun b => some (some a) = b) ((↑s.tail).get n)
⊢ a ∈ s
state_after: case intro
α : Type u
β : Type v
γ : Type w
a : α
n : ℕ
⊢ ∀ {s : WSeq α}, a ∈ s.tail → (fun b => some (some a) = b) ((↑s.tail).get n) → a ∈ s
tactic: revert s
state_before: case intro
α : Type u
β : Type v
γ : Type w
a : α
n : ℕ
⊢ ∀ {s : WSeq α}, a ∈ s.tail → (fun b => some (some a) = b) ((↑s.tail).get n) → a ∈ s
state_after: case intro
α : Type u
β : Type v
γ : Type w
a : α
n : ℕ
⊢ ∀ {s : WSeq α}, a ∈ s.tail → some (some a) = ↑s.tail n → a ∈ s
tactic: simp only [Stream'.get]
state_before: case intro
α : Type u
β : Type v
γ : Type w
a : α
n : ℕ
⊢ ∀ {s : WSeq α}, a ∈ s.tail → some (some a) = ↑s.tail n → a ∈ s
state_after: case intro.zero.h2
α : Type u
β : Type v
γ : Type w
a x : α
s : WSeq α
m : a ∈ s
e : some (some a) = ↑s 0
⊢ a = x ∨ a ∈ s

case intro.succ.h2
α : Type u
β : Type v
γ : Type w
a : α
n : ℕ
IH : ∀ {s : WSeq α}, a ∈ s.tail → some (some a) = ↑s.tail n → a ∈ s
x : α
s : WSeq α
m : a ∈ s
e : some (some a) = ↑s (n + 1)
⊢ a = x ∨ a ∈ s

case intro.succ.h3
α : Type u
β : Type v
γ : Type w
a : α
n : ℕ
IH : ∀ {s : WSeq α}, a ∈ s.tail → some (some a) = ↑s.tail n → a ∈ s
s : WSeq α
m : a ∈ s.tail
e : some (some a) = ↑s.tail.think (n + 1)
⊢ a ∈ s
tactic: induction' n with n IH <;> intro s <;> induction' s using WSeq.recOn with x s s <;>
    simp <;> intro m e <;>
    injections
Theorem: Polynomial.Chebyshev.aeval_T
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Chebyshev.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing A
inst✝ : Algebra R A
x : A
n : ℤ
⊢ (aeval x) (T R n) = eval x (T A n)
state_after: no goals
tactic: rw [aeval_def, eval₂_eq_eval_map, map_T]
Theorem: Ideal.ideal_prod_prime
File: Mathlib/RingTheory/Ideal/Prod.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝¹ : Semiring R
inst✝ : Semiring S
I✝ I' : Ideal R
J J' : Ideal S
I : Ideal (R × S)
⊢ I.IsPrime ↔ (∃ p, p.IsPrime ∧ I = p.prod ⊤) ∨ ∃ p, p.IsPrime ∧ I = ⊤.prod p
state_after: case mp
R : Type u
S : Type v
inst✝¹ : Semiring R
inst✝ : Semiring S
I✝ I' : Ideal R
J J' : Ideal S
I : Ideal (R × S)
⊢ I.IsPrime → (∃ p, p.IsPrime ∧ I = p.prod ⊤) ∨ ∃ p, p.IsPrime ∧ I = ⊤.prod p

case mpr
R : Type u
S : Type v
inst✝¹ : Semiring R
inst✝ : Semiring S
I✝ I' : Ideal R
J J' : Ideal S
I : Ideal (R × S)
⊢ ((∃ p, p.IsPrime ∧ I = p.prod ⊤) ∨ ∃ p, p.IsPrime ∧ I = ⊤.prod p) → I.IsPrime
tactic: constructor
Theorem: orderOf_pow_orderOf_div
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 : ℕ
x : G
n : ℕ
hx : orderOf x ≠ 0
hn : n ∣ orderOf x
⊢ orderOf (x ^ (orderOf x / n)) = n
state_after: 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 : ℕ
x : G
n : ℕ
hx : orderOf x ≠ 0
hn : n ∣ orderOf x
⊢ orderOf x / n ≠ 0
tactic: rw [orderOf_pow_of_dvd _ (Nat.div_dvd_of_dvd hn), Nat.div_div_self hn hx]
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 : ℕ
x : G
n : ℕ
hx : orderOf x ≠ 0
hn : n ∣ orderOf x
⊢ orderOf x / n ≠ 0
state_after: 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 : ℕ
x : G
n : ℕ
hx : orderOf x / n * n ≠ 0
hn : n ∣ orderOf x
⊢ orderOf x / n ≠ 0
tactic: rw [← Nat.div_mul_cancel hn] at hx
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 : ℕ
x : G
n : ℕ
hx : orderOf x / n * n ≠ 0
hn : n ∣ orderOf x
⊢ orderOf x / n ≠ 0
state_after: no goals
tactic: exact left_ne_zero_of_mul hx
Theorem: CategoryTheory.Limits.biprod.desc_eq
File: Mathlib/CategoryTheory/Preadditive/Biproducts.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Preadditive C
X Y : C
inst✝ : HasBinaryBiproduct X Y
T : C
f : X ⟶ T
g : Y ⟶ T
⊢ desc f g = fst ≫ f + snd ≫ g
state_after: no goals
tactic: ext <;> simp [add_comp]
Theorem: add_eq_left_iff_le
File: Mathlib/Algebra/Order/Kleene.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
π : ι → Type u_4
inst✝ : IdemSemiring α
a b c : α
⊢ a + b = a ↔ b ≤ a
state_after: no goals
tactic: simp