ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Nat.minSqFacProp_div
File: Mathlib/Data/Nat/Squarefree.lean

Proof steps:
state_before: s : Finset ℕ
m n✝ p n k : ℕ
pk : Prime k
dk : k ∣ n
dkk : ¬k * k ∣ n
o : Option ℕ
H : (n / k).MinSqFacProp o
⊢ n.MinSqFacProp o
state_after: s : Finset ℕ
m n✝ p n k : ℕ
pk : Prime k
dk : k ∣ n
dkk : ¬k * k ∣ n
o : Option ℕ
H : (n / k).MinSqFacProp o
this : ∀ (p : ℕ), Prime p → p * p ∣ n → k * (p * p) ∣ n
⊢ n.MinSqFacProp o
tactic: have : ∀ p, Prime p → p * p ∣ n → k * (p * p) ∣ n := fun p pp dp =>
    have :=
      (coprime_primes pk pp).2 fun e => by
        subst e
        contradiction
    (coprime_mul_iff_right.2 ⟨this, this⟩).mul_dvd_of_dvd_of_dvd dk dp
state_before: s : Finset ℕ
m n✝ p n k : ℕ
pk : Prime k
dk : k ∣ n
dkk : ¬k * k ∣ n
o : Option ℕ
H : (n / k).MinSqFacProp o
this : ∀ (p : ℕ), Prime p → p * p ∣ n → k * (p * p) ∣ n
⊢ n.MinSqFacProp o
state_after: case none
s : Finset ℕ
m n✝ p n k : ℕ
pk : Prime k
dk : k ∣ n
dkk : ¬k * k ∣ n
this : ∀ (p : ℕ), Prime p → p * p ∣ n → k * (p * p) ∣ n
H : (n / k).MinSqFacProp none
⊢ n.MinSqFacProp none

case some
s : Finset ℕ
m n✝ p n k : ℕ
pk : Prime k
dk : k ∣ n
dkk : ¬k * k ∣ n
this : ∀ (p : ℕ), Prime p → p * p ∣ n → k * (p * p) ∣ n
d : ℕ
H : (n / k).MinSqFacProp (some d)
⊢ n.MinSqFacProp (some d)
tactic: cases' o with d
Theorem: ENNReal.toNNReal_div
File: Mathlib/Data/ENNReal/Real.lean

Proof steps:
state_before: a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
a b : ℝ≥0∞
⊢ (a / b).toNNReal = a.toNNReal / b.toNNReal
state_after: no goals
tactic: rw [div_eq_mul_inv, toNNReal_mul, toNNReal_inv, div_eq_mul_inv]
Theorem: IsAddUnit.add_liftRight_neg
File: Mathlib/Algebra/Group/Units/Hom.lean

Proof steps:
state_before: F : Type u_1
G : Type u_2
α : Type u_3
M : Type u_4
N : Type u_5
inst✝³ : FunLike F M N
inst✝² : FunLike G N M
inst✝¹ : Monoid M
inst✝ : Monoid N
f : M →* N
h : ∀ (x : M), IsUnit (f x)
x : M
⊢ ∀ (x : M), ↑⋯.unit = f x
state_after: F : Type u_1
G : Type u_2
α : Type u_3
M : Type u_4
N : Type u_5
inst✝³ : FunLike F M N
inst✝² : FunLike G N M
inst✝¹ : Monoid M
inst✝ : Monoid N
f : M →* N
h : ∀ (x : M), IsUnit (f x)
x x✝ : M
⊢ ↑⋯.unit = f x✝
tactic: intro
state_before: F : Type u_1
G : Type u_2
α : Type u_3
M : Type u_4
N : Type u_5
inst✝³ : FunLike F M N
inst✝² : FunLike G N M
inst✝¹ : Monoid M
inst✝ : Monoid N
f : M →* N
h : ∀ (x : M), IsUnit (f x)
x x✝ : M
⊢ ↑⋯.unit = f x✝
state_after: no goals
tactic: rfl
Theorem: List.Ico.eq_nil_of_le
File: Mathlib/Data/List/Intervals.lean

Proof steps:
state_before: n m : ℕ
h : m ≤ n
⊢ Ico n m = []
state_after: no goals
tactic: simp [Ico, Nat.sub_eq_zero_iff_le.mpr h]
Theorem: PartENat.toWithTop_natCast
File: Mathlib/Data/Nat/PartENat.lean

Proof steps:
state_before: n : ℕ
x✝ : Decidable (↑n).Dom
⊢ (↑n).toWithTop = ↑n
state_after: n : ℕ
x✝ : Decidable (↑n).Dom
⊢ (↑n).toWithTop = (↑n).toWithTop
tactic: simp only [← toWithTop_some]
state_before: n : ℕ
x✝ : Decidable (↑n).Dom
⊢ (↑n).toWithTop = (↑n).toWithTop
state_after: no goals
tactic: congr
Theorem: Real.nat_sqrt_le_real_sqrt
File: Mathlib/Data/Real/Sqrt.lean

Proof steps:
state_before: x✝ y✝ x y : ℝ
a : ℕ
⊢ ↑a.sqrt ≤ √↑a
state_after: x✝ y✝ x y : ℝ
a : ℕ
⊢ ↑a.sqrt ^ 2 ≤ ↑a
tactic: rw [Real.le_sqrt (Nat.cast_nonneg _) (Nat.cast_nonneg _)]
state_before: x✝ y✝ x y : ℝ
a : ℕ
⊢ ↑a.sqrt ^ 2 ≤ ↑a
state_after: x✝ y✝ x y : ℝ
a : ℕ
⊢ a.sqrt ^ 2 ≤ a
tactic: norm_cast
state_before: x✝ y✝ x y : ℝ
a : ℕ
⊢ a.sqrt ^ 2 ≤ a
state_after: no goals
tactic: exact Nat.sqrt_le' a
Theorem: EuclideanGeometry.image_inversion_sphere_dist_center
File: Mathlib/Geometry/Euclidean/Inversion/ImageHyperplane.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
c x y : P
R : ℝ
hR : R ≠ 0
hy : y ≠ c
⊢ inversion c R '' sphere y (dist y c) = insert c ↑(perpBisector c (inversion c R y))
state_after: no goals
tactic: rw [image_eq_preimage_of_inverse (inversion_involutive _ hR) (inversion_involutive _ hR),
    preimage_inversion_sphere_dist_center hR hy]
Theorem: CircleDeg1Lift.pow_mono
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

Proof steps:
state_before: f✝ g✝ f g : CircleDeg1Lift
h : f ≤ g
n : ℕ
x : ℝ
⊢ (f ^ n) x ≤ (g ^ n) x
state_after: no goals
tactic: simp only [coe_pow, iterate_mono h n x]
Theorem: AddSubgroup.closure_induction'
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H K : Subgroup G
k : Set G
p : (x : G) → x ∈ closure k → Prop
mem : ∀ (x : G) (h : x ∈ k), p x ⋯
one : p 1 ⋯
mul : ∀ (x : G) (hx : x ∈ closure k) (y : G) (hy : y ∈ closure k), p x hx → p y hy → p (x * y) ⋯
inv : ∀ (x : G) (hx : x ∈ closure k), p x hx → p x⁻¹ ⋯
x : G
hx : x ∈ closure k
⊢ p x hx
state_after: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H K : Subgroup G
k : Set G
p : (x : G) → x ∈ closure k → Prop
mem : ∀ (x : G) (h : x ∈ k), p x ⋯
one : p 1 ⋯
mul : ∀ (x : G) (hx : x ∈ closure k) (y : G) (hy : y ∈ closure k), p x hx → p y hy → p (x * y) ⋯
inv : ∀ (x : G) (hx : x ∈ closure k), p x hx → p x⁻¹ ⋯
x : G
hx : x ∈ closure k
⊢ ∃ (x_1 : x ∈ closure k), p x x_1
tactic: refine Exists.elim ?_ fun (hx : x ∈ closure k) (hc : p x hx) => hc
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H K : Subgroup G
k : Set G
p : (x : G) → x ∈ closure k → Prop
mem : ∀ (x : G) (h : x ∈ k), p x ⋯
one : p 1 ⋯
mul : ∀ (x : G) (hx : x ∈ closure k) (y : G) (hy : y ∈ closure k), p x hx → p y hy → p (x * y) ⋯
inv : ∀ (x : G) (hx : x ∈ closure k), p x hx → p x⁻¹ ⋯
x : G
hx : x ∈ closure k
⊢ ∃ (x_1 : x ∈ closure k), p x x_1
state_after: no goals
tactic: exact
    closure_induction hx (fun x hx => ⟨_, mem x hx⟩) ⟨_, one⟩
      (fun x y ⟨hx', hx⟩ ⟨hy', hy⟩ => ⟨_, mul _ _ _ _ hx hy⟩) fun x ⟨hx', hx⟩ => ⟨_, inv _ _ hx⟩
Theorem: NormedAddCommGroup.tendsto_atTop
File: Mathlib/Analysis/Normed/Field/Basic.lean

Proof steps:
state_before: α : Type u_1
β✝ : Type u_2
γ : Type u_3
ι : Type u_4
inst✝² : Nonempty α
inst✝¹ : SemilatticeSup α
β : Type u_5
inst✝ : SeminormedAddCommGroup β
f : α → β
b : β
⊢ (∀ (ib : ℝ), 0 < ib → ∃ ia, True ∧ ∀ x ∈ Set.Ici ia, f x ∈ ball b ib) ↔
    ∀ (ε : ℝ), 0 < ε → ∃ N, ∀ (n : α), N ≤ n → ‖f n - b‖ < ε
state_after: no goals
tactic: simp [dist_eq_norm]
Theorem: HahnSeries.addOppositeEquiv_orderTop
File: Mathlib/RingTheory/HahnSeries/Addition.lean

Proof steps:
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x : HahnSeries Γ Rᵃᵒᵖ
⊢ (AddOpposite.unop (addOppositeEquiv x)).orderTop = x.orderTop
state_after: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x : HahnSeries Γ Rᵃᵒᵖ
⊢ (if h : AddOpposite.unop (addOppositeEquiv x) = 0 then ⊤ else ↑(⋯.min ⋯)) = if h : x = 0 then ⊤ else ↑(⋯.min ⋯)
tactic: simp only [orderTop, AddOpposite.unop_op, mk_eq_zero, AddEquivClass.map_eq_zero_iff,
    addOppositeEquiv_support, ne_eq]
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x : HahnSeries Γ Rᵃᵒᵖ
⊢ (if h : AddOpposite.unop (addOppositeEquiv x) = 0 then ⊤ else ↑(⋯.min ⋯)) = if h : x = 0 then ⊤ else ↑(⋯.min ⋯)
state_after: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x : HahnSeries Γ Rᵃᵒᵖ
⊢ (if h : (fun a => AddOpposite.unop (x.coeff a)) = 0 then ⊤ else ↑(⋯.min ⋯)) = if h : x = 0 then ⊤ else ↑(⋯.min ⋯)
tactic: simp only [addOppositeEquiv_apply, AddOpposite.unop_op, mk_eq_zero, zero_coeff]
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x : HahnSeries Γ Rᵃᵒᵖ
⊢ (if h : (fun a => AddOpposite.unop (x.coeff a)) = 0 then ⊤ else ↑(⋯.min ⋯)) = if h : x = 0 then ⊤ else ↑(⋯.min ⋯)
state_after: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x : HahnSeries Γ Rᵃᵒᵖ
⊢ (if h : ∀ (a : Γ), AddOpposite.unop (x.coeff a) = 0 a then ⊤ else ↑(⋯.min ⋯)) =
    if h : ∀ (a : Γ), x.coeff a = coeff 0 a then ⊤ else ↑(⋯.min ⋯)
tactic: simp_rw [HahnSeries.ext_iff x 0, Function.funext_iff]
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x : HahnSeries Γ Rᵃᵒᵖ
⊢ (if h : ∀ (a : Γ), AddOpposite.unop (x.coeff a) = 0 a then ⊤ else ↑(⋯.min ⋯)) =
    if h : ∀ (a : Γ), x.coeff a = coeff 0 a then ⊤ else ↑(⋯.min ⋯)
state_after: no goals
tactic: simp only [Pi.zero_apply, AddOpposite.unop_eq_zero_iff, zero_coeff]
Theorem: PicardLindelof.exists_contracting_iterate
File: Mathlib/Analysis/ODE/PicardLindelof.lean

Proof steps:
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
v : PicardLindelof E
inst✝ : CompleteSpace E
⊢ ∃ N K, ContractingWith K FunSpace.next^[N]
state_after: case intro
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
v : PicardLindelof E
inst✝ : CompleteSpace E
N : ℕ
hN : (↑v.L * v.tDist) ^ N / ↑N ! < 1
⊢ ∃ N K, ContractingWith K FunSpace.next^[N]
tactic: rcases ((Real.tendsto_pow_div_factorial_atTop (v.L * v.tDist)).eventually
    (gt_mem_nhds zero_lt_one)).exists with ⟨N, hN⟩
state_before: case intro
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
v : PicardLindelof E
inst✝ : CompleteSpace E
N : ℕ
hN : (↑v.L * v.tDist) ^ N / ↑N ! < 1
⊢ ∃ N K, ContractingWith K FunSpace.next^[N]
state_after: case intro
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
v : PicardLindelof E
inst✝ : CompleteSpace E
N : ℕ
hN : (↑v.L * v.tDist) ^ N / ↑N ! < 1
this : 0 ≤ (↑v.L * v.tDist) ^ N / ↑N !
⊢ ∃ N K, ContractingWith K FunSpace.next^[N]
tactic: have : (0 : ℝ) ≤ (v.L * v.tDist) ^ N / N ! :=
    div_nonneg (pow_nonneg (mul_nonneg v.L.2 v.tDist_nonneg) _) (Nat.cast_nonneg _)
state_before: case intro
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
v : PicardLindelof E
inst✝ : CompleteSpace E
N : ℕ
hN : (↑v.L * v.tDist) ^ N / ↑N ! < 1
this : 0 ≤ (↑v.L * v.tDist) ^ N / ↑N !
⊢ ∃ N K, ContractingWith K FunSpace.next^[N]
state_after: no goals
tactic: exact ⟨N, ⟨_, this⟩, hN, LipschitzWith.of_dist_le_mul fun f g =>
    FunSpace.dist_iterate_next_le f g N⟩
Theorem: continuous_if_le
File: Mathlib/Topology/Order/OrderClosed.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁵ : TopologicalSpace α
inst✝⁴ : LinearOrder α
inst✝³ : OrderClosedTopology α
f g : β → α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : (x : β) → Decidable (f x ≤ g x)
f' g' : β → γ
hf : Continuous f
hg : Continuous g
hf' : ContinuousOn f' {x | f x ≤ g x}
hg' : ContinuousOn g' {x | g x ≤ f x}
hfg : ∀ (x : β), f x = g x → f' x = g' x
⊢ Continuous fun x => if f x ≤ g x then f' x else g' x
state_after: case refine_1
α : Type u
β : Type v
γ : Type w
inst✝⁵ : TopologicalSpace α
inst✝⁴ : LinearOrder α
inst✝³ : OrderClosedTopology α
f g : β → α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : (x : β) → Decidable (f x ≤ g x)
f' g' : β → γ
hf : Continuous f
hg : Continuous g
hf' : ContinuousOn f' {x | f x ≤ g x}
hg' : ContinuousOn g' {x | g x ≤ f x}
hfg : ∀ (x : β), f x = g x → f' x = g' x
⊢ ContinuousOn f' (closure {x | f x ≤ g x})

case refine_2
α : Type u
β : Type v
γ : Type w
inst✝⁵ : TopologicalSpace α
inst✝⁴ : LinearOrder α
inst✝³ : OrderClosedTopology α
f g : β → α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : (x : β) → Decidable (f x ≤ g x)
f' g' : β → γ
hf : Continuous f
hg : Continuous g
hf' : ContinuousOn f' {x | f x ≤ g x}
hg' : ContinuousOn g' {x | g x ≤ f x}
hfg : ∀ (x : β), f x = g x → f' x = g' x
⊢ closure {x | ¬f x ≤ g x} ⊆ {x | g x ≤ f x}
tactic: refine continuous_if (fun a ha => hfg _ (frontier_le_subset_eq hf hg ha)) ?_ (hg'.mono ?_)
Theorem: Matrix.diagonal_updateColumn_single
File: Mathlib/Data/Matrix/RowCol.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
M : Matrix m n α
i✝ : m
j : n
b : n → α
c : m → α
inst✝¹ : DecidableEq n
inst✝ : Zero α
v : n → α
i : n
x : α
⊢ (diagonal v).updateColumn i (Pi.single i x) = diagonal (Function.update v i x)
state_after: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
M : Matrix m n α
i✝ : m
j✝ : n
b : n → α
c : m → α
inst✝¹ : DecidableEq n
inst✝ : Zero α
v : n → α
i : n
x : α
j k : n
⊢ (diagonal v).updateColumn i (Pi.single i x) j k = diagonal (Function.update v i x) j k
tactic: ext j k
state_before: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
M : Matrix m n α
i✝ : m
j✝ : n
b : n → α
c : m → α
inst✝¹ : DecidableEq n
inst✝ : Zero α
v : n → α
i : n
x : α
j k : n
⊢ (diagonal v).updateColumn i (Pi.single i x) j k = diagonal (Function.update v i x) j k
state_after: case a.inl
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
M : Matrix m n α
i✝ : m
j✝ : n
b : n → α
c : m → α
inst✝¹ : DecidableEq n
inst✝ : Zero α
v : n → α
i : n
x : α
j : n
⊢ (diagonal v).updateColumn i (Pi.single i x) j j = diagonal (Function.update v i x) j j

case a.inr
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
M : Matrix m n α
i✝ : m
j✝ : n
b : n → α
c : m → α
inst✝¹ : DecidableEq n
inst✝ : Zero α
v : n → α
i : n
x : α
j k : n
hjk : j ≠ k
⊢ (diagonal v).updateColumn i (Pi.single i x) j k = diagonal (Function.update v i x) j k
tactic: obtain rfl | hjk := eq_or_ne j k
Theorem: Basis.reindexRange_self
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
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b b₁ : Basis ι R M
i✝ : ι
c : R
x : M
b' : Basis ι' R M'
e : ι ≃ ι'
i : ι
h : optParam (b i ∈ range ⇑b) ⋯
⊢ b.reindexRange ⟨b i, h⟩ = b i
state_after: case pos
ι : 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
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b b₁ : Basis ι R M
i✝ : ι
c : R
x : M
b' : Basis ι' R M'
e : ι ≃ ι'
i : ι
h : optParam (b i ∈ range ⇑b) ⋯
htr : Nontrivial R
⊢ b.reindexRange ⟨b i, h⟩ = b i

case neg
ι : 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
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b b₁ : Basis ι R M
i✝ : ι
c : R
x : M
b' : Basis ι' R M'
e : ι ≃ ι'
i : ι
h : optParam (b i ∈ range ⇑b) ⋯
htr : ¬Nontrivial R
⊢ b.reindexRange ⟨b i, h⟩ = b i
tactic: by_cases htr : Nontrivial R
Theorem: RelIso.symm_apply_rel
File: Mathlib/Order/RelIso/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
e : r ≃r s
x : β
y : α
⊢ r (e.symm x) y ↔ s x (e y)
state_after: no goals
tactic: rw [← e.map_rel_iff, e.apply_symm_apply]
Theorem: LinearMap.IsSymmetric.conj_inner_sym
File: Mathlib/Analysis/InnerProductSpace/Symmetric.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
E' : Type u_3
F : Type u_4
G : Type u_5
inst✝⁸ : RCLike 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : InnerProductSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : InnerProductSpace 𝕜 G
inst✝¹ : NormedAddCommGroup E'
inst✝ : InnerProductSpace ℝ E'
T : E →ₗ[𝕜] E
hT : T.IsSymmetric
x y : E
⊢ (starRingEnd 𝕜) ⟪T x, y⟫_𝕜 = ⟪T y, x⟫_𝕜
state_after: no goals
tactic: rw [hT x y, inner_conj_symm]
Theorem: Primrec.sum_casesOn
File: Mathlib/Computability/Primrec.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → β ⊕ γ
g : α → β → σ
h : α → γ → σ
hf : Primrec f
hg : Primrec₂ g
hh : Primrec₂ h
a : α
⊢ (bif (encode (f a)).bodd then Option.map (h a) (decode (encode (f a)).div2)
    else Option.map (g a) (decode (encode (f a)).div2)) =
    some (Sum.casesOn (f a) (g a) (h a))
state_after: no goals
tactic: cases' f a with b c <;> simp [Nat.div2_val, encodek]
Theorem: ContinuousLinearMap.intervalIntegral_comp_comm
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

Proof steps:
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : CompleteSpace E
inst✝⁶ : NormedSpace ℝ E
a b : ℝ
μ : Measure ℝ
f : ℝ → E
inst✝⁵ : RCLike 𝕜
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
L : E →L[𝕜] F
hf : IntervalIntegrable f μ a b
⊢ ∫ (x : ℝ) in a..b, L (f x) ∂μ = L (∫ (x : ℝ) in a..b, f x ∂μ)
state_after: no goals
tactic: simp_rw [intervalIntegral, L.integral_comp_comm hf.1, L.integral_comp_comm hf.2, L.map_sub]
Theorem: List.infix_append'
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α : Type u_1
l₁ l₂ l₃ : List α
⊢ l₂ <:+: l₁ ++ (l₂ ++ l₃)
state_after: α : Type u_1
l₁ l₂ l₃ : List α
⊢ l₂ <:+: l₁ ++ l₂ ++ l₃
tactic: rw [← List.append_assoc]
state_before: α : Type u_1
l₁ l₂ l₃ : List α
⊢ l₂ <:+: l₁ ++ l₂ ++ l₃
state_after: no goals
tactic: apply infix_append
Theorem: UniqueFactorizationMonoid.exists_mem_normalizedFactors
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

Proof steps:
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
x : α
hx : x ≠ 0
h : ¬IsUnit x
⊢ ∃ p, p ∈ normalizedFactors x
state_after: case intro.intro
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
x : α
hx : x ≠ 0
h : ¬IsUnit x
p' : α
hp' : Irreducible p'
hp'x : p' ∣ x
⊢ ∃ p, p ∈ normalizedFactors x
tactic: obtain ⟨p', hp', hp'x⟩ := WfDvdMonoid.exists_irreducible_factor h hx
state_before: case intro.intro
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
x : α
hx : x ≠ 0
h : ¬IsUnit x
p' : α
hp' : Irreducible p'
hp'x : p' ∣ x
⊢ ∃ p, p ∈ normalizedFactors x
state_after: case intro.intro.intro.intro
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
x : α
hx : x ≠ 0
h : ¬IsUnit x
p' : α
hp' : Irreducible p'
hp'x : p' ∣ x
p : α
hp : p ∈ normalizedFactors x
right✝ : p' ~ᵤ p
⊢ ∃ p, p ∈ normalizedFactors x
tactic: obtain ⟨p, hp, _⟩ := exists_mem_normalizedFactors_of_dvd hx hp' hp'x
state_before: case intro.intro.intro.intro
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
x : α
hx : x ≠ 0
h : ¬IsUnit x
p' : α
hp' : Irreducible p'
hp'x : p' ∣ x
p : α
hp : p ∈ normalizedFactors x
right✝ : p' ~ᵤ p
⊢ ∃ p, p ∈ normalizedFactors x
state_after: no goals
tactic: exact ⟨p, hp⟩
Theorem: IsSquare.mul
File: Mathlib/Algebra/Group/Even.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝ : CommSemigroup α
a b : α
⊢ IsSquare a → IsSquare b → IsSquare (a * b)
state_after: case intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝ : CommSemigroup α
a b : α
⊢ IsSquare (a * a * (b * b))
tactic: rintro ⟨a, rfl⟩ ⟨b, rfl⟩
state_before: case intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝ : CommSemigroup α
a b : α
⊢ IsSquare (a * a * (b * b))
state_after: no goals
tactic: exact ⟨a * b, mul_mul_mul_comm _ _ _ _⟩
Theorem: BoxIntegral.Prepartition.sum_fiberwise
File: Mathlib/Analysis/BoxIntegral/Partition/Basic.lean

Proof steps:
state_before: ι : Type u_1
I J J₁ J₂ : Box ι
π✝ π₁ π₂ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
α : Type u_2
M : Type u_3
inst✝ : AddCommMonoid M
π : Prepartition I
f : Box ι → α
g : Box ι → M
⊢ ∑ y ∈ Finset.image f π.boxes, ∑ J ∈ (π.filter fun J => f J = y).boxes, g J = ∑ J ∈ π.boxes, g J
state_after: no goals
tactic: convert sum_fiberwise_of_maps_to (fun _ => Finset.mem_image_of_mem f) g
Theorem: ExteriorAlgebra.GradedAlgebra.liftι_eq
File: Mathlib/LinearAlgebra/ExteriorAlgebra/Grading.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
i : ℕ
x : ↥(⋀[R]^i M)
⊢ (liftι R M) ↑x = (DirectSum.of (fun i => ↥(⋀[R]^i M)) i) x
state_after: case mk
R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
i : ℕ
x : ExteriorAlgebra R M
hx : x ∈ ⋀[R]^i M
⊢ (liftι R M) ↑⟨x, hx⟩ = (DirectSum.of (fun i => ↥(⋀[R]^i M)) i) ⟨x, hx⟩
tactic: cases' x with x hx
state_before: case mk
R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
i : ℕ
x : ExteriorAlgebra R M
hx : x ∈ ⋀[R]^i M
⊢ (liftι R M) ↑⟨x, hx⟩ = (DirectSum.of (fun i => ↥(⋀[R]^i M)) i) ⟨x, hx⟩
state_after: case mk
R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
i : ℕ
x : ExteriorAlgebra R M
hx : x ∈ ⋀[R]^i M
⊢ (liftι R M) x = (DirectSum.of (fun i => ↥(⋀[R]^i M)) i) ⟨x, hx⟩
tactic: dsimp only [Subtype.coe_mk, DirectSum.lof_eq_of]
state_before: case mk
R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
i : ℕ
x : ExteriorAlgebra R M
hx : x ∈ ⋀[R]^i M
⊢ (liftι R M) x = (DirectSum.of (fun i => ↥(⋀[R]^i M)) i) ⟨x, hx⟩
state_after: no goals
tactic: induction hx using Submodule.pow_induction_on_left' with
  | algebraMap => simp_rw [AlgHom.commutes, DirectSum.algebraMap_apply]; rfl
  -- FIXME: specialized `map_add` to avoid a (whole-declaration) timeout
  | add _ _ _ _ _ ihx ihy => simp_rw [AlgHom.map_add, ihx, ihy, ← AddMonoidHom.map_add]; rfl
  | mem_mul _ hm _ _ _ ih =>
      obtain ⟨_, rfl⟩ := hm
      simp_rw [AlgHom.map_mul, ih, GradedAlgebra.liftι, lift_ι_apply, GradedAlgebra.ι_apply R M,
        DirectSum.of_mul_of]
      exact DirectSum.of_eq_of_gradedMonoid_eq (Sigma.subtype_ext (add_comm _ _) rfl)
Theorem: Cardinal.mk_toNat_eq_card
File: Mathlib/SetTheory/Cardinal/ToNat.lean

Proof steps:
state_before: α : Type u
c d : Cardinal.{u}
inst✝ : Fintype α
⊢ toNat #α = Fintype.card α
state_after: no goals
tactic: simp