ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: DirichletCharacter.conductor_le_conductor_mem_conductorSet
File: Mathlib/NumberTheory/DirichletCharacter/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommMonoidWithZero R
n : ℕ
χ : DirichletCharacter R n
d : ℕ
hd : d ∈ χ.conductorSet
⊢ χ.conductor ≤ (Classical.choose ⋯).conductor
state_after: R : Type u_1
inst✝ : CommMonoidWithZero R
n : ℕ
χ : DirichletCharacter R n
d : ℕ
hd : d ∈ χ.conductorSet
⊢ χ = (changeLevel ⋯) ⋯.choose
tactic: refine Nat.sInf_le <| (mem_conductorSet_iff χ).mpr <|
    ⟨dvd_trans (conductor_dvd_level _) hd.1,
     (factorsThrough_conductor (Classical.choose hd.2)).2.choose, ?_⟩
state_before: R : Type u_1
inst✝ : CommMonoidWithZero R
n : ℕ
χ : DirichletCharacter R n
d : ℕ
hd : d ∈ χ.conductorSet
⊢ χ = (changeLevel ⋯) ⋯.choose
state_after: R : Type u_1
inst✝ : CommMonoidWithZero R
n : ℕ
χ : DirichletCharacter R n
d : ℕ
hd : d ∈ χ.conductorSet
⊢ χ = (changeLevel ⋯) (Classical.choose ⋯)
tactic: rw [changeLevel_trans _ (conductor_dvd_level _) hd.dvd,
      ← (factorsThrough_conductor (Classical.choose hd.2)).2.choose_spec]
state_before: R : Type u_1
inst✝ : CommMonoidWithZero R
n : ℕ
χ : DirichletCharacter R n
d : ℕ
hd : d ∈ χ.conductorSet
⊢ χ = (changeLevel ⋯) (Classical.choose ⋯)
state_after: no goals
tactic: exact hd.eq_changeLevel
Theorem: Real.arctan_eq_of_tan_eq
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean

Proof steps:
state_before: x y : ℝ
h : tan x = y
hx : x ∈ Ioo (-(π / 2)) (π / 2)
⊢ tan (arctan y) = tan x
state_after: no goals
tactic: rw [tan_arctan, h]
Theorem: AddLECancellable.lt_add_of_tsub_lt_right
File: Mathlib/Algebra/Order/Sub/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : PartialOrder α
inst✝² : AddCommSemigroup α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
hc : AddLECancellable c
h : a - c < b
⊢ a < b + c
state_after: α : Type u_1
β : Type u_2
inst✝³ : PartialOrder α
inst✝² : AddCommSemigroup α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
hc : AddLECancellable c
h : a - c < b
⊢ a - c ≤ b ∧ a ≠ b + c
tactic: rw [lt_iff_le_and_ne, ← tsub_le_iff_right]
state_before: α : Type u_1
β : Type u_2
inst✝³ : PartialOrder α
inst✝² : AddCommSemigroup α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
hc : AddLECancellable c
h : a - c < b
⊢ a - c ≤ b ∧ a ≠ b + c
state_after: α : Type u_1
β : Type u_2
inst✝³ : PartialOrder α
inst✝² : AddCommSemigroup α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
hc : AddLECancellable c
h : a - c < b
⊢ a ≠ b + c
tactic: refine ⟨h.le, ?_⟩
state_before: α : Type u_1
β : Type u_2
inst✝³ : PartialOrder α
inst✝² : AddCommSemigroup α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
hc : AddLECancellable c
h : a - c < b
⊢ a ≠ b + c
state_after: α : Type u_1
β : Type u_2
inst✝³ : PartialOrder α
inst✝² : AddCommSemigroup α
inst✝¹ : Sub α
inst✝ : OrderedSub α
b c d : α
hc : AddLECancellable c
h : b + c - c < b
⊢ False
tactic: rintro rfl
state_before: α : Type u_1
β : Type u_2
inst✝³ : PartialOrder α
inst✝² : AddCommSemigroup α
inst✝¹ : Sub α
inst✝ : OrderedSub α
b c d : α
hc : AddLECancellable c
h : b + c - c < b
⊢ False
state_after: no goals
tactic: simp [hc] at h
Theorem: Basis.det_reindex
File: Mathlib/LinearAlgebra/Determinant.lean

Proof steps:
state_before: R : Type u_1
inst✝¹⁰ : CommRing R
M : Type u_2
inst✝⁹ : AddCommGroup M
inst✝⁸ : Module R M
M' : Type u_3
inst✝⁷ : AddCommGroup M'
inst✝⁶ : Module R M'
ι : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Fintype ι
e✝ : Basis ι R M
A : Type u_5
inst✝³ : CommRing A
inst✝² : Module A M
ι' : Type u_6
inst✝¹ : Fintype ι'
inst✝ : DecidableEq ι'
b : Basis ι R M
v : ι' → M
e : ι ≃ ι'
⊢ (b.reindex e).det v = b.det (v ∘ ⇑e)
state_after: no goals
tactic: rw [Basis.det_apply, Basis.toMatrix_reindex', det_reindexAlgEquiv, Basis.det_apply]
Theorem: SetTheory.PGame.neg_insertRight_neg
File: Mathlib/SetTheory/Game/PGame.lean

Proof steps:
state_before: xl xr : Type u
x x' : PGame
⊢ (-x).insertRight (-x') = -x.insertLeft x'
state_after: case mk
xl xr : Type u
x' : PGame
α✝ β✝ : Type u
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
⊢ (-mk α✝ β✝ a✝¹ a✝).insertRight (-x') = -(mk α✝ β✝ a✝¹ a✝).insertLeft x'
tactic: cases x
state_before: case mk
xl xr : Type u
x' : PGame
α✝ β✝ : Type u
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
⊢ (-mk α✝ β✝ a✝¹ a✝).insertRight (-x') = -(mk α✝ β✝ a✝¹ a✝).insertLeft x'
state_after: case mk.mk
xl xr α✝¹ β✝¹ : Type u
a✝³ : α✝¹ → PGame
a✝² : β✝¹ → PGame
α✝ β✝ : Type u
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
⊢ (-mk α✝¹ β✝¹ a✝³ a✝²).insertRight (-mk α✝ β✝ a✝¹ a✝) = -(mk α✝¹ β✝¹ a✝³ a✝²).insertLeft (mk α✝ β✝ a✝¹ a✝)
tactic: cases x'
state_before: case mk.mk
xl xr α✝¹ β✝¹ : Type u
a✝³ : α✝¹ → PGame
a✝² : β✝¹ → PGame
α✝ β✝ : Type u
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
⊢ (-mk α✝¹ β✝¹ a✝³ a✝²).insertRight (-mk α✝ β✝ a✝¹ a✝) = -(mk α✝¹ β✝¹ a✝³ a✝²).insertLeft (mk α✝ β✝ a✝¹ a✝)
state_after: case mk.mk
xl xr α✝¹ β✝¹ : Type u
a✝³ : α✝¹ → PGame
a✝² : β✝¹ → PGame
α✝ β✝ : Type u
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
⊢ mk β✝¹ (α✝¹ ⊕ PUnit.{u + 1}) (fun j => -a✝² j)
      (Sum.elim (fun i => -a✝³ i) fun x => mk β✝ α✝ (fun j => -a✝ j) fun i => -a✝¹ i) =
    mk β✝¹ (α✝¹ ⊕ PUnit.{u + 1}) (fun j => -a✝² j) fun i => -Sum.elim a✝³ (fun x => mk α✝ β✝ a✝¹ a✝) i
tactic: dsimp [insertRight, insertLeft]
state_before: case mk.mk
xl xr α✝¹ β✝¹ : Type u
a✝³ : α✝¹ → PGame
a✝² : β✝¹ → PGame
α✝ β✝ : Type u
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
⊢ mk β✝¹ (α✝¹ ⊕ PUnit.{u + 1}) (fun j => -a✝² j)
      (Sum.elim (fun i => -a✝³ i) fun x => mk β✝ α✝ (fun j => -a✝ j) fun i => -a✝¹ i) =
    mk β✝¹ (α✝¹ ⊕ PUnit.{u + 1}) (fun j => -a✝² j) fun i => -Sum.elim a✝³ (fun x => mk α✝ β✝ a✝¹ a✝) i
state_after: no goals
tactic: congr! with (i | j)
Theorem: Equiv.Perm.cycleOf_apply_apply_pow_self
File: Mathlib/GroupTheory/Perm/Cycle/Factors.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f✝ g : Perm α
x✝ y : α
inst✝² : DecidableRel f✝.SameCycle
inst✝¹ : DecidableRel g.SameCycle
f : Perm α
inst✝ : DecidableRel f.SameCycle
x : α
k : ℕ
⊢ (f.cycleOf x) ((f ^ k) x) = (f ^ (k + 1)) x
state_after: no goals
tactic: convert cycleOf_apply_apply_zpow_self f x k using 1
Theorem: AkraBazziRecurrence.eventually_asympBound_pos
File: Mathlib/Computability/AkraBazzi/AkraBazzi.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ ∀ᶠ (n : ℕ) in atTop, 0 < asympBound g a b n
state_after: case h
α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
n : ℕ
hn : 0 < n
⊢ 0 < asympBound g a b n
tactic: filter_upwards [eventually_gt_atTop 0] with n hn
state_before: case h
α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
n : ℕ
hn : 0 < n
⊢ 0 < asympBound g a b n
state_after: no goals
tactic: exact R.asympBound_pos n hn
Theorem: PMF.bind_comm
File: Mathlib/Probability/ProbabilityMassFunction/Monad.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p✝ : PMF α
f✝ : α → PMF β
g : β → PMF γ
p : PMF α
q : PMF β
f : α → β → PMF γ
b : γ
⊢ (p.bind fun a => q.bind (f a)) b = (q.bind fun b => p.bind fun a => f a b) b
state_after: no goals
tactic: simpa only [ENNReal.coe_inj.symm, bind_apply, ENNReal.tsum_mul_left.symm,
      ENNReal.tsum_mul_right.symm, mul_assoc, mul_left_comm, mul_comm] using ENNReal.tsum_comm
Theorem: zero_leftAddCoset
File: Mathlib/GroupTheory/Coset.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Monoid α
s : Set α
⊢ ∀ (x : α), x ∈ 1 • s ↔ x ∈ s
state_after: no goals
tactic: simp [← image_smul]
Theorem: Nat.pow_left_injective
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
hn : n ≠ 0
⊢ Injective fun a => a ^ n
state_after: no goals
tactic: simp [Injective, le_antisymm_iff, Nat.pow_le_pow_iff_left hn]
Theorem: PartENat.find_le
File: Mathlib/Data/Nat/PartENat.lean

Proof steps:
state_before: P : ℕ → Prop
inst✝ : DecidablePred P
n : ℕ
h : P n
⊢ find P ≤ ↑n
state_after: P : ℕ → Prop
inst✝ : DecidablePred P
n : ℕ
h : P n
⊢ ∃ (h : (find P).Dom), (find P).get h ≤ n
tactic: rw [le_coe_iff]
state_before: P : ℕ → Prop
inst✝ : DecidablePred P
n : ℕ
h : P n
⊢ ∃ (h : (find P).Dom), (find P).get h ≤ n
state_after: no goals
tactic: exact ⟨⟨_, h⟩, @Nat.find_min' P _ _ _ h⟩
Theorem: Set.preimage_const
File: Mathlib/Data/Set/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f : α → β
g : β → γ
b : β
s : Set β
inst✝ : Decidable (b ∈ s)
⊢ (fun x => b) ⁻¹' s = if b ∈ s then univ else ∅
state_after: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f : α → β
g : β → γ
b : β
s : Set β
inst✝ : Decidable (b ∈ s)
hb : b ∈ s
⊢ (fun x => b) ⁻¹' s = univ

case neg
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f : α → β
g : β → γ
b : β
s : Set β
inst✝ : Decidable (b ∈ s)
hb : b ∉ s
⊢ (fun x => b) ⁻¹' s = ∅
tactic: split_ifs with hb
state_before: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f : α → β
g : β → γ
b : β
s : Set β
inst✝ : Decidable (b ∈ s)
hb : b ∈ s
⊢ (fun x => b) ⁻¹' s = univ

case neg
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f : α → β
g : β → γ
b : β
s : Set β
inst✝ : Decidable (b ∈ s)
hb : b ∉ s
⊢ (fun x => b) ⁻¹' s = ∅
state_after: no goals
tactic: exacts [preimage_const_of_mem hb, preimage_const_of_not_mem hb]
Theorem: Ideal.hasBasis_nhds_adic
File: Mathlib/Topology/Algebra/Nonarchimedean/AdicTopology.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommRing R
I : Ideal R
x : R
⊢ (𝓝 x).HasBasis (fun _n => True) fun n => (fun y => x + y) '' ↑(I ^ n)
state_after: R : Type u_1
inst✝ : CommRing R
I : Ideal R
x : R
this : TopologicalSpace R := I.adicTopology
⊢ (𝓝 x).HasBasis (fun _n => True) fun n => (fun y => x + y) '' ↑(I ^ n)
tactic: letI := I.adicTopology
state_before: R : Type u_1
inst✝ : CommRing R
I : Ideal R
x : R
this : TopologicalSpace R := I.adicTopology
⊢ (𝓝 x).HasBasis (fun _n => True) fun n => (fun y => x + y) '' ↑(I ^ n)
state_after: R : Type u_1
inst✝ : CommRing R
I : Ideal R
x : R
this✝ : TopologicalSpace R := I.adicTopology
this : (Filter.map (fun y => x + y) (𝓝 0)).HasBasis (fun _n => True) fun i => (fun y => x + y) '' ↑(I ^ i)
⊢ (𝓝 x).HasBasis (fun _n => True) fun n => (fun y => x + y) '' ↑(I ^ n)
tactic: have := I.hasBasis_nhds_zero_adic.map fun y => x + y
state_before: R : Type u_1
inst✝ : CommRing R
I : Ideal R
x : R
this✝ : TopologicalSpace R := I.adicTopology
this : (Filter.map (fun y => x + y) (𝓝 0)).HasBasis (fun _n => True) fun i => (fun y => x + y) '' ↑(I ^ i)
⊢ (𝓝 x).HasBasis (fun _n => True) fun n => (fun y => x + y) '' ↑(I ^ n)
state_after: no goals
tactic: rwa [map_add_left_nhds_zero x] at this
Theorem: Nat.le_half_of_half_lt_sub
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
h : a / 2 < a - b
⊢ b ≤ a / 2
state_after: a b c d m n k : ℕ
p q : ℕ → Prop
h : a / 2 < a - b
⊢ b * 2 ≤ a
tactic: rw [Nat.le_div_iff_mul_le Nat.two_pos]
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
h : a / 2 < a - b
⊢ b * 2 ≤ a
state_after: a b c d m n k : ℕ
p q : ℕ → Prop
h : a + b * 2 < a + a
⊢ b * 2 ≤ a
tactic: rw [Nat.div_lt_iff_lt_mul Nat.two_pos, Nat.sub_mul, Nat.lt_sub_iff_add_lt,
    Nat.mul_two a] at h
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
h : a + b * 2 < a + a
⊢ b * 2 ≤ a
state_after: no goals
tactic: exact Nat.le_of_lt (Nat.lt_of_add_lt_add_left h)
Theorem: Lagrange.interpolate_eq_sum_interpolate_insert_sdiff
File: Mathlib/LinearAlgebra/Lagrange.lean

Proof steps:
state_before: F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s t : Finset ι
i j : ι
v r r' : ι → F
hvt : Set.InjOn v ↑t
hs : s.Nonempty
hst : s ⊆ t
⊢ (interpolate t v) r = ∑ i ∈ s, (interpolate (insert i (t \ s)) v) r * Lagrange.basis s v i
state_after: F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s t : Finset ι
i j : ι
v r r' : ι → F
hvt : Set.InjOn v ↑t
hs : s.Nonempty
hst : s ⊆ t
⊢ ∑ i ∈ s, (interpolate (insert i (t \ s)) v) r * Lagrange.basis s v i = (interpolate t v) r
tactic: symm
state_before: F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s t : Finset ι
i j : ι
v r r' : ι → F
hvt : Set.InjOn v ↑t
hs : s.Nonempty
hst : s ⊆ t
⊢ ∑ i ∈ s, (interpolate (insert i (t \ s)) v) r * Lagrange.basis s v i = (interpolate t v) r
state_after: case refine_1
F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s t : Finset ι
i j : ι
v r r' : ι → F
hvt : Set.InjOn v ↑t
hs : s.Nonempty
hst : s ⊆ t
⊢ (s.sup fun b => ((interpolate (insert b (t \ s)) v) r * Lagrange.basis s v b).degree) < ↑t.card

case refine_2
F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s t : Finset ι
i✝ j : ι
v r r' : ι → F
hvt : Set.InjOn v ↑t
hs : s.Nonempty
hst : s ⊆ t
i : ι
hi : i ∈ t
⊢ eval (v i) (∑ i ∈ s, (interpolate (insert i (t \ s)) v) r * Lagrange.basis s v i) = r i
tactic: refine eq_interpolate_of_eval_eq _ hvt (lt_of_le_of_lt (degree_sum_le _ _) ?_) fun i hi => ?_
Theorem: abs_lt_of_sq_lt_sq
File: Mathlib/Algebra/Order/Ring/Abs.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedRing α
n : ℕ
a b c : α
h : a ^ 2 < b ^ 2
hb : 0 ≤ b
⊢ |a| < b
state_after: no goals
tactic: rwa [← abs_of_nonneg hb, ← sq_lt_sq]
Theorem: Pi.continuous_curry
File: Mathlib/Control/LawfulFix.lean

Proof steps:
state_before: α : Type u_1
β : α → Type u_2
γ : (a : α) → β a → Type u_3
inst✝ : (x : α) → (y : β x) → OmegaCompletePartialOrder (γ x y)
c : Chain ((x : (a : α) × β a) → γ x.fst x.snd)
⊢ (monotoneCurry α β γ) (ωSup c) = ωSup (c.map (monotoneCurry α β γ))
state_after: case h.h
α : Type u_1
β : α → Type u_2
γ : (a : α) → β a → Type u_3
inst✝ : (x : α) → (y : β x) → OmegaCompletePartialOrder (γ x y)
c : Chain ((x : (a : α) × β a) → γ x.fst x.snd)
x : α
y : β x
⊢ (monotoneCurry α β γ) (ωSup c) x y = ωSup (c.map (monotoneCurry α β γ)) x y
tactic: ext x y
state_before: case h.h
α : Type u_1
β : α → Type u_2
γ : (a : α) → β a → Type u_3
inst✝ : (x : α) → (y : β x) → OmegaCompletePartialOrder (γ x y)
c : Chain ((x : (a : α) × β a) → γ x.fst x.snd)
x : α
y : β x
⊢ (monotoneCurry α β γ) (ωSup c) x y = ωSup (c.map (monotoneCurry α β γ)) x y
state_after: case h.h
α : Type u_1
β : α → Type u_2
γ : (a : α) → β a → Type u_3
inst✝ : (x : α) → (y : β x) → OmegaCompletePartialOrder (γ x y)
c : Chain ((x : (a : α) × β a) → γ x.fst x.snd)
x : α
y : β x
⊢ ωSup (c.map (evalOrderHom ⟨x, y⟩)) = ωSup (((c.map (monotoneCurry α β γ)).map (evalOrderHom x)).map (evalOrderHom y))
tactic: dsimp [curry, ωSup]
state_before: case h.h
α : Type u_1
β : α → Type u_2
γ : (a : α) → β a → Type u_3
inst✝ : (x : α) → (y : β x) → OmegaCompletePartialOrder (γ x y)
c : Chain ((x : (a : α) × β a) → γ x.fst x.snd)
x : α
y : β x
⊢ ωSup (c.map (evalOrderHom ⟨x, y⟩)) = ωSup (((c.map (monotoneCurry α β γ)).map (evalOrderHom x)).map (evalOrderHom y))
state_after: case h.h
α : Type u_1
β : α → Type u_2
γ : (a : α) → β a → Type u_3
inst✝ : (x : α) → (y : β x) → OmegaCompletePartialOrder (γ x y)
c : Chain ((x : (a : α) × β a) → γ x.fst x.snd)
x : α
y : β x
⊢ ωSup (c.map (evalOrderHom ⟨x, y⟩)) =
    ωSup (c.map (((evalOrderHom y).comp (evalOrderHom x)).comp (monotoneCurry α β γ)))
tactic: rw [map_comp, map_comp]
state_before: case h.h
α : Type u_1
β : α → Type u_2
γ : (a : α) → β a → Type u_3
inst✝ : (x : α) → (y : β x) → OmegaCompletePartialOrder (γ x y)
c : Chain ((x : (a : α) × β a) → γ x.fst x.snd)
x : α
y : β x
⊢ ωSup (c.map (evalOrderHom ⟨x, y⟩)) =
    ωSup (c.map (((evalOrderHom y).comp (evalOrderHom x)).comp (monotoneCurry α β γ)))
state_after: no goals
tactic: rfl
Theorem: hasDerivAt_ofReal_cpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean

Proof steps:
state_before: f g : ℂ → ℂ
s : Set ℂ
f' g' x✝ c : ℂ
x : ℝ
hx : x ≠ 0
r : ℂ
hr : r ≠ -1
⊢ HasDerivAt (fun y => ↑y ^ (r + 1) / (r + 1)) (↑x ^ r) x
state_after: f g : ℂ → ℂ
s : Set ℂ
f' g' x✝ c : ℂ
x : ℝ
hx : x ≠ 0
r : ℂ
hr : r + 1 ≠ 0
⊢ HasDerivAt (fun y => ↑y ^ (r + 1) / (r + 1)) (↑x ^ r) x
tactic: rw [Ne, ← add_eq_zero_iff_eq_neg, ← Ne] at hr
state_before: f g : ℂ → ℂ
s : Set ℂ
f' g' x✝ c : ℂ
x : ℝ
hx : x ≠ 0
r : ℂ
hr : r + 1 ≠ 0
⊢ HasDerivAt (fun y => ↑y ^ (r + 1) / (r + 1)) (↑x ^ r) x
state_after: case inl
f g : ℂ → ℂ
s : Set ℂ
f' g' x✝ c : ℂ
x : ℝ
hx✝ : x ≠ 0
r : ℂ
hr : r + 1 ≠ 0
hx : 0 < x
⊢ HasDerivAt (fun y => ↑y ^ (r + 1) / (r + 1)) (↑x ^ r) x

case inr
f g : ℂ → ℂ
s : Set ℂ
f' g' x✝ c : ℂ
x : ℝ
hx✝ : x ≠ 0
r : ℂ
hr : r + 1 ≠ 0
hx : 0 > x
⊢ HasDerivAt (fun y => ↑y ^ (r + 1) / (r + 1)) (↑x ^ r) x
tactic: rcases lt_or_gt_of_ne hx.symm with (hx | hx)
Theorem: MeasurableEmbedding.integrableOn_map_iff
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
f✝ g : α → E
s✝ t : Set α
μ✝ ν : Measure α
inst✝ : MeasurableSpace β
e : α → β
he : MeasurableEmbedding e
f : β → E
μ : Measure α
s : Set β
⊢ IntegrableOn f s (Measure.map e μ) ↔ IntegrableOn (f ∘ e) (e ⁻¹' s) μ
state_after: no goals
tactic: simp_rw [IntegrableOn, he.restrict_map, he.integrable_map_iff]
Theorem: Subalgebra.rank_sup_le_of_free
File: Mathlib/LinearAlgebra/TensorProduct/Subalgebra.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing S
inst✝² : Algebra R S
A B : Subalgebra R S
inst✝¹ : Module.Free R ↥A
inst✝ : Module.Free R ↥B
⊢ Module.rank R ↥(A ⊔ B) ≤ Module.rank R ↥A * Module.rank R ↥B
state_after: R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing S
inst✝² : Algebra R S
A B : Subalgebra R S
inst✝¹ : Module.Free R ↥A
inst✝ : Module.Free R ↥B
a✝ : Nontrivial R
⊢ Module.rank R ↥(A ⊔ B) ≤ Module.rank R ↥A * Module.rank R ↥B
tactic: nontriviality R
state_before: R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing S
inst✝² : Algebra R S
A B : Subalgebra R S
inst✝¹ : Module.Free R ↥A
inst✝ : Module.Free R ↥B
a✝ : Nontrivial R
⊢ Module.rank R ↥(A ⊔ B) ≤ Module.rank R ↥A * Module.rank R ↥B
state_after: R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing S
inst✝² : Algebra R S
A B : Subalgebra R S
inst✝¹ : Module.Free R ↥A
inst✝ : Module.Free R ↥B
a✝ : Nontrivial R
⊢ Module.rank R ↥(A.mulMap B).range ≤ Module.rank R (↥A ⊗[R] ↥B)
tactic: rw [← rank_tensorProduct', ← mulMap_range]
state_before: R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing S
inst✝² : Algebra R S
A B : Subalgebra R S
inst✝¹ : Module.Free R ↥A
inst✝ : Module.Free R ↥B
a✝ : Nontrivial R
⊢ Module.rank R ↥(A.mulMap B).range ≤ Module.rank R (↥A ⊗[R] ↥B)
state_after: no goals
tactic: exact rank_range_le (A.mulMap B).toLinearMap
Theorem: List.unzip_zip
File: Mathlib/Data/List/Zip.lean

Proof steps:
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
l₁ : List α
l₂ : List β
h : l₁.length = l₂.length
⊢ (l₁.zip l₂).unzip = (l₁, l₂)
state_after: no goals
tactic: rw [← Prod.mk.eta (p := unzip (zip l₁ l₂)),
    unzip_zip_left (le_of_eq h), unzip_zip_right (ge_of_eq h)]
Theorem: CategoryTheory.Iso.map_hom_inv_id_app
File: Mathlib/CategoryTheory/Functor/Category.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✝ G H I : C ⥤ D
X Y : C
e : X ≅ Y
F : C ⥤ D ⥤ E
Z : D
⊢ (F.map e.hom).app Z ≫ (F.map e.inv).app Z = 𝟙 ((F.obj X).obj Z)
state_after: no goals
tactic: simp [← NatTrans.comp_app, ← Functor.map_comp]
Theorem: Rat.add_def
File: .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean

Proof steps:
state_before: a b : Rat
⊢ a + b = normalize (a.num * ↑b.den + b.num * ↑a.den) (a.den * b.den) ⋯
state_after: a b : Rat
⊢ a.add b = normalize (a.num * ↑b.den + b.num * ↑a.den) (a.den * b.den) ⋯
tactic: show Rat.add .. = _
state_before: a b : Rat
⊢ a.add b = normalize (a.num * ↑b.den + b.num * ↑a.den) (a.den * b.den) ⋯
state_after: a b : Rat
⊢ (let g := a.den.gcd b.den;
    if hg : g = 1 then
      let_fun den_nz := ⋯;
      let_fun reduced := ⋯;
      { num := a.num * ↑b.den + b.num * ↑a.den, den := a.den * b.den, den_nz := den_nz, reduced := reduced }
    else
      let den := a.den / g * b.den;
      let num := a.num * ↑(b.den / g) + b.num * ↑(a.den / g);
      let g1 := num.natAbs.gcd g;
      let_fun den_nz := ⋯;
      let_fun e := ⋯;
      maybeNormalize num den g1 ⋯ ⋯) =
    normalize (a.num * ↑b.den + b.num * ↑a.den) (a.den * b.den) ⋯
tactic: delta Rat.add
state_before: a b : Rat
⊢ (let g := a.den.gcd b.den;
    if hg : g = 1 then
      let_fun den_nz := ⋯;
      let_fun reduced := ⋯;
      { num := a.num * ↑b.den + b.num * ↑a.den, den := a.den * b.den, den_nz := den_nz, reduced := reduced }
    else
      let den := a.den / g * b.den;
      let num := a.num * ↑(b.den / g) + b.num * ↑(a.den / g);
      let g1 := num.natAbs.gcd g;
      let_fun den_nz := ⋯;
      let_fun e := ⋯;
      maybeNormalize num den g1 ⋯ ⋯) =
    normalize (a.num * ↑b.den + b.num * ↑a.den) (a.den * b.den) ⋯
state_after: a b : Rat
⊢ (if hg : a.den.gcd b.den = 1 then
      { num := a.num * ↑b.den + b.num * ↑a.den, den := a.den * b.den, den_nz := ⋯, reduced := ⋯ }
    else
      maybeNormalize (a.num * ↑(b.den / a.den.gcd b.den) + b.num * ↑(a.den / a.den.gcd b.den))
        (a.den / a.den.gcd b.den * b.den)
        ((a.num * ↑(b.den / a.den.gcd b.den) + b.num * ↑(a.den / a.den.gcd b.den)).natAbs.gcd (a.den.gcd b.den)) ⋯ ⋯) =
    normalize (a.num * ↑b.den + b.num * ↑a.den) (a.den * b.den) ⋯
tactic: dsimp only
state_before: a b : Rat
⊢ (if hg : a.den.gcd b.den = 1 then
      { num := a.num * ↑b.den + b.num * ↑a.den, den := a.den * b.den, den_nz := ⋯, reduced := ⋯ }
    else
      maybeNormalize (a.num * ↑(b.den / a.den.gcd b.den) + b.num * ↑(a.den / a.den.gcd b.den))
        (a.den / a.den.gcd b.den * b.den)
        ((a.num * ↑(b.den / a.den.gcd b.den) + b.num * ↑(a.den / a.den.gcd b.den)).natAbs.gcd (a.den.gcd b.den)) ⋯ ⋯) =
    normalize (a.num * ↑b.den + b.num * ↑a.den) (a.den * b.den) ⋯
state_after: case isTrue
a b : Rat
h✝ : a.den.gcd b.den = 1
⊢ { num := a.num * ↑b.den + b.num * ↑a.den, den := a.den * b.den, den_nz := ⋯, reduced := ⋯ } =
    normalize (a.num * ↑b.den + b.num * ↑a.den) (a.den * b.den) ⋯

case isFalse
a b : Rat
h✝ : ¬a.den.gcd b.den = 1
⊢ maybeNormalize (a.num * ↑(b.den / a.den.gcd b.den) + b.num * ↑(a.den / a.den.gcd b.den))
      (a.den / a.den.gcd b.den * b.den)
      ((a.num * ↑(b.den / a.den.gcd b.den) + b.num * ↑(a.den / a.den.gcd b.den)).natAbs.gcd (a.den.gcd b.den)) ⋯ ⋯ =
    normalize (a.num * ↑b.den + b.num * ↑a.den) (a.den * b.den) ⋯
tactic: split
Theorem: le_compl_iff_disjoint_right
File: Mathlib/Order/Heyting/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : HeytingAlgebra α
a b c : α
⊢ a ≤ bᶜ ↔ Disjoint a b
state_after: no goals
tactic: rw [← himp_bot, le_himp_iff, disjoint_iff_inf_le]
Theorem: spectrum.exists_nnnorm_eq_spectralRadius_of_nonempty
File: Mathlib/Analysis/Normed/Algebra/Spectrum.lean

Proof steps:
state_before: 𝕜 : Type u_1
A : Type u_2
inst✝⁴ : NormedField 𝕜
inst✝³ : NormedRing A
inst✝² : NormedAlgebra 𝕜 A
inst✝¹ : CompleteSpace A
inst✝ : ProperSpace 𝕜
a : A
ha : (σ a).Nonempty
⊢ ∃ k ∈ σ a, ↑‖k‖₊ = spectralRadius 𝕜 a
state_after: case intro.intro
𝕜 : Type u_1
A : Type u_2
inst✝⁴ : NormedField 𝕜
inst✝³ : NormedRing A
inst✝² : NormedAlgebra 𝕜 A
inst✝¹ : CompleteSpace A
inst✝ : ProperSpace 𝕜
a : A
ha : (σ a).Nonempty
k : 𝕜
hk : k ∈ σ a
h : IsMaxOn (fun a => ‖a‖₊) (σ a) k
⊢ ∃ k ∈ σ a, ↑‖k‖₊ = spectralRadius 𝕜 a
tactic: obtain ⟨k, hk, h⟩ := (spectrum.isCompact a).exists_isMaxOn ha continuous_nnnorm.continuousOn
state_before: case intro.intro
𝕜 : Type u_1
A : Type u_2
inst✝⁴ : NormedField 𝕜
inst✝³ : NormedRing A
inst✝² : NormedAlgebra 𝕜 A
inst✝¹ : CompleteSpace A
inst✝ : ProperSpace 𝕜
a : A
ha : (σ a).Nonempty
k : 𝕜
hk : k ∈ σ a
h : IsMaxOn (fun a => ‖a‖₊) (σ a) k
⊢ ∃ k ∈ σ a, ↑‖k‖₊ = spectralRadius 𝕜 a
state_after: no goals
tactic: exact ⟨k, hk, le_antisymm (le_iSup₂ (α := ℝ≥0∞) k hk) (iSup₂_le <| mod_cast h)⟩