ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: TopologicalSpace.NoetherianSpace.isCompact
File: Mathlib/Topology/NoetherianSpace.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : NoetherianSpace α
s : Set α
⊢ IsCompact s
state_after: α : Type u_1
β : Type u_2
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : NoetherianSpace α
s : Set α
ι✝ : Type u_1
U : ι✝ → Set α
hUo : ∀ (i : ι✝), IsOpen (U i)
hs : s ⊆ ⋃ i, U i
⊢ ∃ t, s ⊆ ⋃ i ∈ t, U i
tactic: refine isCompact_iff_finite_subcover.2 fun U hUo hs => ?_
state_before: α : Type u_1
β : Type u_2
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : NoetherianSpace α
s : Set α
ι✝ : Type u_1
U : ι✝ → Set α
hUo : ∀ (i : ι✝), IsOpen (U i)
hs : s ⊆ ⋃ i, U i
⊢ ∃ t, s ⊆ ⋃ i ∈ t, U i
state_after: case intro
α : Type u_1
β : Type u_2
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : NoetherianSpace α
s : Set α
ι✝ : Type u_1
U : ι✝ → Set α
hUo : ∀ (i : ι✝), IsOpen (U i)
hs : s ⊆ ⋃ i, U i
t : Finset ι✝
ht : ↑{ carrier := ⋃ i, U i, is_open' := ⋯ } ⊆ ⋃ i ∈ t, U i
⊢ ∃ t, s ⊆ ⋃ i ∈ t, U i
tactic: rcases ((noetherianSpace_iff_opens α).mp ‹_› ⟨⋃ i, U i, isOpen_iUnion hUo⟩).elim_finite_subcover U
    hUo Set.Subset.rfl with ⟨t, ht⟩
state_before: case intro
α : Type u_1
β : Type u_2
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : NoetherianSpace α
s : Set α
ι✝ : Type u_1
U : ι✝ → Set α
hUo : ∀ (i : ι✝), IsOpen (U i)
hs : s ⊆ ⋃ i, U i
t : Finset ι✝
ht : ↑{ carrier := ⋃ i, U i, is_open' := ⋯ } ⊆ ⋃ i ∈ t, U i
⊢ ∃ t, s ⊆ ⋃ i ∈ t, U i
state_after: no goals
tactic: exact ⟨t, hs.trans ht⟩
Theorem: Filter.map_swap4_prod
File: Mathlib/Order/Filter/Prod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s : Set α
t : Set β
f : Filter α
g : Filter β
h : Filter γ
k : Filter δ
⊢ map (fun p => ((p.1.1, p.2.1), p.1.2, p.2.2)) ((f ×ˢ g) ×ˢ h ×ˢ k) = (f ×ˢ h) ×ˢ g ×ˢ k
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s : Set α
t : Set β
f : Filter α
g : Filter β
h : Filter γ
k : Filter δ
⊢ comap ((Prod.fst ∘ Prod.fst) ∘ fun p => ((p.1.1, p.2.1), p.1.2, p.2.2)) f ⊓
        comap ((Prod.snd ∘ Prod.fst) ∘ fun p => ((p.1.1, p.2.1), p.1.2, p.2.2)) g ⊓
      (comap ((Prod.fst ∘ Prod.snd) ∘ fun p => ((p.1.1, p.2.1), p.1.2, p.2.2)) h ⊓
        comap ((Prod.snd ∘ Prod.snd) ∘ fun p => ((p.1.1, p.2.1), p.1.2, p.2.2)) k) =
    comap (Prod.fst ∘ Prod.fst) f ⊓ comap (Prod.snd ∘ Prod.fst) h ⊓
      (comap (Prod.fst ∘ Prod.snd) g ⊓ comap (Prod.snd ∘ Prod.snd) k)
tactic: simp_rw [map_swap4_eq_comap, SProd.sprod, Filter.prod, comap_inf, comap_comap]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s : Set α
t : Set β
f : Filter α
g : Filter β
h : Filter γ
k : Filter δ
⊢ comap ((Prod.fst ∘ Prod.fst) ∘ fun p => ((p.1.1, p.2.1), p.1.2, p.2.2)) f ⊓
        comap ((Prod.snd ∘ Prod.fst) ∘ fun p => ((p.1.1, p.2.1), p.1.2, p.2.2)) g ⊓
      (comap ((Prod.fst ∘ Prod.snd) ∘ fun p => ((p.1.1, p.2.1), p.1.2, p.2.2)) h ⊓
        comap ((Prod.snd ∘ Prod.snd) ∘ fun p => ((p.1.1, p.2.1), p.1.2, p.2.2)) k) =
    comap (Prod.fst ∘ Prod.fst) f ⊓ comap (Prod.snd ∘ Prod.fst) h ⊓
      (comap (Prod.fst ∘ Prod.snd) g ⊓ comap (Prod.snd ∘ Prod.snd) k)
state_after: no goals
tactic: ac_rfl
Theorem: Submodule.comap_snd
File: Mathlib/LinearAlgebra/Prod.lean

Proof steps:
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
⊢ comap (snd R M M₂) q = ⊤.prod q
state_after: case h.mk
R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
x : M
y : M₂
⊢ (x, y) ∈ comap (snd R M M₂) q ↔ (x, y) ∈ ⊤.prod q
tactic: ext ⟨x, y⟩
state_before: case h.mk
R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
x : M
y : M₂
⊢ (x, y) ∈ comap (snd R M M₂) q ↔ (x, y) ∈ ⊤.prod q
state_after: no goals
tactic: simp
Theorem: MvPolynomial.totalDegree_neg
File: Mathlib/Algebra/MvPolynomial/CommRing.lean

Proof steps:
state_before: R : Type u
S : Type v
σ : Type u_1
a✝ a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommRing R
p q a : MvPolynomial σ R
⊢ (-a).totalDegree = a.totalDegree
state_after: no goals
tactic: simp only [totalDegree, support_neg]
Theorem: Polynomial.degree_le_of_dvd
File: Mathlib/Algebra/Polynomial/RingDivision.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p✝ q✝ p q : R[X]
h1 : p ∣ q
h2 : q ≠ 0
⊢ p.degree ≤ q.degree
state_after: case intro
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p✝ q✝ p q : R[X]
h2 : p * q ≠ 0
⊢ p.degree ≤ (p * q).degree
tactic: rcases h1 with ⟨q, rfl⟩
state_before: case intro
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p✝ q✝ p q : R[X]
h2 : p * q ≠ 0
⊢ p.degree ≤ (p * q).degree
state_after: case intro
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p✝ q✝ p q : R[X]
h2 : p ≠ 0 ∧ q ≠ 0
⊢ p.degree ≤ (p * q).degree
tactic: rw [mul_ne_zero_iff] at h2
state_before: case intro
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p✝ q✝ p q : R[X]
h2 : p ≠ 0 ∧ q ≠ 0
⊢ p.degree ≤ (p * q).degree
state_after: no goals
tactic: exact degree_le_mul_left p h2.2
Theorem: PNat.Coprime.gcd_mul
File: Mathlib/Data/PNat/Prime.lean

Proof steps:
state_before: k m n : ℕ+
h : m.Coprime n
⊢ k.gcd (m * n) = k.gcd m * k.gcd n
state_after: k m n : ℕ+
h : (↑m).Coprime ↑n
⊢ k.gcd (m * n) = k.gcd m * k.gcd n
tactic: rw [← coprime_coe] at h
state_before: k m n : ℕ+
h : (↑m).Coprime ↑n
⊢ k.gcd (m * n) = k.gcd m * k.gcd n
state_after: case a
k m n : ℕ+
h : (↑m).Coprime ↑n
⊢ ↑(k.gcd (m * n)) = ↑(k.gcd m * k.gcd n)
tactic: apply eq
state_before: case a
k m n : ℕ+
h : (↑m).Coprime ↑n
⊢ ↑(k.gcd (m * n)) = ↑(k.gcd m * k.gcd n)
state_after: case a
k m n : ℕ+
h : (↑m).Coprime ↑n
⊢ (↑k).gcd (↑m * ↑n) = (↑k).gcd ↑m * (↑k).gcd ↑n
tactic: simp only [gcd_coe, mul_coe]
state_before: case a
k m n : ℕ+
h : (↑m).Coprime ↑n
⊢ (↑k).gcd (↑m * ↑n) = (↑k).gcd ↑m * (↑k).gcd ↑n
state_after: no goals
tactic: apply Nat.Coprime.gcd_mul k h
Theorem: mulRothNumber_spec
File: Mathlib/Combinatorics/Additive/AP/Three/Defs.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
inst✝³ : DecidableEq α
inst✝² : Monoid α
inst✝¹ : DecidableEq β
inst✝ : Monoid β
s t : Finset α
⊢ ThreeGPFree ↑∅
state_after: F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
inst✝³ : DecidableEq α
inst✝² : Monoid α
inst✝¹ : DecidableEq β
inst✝ : Monoid β
s t : Finset α
⊢ ThreeGPFree ∅
tactic: norm_cast
state_before: F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
inst✝³ : DecidableEq α
inst✝² : Monoid α
inst✝¹ : DecidableEq β
inst✝ : Monoid β
s t : Finset α
⊢ ThreeGPFree ∅
state_after: no goals
tactic: exact threeGPFree_empty
Theorem: Multiset.union_zero
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s t u : Multiset α
a b : α
⊢ s ∪ 0 = s
state_after: no goals
tactic: simp [union_def]
Theorem: IsPrimitiveRoot.zmodEquivZPowers_apply_coe_nat
File: Mathlib/RingTheory/RootsOfUnity/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
G : Type u_3
R : Type u_4
S : Type u_5
F : Type u_6
inst✝³ : CommMonoid M
inst✝² : CommMonoid N
inst✝¹ : DivisionCommMonoid G
k l : ℕ
inst✝ : CommRing R
ζ : Rˣ
h : IsPrimitiveRoot ζ k
i : ℕ
⊢ h.zmodEquivZPowers ↑i = Additive.ofMul ⟨ζ ^ i, ⋯⟩
state_after: M : Type u_1
N : Type u_2
G : Type u_3
R : Type u_4
S : Type u_5
F : Type u_6
inst✝³ : CommMonoid M
inst✝² : CommMonoid N
inst✝¹ : DivisionCommMonoid G
k l : ℕ
inst✝ : CommRing R
ζ : Rˣ
h : IsPrimitiveRoot ζ k
i : ℕ
this : ↑i = ↑↑i
⊢ h.zmodEquivZPowers ↑i = Additive.ofMul ⟨ζ ^ i, ⋯⟩
tactic: have : (i : ZMod k) = (i : ℤ) := by norm_cast
state_before: M : Type u_1
N : Type u_2
G : Type u_3
R : Type u_4
S : Type u_5
F : Type u_6
inst✝³ : CommMonoid M
inst✝² : CommMonoid N
inst✝¹ : DivisionCommMonoid G
k l : ℕ
inst✝ : CommRing R
ζ : Rˣ
h : IsPrimitiveRoot ζ k
i : ℕ
this : ↑i = ↑↑i
⊢ h.zmodEquivZPowers ↑i = Additive.ofMul ⟨ζ ^ i, ⋯⟩
state_after: no goals
tactic: simp only [this, zmodEquivZPowers_apply_coe_int, zpow_natCast]
Theorem: MeasureTheory.AEEqFun.mk_coeFn
File: Mathlib/MeasureTheory/Function/AEEqFun.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : MeasurableSpace α
μ ν : Measure α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α →ₘ[μ] β
⊢ mk ↑f ⋯ = f
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : MeasurableSpace α
μ ν : Measure α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α →ₘ[μ] β
⊢ mk ↑f ⋯ = Quotient.mk'' (Quotient.out' f)
tactic: conv_rhs => rw [← Quotient.out_eq' f]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : MeasurableSpace α
μ ν : Measure α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α →ₘ[μ] β
⊢ mk ↑f ⋯ = Quotient.mk'' (Quotient.out' f)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : MeasurableSpace α
μ ν : Measure α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α →ₘ[μ] β
g : { f // AEStronglyMeasurable f μ } := Quotient.out' f
⊢ mk ↑f ⋯ = Quotient.mk'' g
tactic: set g : { f : α → β // AEStronglyMeasurable f μ } := Quotient.out' f
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : MeasurableSpace α
μ ν : Measure α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α →ₘ[μ] β
g : { f // AEStronglyMeasurable f μ } := Quotient.out' f
⊢ mk ↑f ⋯ = Quotient.mk'' g
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : MeasurableSpace α
μ ν : Measure α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α →ₘ[μ] β
g : { f // AEStronglyMeasurable f μ } := Quotient.out' f
this : g = ⟨↑g, ⋯⟩
⊢ mk ↑f ⋯ = Quotient.mk'' g
tactic: have : g = ⟨g.1, g.2⟩ := Subtype.eq rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : MeasurableSpace α
μ ν : Measure α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α →ₘ[μ] β
g : { f // AEStronglyMeasurable f μ } := Quotient.out' f
this : g = ⟨↑g, ⋯⟩
⊢ mk ↑f ⋯ = Quotient.mk'' g
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : MeasurableSpace α
μ ν : Measure α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α →ₘ[μ] β
g : { f // AEStronglyMeasurable f μ } := Quotient.out' f
this : g = ⟨↑g, ⋯⟩
⊢ ↑f =ᶠ[ae μ] ↑g
tactic: rw [this, ← mk, mk_eq_mk]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : MeasurableSpace α
μ ν : Measure α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α →ₘ[μ] β
g : { f // AEStronglyMeasurable f μ } := Quotient.out' f
this : g = ⟨↑g, ⋯⟩
⊢ ↑f =ᶠ[ae μ] ↑g
state_after: no goals
tactic: exact (AEStronglyMeasurable.ae_eq_mk _).symm
Theorem: AddSemiconjBy.add_left
File: Mathlib/Algebra/Group/Semiconj/Defs.lean

Proof steps:
state_before: S : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Semigroup S
a b x y z x' y' : S
ha : SemiconjBy a y z
hb : SemiconjBy b x y
⊢ SemiconjBy (a * b) x z
state_after: S : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Semigroup S
a b x y z x' y' : S
ha : SemiconjBy a y z
hb : SemiconjBy b x y
⊢ a * b * x = z * (a * b)
tactic: unfold SemiconjBy
state_before: S : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Semigroup S
a b x y z x' y' : S
ha : SemiconjBy a y z
hb : SemiconjBy b x y
⊢ a * b * x = z * (a * b)
state_after: no goals
tactic: rw [mul_assoc, hb.eq, ← mul_assoc, ha.eq, mul_assoc]
Theorem: Int.gcd_zero_right
File: Mathlib/Data/Int/GCD.lean

Proof steps:
state_before: i : ℤ
⊢ i.gcd 0 = i.natAbs
state_after: no goals
tactic: simp [gcd]
Theorem: Nat.pred_eq_ppred
File: Mathlib/Data/Nat/PSub.lean

Proof steps:
state_before: n : ℕ
⊢ n.pred = n.ppred.getD 0
state_after: no goals
tactic: cases n <;> rfl
Theorem: denseRange_discrete
File: Mathlib/Topology/Order.lean

Proof steps:
state_before: α : Type u_1
t t₁ t₂ : TopologicalSpace α
s : Set α
inst✝¹ : TopologicalSpace α
inst✝ : DiscreteTopology α
β : Type u_2
ι : Type u_3
f : ι → α
⊢ DenseRange f ↔ Surjective f
state_after: no goals
tactic: rw [DenseRange, dense_discrete, range_iff_surjective]
Theorem: ProbabilityTheory.setIntegral_stieltjesOfMeasurableRat_rat
File: Mathlib/Probability/Kernel/Disintegration/CdfToKernel.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α (β × ℝ)
ν : Kernel α β
f : α × β → ℚ → ℝ
hf : IsRatCondKernelCDF f κ ν
a : α
q : ℚ
s : Set β
hs : MeasurableSet s
⊢ ∫ (b : β) in s, ↑(stieltjesOfMeasurableRat f ⋯ (a, b)) ↑q ∂ν a = ((κ a) (s ×ˢ Iic ↑q)).toReal
state_after: α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α (β × ℝ)
ν : Kernel α β
f : α × β → ℚ → ℝ
hf : IsRatCondKernelCDF f κ ν
a : α
q : ℚ
s : Set β
hs : MeasurableSet s
⊢ ∀ᵐ (x : β) ∂ν a, x ∈ s → ↑(stieltjesOfMeasurableRat f ⋯ (a, x)) ↑q = (fun b => f (a, b) q) x
tactic: rw [setIntegral_congr_ae hs (g := fun b ↦ f (a, b) q) ?_, hf.setIntegral a hs]
state_before: α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α (β × ℝ)
ν : Kernel α β
f : α × β → ℚ → ℝ
hf : IsRatCondKernelCDF f κ ν
a : α
q : ℚ
s : Set β
hs : MeasurableSet s
⊢ ∀ᵐ (x : β) ∂ν a, x ∈ s → ↑(stieltjesOfMeasurableRat f ⋯ (a, x)) ↑q = (fun b => f (a, b) q) x
state_after: no goals
tactic: filter_upwards [stieltjesOfMeasurableRat_ae_eq hf a q] with b hb using fun _ ↦ hb
Theorem: CategoryTheory.Limits.WidePushoutShape.mkCocone_pt
File: Mathlib/CategoryTheory/Limits/Shapes/WidePullbacks.lean

Proof steps:
state_before: J : Type w
C : Type u
inst✝ : Category.{v, u} C
F : WidePushoutShape J ⥤ C
X : C
f✝ : F.obj none ⟶ X
ι : (j : J) → F.obj (some j) ⟶ X
w : ∀ (j : J), F.map (Hom.init j) ≫ ι j = f✝
j j' : WidePushoutShape J
f : j ⟶ j'
⊢ F.map f ≫
      (fun j =>
          match j with
          | none => f✝
          | some j => ι j)
        j' =
    (fun j =>
          match j with
          | none => f✝
          | some j => ι j)
        j ≫
      ((Functor.const (WidePushoutShape J)).obj X).map f
state_after: no goals
tactic: cases j <;> cases j' <;> cases f <;> dsimp <;> simp [w]
Theorem: LaurentPolynomial.toLaurent_support
File: Mathlib/Algebra/Polynomial/Laurent.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
f : R[X]
⊢ (toLaurent f).support = Finset.map Nat.castEmbedding f.support
state_after: R : Type u_1
inst✝ : Semiring R
f : R[X]
s : Finset ℕ
hd : f.support = s
⊢ (toLaurent f).support = Finset.map Nat.castEmbedding s
tactic: generalize hd : f.support = s
state_before: R : Type u_1
inst✝ : Semiring R
f : R[X]
s : Finset ℕ
hd : f.support = s
⊢ (toLaurent f).support = Finset.map Nat.castEmbedding s
state_after: R : Type u_1
inst✝ : Semiring R
s : Finset ℕ
⊢ ∀ (f : R[X]), f.support = s → (toLaurent f).support = Finset.map Nat.castEmbedding s
tactic: revert f
state_before: R : Type u_1
inst✝ : Semiring R
s : Finset ℕ
⊢ ∀ (f : R[X]), f.support = s → (toLaurent f).support = Finset.map Nat.castEmbedding s
state_after: case refine_1
R : Type u_1
inst✝ : Semiring R
⊢ ∀ (f : R[X]), f.support = ∅ → (toLaurent f).support = Finset.map Nat.castEmbedding ∅

case refine_2
R : Type u_1
inst✝ : Semiring R
⊢ ∀ ⦃a : ℕ⦄ {s : Finset ℕ},
    a ∉ s →
      (∀ (f : R[X]), f.support = s → (toLaurent f).support = Finset.map Nat.castEmbedding s) →
        ∀ (f : R[X]), f.support = insert a s → (toLaurent f).support = Finset.map Nat.castEmbedding (insert a s)
tactic: refine Finset.induction_on s ?_ ?_ <;> clear s
Theorem: BddBelow.isBoundedUnder
File: Mathlib/Order/LiminfLimsup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
r : α → α → Prop
f✝ g : Filter α
inst✝ : Preorder α
f : Filter β
u : β → α
b : α
hb : b ∈ lowerBounds (range u)
⊢ ∀ (x : β), u x ≥ b
state_after: no goals
tactic: simpa [mem_lowerBounds] using hb
Theorem: WithTop.monotone_map_iff
File: Mathlib/Order/WithBot.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
⊢ ((Monotone fun a => map f ↑a) ∧ ∀ (x : α), map f ↑x ≤ map f ⊤) ↔ Monotone f
state_after: no goals
tactic: simp [Monotone]
Theorem: ciSup_const
File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : ConditionallyCompleteLattice α
s t : Set α
a✝ b : α
hι : Nonempty ι
a : α
⊢ ⨆ x, a = a
state_after: no goals
tactic: rw [iSup, range_const, csSup_singleton]
Theorem: add_self_nonpos_iff
File: Mathlib/Algebra/Order/Monoid/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrderedCommMonoid α
a : α
⊢ a * a ≤ 1 ↔ a ≤ 1
state_after: no goals
tactic: simp [← not_iff_not]
Theorem: Function.minimalPeriod_fst_dvd
File: Mathlib/Dynamics/PeriodicPts.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
f : α → α
g : β → β
x : α × β
a : α
b : β
m n : ℕ
⊢ minimalPeriod f x.1 ∣ minimalPeriod (Prod.map f g) x
state_after: α : Type u_1
β : Type u_2
f : α → α
g : β → β
x : α × β
a : α
b : β
m n : ℕ
⊢ minimalPeriod f x.1 ∣ (minimalPeriod f x.1).lcm (minimalPeriod g x.2)
tactic: rw [minimalPeriod_prod_map]
state_before: α : Type u_1
β : Type u_2
f : α → α
g : β → β
x : α × β
a : α
b : β
m n : ℕ
⊢ minimalPeriod f x.1 ∣ (minimalPeriod f x.1).lcm (minimalPeriod g x.2)
state_after: no goals
tactic: exact Nat.dvd_lcm_left _ _
Theorem: vadd_univ_pi
File: Mathlib/Algebra/Module/PointwisePi.lean

Proof steps:
state_before: K : Type u_1
ι : Type u_2
R : ι → Type u_3
inst✝ : (i : ι) → SMul K (R i)
r : K
t : (i : ι) → Set (R i)
x : (i : ι) → R i
h : x ∈ univ.pi (r • t)
⊢ x ∈ r • univ.pi t
state_after: case refine_1
K : Type u_1
ι : Type u_2
R : ι → Type u_3
inst✝ : (i : ι) → SMul K (R i)
r : K
t : (i : ι) → Set (R i)
x : (i : ι) → R i
h : x ∈ univ.pi (r • t)
i : ι
x✝ : i ∈ univ
⊢ (fun i => Classical.choose ⋯) i ∈ t i

case refine_2
K : Type u_1
ι : Type u_2
R : ι → Type u_3
inst✝ : (i : ι) → SMul K (R i)
r : K
t : (i : ι) → Set (R i)
x : (i : ι) → R i
h : x ∈ univ.pi (r • t)
i : ι
⊢ (fun x => r • x) (fun i => Classical.choose ⋯) i = x i
tactic: refine ⟨fun i ↦ Classical.choose (h i <| Set.mem_univ _), fun i _ ↦ ?_, funext fun i ↦ ?_⟩
Theorem: AddMonoid.Coprod.toSum_surjective
File: Mathlib/GroupTheory/Coprod/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
inst✝¹ : Monoid M
inst✝ : Monoid N
x : M × N
⊢ toProd (inl x.1 * inr x.2) = x
state_after: no goals
tactic: rw [map_mul, toProd_apply_inl, toProd_apply_inr, Prod.fst_mul_snd]
Theorem: SimpleGraph.edist_eq_zero_iff
File: Mathlib/Combinatorics/SimpleGraph/Metric.lean

Proof steps:
state_before: V : Type u_1
G : SimpleGraph V
u v w : V
⊢ G.edist u v = 0 ↔ u = v
state_after: no goals
tactic: apply Iff.intro <;> simp [edist, ENat.iInf_eq_zero]
Theorem: Finset.exists_max_image
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✝ : LinearOrder α
s : Finset β
f : β → α
h : s.Nonempty
⊢ ∃ x ∈ s, ∀ x' ∈ s, f x' ≤ f x
state_after: case intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s : Finset β
f : β → α
h : s.Nonempty
y : α
hy : (image f s).max = ↑y
⊢ ∃ x ∈ s, ∀ x' ∈ s, f x' ≤ f x
tactic: cases' max_of_nonempty (h.image f) with y hy
state_before: case intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s : Finset β
f : β → α
h : s.Nonempty
y : α
hy : (image f s).max = ↑y
⊢ ∃ x ∈ s, ∀ x' ∈ s, f x' ≤ f x
state_after: case intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s : Finset β
f : β → α
h : s.Nonempty
x : β
hx : x ∈ s
hy : (image f s).max = ↑(f x)
⊢ ∃ x ∈ s, ∀ x' ∈ s, f x' ≤ f x
tactic: rcases mem_image.mp (mem_of_max hy) with ⟨x, hx, rfl⟩
state_before: case intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s : Finset β
f : β → α
h : s.Nonempty
x : β
hx : x ∈ s
hy : (image f s).max = ↑(f x)
⊢ ∃ x ∈ s, ∀ x' ∈ s, f x' ≤ f x
state_after: no goals
tactic: exact ⟨x, hx, fun x' hx' => le_max_of_eq (mem_image_of_mem f hx') hy⟩
Theorem: Polynomial.degree_linear
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

Proof steps:
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
ha : a ≠ 0
⊢ (C a * X + C b).degree = 1
state_after: no goals
tactic: rw [degree_add_eq_left_of_degree_lt <| degree_C_lt_degree_C_mul_X ha, degree_C_mul_X ha]
Theorem: Set.Ioc_union_Ioi
File: Mathlib/Order/Interval/Set/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h : c ≤ max a b
⊢ Ioc a b ∪ Ioi c = Ioi (min a c)
state_after: case inl
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : a ≤ b
h : c ≤ b
⊢ Ioc a b ∪ Ioi c = Ioi (min a c)

case inr
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : b ≤ a
h : c ≤ a
⊢ Ioc a b ∪ Ioi c = Ioi (min a c)
tactic: rcases le_total a b with hab | hab <;> simp [hab] at h
Theorem: Equiv.naturality
File: Mathlib/Control/Traversable/Equiv.lean

Proof steps:
state_before: t t' : Type u → Type u
eqv : (α : Type u) → t α ≃ t' α
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
η : ApplicativeTransformation F G
α β γ : Type u
f : α → F β
x : t' α
⊢ (fun {α} => η.app α) (Equiv.traverse eqv f x) = Equiv.traverse eqv ((fun {α} => η.app α) ∘ f) x
state_after: no goals
tactic: simp only [Equiv.traverse, functor_norm]
Theorem: Polynomial.contract_one
File: Mathlib/Algebra/Polynomial/Expand.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p q : ℕ
f : R[X]
n : ℕ
⊢ (contract 1 f).coeff n = f.coeff n
state_after: no goals
tactic: rw [coeff_contract one_ne_zero, mul_one]
Theorem: Ordinal.dvd_of_mod_eq_zero
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
a b : Ordinal.{u_4}
H : a % b = 0
⊢ a = b * (a / b)
state_after: no goals
tactic: simpa [H] using (div_add_mod a b).symm