ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: lt_iff_exists_mul
File: Mathlib/Algebra/Order/Monoid/Canonical/Defs.lean

Proof steps:
state_before: α : Type u
inst✝¹ : CanonicallyOrderedCommMonoid α
a b c d : α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
⊢ a < b ↔ ∃ c, c > 1 ∧ b = a * c
state_after: α : Type u
inst✝¹ : CanonicallyOrderedCommMonoid α
a b c d : α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
⊢ (∃ x, b = a * x ∧ a ≠ b) ↔ ∃ c, c > 1 ∧ b = a * c
tactic: rw [lt_iff_le_and_ne, le_iff_exists_mul, ← exists_and_right]
state_before: α : Type u
inst✝¹ : CanonicallyOrderedCommMonoid α
a b c d : α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
⊢ (∃ x, b = a * x ∧ a ≠ b) ↔ ∃ c, c > 1 ∧ b = a * c
state_after: case h
α : Type u
inst✝¹ : CanonicallyOrderedCommMonoid α
a b c d : α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
⊢ ∀ (a_1 : α), b = a * a_1 ∧ a ≠ b ↔ a_1 > 1 ∧ b = a * a_1
tactic: apply exists_congr
state_before: case h
α : Type u
inst✝¹ : CanonicallyOrderedCommMonoid α
a b c d : α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
⊢ ∀ (a_1 : α), b = a * a_1 ∧ a ≠ b ↔ a_1 > 1 ∧ b = a * a_1
state_after: case h
α : Type u
inst✝¹ : CanonicallyOrderedCommMonoid α
a b c✝ d : α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
c : α
⊢ b = a * c ∧ a ≠ b ↔ c > 1 ∧ b = a * c
tactic: intro c
state_before: case h
α : Type u
inst✝¹ : CanonicallyOrderedCommMonoid α
a b c✝ d : α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
c : α
⊢ b = a * c ∧ a ≠ b ↔ c > 1 ∧ b = a * c
state_after: case h
α : Type u
inst✝¹ : CanonicallyOrderedCommMonoid α
a b c✝ d : α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
c : α
⊢ b = a * c → (a ≠ b ↔ 1 < c)
tactic: rw [and_comm, and_congr_left_iff, gt_iff_lt]
state_before: case h
α : Type u
inst✝¹ : CanonicallyOrderedCommMonoid α
a b c✝ d : α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
c : α
⊢ b = a * c → (a ≠ b ↔ 1 < c)
state_after: case h
α : Type u
inst✝¹ : CanonicallyOrderedCommMonoid α
a c✝ d : α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
c : α
⊢ a ≠ a * c ↔ 1 < c
tactic: rintro rfl
state_before: case h
α : Type u
inst✝¹ : CanonicallyOrderedCommMonoid α
a c✝ d : α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
c : α
⊢ a ≠ a * c ↔ 1 < c
state_after: case h.mp
α : Type u
inst✝¹ : CanonicallyOrderedCommMonoid α
a c✝ d : α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
c : α
⊢ a ≠ a * c → 1 < c

case h.mpr
α : Type u
inst✝¹ : CanonicallyOrderedCommMonoid α
a c✝ d : α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
c : α
⊢ 1 < c → a ≠ a * c
tactic: constructor
Theorem: CategoryTheory.Bicategory.leftUnitor_comp_inv
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

Proof steps:
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
⊢ (λ_ (f ≫ g)).inv = (λ_ f).inv ▷ g ≫ (α_ (𝟙 a) f g).hom
state_after: no goals
tactic: simp
Theorem: NNReal.rpow_sum_le_const_mul_sum_rpow
File: Mathlib/Analysis/MeanInequalities.lean

Proof steps:
state_before: ι : Type u
s : Finset ι
f : ι → ℝ≥0
p : ℝ
hp : 1 ≤ p
⊢ (∑ i ∈ s, f i) ^ p ≤ ↑s.card ^ (p - 1) * ∑ i ∈ s, f i ^ p
state_after: case inl
ι : Type u
s : Finset ι
f : ι → ℝ≥0
p : ℝ
hp✝ : 1 ≤ p
hp : 1 = p
⊢ (∑ i ∈ s, f i) ^ p ≤ ↑s.card ^ (p - 1) * ∑ i ∈ s, f i ^ p

case inr
ι : Type u
s : Finset ι
f : ι → ℝ≥0
p : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
⊢ (∑ i ∈ s, f i) ^ p ≤ ↑s.card ^ (p - 1) * ∑ i ∈ s, f i ^ p
tactic: cases' eq_or_lt_of_le hp with hp hp
state_before: case inr
ι : Type u
s : Finset ι
f : ι → ℝ≥0
p : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
⊢ (∑ i ∈ s, f i) ^ p ≤ ↑s.card ^ (p - 1) * ∑ i ∈ s, f i ^ p
state_after: case inr
ι : Type u
s : Finset ι
f : ι → ℝ≥0
p : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
q : ℝ := p / (p - 1)
⊢ (∑ i ∈ s, f i) ^ p ≤ ↑s.card ^ (p - 1) * ∑ i ∈ s, f i ^ p
tactic: let q : ℝ := p / (p - 1)
state_before: case inr
ι : Type u
s : Finset ι
f : ι → ℝ≥0
p : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
q : ℝ := p / (p - 1)
⊢ (∑ i ∈ s, f i) ^ p ≤ ↑s.card ^ (p - 1) * ∑ i ∈ s, f i ^ p
state_after: case inr
ι : Type u
s : Finset ι
f : ι → ℝ≥0
p : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
q : ℝ := p / (p - 1)
hpq : p.IsConjExponent q
⊢ (∑ i ∈ s, f i) ^ p ≤ ↑s.card ^ (p - 1) * ∑ i ∈ s, f i ^ p
tactic: have hpq : p.IsConjExponent q := .conjExponent hp
state_before: case inr
ι : Type u
s : Finset ι
f : ι → ℝ≥0
p : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
q : ℝ := p / (p - 1)
hpq : p.IsConjExponent q
⊢ (∑ i ∈ s, f i) ^ p ≤ ↑s.card ^ (p - 1) * ∑ i ∈ s, f i ^ p
state_after: case inr
ι : Type u
s : Finset ι
f : ι → ℝ≥0
p : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
q : ℝ := p / (p - 1)
hpq : p.IsConjExponent q
hp₁ : 1 / p * p = 1
⊢ (∑ i ∈ s, f i) ^ p ≤ ↑s.card ^ (p - 1) * ∑ i ∈ s, f i ^ p
tactic: have hp₁ : 1 / p * p = 1 := one_div_mul_cancel hpq.ne_zero
state_before: case inr
ι : Type u
s : Finset ι
f : ι → ℝ≥0
p : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
q : ℝ := p / (p - 1)
hpq : p.IsConjExponent q
hp₁ : 1 / p * p = 1
⊢ (∑ i ∈ s, f i) ^ p ≤ ↑s.card ^ (p - 1) * ∑ i ∈ s, f i ^ p
state_after: case inr
ι : Type u
s : Finset ι
f : ι → ℝ≥0
p : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
q : ℝ := p / (p - 1)
hpq : p.IsConjExponent q
hp₁ : 1 / p * p = 1
hq : 1 / q * p = p - 1
⊢ (∑ i ∈ s, f i) ^ p ≤ ↑s.card ^ (p - 1) * ∑ i ∈ s, f i ^ p
tactic: have hq : 1 / q * p = p - 1 := by
    rw [← hpq.div_conj_eq_sub_one]
    ring
state_before: case inr
ι : Type u
s : Finset ι
f : ι → ℝ≥0
p : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
q : ℝ := p / (p - 1)
hpq : p.IsConjExponent q
hp₁ : 1 / p * p = 1
hq : 1 / q * p = p - 1
⊢ (∑ i ∈ s, f i) ^ p ≤ ↑s.card ^ (p - 1) * ∑ i ∈ s, f i ^ p
state_after: no goals
tactic: simpa only [NNReal.mul_rpow, ← NNReal.rpow_mul, hp₁, hq, one_mul, one_rpow, rpow_one,
    Pi.one_apply, sum_const, Nat.smul_one_eq_cast] using
    NNReal.rpow_le_rpow (inner_le_Lp_mul_Lq s 1 f hpq.symm) hpq.nonneg
Theorem: AddLocalization.mk_left_injective
File: Mathlib/GroupTheory/MonoidLocalization/Basic.lean

Proof steps:
state_before: α : Type u_1
inst✝ : CancelCommMonoid α
s : Submonoid α
a₁ b₁ : α
a₂ b₂ b : ↥s
c d : α
h : (fun a => mk a b) c = (fun a => mk a b) d
⊢ c = d
state_after: no goals
tactic: simpa [-mk_eq_monoidOf_mk', mk_eq_mk_iff, r_iff_exists] using h
Theorem: AlgebraicGeometry.topologically_iso_le
File: Mathlib/AlgebraicGeometry/Morphisms/Constructors.lean

Proof steps:
state_before: P : {α β : Type u} → [inst : TopologicalSpace α] → [inst : TopologicalSpace β] → (α → β) → Prop
hP : ∀ {α β : Type u} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] (f : α ≃ₜ β), P ⇑f
⊢ MorphismProperty.isomorphisms Scheme ≤ topologically fun {α β} [TopologicalSpace α] [TopologicalSpace β] => P
state_after: P : {α β : Type u} → [inst : TopologicalSpace α] → [inst : TopologicalSpace β] → (α → β) → Prop
hP : ∀ {α β : Type u} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] (f : α ≃ₜ β), P ⇑f
X Y : Scheme
e : X ⟶ Y
he : IsIso e
⊢ topologically (fun {α β} [TopologicalSpace α] [TopologicalSpace β] => P) e
tactic: intro X Y e (he : IsIso e)
state_before: P : {α β : Type u} → [inst : TopologicalSpace α] → [inst : TopologicalSpace β] → (α → β) → Prop
hP : ∀ {α β : Type u} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] (f : α ≃ₜ β), P ⇑f
X Y : Scheme
e : X ⟶ Y
he : IsIso e
⊢ topologically (fun {α β} [TopologicalSpace α] [TopologicalSpace β] => P) e
state_after: P : {α β : Type u} → [inst : TopologicalSpace α] → [inst : TopologicalSpace β] → (α → β) → Prop
hP : ∀ {α β : Type u} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] (f : α ≃ₜ β), P ⇑f
X Y : Scheme
e : X ⟶ Y
he this : IsIso e
⊢ topologically (fun {α β} [TopologicalSpace α] [TopologicalSpace β] => P) e
tactic: have : IsIso e := he
state_before: P : {α β : Type u} → [inst : TopologicalSpace α] → [inst : TopologicalSpace β] → (α → β) → Prop
hP : ∀ {α β : Type u} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] (f : α ≃ₜ β), P ⇑f
X Y : Scheme
e : X ⟶ Y
he this : IsIso e
⊢ topologically (fun {α β} [TopologicalSpace α] [TopologicalSpace β] => P) e
state_after: no goals
tactic: exact hP (TopCat.homeoOfIso (asIso e.val.base))
Theorem: FunctionField.InftyValuation.map_one'
File: Mathlib/NumberTheory/FunctionField.lean

Proof steps:
state_before: Fq F : Type
inst✝² : Field Fq
inst✝¹ : Field F
inst✝ : DecidableEq (RatFunc Fq)
⊢ ↑(Multiplicative.ofAdd (RatFunc.intDegree 1)) = 1
state_after: no goals
tactic: rw [RatFunc.intDegree_one, ofAdd_zero, WithZero.coe_one]
Theorem: SimpleGraph.Subgraph.mem_verts_if_mem_edge
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

Proof steps:
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
G' : G.Subgraph
e : Sym2 V
v : V
he : e ∈ G'.edgeSet
hv : v ∈ e
⊢ v ∈ G'.verts
state_after: case h
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
G' : G.Subgraph
v x✝ y✝ : V
he : s(x✝, y✝) ∈ G'.edgeSet
hv : v ∈ s(x✝, y✝)
⊢ v ∈ G'.verts
tactic: induction e
state_before: case h
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
G' : G.Subgraph
v x✝ y✝ : V
he : s(x✝, y✝) ∈ G'.edgeSet
hv : v ∈ s(x✝, y✝)
⊢ v ∈ G'.verts
state_after: case h.inl
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
G' : G.Subgraph
v y✝ : V
he : s(v, y✝) ∈ G'.edgeSet
hv : v ∈ s(v, y✝)
⊢ v ∈ G'.verts

case h.inr
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
G' : G.Subgraph
v x✝ : V
he : s(x✝, v) ∈ G'.edgeSet
hv : v ∈ s(x✝, v)
⊢ v ∈ G'.verts
tactic: rcases Sym2.mem_iff.mp hv with (rfl | rfl)
Theorem: Disjoint.of_orderEmbedding
File: Mathlib/Order/Hom/Basic.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝³ : PartialOrder α
inst✝² : PartialOrder β
f : α ↪o β
inst✝¹ : OrderBot α
inst✝ : OrderBot β
a₁ a₂ : α
⊢ Disjoint (f a₁) (f a₂) → Disjoint a₁ a₂
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝³ : PartialOrder α
inst✝² : PartialOrder β
f : α ↪o β
inst✝¹ : OrderBot α
inst✝ : OrderBot β
a₁ a₂ : α
h : Disjoint (f a₁) (f a₂)
x : α
h₁ : x ≤ a₁
h₂ : x ≤ a₂
⊢ x ≤ ⊥
tactic: intro h x h₁ h₂
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝³ : PartialOrder α
inst✝² : PartialOrder β
f : α ↪o β
inst✝¹ : OrderBot α
inst✝ : OrderBot β
a₁ a₂ : α
h : Disjoint (f a₁) (f a₂)
x : α
h₁ : x ≤ a₁
h₂ : x ≤ a₂
⊢ x ≤ ⊥
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝³ : PartialOrder α
inst✝² : PartialOrder β
f : α ↪o β
inst✝¹ : OrderBot α
inst✝ : OrderBot β
a₁ a₂ : α
h : Disjoint (f a₁) (f a₂)
x : α
h₁ : f x ≤ f a₁
h₂ : f x ≤ f a₂
⊢ f x ≤ f ⊥
tactic: rw [← f.le_iff_le] at h₁ h₂ ⊢
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝³ : PartialOrder α
inst✝² : PartialOrder β
f : α ↪o β
inst✝¹ : OrderBot α
inst✝ : OrderBot β
a₁ a₂ : α
h : Disjoint (f a₁) (f a₂)
x : α
h₁ : f x ≤ f a₁
h₂ : f x ≤ f a₂
⊢ f x ≤ f ⊥
state_after: no goals
tactic: calc
    f x ≤ ⊥ := h h₁ h₂
    _ ≤ f ⊥ := bot_le
Theorem: MeasureTheory.Measure.snd_dirac_unit_compProd_const
File: Mathlib/Probability/Kernel/MeasureCompProd.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
μ✝ : Measure α
κ η : Kernel α β
μ : Measure β
inst✝ : IsFiniteMeasure μ
⊢ (dirac () ⊗ₘ Kernel.const Unit μ).snd = μ
state_after: α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
μ✝ : Measure α
κ η : Kernel α β
μ : Measure β
inst✝ : IsFiniteMeasure μ
⊢ map (Prod.snd ∘ Prod.mk ()) μ = μ
tactic: rw [dirac_unit_compProd_const, snd, map_map measurable_snd measurable_prod_mk_left]
state_before: α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
μ✝ : Measure α
κ η : Kernel α β
μ : Measure β
inst✝ : IsFiniteMeasure μ
⊢ map (Prod.snd ∘ Prod.mk ()) μ = μ
state_after: no goals
tactic: simp
Theorem: Real.map_volume_mul_left
File: Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean

Proof steps:
state_before: ι : Type u_1
inst✝ : Fintype ι
a : ℝ
h : a ≠ 0
⊢ Measure.map (fun x => a * x) volume = ofReal |a⁻¹| • volume
state_after: no goals
tactic: conv_rhs =>
    rw [← Real.smul_map_volume_mul_left h, smul_smul, ← ENNReal.ofReal_mul (abs_nonneg _), ←
      abs_mul, inv_mul_cancel h, abs_one, ENNReal.ofReal_one, one_smul]
Theorem: not_IntegrableOn_Ici_inv
File: Mathlib/Analysis/SpecialFunctions/NonIntegrable.lean

Proof steps:
state_before: E : Type u_1
F : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedAddCommGroup F
a : ℝ
⊢ ¬IntegrableOn (fun x => x⁻¹) (Ici a) volume
state_after: E : Type u_1
F : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedAddCommGroup F
a : ℝ
A : ∀ᶠ (x : ℝ) in atTop, HasDerivAt (fun x => Real.log x) x⁻¹ x
⊢ ¬IntegrableOn (fun x => x⁻¹) (Ici a) volume
tactic: have A : ∀ᶠ x in atTop, HasDerivAt (fun x => Real.log x) x⁻¹ x := by
    filter_upwards [Ioi_mem_atTop 0] with x hx using Real.hasDerivAt_log (ne_of_gt hx)
state_before: E : Type u_1
F : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedAddCommGroup F
a : ℝ
A : ∀ᶠ (x : ℝ) in atTop, HasDerivAt (fun x => Real.log x) x⁻¹ x
⊢ ¬IntegrableOn (fun x => x⁻¹) (Ici a) volume
state_after: E : Type u_1
F : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedAddCommGroup F
a : ℝ
A : ∀ᶠ (x : ℝ) in atTop, HasDerivAt (fun x => Real.log x) x⁻¹ x
B : Tendsto (fun x => ‖Real.log x‖) atTop atTop
⊢ ¬IntegrableOn (fun x => x⁻¹) (Ici a) volume
tactic: have B : Tendsto (fun x => ‖Real.log x‖) atTop atTop :=
    tendsto_norm_atTop_atTop.comp Real.tendsto_log_atTop
state_before: E : Type u_1
F : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedAddCommGroup F
a : ℝ
A : ∀ᶠ (x : ℝ) in atTop, HasDerivAt (fun x => Real.log x) x⁻¹ x
B : Tendsto (fun x => ‖Real.log x‖) atTop atTop
⊢ ¬IntegrableOn (fun x => x⁻¹) (Ici a) volume
state_after: no goals
tactic: exact not_integrableOn_of_tendsto_norm_atTop_of_deriv_isBigO_filter atTop (Ici_mem_atTop a)
    (A.mono (fun x hx ↦ hx.differentiableAt)) B
    (Filter.EventuallyEq.isBigO (A.mono (fun x hx ↦ hx.deriv)))
Theorem: CategoryTheory.monoidalOfHasFiniteProducts.associator_inv_fst_fst
File: Mathlib/CategoryTheory/Monoidal/OfHasFiniteProducts.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
X✝ Y✝ : C
inst✝¹ : HasTerminal C
inst✝ : HasBinaryProducts C
X Y Z : C
⊢ (α_ X Y Z).inv ≫ prod.fst ≫ prod.fst = prod.fst
state_after: no goals
tactic: simp [associator_inv]
Theorem: HurwitzZeta.hurwitzZeta_neg_nat
File: Mathlib/NumberTheory/LSeries/HurwitzZetaValues.lean

Proof steps:
state_before: k : ℕ
x : ℝ
hk : k ≠ 0
hx : x ∈ Icc 0 1
⊢ hurwitzZeta (↑x) (-↑k) =
    -1 / (↑k + 1) * Polynomial.eval (↑x) (Polynomial.map (algebraMap ℚ ℂ) (Polynomial.bernoulli (k + 1)))
state_after: case intro.inl
x : ℝ
hx : x ∈ Icc 0 1
n : ℕ
hk : 2 * n ≠ 0
⊢ hurwitzZeta (↑x) (-↑(2 * n)) =
    -1 / (↑(2 * n) + 1) * Polynomial.eval (↑x) (Polynomial.map (algebraMap ℚ ℂ) (Polynomial.bernoulli (2 * n + 1)))

case intro.inr
x : ℝ
hx : x ∈ Icc 0 1
n : ℕ
hk : 2 * n + 1 ≠ 0
⊢ hurwitzZeta (↑x) (-↑(2 * n + 1)) =
    -1 / (↑(2 * n + 1) + 1) *
      Polynomial.eval (↑x) (Polynomial.map (algebraMap ℚ ℂ) (Polynomial.bernoulli (2 * n + 1 + 1)))
tactic: rcases Nat.even_or_odd' k with ⟨n, (rfl | rfl)⟩
Theorem: inv_pos_le_iff_one_le_mul'
File: Mathlib/Algebra/Order/Field/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
ha : 0 < a
⊢ a⁻¹ ≤ b ↔ 1 ≤ a * b
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
ha : 0 < a
⊢ 1 / a ≤ b ↔ 1 ≤ a * b
tactic: rw [inv_eq_one_div]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
ha : 0 < a
⊢ 1 / a ≤ b ↔ 1 ≤ a * b
state_after: no goals
tactic: exact div_le_iff' ha
Theorem: List.splitWrtCompositionAux_cons
File: Mathlib/Combinatorics/Enumerative/Composition.lean

Proof steps:
state_before: n✝ : ℕ
α : Type u_1
l : List α
n : ℕ
ns : List ℕ
⊢ l.splitWrtCompositionAux (n :: ns) = take n l :: (drop n l).splitWrtCompositionAux ns
state_after: no goals
tactic: simp [splitWrtCompositionAux]
Theorem: CoxeterSystem.length_mul_mod_two
File: Mathlib/GroupTheory/Coxeter/Length.lean

Proof steps:
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w₁ w₂ : W
⊢ cs.length (w₁ * w₂) % 2 = (cs.length w₁ + cs.length w₂) % 2
state_after: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w₁ w₂ : W
⊢ ↑(cs.length (w₁ * w₂)) = ↑(cs.length w₁) + ↑(cs.length w₂)
tactic: rw [← ZMod.natCast_eq_natCast_iff', Nat.cast_add]
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w₁ w₂ : W
⊢ ↑(cs.length (w₁ * w₂)) = ↑(cs.length w₁) + ↑(cs.length w₂)
state_after: no goals
tactic: simpa only [lengthParity_eq_ofAdd_length, ofAdd_add] using map_mul cs.lengthParity w₁ w₂
Theorem: RatFunc.denom_zero
File: Mathlib/FieldTheory/RatFunc/Basic.lean

Proof steps:
state_before: K : Type u
inst✝ : Field K
⊢ denom 0 = 1
state_after: no goals
tactic: convert denom_div (0 : K[X]) one_ne_zero <;> simp
Theorem: Int.lnot_bit
File: Mathlib/Data/Int/Bitwise.lean

Proof steps:
state_before: b : Bool
n : ℕ
⊢ (bit b ↑n).lnot = bit (!b) (↑n).lnot
state_after: no goals
tactic: simp [lnot]
state_before: b : Bool
n : ℕ
⊢ (bit b -[n+1]).lnot = bit (!b) -[n+1].lnot
state_after: no goals
tactic: simp [lnot]
Theorem: IsUnit.div_eq_div_iff
File: Mathlib/Algebra/Group/Units.lean

Proof steps:
state_before: α : Type u
M : Type u_1
N : Type u_2
inst✝ : DivisionCommMonoid α
a b c d : α
hb : IsUnit b
hd : IsUnit d
⊢ a / b = c / d ↔ a * d = c * b
state_after: no goals
tactic: rw [← (hb.mul hd).mul_left_inj, ← mul_assoc, hb.div_mul_cancel, ← mul_assoc, mul_right_comm,
    hd.div_mul_cancel]
Theorem: Filter.Tendsto.atBot_mul_neg
File: Mathlib/Topology/Algebra/Order/Field.lean

Proof steps:
state_before: 𝕜 : Type u_1
α : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
C : 𝕜
hC : C < 0
hf : Tendsto f l atBot
hg : Tendsto g l (𝓝 C)
⊢ Tendsto (fun x => f x * g x) l atTop
state_after: 𝕜 : Type u_1
α : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
C : 𝕜
hC : C < 0
hf : Tendsto f l atBot
hg : Tendsto g l (𝓝 C)
this : Tendsto (fun x => (Neg.neg ∘ f) x * g x) l atBot
⊢ Tendsto (fun x => f x * g x) l atTop
tactic: have := (tendsto_neg_atBot_atTop.comp hf).atTop_mul_neg hC hg
Theorem: Stream'.Seq.destruct_eq_cons
File: Mathlib/Data/Seq/Seq.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
s : Seq α
a : α
s' : Seq α
⊢ s.destruct = some (a, s') → s = cons a s'
state_after: α : Type u
β : Type v
γ : Type w
s : Seq α
a : α
s' : Seq α
⊢ Option.map (fun a' => (a', s.tail)) (s.get? 0) = some (a, s') → s = cons a s'
tactic: dsimp [destruct]
state_before: α : Type u
β : Type v
γ : Type w
s : Seq α
a : α
s' : Seq α
⊢ Option.map (fun a' => (a', s.tail)) (s.get? 0) = some (a, s') → s = cons a s'
state_after: case none
α : Type u
β : Type v
γ : Type w
s : Seq α
a : α
s' : Seq α
f0 : s.get? 0 = none
h : Option.map (fun a' => (a', s.tail)) none = some (a, s')
⊢ s = cons a s'

case some
α : Type u
β : Type v
γ : Type w
s : Seq α
a : α
s' : Seq α
a' : α
f0 : s.get? 0 = some a'
h : Option.map (fun a' => (a', s.tail)) (some a') = some (a, s')
⊢ s = cons a s'
tactic: induction' f0 : get? s 0 with a' <;> intro h
Theorem: MvPolynomial.rename_rename
File: Mathlib/Algebra/MvPolynomial/Rename.lean

Proof steps:
state_before: σ : Type u_1
τ : Type u_2
α : Type u_3
R : Type u_4
S : Type u_5
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
g : τ → α
p : MvPolynomial σ R
⊢ (rename g) (eval₂ C (X ∘ f) p) = (rename (g ∘ f)) p
state_after: σ : Type u_1
τ : Type u_2
α : Type u_3
R : Type u_4
S : Type u_5
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
g : τ → α
p : MvPolynomial σ R
⊢ (eval₂Hom (algebraMap R (MvPolynomial α R)) (X ∘ g)) (eval₂ C (X ∘ f) p) =
    (eval₂Hom (algebraMap R (MvPolynomial α R)) (X ∘ g ∘ f)) p
tactic: simp only [rename, aeval_eq_eval₂Hom]
state_before: σ : Type u_1
τ : Type u_2
α : Type u_3
R : Type u_4
S : Type u_5
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
g : τ → α
p : MvPolynomial σ R
⊢ (eval₂Hom (algebraMap R (MvPolynomial α R)) (X ∘ g)) (eval₂ C (X ∘ f) p) =
    (eval₂Hom (algebraMap R (MvPolynomial α R)) (X ∘ g ∘ f)) p
state_after: σ : Type u_1
τ : Type u_2
α : Type u_3
R : Type u_4
S : Type u_5
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
g : τ → α
p : MvPolynomial σ R
⊢ eval₂ ((eval₂Hom (algebraMap R (MvPolynomial α R)) (X ∘ g)).comp C)
      (⇑(eval₂Hom (algebraMap R (MvPolynomial α R)) (X ∘ g)) ∘ X ∘ f) p =
    (eval₂Hom (algebraMap R (MvPolynomial α R)) (X ∘ g ∘ f)) p
tactic: rw [eval₂_comp_left (eval₂Hom (algebraMap R (MvPolynomial α R)) (X ∘ g)) C (X ∘ f) p]
state_before: σ : Type u_1
τ : Type u_2
α : Type u_3
R : Type u_4
S : Type u_5
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
g : τ → α
p : MvPolynomial σ R
⊢ eval₂ ((eval₂Hom (algebraMap R (MvPolynomial α R)) fun x => X (g x)).comp C) (fun x => X (g (f x))) p =
    (eval₂Hom (algebraMap R (MvPolynomial α R)) fun x => X (g (f x))) p
state_after: σ : Type u_1
τ : Type u_2
α : Type u_3
R : Type u_4
S : Type u_5
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
g : τ → α
p : MvPolynomial σ R
⊢ (eval₂Hom (algebraMap R (MvPolynomial α R)) fun x => X (g x)).comp C = algebraMap R (MvPolynomial α R)
tactic: refine eval₂Hom_congr ?_ rfl rfl
state_before: σ : Type u_1
τ : Type u_2
α : Type u_3
R : Type u_4
S : Type u_5
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
g : τ → α
p : MvPolynomial σ R
⊢ (eval₂Hom (algebraMap R (MvPolynomial α R)) fun x => X (g x)).comp C = algebraMap R (MvPolynomial α R)
state_after: case a
σ : Type u_1
τ : Type u_2
α : Type u_3
R : Type u_4
S : Type u_5
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
g : τ → α
p : MvPolynomial σ R
x✝ : R
⊢ ((eval₂Hom (algebraMap R (MvPolynomial α R)) fun x => X (g x)).comp C) x✝ = (algebraMap R (MvPolynomial α R)) x✝
tactic: ext1
state_before: case a
σ : Type u_1
τ : Type u_2
α : Type u_3
R : Type u_4
S : Type u_5
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
g : τ → α
p : MvPolynomial σ R
x✝ : R
⊢ ((eval₂Hom (algebraMap R (MvPolynomial α R)) fun x => X (g x)).comp C) x✝ = (algebraMap R (MvPolynomial α R)) x✝
state_after: no goals
tactic: simp only [comp_apply, RingHom.coe_comp, eval₂Hom_C]
Theorem: Profinite.NobelingProof.Products.max_eq_o_cons_tail'
File: Mathlib/Topology/Category/Profinite/Nobeling.lean

Proof steps:
state_before: I : Type u
inst✝² : LinearOrder I
inst✝¹ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
hC : IsClosed C
hsC : contained C (Order.succ o)
ho : o < Ordinal.type fun x x_1 => x < x_1
inst✝ : Inhabited I
l : Products I
hl : ↑l ≠ []
hlh : (↑l).head! = term I ho
hlc : List.Chain' (fun x x_1 => x > x_1) (term I ho :: ↑l.Tail)
⊢ l = ⟨term I ho :: ↑l.Tail, hlc⟩
state_after: I : Type u
inst✝² : LinearOrder I
inst✝¹ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
hC : IsClosed C
hsC : contained C (Order.succ o)
ho : o < Ordinal.type fun x x_1 => x < x_1
inst✝ : Inhabited I
l : Products I
hl : ↑l ≠ []
hlh : (↑l).head! = term I ho
hlc : List.Chain' (fun x x_1 => x > x_1) (term I ho :: ↑l.Tail)
⊢ l = ⟨↑l, ⋯⟩
tactic: simp_rw [← max_eq_o_cons_tail ho l hl hlh]
state_before: I : Type u
inst✝² : LinearOrder I
inst✝¹ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
hC : IsClosed C
hsC : contained C (Order.succ o)
ho : o < Ordinal.type fun x x_1 => x < x_1
inst✝ : Inhabited I
l : Products I
hl : ↑l ≠ []
hlh : (↑l).head! = term I ho
hlc : List.Chain' (fun x x_1 => x > x_1) (term I ho :: ↑l.Tail)
⊢ l = ⟨↑l, ⋯⟩
state_after: no goals
tactic: rfl