ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: List.Nat.nodup_antidiagonalTuple
File: Mathlib/Data/Fin/Tuple/NatAntidiagonal.lean

Proof steps:
state_before: k n : ℕ
⊢ (antidiagonalTuple k n).Nodup
state_after: case zero
n : ℕ
⊢ (antidiagonalTuple 0 n).Nodup

case succ
k : ℕ
ih : ∀ (n : ℕ), (antidiagonalTuple k n).Nodup
n : ℕ
⊢ (antidiagonalTuple (k + 1) n).Nodup
tactic: induction' k with k ih generalizing n
state_before: case succ
k : ℕ
ih : ∀ (n : ℕ), (antidiagonalTuple k n).Nodup
n : ℕ
⊢ (antidiagonalTuple (k + 1) n).Nodup
state_after: case succ
k : ℕ
ih : ∀ (n : ℕ), (antidiagonalTuple k n).Nodup
n : ℕ
⊢ (∀ x ∈ antidiagonal n, (map (fun x_1 => Fin.cons x.1 x_1) (antidiagonalTuple k x.2)).Nodup) ∧
    Pairwise
      (fun a b =>
        (map (fun x => Fin.cons a.1 x) (antidiagonalTuple k a.2)).Disjoint
          (map (fun x => Fin.cons b.1 x) (antidiagonalTuple k b.2)))
      (antidiagonal n)
tactic: simp_rw [antidiagonalTuple, List.nodup_bind]
state_before: case succ
k : ℕ
ih : ∀ (n : ℕ), (antidiagonalTuple k n).Nodup
n : ℕ
⊢ (∀ x ∈ antidiagonal n, (map (fun x_1 => Fin.cons x.1 x_1) (antidiagonalTuple k x.2)).Nodup) ∧
    Pairwise
      (fun a b =>
        (map (fun x => Fin.cons a.1 x) (antidiagonalTuple k a.2)).Disjoint
          (map (fun x => Fin.cons b.1 x) (antidiagonalTuple k b.2)))
      (antidiagonal n)
state_after: case succ.left
k : ℕ
ih : ∀ (n : ℕ), (antidiagonalTuple k n).Nodup
n : ℕ
⊢ ∀ x ∈ antidiagonal n, (map (fun x_1 => Fin.cons x.1 x_1) (antidiagonalTuple k x.2)).Nodup

case succ.right
k : ℕ
ih : ∀ (n : ℕ), (antidiagonalTuple k n).Nodup
n : ℕ
⊢ Pairwise
    (fun a b =>
      (map (fun x => Fin.cons a.1 x) (antidiagonalTuple k a.2)).Disjoint
        (map (fun x => Fin.cons b.1 x) (antidiagonalTuple k b.2)))
    (antidiagonal n)
tactic: constructor
state_before: case succ.right
k : ℕ
ih : ∀ (n : ℕ), (antidiagonalTuple k n).Nodup
n : ℕ
⊢ Pairwise
    (fun a b =>
      (map (fun x => Fin.cons a.1 x) (antidiagonalTuple k a.2)).Disjoint
        (map (fun x => Fin.cons b.1 x) (antidiagonalTuple k b.2)))
    (antidiagonal n)
state_after: case succ.right.zero
k : ℕ
ih : ∀ (n : ℕ), (antidiagonalTuple k n).Nodup
⊢ Pairwise
    (fun a b =>
      (map (fun x => Fin.cons a.1 x) (antidiagonalTuple k a.2)).Disjoint
        (map (fun x => Fin.cons b.1 x) (antidiagonalTuple k b.2)))
    (antidiagonal 0)

case succ.right.succ
k : ℕ
ih : ∀ (n : ℕ), (antidiagonalTuple k n).Nodup
n : ℕ
n_ih :
  Pairwise
    (fun a b =>
      (map (fun x => Fin.cons a.1 x) (antidiagonalTuple k a.2)).Disjoint
        (map (fun x => Fin.cons b.1 x) (antidiagonalTuple k b.2)))
    (antidiagonal n)
⊢ Pairwise
    (fun a b =>
      (map (fun x => Fin.cons a.1 x) (antidiagonalTuple k a.2)).Disjoint
        (map (fun x => Fin.cons b.1 x) (antidiagonalTuple k b.2)))
    (antidiagonal (n + 1))
tactic: induction' n with n n_ih
Theorem: inseparable_iff_mem_closure
File: Mathlib/Topology/Inseparable.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x y z : X
s : Set X
f g : X → Y
⊢ x ⤳ y ∧ y ⤳ x ↔ x ∈ closure {y} ∧ y ∈ closure {x}
state_after: no goals
tactic: simp only [specializes_iff_mem_closure, and_comm]
Theorem: Subsemigroup.coe_iInf
File: Mathlib/Algebra/Group/Subsemigroup/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
A : Type u_3
inst✝¹ : Mul M
s : Set M
inst✝ : Add A
t : Set A
S✝ : Subsemigroup M
ι : Sort u_4
S : ι → Subsemigroup M
⊢ ↑(⨅ i, S i) = ⋂ i, ↑(S i)
state_after: no goals
tactic: simp only [iInf, coe_sInf, Set.biInter_range]
Theorem: LieIdeal.map_lowerCentralSeries_le
File: Mathlib/Algebra/Lie/Nilpotent.lean

Proof steps:
state_before: R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
k : ℕ
f : L →ₗ⁅R⁆ L'
⊢ map f (lowerCentralSeries R L L k) ≤ lowerCentralSeries R L' L' k
state_after: case zero
R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
f : L →ₗ⁅R⁆ L'
⊢ map f (lowerCentralSeries R L L 0) ≤ lowerCentralSeries R L' L' 0

case succ
R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
f : L →ₗ⁅R⁆ L'
k : ℕ
ih : map f (lowerCentralSeries R L L k) ≤ lowerCentralSeries R L' L' k
⊢ map f (lowerCentralSeries R L L (k + 1)) ≤ lowerCentralSeries R L' L' (k + 1)
tactic: induction' k with k ih
Theorem: List.pairwise_ofFn
File: Mathlib/Data/List/OfFn.lean

Proof steps:
state_before: α : Type u
R : α → α → Prop
n : ℕ
f : Fin n → α
⊢ Pairwise R (ofFn f) ↔ ∀ ⦃i j : Fin n⦄, i < j → R (f i) (f j)
state_after: no goals
tactic: simp only [pairwise_iff_get, (Fin.rightInverse_cast (length_ofFn f)).surjective.forall, get_ofFn,
    ← Fin.not_le, Fin.cast_le_cast]
Theorem: MeasureTheory.SignedMeasure.singularPart_totalVariation
File: Mathlib/MeasureTheory/Decomposition/SignedLebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s : SignedMeasure α
μ : Measure α
⊢ (s.singularPart μ).totalVariation =
    s.toJordanDecomposition.posPart.singularPart μ + s.toJordanDecomposition.negPart.singularPart μ
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s : SignedMeasure α
μ : Measure α
this :
  (s.singularPart μ).toJordanDecomposition =
    JordanDecomposition.mk (s.toJordanDecomposition.posPart.singularPart μ)
      (s.toJordanDecomposition.negPart.singularPart μ) ⋯
⊢ (s.singularPart μ).totalVariation =
    s.toJordanDecomposition.posPart.singularPart μ + s.toJordanDecomposition.negPart.singularPart μ
tactic: have :
    (s.singularPart μ).toJordanDecomposition =
      ⟨s.toJordanDecomposition.posPart.singularPart μ,
        s.toJordanDecomposition.negPart.singularPart μ, singularPart_mutuallySingular s μ⟩ := by
    refine JordanDecomposition.toSignedMeasure_injective ?_
    rw [toSignedMeasure_toJordanDecomposition, singularPart, JordanDecomposition.toSignedMeasure]
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s : SignedMeasure α
μ : Measure α
this :
  (s.singularPart μ).toJordanDecomposition =
    JordanDecomposition.mk (s.toJordanDecomposition.posPart.singularPart μ)
      (s.toJordanDecomposition.negPart.singularPart μ) ⋯
⊢ (s.singularPart μ).totalVariation =
    s.toJordanDecomposition.posPart.singularPart μ + s.toJordanDecomposition.negPart.singularPart μ
state_after: no goals
tactic: rw [totalVariation, this]
Theorem: iteratedFDerivWithin_eq_equiv_comp
File: Mathlib/Analysis/Calculus/IteratedDeriv/Defs.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n : ℕ
f : 𝕜 → F
s : Set 𝕜
x : 𝕜
⊢ iteratedFDerivWithin 𝕜 n f s = ⇑(ContinuousMultilinearMap.piFieldEquiv 𝕜 (Fin n) F) ∘ iteratedDerivWithin n f s
state_after: no goals
tactic: rw [iteratedDerivWithin_eq_equiv_comp, ← Function.comp.assoc, LinearIsometryEquiv.self_comp_symm,
    Function.id_comp]
Theorem: CategoryTheory.Pretriangulated.distinguished_cocone_triangle₁
File: Mathlib/CategoryTheory/Triangulated/Pretriangulated.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : Preadditive C
inst✝ : ∀ (n : ℤ), (shiftFunctor C n).Additive
hC : Pretriangulated C
Y Z : C
g : Y ⟶ Z
⊢ ∃ X f h, Triangle.mk f g h ∈ distinguishedTriangles
state_after: case intro.intro.intro
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : Preadditive C
inst✝ : ∀ (n : ℤ), (shiftFunctor C n).Additive
hC : Pretriangulated C
Y Z : C
g : Y ⟶ Z
X' : C
f' : Z ⟶ X'
g' : X' ⟶ (shiftFunctor C 1).obj Y
mem : Triangle.mk g f' g' ∈ distinguishedTriangles
⊢ ∃ X f h, Triangle.mk f g h ∈ distinguishedTriangles
tactic: obtain ⟨X', f', g', mem⟩ := distinguished_cocone_triangle g
state_before: case intro.intro.intro
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : Preadditive C
inst✝ : ∀ (n : ℤ), (shiftFunctor C n).Additive
hC : Pretriangulated C
Y Z : C
g : Y ⟶ Z
X' : C
f' : Z ⟶ X'
g' : X' ⟶ (shiftFunctor C 1).obj Y
mem : Triangle.mk g f' g' ∈ distinguishedTriangles
⊢ ∃ X f h, Triangle.mk f g h ∈ distinguishedTriangles
state_after: no goals
tactic: exact ⟨_, _, _, inv_rot_of_distTriang _ mem⟩
Theorem: Pretrivialization.symmₗ_apply
File: Mathlib/Topology/VectorBundle/Basic.lean

Proof steps:
state_before: R : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
inst✝⁷ : Semiring R
inst✝⁶ : TopologicalSpace F
inst✝⁵ : TopologicalSpace B
e✝ : Pretrivialization F TotalSpace.proj
x : TotalSpace F E
b✝ : B
y : E b✝
inst✝⁴ : AddCommMonoid F
inst✝³ : Module R F
inst✝² : (x : B) → AddCommMonoid (E x)
inst✝¹ : (x : B) → Module R (E x)
e : Pretrivialization F TotalSpace.proj
inst✝ : Pretrivialization.IsLinear R e
b : B
⊢ F →ₗ[R] E b
state_after: R : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
inst✝⁷ : Semiring R
inst✝⁶ : TopologicalSpace F
inst✝⁵ : TopologicalSpace B
e✝ : Pretrivialization F TotalSpace.proj
x : TotalSpace F E
b✝ : B
y : E b✝
inst✝⁴ : AddCommMonoid F
inst✝³ : Module R F
inst✝² : (x : B) → AddCommMonoid (E x)
inst✝¹ : (x : B) → Module R (E x)
e : Pretrivialization F TotalSpace.proj
inst✝ : Pretrivialization.IsLinear R e
b : B
⊢ IsLinearMap R (e.symm b)
tactic: refine IsLinearMap.mk' (e.symm b) ?_
state_before: R : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
inst✝⁷ : Semiring R
inst✝⁶ : TopologicalSpace F
inst✝⁵ : TopologicalSpace B
e✝ : Pretrivialization F TotalSpace.proj
x : TotalSpace F E
b✝ : B
y : E b✝
inst✝⁴ : AddCommMonoid F
inst✝³ : Module R F
inst✝² : (x : B) → AddCommMonoid (E x)
inst✝¹ : (x : B) → Module R (E x)
e : Pretrivialization F TotalSpace.proj
inst✝ : Pretrivialization.IsLinear R e
b : B
⊢ IsLinearMap R (e.symm b)
state_after: case pos
R : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
inst✝⁷ : Semiring R
inst✝⁶ : TopologicalSpace F
inst✝⁵ : TopologicalSpace B
e✝ : Pretrivialization F TotalSpace.proj
x : TotalSpace F E
b✝ : B
y : E b✝
inst✝⁴ : AddCommMonoid F
inst✝³ : Module R F
inst✝² : (x : B) → AddCommMonoid (E x)
inst✝¹ : (x : B) → Module R (E x)
e : Pretrivialization F TotalSpace.proj
inst✝ : Pretrivialization.IsLinear R e
b : B
hb : b ∈ e.baseSet
⊢ IsLinearMap R (e.symm b)

case neg
R : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
inst✝⁷ : Semiring R
inst✝⁶ : TopologicalSpace F
inst✝⁵ : TopologicalSpace B
e✝ : Pretrivialization F TotalSpace.proj
x : TotalSpace F E
b✝ : B
y : E b✝
inst✝⁴ : AddCommMonoid F
inst✝³ : Module R F
inst✝² : (x : B) → AddCommMonoid (E x)
inst✝¹ : (x : B) → Module R (E x)
e : Pretrivialization F TotalSpace.proj
inst✝ : Pretrivialization.IsLinear R e
b : B
hb : b ∉ e.baseSet
⊢ IsLinearMap R (e.symm b)
tactic: by_cases hb : b ∈ e.baseSet
Theorem: Complex.lift_apply
File: Mathlib/Data/Complex/Module.lean

Proof steps:
state_before: A : Type u_1
inst✝¹ : Ring A
inst✝ : Algebra ℝ A
F : ℂ →ₐ[ℝ] A
⊢ F I * F I = -1
state_after: no goals
tactic: rw [← map_mul, I_mul_I, map_neg, map_one]
Theorem: Matrix.empty_vecAppend
File: Mathlib/Data/Fin/VecNotation.lean

Proof steps:
state_before: α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin n → α
⊢ vecAppend ⋯ ![] v = v
state_after: case h
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin n → α
x✝ : Fin n
⊢ vecAppend ⋯ ![] v x✝ = v x✝
tactic: ext
state_before: case h
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin n → α
x✝ : Fin n
⊢ vecAppend ⋯ ![] v x✝ = v x✝
state_after: no goals
tactic: simp [vecAppend_eq_ite]
Theorem: Multiset.sum_eq_zero_iff
File: Mathlib/Algebra/Order/BigOperators/Group/Multiset.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : CanonicallyOrderedCommMonoid α
m : Multiset α
a : α
l : List α
⊢ prod ⟦l⟧ = 1 ↔ ∀ x ∈ ⟦l⟧, x = 1
state_after: no goals
tactic: simpa using List.prod_eq_one_iff
Theorem: List.zipLeft'_nil_right
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a : α
as : List α
b : β
bs : List β
⊢ as.zipLeft' [] = (map (fun a => (a, none)) as, [])
state_after: no goals
tactic: cases as <;> rfl
Theorem: MeasureTheory.stoppedProcess_eq'
File: Mathlib/Probability/Process/Stopping.lean

Proof steps:
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
f : Filtration ℕ m
u : ℕ → Ω → β
τ π : Ω → ℕ
inst✝ : AddCommMonoid β
n : ℕ
this : {a | n ≤ τ a}.indicator (u n) = {a | n + 1 ≤ τ a}.indicator (u n) + {a | τ a = n}.indicator (u n)
⊢ stoppedProcess u τ n = {a | n + 1 ≤ τ a}.indicator (u n) + ∑ i ∈ Finset.range (n + 1), {a | τ a = i}.indicator (u i)
state_after: no goals
tactic: rw [stoppedProcess_eq, this, Finset.sum_range_succ_comm, ← add_assoc]
Theorem: inner_lt_one_iff_real_of_norm_one
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 : F
hx : ‖x‖ = 1
hy : ‖y‖ = 1
⊢ ⟪x, y⟫_ℝ < 1 ↔ x ≠ y
state_after: no goals
tactic: convert inner_lt_norm_mul_iff_real (F := F) <;> simp [hx, hy]
Theorem: PosNum.cmp_swap
File: Mathlib/Data/Num/Lemmas.lean

Proof steps:
state_before: α : Type u_1
m : PosNum
⊢ ∀ (n : PosNum), (m.cmp n).swap = n.cmp m
state_after: no goals
tactic: induction' m with m IH m IH <;> intro n <;> cases' n with n n <;> unfold cmp <;>
    try { rfl } <;> rw [← IH] <;> cases cmp m n <;> rfl
Theorem: _private.Mathlib.Algebra.Order.UpperLower.0.LowerSet.zero_add
File: Mathlib/Algebra/Order/UpperLower.lean

Proof steps:
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
s✝ t : Set α
a : α
s : LowerSet α
⊢ Set.Iic 1 * ↑s ⊆ ↑s
state_after: α : Type u_1
inst✝ : OrderedCommGroup α
s✝ t : Set α
a : α
s : LowerSet α
⊢ ⋃ a ∈ Set.Iic 1, a • ↑s ⊆ ↑s
tactic: rw [← smul_eq_mul, ← Set.iUnion_smul_set]
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
s✝ t : Set α
a : α
s : LowerSet α
⊢ ⋃ a ∈ Set.Iic 1, a • ↑s ⊆ ↑s
state_after: no goals
tactic: exact Set.iUnion₂_subset fun _ ↦ s.lower.smul_subset
Theorem: Set.piecewise_same
File: Mathlib/Data/Set/Function.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
δ : α → Sort u_6
s : Set α
f g : (i : α) → δ i
inst✝ : (j : α) → Decidable (j ∈ s)
⊢ s.piecewise f f = f
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
δ : α → Sort u_6
s : Set α
f g : (i : α) → δ i
inst✝ : (j : α) → Decidable (j ∈ s)
x : α
⊢ s.piecewise f f x = f x
tactic: ext x
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
δ : α → Sort u_6
s : Set α
f g : (i : α) → δ i
inst✝ : (j : α) → Decidable (j ∈ s)
x : α
⊢ s.piecewise f f x = f x
state_after: no goals
tactic: by_cases hx : x ∈ s <;> simp [hx]
Theorem: CategoryTheory.shift_shiftFunctorCompIsoId_hom_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).hom.app X) =
    (shiftFunctorCompIsoId C m n ⋯).hom.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).map ((shiftFunctorAdd' C n m 0 h).inv.app X ≫ (shiftFunctorZero C A).hom.app X) =
    (shiftFunctorAdd' C m n 0 ⋯).inv.app ((shiftFunctor C n).obj X) ≫
      (shiftFunctorZero C A).hom.app ((shiftFunctor C n).obj X)
tactic: dsimp [shiftFunctorCompIsoId]
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 ((shiftFunctorAdd' C n m 0 h).inv.app X ≫ (shiftFunctorZero C A).hom.app X) =
    (shiftFunctorAdd' C m n 0 ⋯).inv.app ((shiftFunctor C n).obj X) ≫
      (shiftFunctorZero C A).hom.app ((shiftFunctor C n).obj X)
state_after: no goals
tactic: simpa only [Functor.map_comp, ← shiftFunctorAdd'_zero_add_inv_app n X,
    ← shiftFunctorAdd'_add_zero_inv_app n X]
    using shiftFunctorAdd'_assoc_inv_app n m n 0 0 n h
      (by rw [← neg_eq_of_add_eq_zero_left h, add_right_neg]) (by rw [h, zero_add]) X
Theorem: Rat.MulRingNorm.eq_on_nat_iff_eq
File: Mathlib/NumberTheory/Ostrowski.lean

Proof steps:
state_before: f g : MulRingNorm ℚ
⊢ (∀ (n : ℕ), f ↑n = g ↑n) ↔ f = g
state_after: f g : MulRingNorm ℚ
h : ∀ (n : ℕ), f ↑n = g ↑n
⊢ f = g
tactic: refine ⟨fun h ↦ ?_, fun h n ↦ congrFun (congrArg DFunLike.coe h) ↑n⟩
state_before: f g : MulRingNorm ℚ
h : ∀ (n : ℕ), f ↑n = g ↑n
⊢ f = g
state_after: case a
f g : MulRingNorm ℚ
h : ∀ (n : ℕ), f ↑n = g ↑n
z : ℚ
⊢ f z = g z
tactic: ext z
state_before: case a
f g : MulRingNorm ℚ
h : ∀ (n : ℕ), f ↑n = g ↑n
z : ℚ
⊢ f z = g z
state_after: no goals
tactic: rw [← Rat.num_div_den z, map_div₀, map_div₀, h, eq_on_nat_iff_eq_on_Int.mp h]
Theorem: MeasureTheory.SimpleFunc.finset_sup_apply
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : MeasurableSpace α
K : Type u_5
inst✝¹ : SemilatticeSup β
inst✝ : OrderBot β
f : γ → α →ₛ β
s : Finset γ
a : α
⊢ ↑(s.sup f) a = s.sup fun c => ↑(f c) a
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : MeasurableSpace α
K : Type u_5
inst✝¹ : SemilatticeSup β
inst✝ : OrderBot β
f : γ → α →ₛ β
s : Finset γ
a : α
⊢ ∀ ⦃a_1 : γ⦄ {s : Finset γ},
    a_1 ∉ s →
      (↑(s.sup f) a = s.sup fun c => ↑(f c) a) → ↑((insert a_1 s).sup f) a = (insert a_1 s).sup fun c => ↑(f c) a
tactic: refine Finset.induction_on s rfl ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : MeasurableSpace α
K : Type u_5
inst✝¹ : SemilatticeSup β
inst✝ : OrderBot β
f : γ → α →ₛ β
s : Finset γ
a : α
⊢ ∀ ⦃a_1 : γ⦄ {s : Finset γ},
    a_1 ∉ s →
      (↑(s.sup f) a = s.sup fun c => ↑(f c) a) → ↑((insert a_1 s).sup f) a = (insert a_1 s).sup fun c => ↑(f c) a
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : MeasurableSpace α
K : Type u_5
inst✝¹ : SemilatticeSup β
inst✝ : OrderBot β
f : γ → α →ₛ β
s✝ : Finset γ
a✝¹ : α
a : γ
s : Finset γ
a✝ : a ∉ s
ih : ↑(s.sup f) a✝¹ = s.sup fun c => ↑(f c) a✝¹
⊢ ↑((insert a s).sup f) a✝¹ = (insert a s).sup fun c => ↑(f c) a✝¹
tactic: intro a s _ ih
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : MeasurableSpace α
K : Type u_5
inst✝¹ : SemilatticeSup β
inst✝ : OrderBot β
f : γ → α →ₛ β
s✝ : Finset γ
a✝¹ : α
a : γ
s : Finset γ
a✝ : a ∉ s
ih : ↑(s.sup f) a✝¹ = s.sup fun c => ↑(f c) a✝¹
⊢ ↑((insert a s).sup f) a✝¹ = (insert a s).sup fun c => ↑(f c) a✝¹
state_after: no goals
tactic: rw [Finset.sup_insert, Finset.sup_insert, sup_apply, ih]
Theorem: iSup₂_eq_bot
File: Mathlib/Order/CompleteLattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : (i : ι) → κ i → α
⊢ ⨆ i, ⨆ j, f i j = ⊥ ↔ ∀ (i : ι) (j : κ i), f i j = ⊥
state_after: no goals
tactic: simp
Theorem: MeasureTheory.pdf.IsUniform.cond
File: Mathlib/Probability/Distributions/Uniform.lean

Proof steps:
state_before: E : Type u_1
inst✝ : MeasurableSpace E
m μ : Measure E
Ω : Type u_2
x✝ : MeasurableSpace Ω
ℙ : Measure Ω
X : Ω → E
s : Set E
⊢ IsUniform id s (ProbabilityTheory.cond μ s) μ
state_after: E : Type u_1
inst✝ : MeasurableSpace E
m μ : Measure E
Ω : Type u_2
x✝ : MeasurableSpace Ω
ℙ : Measure Ω
X : Ω → E
s : Set E
⊢ Measure.map id (ProbabilityTheory.cond μ s) = ProbabilityTheory.cond μ s
tactic: unfold IsUniform
state_before: E : Type u_1
inst✝ : MeasurableSpace E
m μ : Measure E
Ω : Type u_2
x✝ : MeasurableSpace Ω
ℙ : Measure Ω
X : Ω → E
s : Set E
⊢ Measure.map id (ProbabilityTheory.cond μ s) = ProbabilityTheory.cond μ s
state_after: no goals
tactic: rw [Measure.map_id]
Theorem: continuousOn_multiset_sum
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 : ι → X → M
s : Multiset ι
t : Set X
⊢ (∀ i ∈ s, ContinuousOn (f i) t) → ContinuousOn (fun a => (Multiset.map (fun i => f i a) s).prod) t
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 : ι → X → M
s : Multiset ι
t : Set X
l : List ι
⊢ (∀ i ∈ Quot.mk Setoid.r l, ContinuousOn (f i) t) →
    ContinuousOn (fun a => (Multiset.map (fun i => f i a) (Quot.mk Setoid.r l)).prod) t
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 : ι → X → M
s : Multiset ι
t : Set X
l : List ι
⊢ (∀ i ∈ Quot.mk Setoid.r l, ContinuousOn (f i) t) →
    ContinuousOn (fun a => (Multiset.map (fun i => f i a) (Quot.mk Setoid.r l)).prod) t
state_after: no goals
tactic: simpa using continuousOn_list_prod l
Theorem: div_right_comm
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✝ : DivisionCommMonoid α
a b c d : α
⊢ a / b / c = a / c / b
state_after: no goals
tactic: simp
Theorem: basis_finite_of_finite_spans
File: Mathlib/LinearAlgebra/Basis.lean

Proof steps:
state_before: ι✝¹ : Type u_1
ι' : Type u_2
R✝ : Type u_3
R₂ : Type u_4
K : Type u_5
M✝ : Type u_6
M'✝ : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
R : Type u
M M₁ : Type v
M' : Type v'
ι✝ : Type w
inst✝⁷ : Ring R
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : AddCommGroup M₁
inst✝³ : Nontrivial R
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M₁
w : Set M
hw : w.Finite
s : span R w = ⊤
ι : Type w
b : Basis ι R M
⊢ Finite ι
state_after: no goals
tactic: classical
  haveI := hw.to_subtype
  cases nonempty_fintype w
  -- We'll work by contradiction, assuming `ι` is infinite.
  rw [← not_infinite_iff_finite]
  intro i
  -- Let `S` be the union of the supports of `x ∈ w` expressed as linear combinations of `b`.
  -- This is a finite set since `w` is finite.
  let S : Finset ι := Finset.univ.sup fun x : w => (b.repr x).support
  let bS : Set M := b '' S
  have h : ∀ x ∈ w, x ∈ span R bS := by
    intro x m
    rw [← b.total_repr x, Finsupp.span_image_eq_map_total, Submodule.mem_map]
    use b.repr x
    simp only [and_true_iff, eq_self_iff_true, Finsupp.mem_supported]
    rw [Finset.coe_subset, ← Finset.le_iff_subset]
    exact Finset.le_sup (f := fun x : w ↦ (b.repr ↑x).support) (Finset.mem_univ (⟨x, m⟩ : w))
  -- Thus this finite subset of the basis elements spans the entire module.
  have k : span R bS = ⊤ := eq_top_iff.2 (le_trans s.ge (span_le.2 h))
  -- Now there is some `x : ι` not in `S`, since `ι` is infinite.
  obtain ⟨x, nm⟩ := Infinite.exists_not_mem_finset S
  -- However it must be in the span of the finite subset,
  have k' : b x ∈ span R bS := by
    rw [k]
    exact mem_top
  -- giving the desire contradiction.
  exact b.linearIndependent.not_mem_span_image nm k'
Theorem: CategoryTheory.Mat_.id_apply_self
File: Mathlib/CategoryTheory/Preadditive/Mat.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Preadditive C
M : Mat_ C
i : M.ι
⊢ 𝟙 M i i = 𝟙 (M.X i)
state_after: no goals
tactic: simp [id_apply]