ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.Functor.mono_map_iff_mono
File: Mathlib/CategoryTheory/Functor/EpiMono.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F : C ⥤ D
X Y : C
f : X ⟶ Y
hF₁ : F.PreservesMonomorphisms
hF₂ : F.ReflectsMonomorphisms
⊢ Mono (F.map f) ↔ Mono f
state_after: case mp
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F : C ⥤ D
X Y : C
f : X ⟶ Y
hF₁ : F.PreservesMonomorphisms
hF₂ : F.ReflectsMonomorphisms
⊢ Mono (F.map f) → Mono f

case mpr
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F : C ⥤ D
X Y : C
f : X ⟶ Y
hF₁ : F.PreservesMonomorphisms
hF₂ : F.ReflectsMonomorphisms
⊢ Mono f → Mono (F.map f)
tactic: constructor
Theorem: CategoryTheory.Functor.punit_ext'
File: Mathlib/CategoryTheory/PUnit.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
F G : C ⥤ Discrete PUnit.{w + 1}
X : C
⊢ F.obj X = G.obj X
state_after: no goals
tactic: simp only [eq_iff_true_of_subsingleton]
Theorem: Nat.coprime_pow_left_iff
File: Mathlib/Data/Nat/GCD/Basic.lean

Proof steps:
state_before: n : ℕ
hn : 0 < n
a b : ℕ
⊢ (a ^ n).Coprime b ↔ a.Coprime b
state_after: case intro
a b n : ℕ
hn : 0 < n.succ
⊢ (a ^ n.succ).Coprime b ↔ a.Coprime b
tactic: obtain ⟨n, rfl⟩ := exists_eq_succ_of_ne_zero hn.ne'
state_before: case intro
a b n : ℕ
hn : 0 < n.succ
⊢ (a ^ n.succ).Coprime b ↔ a.Coprime b
state_after: case intro
a b n : ℕ
hn : 0 < n.succ
⊢ (a ^ n).Coprime b ∧ a.Coprime b ↔ a.Coprime b
tactic: rw [Nat.pow_succ, Nat.coprime_mul_iff_left]
state_before: case intro
a b n : ℕ
hn : 0 < n.succ
⊢ (a ^ n).Coprime b ∧ a.Coprime b ↔ a.Coprime b
state_after: no goals
tactic: exact ⟨And.right, fun hab => ⟨hab.pow_left _, hab⟩⟩
Theorem: Down.compression_idem
File: Mathlib/Combinatorics/SetFamily/Compression/Down.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜✝ ℬ : Finset (Finset α)
s : Finset α
a✝ a : α
𝒜 : Finset (Finset α)
⊢ 𝓓 a (𝓓 a 𝒜) = 𝓓 a 𝒜
state_after: case a
α : Type u_1
inst✝ : DecidableEq α
𝒜✝ ℬ : Finset (Finset α)
s✝ : Finset α
a✝ a : α
𝒜 : Finset (Finset α)
s : Finset α
⊢ s ∈ 𝓓 a (𝓓 a 𝒜) ↔ s ∈ 𝓓 a 𝒜
tactic: ext s
state_before: case a
α : Type u_1
inst✝ : DecidableEq α
𝒜✝ ℬ : Finset (Finset α)
s✝ : Finset α
a✝ a : α
𝒜 : Finset (Finset α)
s : Finset α
⊢ s ∈ 𝓓 a (𝓓 a 𝒜) ↔ s ∈ 𝓓 a 𝒜
state_after: case a
α : Type u_1
inst✝ : DecidableEq α
𝒜✝ ℬ : Finset (Finset α)
s✝ : Finset α
a✝ a : α
𝒜 : Finset (Finset α)
s : Finset α
⊢ s ∈ 𝓓 a 𝒜 ∧ s.erase a ∈ 𝓓 a 𝒜 ∨ s ∉ 𝓓 a 𝒜 ∧ insert a s ∈ 𝓓 a 𝒜 → s ∈ 𝓓 a 𝒜
tactic: refine mem_compression.trans ⟨?_, fun h => Or.inl ⟨h, erase_mem_compression_of_mem_compression h⟩⟩
state_before: case a
α : Type u_1
inst✝ : DecidableEq α
𝒜✝ ℬ : Finset (Finset α)
s✝ : Finset α
a✝ a : α
𝒜 : Finset (Finset α)
s : Finset α
⊢ s ∈ 𝓓 a 𝒜 ∧ s.erase a ∈ 𝓓 a 𝒜 ∨ s ∉ 𝓓 a 𝒜 ∧ insert a s ∈ 𝓓 a 𝒜 → s ∈ 𝓓 a 𝒜
state_after: case a.inl
α : Type u_1
inst✝ : DecidableEq α
𝒜✝ ℬ : Finset (Finset α)
s✝ : Finset α
a✝ a : α
𝒜 : Finset (Finset α)
s : Finset α
h : s ∈ 𝓓 a 𝒜 ∧ s.erase a ∈ 𝓓 a 𝒜
⊢ s ∈ 𝓓 a 𝒜

case a.inr
α : Type u_1
inst✝ : DecidableEq α
𝒜✝ ℬ : Finset (Finset α)
s✝ : Finset α
a✝ a : α
𝒜 : Finset (Finset α)
s : Finset α
h : s ∉ 𝓓 a 𝒜 ∧ insert a s ∈ 𝓓 a 𝒜
⊢ s ∈ 𝓓 a 𝒜
tactic: rintro (h | h)
Theorem: Aesop.Array.size_modify
File: .lake/packages/aesop/Aesop/Util/Basic.lean

Proof steps:
state_before: α : Type u_1
a : Array α
i : Nat
f : α → α
⊢ (a.modify i f).size = a.size
state_after: α : Type u_1
a : Array α
i : Nat
f : α → α
⊢ Array.size
      (if h : i < a.size then do
        let v ← f (a.get ⟨i, ⋯⟩)
        pure (a.set ⟨i, ⋯⟩ v)
      else pure a) =
    a.size
tactic: simp only [Array.modify, Id.run, Array.modifyM]
state_before: α : Type u_1
a : Array α
i : Nat
f : α → α
⊢ Array.size
      (if h : i < a.size then do
        let v ← f (a.get ⟨i, ⋯⟩)
        pure (a.set ⟨i, ⋯⟩ v)
      else pure a) =
    a.size
state_after: no goals
tactic: split <;> simp
Theorem: even_two
File: Mathlib/Algebra/Ring/Parity.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝¹ : Semiring α
inst✝ : Semiring β
a b : α
m n : ℕ
⊢ 2 = 1 + 1
state_after: no goals
tactic: rw [one_add_one_eq_two]
Theorem: bernsteinPolynomial.iterate_derivative_at_0_ne_zero
File: Mathlib/RingTheory/Polynomial/Bernstein.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : CharZero R
n ν : ℕ
h : ν ≤ n
⊢ eval 0 ((⇑derivative)^[ν] (bernsteinPolynomial R n ν)) ≠ 0
state_after: R : Type u_1
inst✝¹ : CommRing R
inst✝ : CharZero R
n ν : ℕ
h : ν ≤ n
⊢ ¬eval (↑(n - (ν - 1))) (ascPochhammer R ν) = 0
tactic: simp only [Int.natCast_eq_zero, bernsteinPolynomial.iterate_derivative_at_0, Ne, Nat.cast_eq_zero]
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : CharZero R
n ν : ℕ
h : ν ≤ n
⊢ ¬eval (↑(n - (ν - 1))) (ascPochhammer R ν) = 0
state_after: R : Type u_1
inst✝¹ : CommRing R
inst✝ : CharZero R
n ν : ℕ
h : ν ≤ n
⊢ ¬↑(eval (n - (ν - 1)) (ascPochhammer ℕ ν)) = 0
tactic: simp only [← ascPochhammer_eval_cast]
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : CharZero R
n ν : ℕ
h : ν ≤ n
⊢ ¬↑(eval (n - (ν - 1)) (ascPochhammer ℕ ν)) = 0
state_after: R : Type u_1
inst✝¹ : CommRing R
inst✝ : CharZero R
n ν : ℕ
h : ν ≤ n
⊢ ¬eval (n - (ν - 1)) (ascPochhammer ℕ ν) = 0
tactic: norm_cast
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : CharZero R
n ν : ℕ
h : ν ≤ n
⊢ ¬eval (n - (ν - 1)) (ascPochhammer ℕ ν) = 0
state_after: case h
R : Type u_1
inst✝¹ : CommRing R
inst✝ : CharZero R
n ν : ℕ
h : ν ≤ n
⊢ 0 < eval (n - (ν - 1)) (ascPochhammer ℕ ν)
tactic: apply ne_of_gt
state_before: case h
R : Type u_1
inst✝¹ : CommRing R
inst✝ : CharZero R
n ν : ℕ
h : ν ≤ n
⊢ 0 < eval (n - (ν - 1)) (ascPochhammer ℕ ν)
state_after: case h.inl
R : Type u_1
inst✝¹ : CommRing R
inst✝ : CharZero R
n : ℕ
h : 0 ≤ n
⊢ 0 < eval (n - (0 - 1)) (ascPochhammer ℕ 0)

case h.inr
R : Type u_1
inst✝¹ : CommRing R
inst✝ : CharZero R
n ν : ℕ
h : ν ≤ n
h' : ν > 0
⊢ 0 < eval (n - (ν - 1)) (ascPochhammer ℕ ν)
tactic: obtain rfl | h' := Nat.eq_zero_or_pos ν
Theorem: solvableByRad.induction3
File: Mathlib/FieldTheory/AbelRuffini.lean

Proof steps:
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
⊢ P α
state_after: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
⊢ P α
tactic: let p := minpoly F (α ^ n)
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
hp : p.comp (X ^ n) ≠ 0
⊢ P α
state_after: case x
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
hp : p.comp (X ^ n) ≠ 0
⊢ Fact (Splits (algebraMap F ?q.SplittingField) (minpoly F α))

case hq
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
hp : p.comp (X ^ n) ≠ 0
⊢ IsSolvable ?q.Gal

case q
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
hp : p.comp (X ^ n) ≠ 0
⊢ F[X]
tactic: apply gal_isSolvable_of_splits
Theorem: List.ofFn_eq_nil_iff
File: Mathlib/Data/List/OfFn.lean

Proof steps:
state_before: α : Type u
n : ℕ
f : Fin n → α
⊢ ofFn f = [] ↔ n = 0
state_after: no goals
tactic: cases n <;> simp only [ofFn_zero, ofFn_succ, eq_self_iff_true, Nat.succ_ne_zero]
Theorem: PowerBasis.minpolyGen_monic
File: Mathlib/RingTheory/PowerBasis.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁸ : CommRing R
inst✝⁷ : Ring S
inst✝⁶ : Algebra R S
A : Type u_4
B : Type u_5
inst✝⁵ : CommRing A
inst✝⁴ : CommRing B
inst✝³ : IsDomain B
inst✝² : Algebra A B
K : Type u_6
inst✝¹ : Field K
inst✝ : Algebra A S
pb : PowerBasis A S
⊢ pb.minpolyGen.Monic
state_after: R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁸ : CommRing R
inst✝⁷ : Ring S
inst✝⁶ : Algebra R S
A : Type u_4
B : Type u_5
inst✝⁵ : CommRing A
inst✝⁴ : CommRing B
inst✝³ : IsDomain B
inst✝² : Algebra A B
K : Type u_6
inst✝¹ : Field K
inst✝ : Algebra A S
pb : PowerBasis A S
a✝ : Nontrivial A
⊢ pb.minpolyGen.Monic
tactic: nontriviality A
state_before: R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁸ : CommRing R
inst✝⁷ : Ring S
inst✝⁶ : Algebra R S
A : Type u_4
B : Type u_5
inst✝⁵ : CommRing A
inst✝⁴ : CommRing B
inst✝³ : IsDomain B
inst✝² : Algebra A B
K : Type u_6
inst✝¹ : Field K
inst✝ : Algebra A S
pb : PowerBasis A S
a✝ : Nontrivial A
⊢ pb.minpolyGen.Monic
state_after: R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁸ : CommRing R
inst✝⁷ : Ring S
inst✝⁶ : Algebra R S
A : Type u_4
B : Type u_5
inst✝⁵ : CommRing A
inst✝⁴ : CommRing B
inst✝³ : IsDomain B
inst✝² : Algebra A B
K : Type u_6
inst✝¹ : Field K
inst✝ : Algebra A S
pb : PowerBasis A S
a✝ : Nontrivial A
⊢ (∑ i : Fin pb.dim, C ((pb.basis.repr (pb.gen ^ pb.dim)) i) * X ^ ↑i).degree < (X ^ pb.dim).degree
tactic: apply (monic_X_pow _).sub_of_left _
state_before: R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁸ : CommRing R
inst✝⁷ : Ring S
inst✝⁶ : Algebra R S
A : Type u_4
B : Type u_5
inst✝⁵ : CommRing A
inst✝⁴ : CommRing B
inst✝³ : IsDomain B
inst✝² : Algebra A B
K : Type u_6
inst✝¹ : Field K
inst✝ : Algebra A S
pb : PowerBasis A S
a✝ : Nontrivial A
⊢ (∑ i : Fin pb.dim, C ((pb.basis.repr (pb.gen ^ pb.dim)) i) * X ^ ↑i).degree < (X ^ pb.dim).degree
state_after: R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁸ : CommRing R
inst✝⁷ : Ring S
inst✝⁶ : Algebra R S
A : Type u_4
B : Type u_5
inst✝⁵ : CommRing A
inst✝⁴ : CommRing B
inst✝³ : IsDomain B
inst✝² : Algebra A B
K : Type u_6
inst✝¹ : Field K
inst✝ : Algebra A S
pb : PowerBasis A S
a✝ : Nontrivial A
⊢ (∑ i : Fin pb.dim, C ((pb.basis.repr (pb.gen ^ pb.dim)) i) * X ^ ↑i).degree < ↑pb.dim
tactic: rw [degree_X_pow]
state_before: R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁸ : CommRing R
inst✝⁷ : Ring S
inst✝⁶ : Algebra R S
A : Type u_4
B : Type u_5
inst✝⁵ : CommRing A
inst✝⁴ : CommRing B
inst✝³ : IsDomain B
inst✝² : Algebra A B
K : Type u_6
inst✝¹ : Field K
inst✝ : Algebra A S
pb : PowerBasis A S
a✝ : Nontrivial A
⊢ (∑ i : Fin pb.dim, C ((pb.basis.repr (pb.gen ^ pb.dim)) i) * X ^ ↑i).degree < ↑pb.dim
state_after: no goals
tactic: exact degree_sum_fin_lt _
Theorem: ENNReal.mul_le_of_le_div
File: Mathlib/Data/ENNReal/Inv.lean

Proof steps:
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
h : a ≤ b / c
⊢ a * c ≤ b
state_after: a b c d : ℝ≥0∞
r p q : ℝ≥0
h : a ≤ b / c
⊢ a * c⁻¹⁻¹ ≤ b
tactic: rw [← inv_inv c]
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
h : a ≤ b / c
⊢ a * c⁻¹⁻¹ ≤ b
state_after: no goals
tactic: exact div_le_of_le_mul h
Theorem: Finset.sup'_union
File: Mathlib/Data/Finset/Lattice.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
s : Finset β
H : s.Nonempty
f✝ : β → α
inst✝ : DecidableEq β
s₁ s₂ : Finset β
h₁ : s₁.Nonempty
h₂ : s₂.Nonempty
f : β → α
a : α
⊢ (s₁ ∪ s₂).sup' ⋯ f ≤ a ↔ s₁.sup' h₁ f ⊔ s₂.sup' h₂ f ≤ a
state_after: no goals
tactic: simp [or_imp, forall_and]
Theorem: Finsupp.card_Ioc
File: Mathlib/Data/Finsupp/Interval.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝² : PartialOrder α
inst✝¹ : Zero α
inst✝ : LocallyFiniteOrder α
f g : ι →₀ α
⊢ (Ioc f g).card = ∏ i ∈ f.support ∪ g.support, (Icc (f i) (g i)).card - 1
state_after: no goals
tactic: rw [card_Ioc_eq_card_Icc_sub_one, card_Icc]
Theorem: Matrix.det_smul_inv_mulVec_eq_cramer
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

Proof steps:
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A✝ B A : Matrix n n α
b : n → α
h : IsUnit A.det
⊢ A.det • A⁻¹ *ᵥ b = A.cramer b
state_after: no goals
tactic: rw [cramer_eq_adjugate_mulVec, A.nonsing_inv_apply h, ← smul_mulVec_assoc, smul_smul,
    h.mul_val_inv, one_smul]
Theorem: MeasureTheory.hasFiniteIntegral_zero_measure
File: Mathlib/MeasureTheory/Function/L1Space.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m✝ : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
m : MeasurableSpace α
f : α → β
⊢ HasFiniteIntegral f 0
state_after: no goals
tactic: simp only [HasFiniteIntegral, lintegral_zero_measure, zero_lt_top]
Theorem: Nat.ModEq.eq_of_abs_lt
File: Mathlib/Data/Nat/ModEq.lean

Proof steps:
state_before: m n a b c d : ℕ
h : a ≡ b [MOD m]
h2 : |↑b - ↑a| < ↑m
⊢ a = b
state_after: case x
m n a b c d : ℕ
h : a ≡ b [MOD m]
h2 : |↑b - ↑a| < ↑m
⊢ Int.ofNat a = Int.ofNat b
tactic: apply Int.ofNat.inj
state_before: case x
m n a b c d : ℕ
h : a ≡ b [MOD m]
h2 : |↑b - ↑a| < ↑m
⊢ Int.ofNat a = Int.ofNat b
state_after: case x
m n a b c d : ℕ
h : a ≡ b [MOD m]
h2 : |↑b - ↑a| < ↑m
⊢ Int.ofNat b - Int.ofNat a = 0
tactic: rw [eq_comm, ← sub_eq_zero]
state_before: case x
m n a b c d : ℕ
h : a ≡ b [MOD m]
h2 : |↑b - ↑a| < ↑m
⊢ Int.ofNat b - Int.ofNat a = 0
state_after: no goals
tactic: exact Int.eq_zero_of_abs_lt_dvd h.dvd h2
Theorem: FilterBasis.eq_iInf_principal
File: Mathlib/Order/Filter/Bases.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
B : FilterBasis α
this : Directed (fun x x_1 => x ≥ x_1) fun s => 𝓟 ↑s
⊢ B.filter = ⨅ s, 𝓟 ↑s
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
B : FilterBasis α
this : Directed (fun x x_1 => x ≥ x_1) fun s => 𝓟 ↑s
U : Set α
⊢ U ∈ B.filter ↔ U ∈ ⨅ s, 𝓟 ↑s
tactic: ext U
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
B : FilterBasis α
this : Directed (fun x x_1 => x ≥ x_1) fun s => 𝓟 ↑s
U : Set α
⊢ U ∈ B.filter ↔ U ∈ ⨅ s, 𝓟 ↑s
state_after: no goals
tactic: simp [mem_filter_iff, mem_iInf_of_directed this]
Theorem: ConvexOn.comp_linearMap
File: Mathlib/Analysis/Convex/Function.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
α : Type u_4
β : Type u_5
ι : Type u_6
inst✝⁷ : OrderedSemiring 𝕜
inst✝⁶ : AddCommMonoid E
inst✝⁵ : AddCommMonoid F
inst✝⁴ : OrderedAddCommMonoid α
inst✝³ : OrderedAddCommMonoid β
inst✝² : Module 𝕜 E
inst✝¹ : Module 𝕜 F
inst✝ : SMul 𝕜 β
f : F → β
s : Set F
hf : ConvexOn 𝕜 s f
g : E →ₗ[𝕜] F
x : E
hx : x ∈ ⇑g ⁻¹' s
y : E
hy : y ∈ ⇑g ⁻¹' s
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ f (g (a • x + b • y)) = f (a • g x + b • g y)
state_after: no goals
tactic: rw [g.map_add, g.map_smul, g.map_smul]
Theorem: Comon_.Mon_OpOpToComon__map_hom
File: Mathlib/CategoryTheory/Monoidal/Comon_.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M : Comon_ C
X✝ Y✝ : (Mon_ Cᵒᵖ)ᵒᵖ
f : X✝ ⟶ Y✝
⊢ f.unop.hom.unop ≫ ((fun A => Mon_OpOpToComon_obj' C (unop A)) Y✝).counit =
    ((fun A => Mon_OpOpToComon_obj' C (unop A)) X✝).counit
state_after: case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M : Comon_ C
X✝ Y✝ : (Mon_ Cᵒᵖ)ᵒᵖ
f : X✝ ⟶ Y✝
⊢ (f.unop.hom.unop ≫ ((fun A => Mon_OpOpToComon_obj' C (unop A)) Y✝).counit).op =
    ((fun A => Mon_OpOpToComon_obj' C (unop A)) X✝).counit.op
tactic: apply Quiver.Hom.op_inj
state_before: case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M : Comon_ C
X✝ Y✝ : (Mon_ Cᵒᵖ)ᵒᵖ
f : X✝ ⟶ Y✝
⊢ (f.unop.hom.unop ≫ ((fun A => Mon_OpOpToComon_obj' C (unop A)) Y✝).counit).op =
    ((fun A => Mon_OpOpToComon_obj' C (unop A)) X✝).counit.op
state_after: no goals
tactic: simp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M : Comon_ C
X✝ Y✝ : (Mon_ Cᵒᵖ)ᵒᵖ
f : X✝ ⟶ Y✝
⊢ f.unop.hom.unop ≫ ((fun A => Mon_OpOpToComon_obj' C (unop A)) Y✝).comul =
    ((fun A => Mon_OpOpToComon_obj' C (unop A)) X✝).comul ≫ (f.unop.hom.unop ⊗ f.unop.hom.unop)
state_after: case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M : Comon_ C
X✝ Y✝ : (Mon_ Cᵒᵖ)ᵒᵖ
f : X✝ ⟶ Y✝
⊢ (f.unop.hom.unop ≫ ((fun A => Mon_OpOpToComon_obj' C (unop A)) Y✝).comul).op =
    (((fun A => Mon_OpOpToComon_obj' C (unop A)) X✝).comul ≫ (f.unop.hom.unop ⊗ f.unop.hom.unop)).op
tactic: apply Quiver.Hom.op_inj
state_before: case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M : Comon_ C
X✝ Y✝ : (Mon_ Cᵒᵖ)ᵒᵖ
f : X✝ ⟶ Y✝
⊢ (f.unop.hom.unop ≫ ((fun A => Mon_OpOpToComon_obj' C (unop A)) Y✝).comul).op =
    (((fun A => Mon_OpOpToComon_obj' C (unop A)) X✝).comul ≫ (f.unop.hom.unop ⊗ f.unop.hom.unop)).op
state_after: no goals
tactic: simp [op_tensorHom]
Theorem: MeasureTheory.tendsto_measure_iUnion
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
inst✝² : Preorder ι
inst✝¹ : IsDirected ι fun x x_1 => x ≤ x_1
inst✝ : Countable ι
s : ι → Set α
hm : Monotone s
⊢ Tendsto (⇑μ ∘ s) atTop (𝓝 (μ (⋃ n, s n)))
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
inst✝² : Preorder ι
inst✝¹ : IsDirected ι fun x x_1 => x ≤ x_1
inst✝ : Countable ι
s : ι → Set α
hm : Monotone s
⊢ Tendsto (⇑μ ∘ s) atTop (𝓝 (⨆ i, μ (s i)))
tactic: rw [measure_iUnion_eq_iSup hm.directed_le]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
inst✝² : Preorder ι
inst✝¹ : IsDirected ι fun x x_1 => x ≤ x_1
inst✝ : Countable ι
s : ι → Set α
hm : Monotone s
⊢ Tendsto (⇑μ ∘ s) atTop (𝓝 (⨆ i, μ (s i)))
state_after: no goals
tactic: exact tendsto_atTop_iSup fun n m hnm => measure_mono <| hm hnm
Theorem: MeasureTheory.setLIntegral_one
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
s : Set α
⊢ ∫⁻ (x : α) in s, 1 ∂μ = μ s
state_after: no goals
tactic: rw [setLIntegral_const, one_mul]
Theorem: List.getElem_eq_getElem?
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
i : ℕ
h : i < l.length
⊢ l[i]?.isSome = true
state_after: no goals
tactic: simp [getElem?_eq_getElem, h]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
i : ℕ
h : i < l.length
⊢ l[i] = l[i]?.get ⋯
state_after: no goals
tactic: simp [getElem_eq_iff]
Theorem: Ordinal.lsub_le_of_range_subset
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Type u
ι' : Type v
f : ι → Ordinal.{max (max u v) w}
g : ι' → Ordinal.{max (max u v) w}
h : range f ⊆ range g
⊢ range (succ ∘ f) ⊆ range (succ ∘ g)
state_after: no goals
tactic: convert Set.image_subset succ h <;> apply Set.range_comp
Theorem: mellin_convergent_iff_norm
File: Mathlib/Analysis/MellinTransform.lean

Proof steps:
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℝ → E
T : Set ℝ
hT : T ⊆ Ioi 0
hT' : MeasurableSet T
hfc : AEStronglyMeasurable f (volume.restrict (Ioi 0))
s : ℂ
⊢ IntegrableOn (fun t => ↑t ^ (s - 1) • f t) T volume ↔ IntegrableOn (fun t => t ^ (s.re - 1) * ‖f t‖) T volume
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℝ → E
T : Set ℝ
hT : T ⊆ Ioi 0
hT' : MeasurableSet T
hfc : AEStronglyMeasurable f (volume.restrict (Ioi 0))
s : ℂ
this : AEStronglyMeasurable (fun t => ↑t ^ (s - 1) • f t) (volume.restrict T)
⊢ IntegrableOn (fun t => ↑t ^ (s - 1) • f t) T volume ↔ IntegrableOn (fun t => t ^ (s.re - 1) * ‖f t‖) T volume
tactic: have : AEStronglyMeasurable (fun t : ℝ => (t : ℂ) ^ (s - 1) • f t) (volume.restrict T) := by
    refine ((ContinuousAt.continuousOn ?_).aestronglyMeasurable hT').smul (hfc.mono_set hT)
    exact fun t ht => continuousAt_ofReal_cpow_const _ _ (Or.inr <| ne_of_gt (hT ht))
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℝ → E
T : Set ℝ
hT : T ⊆ Ioi 0
hT' : MeasurableSet T
hfc : AEStronglyMeasurable f (volume.restrict (Ioi 0))
s : ℂ
this : AEStronglyMeasurable (fun t => ↑t ^ (s - 1) • f t) (volume.restrict T)
⊢ IntegrableOn (fun t => ↑t ^ (s - 1) • f t) T volume ↔ IntegrableOn (fun t => t ^ (s.re - 1) * ‖f t‖) T volume
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℝ → E
T : Set ℝ
hT : T ⊆ Ioi 0
hT' : MeasurableSet T
hfc : AEStronglyMeasurable f (volume.restrict (Ioi 0))
s : ℂ
this : AEStronglyMeasurable (fun t => ↑t ^ (s - 1) • f t) (volume.restrict T)
⊢ IntegrableOn (fun a => ‖↑a ^ (s - 1) • f a‖) T volume ↔ IntegrableOn (fun t => t ^ (s.re - 1) * ‖f t‖) T volume
tactic: rw [IntegrableOn, ← integrable_norm_iff this, ← IntegrableOn]
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℝ → E
T : Set ℝ
hT : T ⊆ Ioi 0
hT' : MeasurableSet T
hfc : AEStronglyMeasurable f (volume.restrict (Ioi 0))
s : ℂ
this : AEStronglyMeasurable (fun t => ↑t ^ (s - 1) • f t) (volume.restrict T)
⊢ IntegrableOn (fun a => ‖↑a ^ (s - 1) • f a‖) T volume ↔ IntegrableOn (fun t => t ^ (s.re - 1) * ‖f t‖) T volume
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℝ → E
T : Set ℝ
hT : T ⊆ Ioi 0
hT' : MeasurableSet T
hfc : AEStronglyMeasurable f (volume.restrict (Ioi 0))
s : ℂ
this : AEStronglyMeasurable (fun t => ↑t ^ (s - 1) • f t) (volume.restrict T)
t : ℝ
ht : t ∈ T
⊢ ‖↑t ^ (s - 1) • f t‖ = t ^ (s.re - 1) * ‖f t‖
tactic: refine integrableOn_congr_fun (fun t ht => ?_) hT'
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℝ → E
T : Set ℝ
hT : T ⊆ Ioi 0
hT' : MeasurableSet T
hfc : AEStronglyMeasurable f (volume.restrict (Ioi 0))
s : ℂ
this : AEStronglyMeasurable (fun t => ↑t ^ (s - 1) • f t) (volume.restrict T)
t : ℝ
ht : t ∈ T
⊢ ‖↑t ^ (s - 1) • f t‖ = t ^ (s.re - 1) * ‖f t‖
state_after: no goals
tactic: simp_rw [norm_smul, Complex.norm_eq_abs, abs_cpow_eq_rpow_re_of_pos (hT ht), sub_re, one_re]
Theorem: CategoryTheory.conjugateEquiv_adjunction_id
File: Mathlib/CategoryTheory/Adjunction/Mates.lean

Proof steps:
state_before: C : Type u₁
D : Type u₂
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Category.{v₂, u₂} D
L₁ L₂ : C ⥤ D
R₁ R₂ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
L R : C ⥤ C
adj : L ⊣ R
α : 𝟭 C ⟶ L
c : C
⊢ ((conjugateEquiv adj Adjunction.id) α).app c = α.app (R.obj c) ≫ adj.counit.app c
state_after: C : Type u₁
D : Type u₂
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Category.{v₂, u₂} D
L₁ L₂ : C ⥤ D
R₁ R₂ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
L R : C ⥤ C
adj : L ⊣ R
α : 𝟭 C ⟶ L
c : C
⊢ 𝟙 (R.obj c) ≫ (𝟙 (R.obj c) ≫ (𝟙 (R.obj c) ≫ α.app (R.obj c) ≫ 𝟙 (L.obj (R.obj c))) ≫ adj.counit.app c) ≫ 𝟙 c =
    α.app (R.obj c) ≫ adj.counit.app c
tactic: dsimp [conjugateEquiv, mateEquiv, Adjunction.id]
state_before: C : Type u₁
D : Type u₂
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Category.{v₂, u₂} D
L₁ L₂ : C ⥤ D
R₁ R₂ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
L R : C ⥤ C
adj : L ⊣ R
α : 𝟭 C ⟶ L
c : C
⊢ 𝟙 (R.obj c) ≫ (𝟙 (R.obj c) ≫ (𝟙 (R.obj c) ≫ α.app (R.obj c) ≫ 𝟙 (L.obj (R.obj c))) ≫ adj.counit.app c) ≫ 𝟙 c =
    α.app (R.obj c) ≫ adj.counit.app c
state_after: no goals
tactic: simp only [comp_id, id_comp]
Theorem: Real.sqrt_le_sqrt
File: Mathlib/Data/Real/Sqrt.lean

Proof steps:
state_before: x y : ℝ
h : x ≤ y
⊢ √x ≤ √y
state_after: x y : ℝ
h : x ≤ y
⊢ x.toNNReal ≤ y.toNNReal
tactic: rw [Real.sqrt, Real.sqrt, NNReal.coe_le_coe, NNReal.sqrt_le_sqrt]
state_before: x y : ℝ
h : x ≤ y
⊢ x.toNNReal ≤ y.toNNReal
state_after: no goals
tactic: exact toNNReal_le_toNNReal h