ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: integral_pow
File: Mathlib/Analysis/SpecialFunctions/Integrals.lean

Proof steps:
state_before: a b : ℝ
n : ℕ
⊢ ∫ (x : ℝ) in a..b, x ^ n = (b ^ (n + 1) - a ^ (n + 1)) / (↑n + 1)
state_after: no goals
tactic: simpa only [← Int.ofNat_succ, zpow_natCast] using integral_zpow (Or.inl n.cast_nonneg)
Theorem: minimals_mono
File: Mathlib/Order/Minimal.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
s t : Set α
a✝ b✝ x : α
inst✝ : IsAntisymm α r₂
h : ∀ (a b : α), r₁ a b → r₂ a b
a : α
ha : a ∈ minimals r₂ s
b : α
hb : b ∈ s
hab : r₁ b a
⊢ r₁ a b
state_after: α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
s t : Set α
a✝ b✝ x : α
inst✝ : IsAntisymm α r₂
h : ∀ (a b : α), r₁ a b → r₂ a b
a : α
ha : a ∈ minimals r₂ s
b : α
hb : b ∈ s
hab : r₁ b a
this : a = b
⊢ r₁ a b
tactic: have := eq_of_mem_minimals ha hb (h _ _ hab)
state_before: α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
s t : Set α
a✝ b✝ x : α
inst✝ : IsAntisymm α r₂
h : ∀ (a b : α), r₁ a b → r₂ a b
a : α
ha : a ∈ minimals r₂ s
b : α
hb : b ∈ s
hab : r₁ b a
this : a = b
⊢ r₁ a b
state_after: α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
s t : Set α
a✝ b x : α
inst✝ : IsAntisymm α r₂
h : ∀ (a b : α), r₁ a b → r₂ a b
a : α
ha : a ∈ minimals r₂ s
hb : a ∈ s
hab : r₁ a a
⊢ r₁ a a
tactic: subst this
state_before: α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
s t : Set α
a✝ b x : α
inst✝ : IsAntisymm α r₂
h : ∀ (a b : α), r₁ a b → r₂ a b
a : α
ha : a ∈ minimals r₂ s
hb : a ∈ s
hab : r₁ a a
⊢ r₁ a a
state_after: no goals
tactic: exact hab
Theorem: WittVector.init_mul
File: Mathlib/RingTheory/WittVector/InitTail.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n✝ : ℕ
R : Type u_1
inst✝ : CommRing R
x y : 𝕎 R
n : ℕ
⊢ init n (x * y) = init n (init n x * init n y)
state_after: no goals
tactic: init_ring using wittMul_vars
Theorem: SimpleGraph.fromEdgeSet_sdiff
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

Proof steps:
state_before: ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v w : V
e : Sym2 V
s✝ s t : Set (Sym2 V)
⊢ fromEdgeSet (s \ t) = fromEdgeSet s \ fromEdgeSet t
state_after: case Adj.h.h.a
ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v✝ w✝ : V
e : Sym2 V
s✝ s t : Set (Sym2 V)
v w : V
⊢ (fromEdgeSet (s \ t)).Adj v w ↔ (fromEdgeSet s \ fromEdgeSet t).Adj v w
tactic: ext v w
state_before: case Adj.h.h.a
ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v✝ w✝ : V
e : Sym2 V
s✝ s t : Set (Sym2 V)
v w : V
⊢ (fromEdgeSet (s \ t)).Adj v w ↔ (fromEdgeSet s \ fromEdgeSet t).Adj v w
state_after: no goals
tactic: constructor <;> simp (config := { contextual := true })
Theorem: Turing.TM1to0.tr_eval
File: Mathlib/Computability/TuringMachine.lean

Proof steps:
state_before: Γ : Type u_1
inst✝² : Inhabited Γ
Λ : Type u_2
inst✝¹ : Inhabited Λ
σ : Type u_3
inst✝ : Inhabited σ
M : Λ → Stmt₁
l : List Γ
⊢ Part.map (fun c => c.Tape.right₀)
      (trCfg M <$> eval (TM1.step M) { l := some default, var := default, Tape := Tape.mk₁ l }) =
    TM1.eval M l
state_after: Γ : Type u_1
inst✝² : Inhabited Γ
Λ : Type u_2
inst✝¹ : Inhabited Λ
σ : Type u_3
inst✝ : Inhabited σ
M : Λ → Stmt₁
l : List Γ
⊢ Part.map ((fun c => c.Tape.right₀) ∘ trCfg M)
      (eval (TM1.step M) { l := some default, var := default, Tape := Tape.mk₁ l }) =
    Part.map (fun c => c.Tape.right₀) (eval (TM1.step M) (TM1.init l))
tactic: rw [Part.map_eq_map, Part.map_map, TM1.eval]
state_before: Γ : Type u_1
inst✝² : Inhabited Γ
Λ : Type u_2
inst✝¹ : Inhabited Λ
σ : Type u_3
inst✝ : Inhabited σ
M : Λ → Stmt₁
l : List Γ
⊢ Part.map ((fun c => c.Tape.right₀) ∘ trCfg M)
      (eval (TM1.step M) { l := some default, var := default, Tape := Tape.mk₁ l }) =
    Part.map (fun c => c.Tape.right₀) (eval (TM1.step M) (TM1.init l))
state_after: no goals
tactic: congr with ⟨⟩
Theorem: inducing_sigma
File: Mathlib/Topology/Constructions.lean

Proof steps:
state_before: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
ι : Type u_5
κ : Type u_6
σ : ι → Type u_7
τ : κ → Type u_8
inst✝² : (i : ι) → TopologicalSpace (σ i)
inst✝¹ : (k : κ) → TopologicalSpace (τ k)
inst✝ : TopologicalSpace X
f : Sigma σ → X
⊢ Inducing f ↔ (∀ (i : ι), Inducing (f ∘ Sigma.mk i)) ∧ ∀ (i : ι), ∃ U, IsOpen U ∧ ∀ (x : Sigma σ), f x ∈ U ↔ x.fst = i
state_after: case refine_1
X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
ι : Type u_5
κ : Type u_6
σ : ι → Type u_7
τ : κ → Type u_8
inst✝² : (i : ι) → TopologicalSpace (σ i)
inst✝¹ : (k : κ) → TopologicalSpace (τ k)
inst✝ : TopologicalSpace X
f : Sigma σ → X
h : Inducing f
i : ι
⊢ ∃ U, IsOpen U ∧ ∀ (x : Sigma σ), f x ∈ U ↔ x.fst = i

case refine_2
X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
ι : Type u_5
κ : Type u_6
σ : ι → Type u_7
τ : κ → Type u_8
inst✝² : (i : ι) → TopologicalSpace (σ i)
inst✝¹ : (k : κ) → TopologicalSpace (τ k)
inst✝ : TopologicalSpace X
f : Sigma σ → X
⊢ ((∀ (i : ι), Inducing (f ∘ Sigma.mk i)) ∧ ∀ (i : ι), ∃ U, IsOpen U ∧ ∀ (x : Sigma σ), f x ∈ U ↔ x.fst = i) →
    Inducing f
tactic: refine ⟨fun h ↦ ⟨fun i ↦ h.comp embedding_sigmaMk.1, fun i ↦ ?_⟩, ?_⟩
Theorem: Part.ofOption_eq_get
File: Mathlib/Data/Part.lean

Proof steps:
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
α : Type u_4
o : Option α
h₁ : (↑o).Dom
h₂ : { Dom := o.isSome = true, get := o.get }.Dom
⊢ (↑o).get h₁ = { Dom := o.isSome = true, get := o.get }.get h₂
state_after: case none
α✝ : Type u_1
β : Type u_2
γ : Type u_3
α : Type u_4
h₁ : (↑Option.none).Dom
h₂ : { Dom := Option.none.isSome = true, get := Option.none.get }.Dom
⊢ (↑Option.none).get h₁ = { Dom := Option.none.isSome = true, get := Option.none.get }.get h₂

case some
α✝ : Type u_1
β : Type u_2
γ : Type u_3
α : Type u_4
val✝ : α
h₁ : (↑(Option.some val✝)).Dom
h₂ : { Dom := (Option.some val✝).isSome = true, get := (Option.some val✝).get }.Dom
⊢ (↑(Option.some val✝)).get h₁ = { Dom := (Option.some val✝).isSome = true, get := (Option.some val✝).get }.get h₂
tactic: cases o
Theorem: Polynomial.eq_C_of_degree_le_zero
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
h : p.degree ≤ 0
⊢ p = C (p.coeff 0)
state_after: case a.zero
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
h : p.degree ≤ 0
⊢ p.coeff 0 = (C (p.coeff 0)).coeff 0

case a.succ
R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
h : p.degree ≤ 0
n : ℕ
⊢ p.coeff (n + 1) = (C (p.coeff 0)).coeff (n + 1)
tactic: ext (_ | n)
state_before: case a.succ
R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
h : p.degree ≤ 0
n : ℕ
⊢ p.coeff (n + 1) = (C (p.coeff 0)).coeff (n + 1)
state_after: case a.succ
R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
h : p.degree ≤ 0
n : ℕ
⊢ p.degree < ↑(n + 1)
tactic: rw [coeff_C, if_neg (Nat.succ_ne_zero _), coeff_eq_zero_of_degree_lt]
state_before: case a.succ
R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
h : p.degree ≤ 0
n : ℕ
⊢ p.degree < ↑(n + 1)
state_after: no goals
tactic: exact h.trans_lt (WithBot.coe_lt_coe.2 n.succ_pos)
Theorem: IsLocalization.coeffIntegerNormalization_of_not_mem_support
File: Mathlib/RingTheory/Localization/Integral.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommRing R
M : Submonoid R
S : Type u_2
inst✝³ : CommRing S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommRing P
inst✝ : IsLocalization M S
p : S[X]
i : ℕ
h : p.coeff i = 0
⊢ coeffIntegerNormalization M p i = 0
state_after: no goals
tactic: simp only [coeffIntegerNormalization, h, mem_support_iff, eq_self_iff_true, not_true, Ne,
    dif_neg, not_false_iff]
Theorem: CategoryTheory.Limits.coequalizer.isoTargetOfSelf_hom
File: Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
f g : X ⟶ Y
⊢ f ≫ 𝟙 Y = f ≫ 𝟙 Y
state_after: no goals
tactic: simp
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
f g : X ⟶ Y
⊢ (isoTargetOfSelf f).hom = desc (𝟙 Y) ⋯
state_after: case h
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f g : X ⟶ Y
⊢ π f f ≫ (isoTargetOfSelf f).hom = π f f ≫ desc (𝟙 Y) ⋯
tactic: ext
state_before: case h
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f g : X ⟶ Y
⊢ π f f ≫ (isoTargetOfSelf f).hom = π f f ≫ desc (𝟙 Y) ⋯
state_after: no goals
tactic: simp [coequalizer.isoTargetOfSelf]
Theorem: Units.inv_eq_of_mul_eq_one_left
File: Mathlib/Algebra/Group/Units.lean

Proof steps:
state_before: α : Type u
inst✝ : Monoid α
a✝ b c u : αˣ
a : α
h : a * ↑u = 1
⊢ ↑u⁻¹ = 1 * ↑u⁻¹
state_after: no goals
tactic: rw [one_mul]
state_before: α : Type u
inst✝ : Monoid α
a✝ b c u : αˣ
a : α
h : a * ↑u = 1
⊢ 1 * ↑u⁻¹ = a
state_after: no goals
tactic: rw [← h, mul_inv_cancel_right]
Theorem: MeasureTheory.measure_of_cont_bdd_of_tendsto_indicator
File: Mathlib/MeasureTheory/Measure/HasOuterApproxClosed.lean

Proof steps:
state_before: Ω : Type u_1
inst✝⁴ : TopologicalSpace Ω
inst✝³ : MeasurableSpace Ω
inst✝² inst✝¹ : OpensMeasurableSpace Ω
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
c : ℝ≥0
E : Set Ω
E_mble : MeasurableSet E
fs : ℕ → Ω →ᵇ ℝ≥0
fs_bdd : ∀ (n : ℕ) (ω : Ω), (fs n) ω ≤ c
fs_lim : Tendsto (fun n ω => (fs n) ω) atTop (𝓝 (E.indicator fun x => 1))
⊢ Tendsto (fun n => ∫⁻ (ω : Ω), ↑((fs n) ω) ∂μ) atTop (𝓝 (μ E))
state_after: Ω : Type u_1
inst✝⁴ : TopologicalSpace Ω
inst✝³ : MeasurableSpace Ω
inst✝² inst✝¹ : OpensMeasurableSpace Ω
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
c : ℝ≥0
E : Set Ω
E_mble : MeasurableSet E
fs : ℕ → Ω →ᵇ ℝ≥0
fs_bdd : ∀ (n : ℕ) (ω : Ω), (fs n) ω ≤ c
fs_lim : Tendsto (fun n ω => (fs n) ω) atTop (𝓝 (E.indicator fun x => 1))
fs_lim' : ∀ (ω : Ω), Tendsto (fun n => (fs n) ω) atTop (𝓝 (E.indicator (fun x => 1) ω))
⊢ Tendsto (fun n => ∫⁻ (ω : Ω), ↑((fs n) ω) ∂μ) atTop (𝓝 (μ E))
tactic: have fs_lim' :
    ∀ ω, Tendsto (fun n : ℕ ↦ (fs n ω : ℝ≥0)) atTop (𝓝 (indicator E (fun _ ↦ (1 : ℝ≥0)) ω)) := by
    rw [tendsto_pi_nhds] at fs_lim
    exact fun ω ↦ fs_lim ω
state_before: Ω : Type u_1
inst✝⁴ : TopologicalSpace Ω
inst✝³ : MeasurableSpace Ω
inst✝² inst✝¹ : OpensMeasurableSpace Ω
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
c : ℝ≥0
E : Set Ω
E_mble : MeasurableSet E
fs : ℕ → Ω →ᵇ ℝ≥0
fs_bdd : ∀ (n : ℕ) (ω : Ω), (fs n) ω ≤ c
fs_lim : Tendsto (fun n ω => (fs n) ω) atTop (𝓝 (E.indicator fun x => 1))
fs_lim' : ∀ (ω : Ω), Tendsto (fun n => (fs n) ω) atTop (𝓝 (E.indicator (fun x => 1) ω))
⊢ Tendsto (fun n => ∫⁻ (ω : Ω), ↑((fs n) ω) ∂μ) atTop (𝓝 (μ E))
state_after: no goals
tactic: apply measure_of_cont_bdd_of_tendsto_filter_indicator μ E_mble fs
    (eventually_of_forall fun n ↦ eventually_of_forall (fs_bdd n)) (eventually_of_forall fs_lim')
Theorem: Stirling.second_wallis_limit
File: Mathlib/Analysis/SpecialFunctions/Stirling.lean

Proof steps:
state_before: a : ℝ
hane : a ≠ 0
ha : Tendsto stirlingSeq atTop (𝓝 a)
⊢ Tendsto Wallis.W atTop (𝓝 (a ^ 2 / 2))
state_after: a : ℝ
hane : a ≠ 0
ha : Tendsto stirlingSeq atTop (𝓝 a)
⊢ Tendsto (fun n => stirlingSeq n ^ 4 / stirlingSeq (2 * n) ^ 2 * (↑n / (2 * ↑n + 1))) atTop (𝓝 (a ^ 2 / 2))
tactic: refine Tendsto.congr' (eventually_atTop.mpr ⟨1, fun n hn =>
    stirlingSeq_pow_four_div_stirlingSeq_pow_two_eq n (one_le_iff_ne_zero.mp hn)⟩) ?_
state_before: a : ℝ
hane : a ≠ 0
ha : Tendsto stirlingSeq atTop (𝓝 a)
⊢ Tendsto (fun n => stirlingSeq n ^ 4 / stirlingSeq (2 * n) ^ 2 * (↑n / (2 * ↑n + 1))) atTop (𝓝 (a ^ 2 / 2))
state_after: a : ℝ
hane : a ≠ 0
ha : Tendsto stirlingSeq atTop (𝓝 a)
h : a ^ 2 / 2 = a ^ 4 / a ^ 2 * (1 / 2)
⊢ Tendsto (fun n => stirlingSeq n ^ 4 / stirlingSeq (2 * n) ^ 2 * (↑n / (2 * ↑n + 1))) atTop (𝓝 (a ^ 2 / 2))
tactic: have h : a ^ 2 / 2 = a ^ 4 / a ^ 2 * (1 / 2) := by
    rw [mul_one_div, ← mul_one_div (a ^ 4) (a ^ 2), one_div, ← pow_sub_of_lt a]
    norm_num
state_before: a : ℝ
hane : a ≠ 0
ha : Tendsto stirlingSeq atTop (𝓝 a)
h : a ^ 2 / 2 = a ^ 4 / a ^ 2 * (1 / 2)
⊢ Tendsto (fun n => stirlingSeq n ^ 4 / stirlingSeq (2 * n) ^ 2 * (↑n / (2 * ↑n + 1))) atTop (𝓝 (a ^ 2 / 2))
state_after: a : ℝ
hane : a ≠ 0
ha : Tendsto stirlingSeq atTop (𝓝 a)
h : a ^ 2 / 2 = a ^ 4 / a ^ 2 * (1 / 2)
⊢ Tendsto (fun n => stirlingSeq n ^ 4 / stirlingSeq (2 * n) ^ 2 * (↑n / (2 * ↑n + 1))) atTop
    (𝓝 (a ^ 4 / a ^ 2 * (1 / 2)))
tactic: rw [h]
state_before: a : ℝ
hane : a ≠ 0
ha : Tendsto stirlingSeq atTop (𝓝 a)
h : a ^ 2 / 2 = a ^ 4 / a ^ 2 * (1 / 2)
⊢ Tendsto (fun n => stirlingSeq n ^ 4 / stirlingSeq (2 * n) ^ 2 * (↑n / (2 * ↑n + 1))) atTop
    (𝓝 (a ^ 4 / a ^ 2 * (1 / 2)))
state_after: no goals
tactic: exact ((ha.pow 4).div ((ha.comp (tendsto_id.const_mul_atTop' two_pos)).pow 2)
    (pow_ne_zero 2 hane)).mul tendsto_self_div_two_mul_self_add_one
Theorem: Finset.Ioi_add_Ici_subset
File: Mathlib/Data/Finset/Pointwise/Interval.lean

Proof steps:
state_before: α : Type u_1
inst✝⁵ : Mul α
inst✝⁴ : PartialOrder α
inst✝³ : DecidableEq α
inst✝² : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝¹ : CovariantClass α α (Function.swap HMul.hMul) LT.lt
inst✝ : LocallyFiniteOrderTop α
a b : α
⊢ ↑(Ioi a * Ici b) ⊆ ↑(Ioi (a * b))
state_after: no goals
tactic: simpa using Set.Ioi_mul_Ici_subset' _ _
Theorem: Finset.filter_False
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
s✝ t : Finset α
h : DecidablePred fun x => False
s : Finset α
⊢ filter (fun x => False) s = ∅
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
s✝ t : Finset α
h : DecidablePred fun x => False
s : Finset α
a✝ : α
⊢ a✝ ∈ filter (fun x => False) s ↔ a✝ ∈ ∅
tactic: ext
state_before: case a
α : Type u_1
β : Type u_2
γ : Type u_3
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
s✝ t : Finset α
h : DecidablePred fun x => False
s : Finset α
a✝ : α
⊢ a✝ ∈ filter (fun x => False) s ↔ a✝ ∈ ∅
state_after: no goals
tactic: simp
Theorem: Int.Prime.dvd_pow
File: Mathlib/RingTheory/Int/Basic.lean

Proof steps:
state_before: n : ℤ
k p : ℕ
hp : Nat.Prime p
h : ↑p ∣ n ^ k
⊢ p ∣ n.natAbs
state_after: n : ℤ
k p : ℕ
hp : Nat.Prime p
h : p ∣ n.natAbs ^ k
⊢ p ∣ n.natAbs
tactic: rw [Int.natCast_dvd, Int.natAbs_pow] at h
state_before: n : ℤ
k p : ℕ
hp : Nat.Prime p
h : p ∣ n.natAbs ^ k
⊢ p ∣ n.natAbs
state_after: no goals
tactic: exact hp.dvd_of_dvd_pow h
Theorem: prod_le_borel_prod
File: Mathlib/MeasureTheory/Constructions/BorelSpace/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
γ₂ : Type u_4
δ : Type u_5
ι : Sort y
s t u : Set α
inst✝⁹ : TopologicalSpace α
inst✝⁸ : MeasurableSpace α
inst✝⁷ : BorelSpace α
inst✝⁶ : TopologicalSpace β
inst✝⁵ : MeasurableSpace β
inst✝⁴ : BorelSpace β
inst✝³ : TopologicalSpace γ
inst✝² : MeasurableSpace γ
inst✝¹ : BorelSpace γ
inst✝ : MeasurableSpace δ
⊢ Prod.instMeasurableSpace ≤ borel (α × β)
state_after: case refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
γ₂ : Type u_4
δ : Type u_5
ι : Sort y
s t u : Set α
inst✝⁹ : TopologicalSpace α
inst✝⁸ : MeasurableSpace α
inst✝⁷ : BorelSpace α
inst✝⁶ : TopologicalSpace β
inst✝⁵ : MeasurableSpace β
inst✝⁴ : BorelSpace β
inst✝³ : TopologicalSpace γ
inst✝² : MeasurableSpace γ
inst✝¹ : BorelSpace γ
inst✝ : MeasurableSpace δ
⊢ MeasurableSpace.comap Prod.fst (borel α) ≤ borel (α × β)

case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
γ₂ : Type u_4
δ : Type u_5
ι : Sort y
s t u : Set α
inst✝⁹ : TopologicalSpace α
inst✝⁸ : MeasurableSpace α
inst✝⁷ : BorelSpace α
inst✝⁶ : TopologicalSpace β
inst✝⁵ : MeasurableSpace β
inst✝⁴ : BorelSpace β
inst✝³ : TopologicalSpace γ
inst✝² : MeasurableSpace γ
inst✝¹ : BorelSpace γ
inst✝ : MeasurableSpace δ
⊢ MeasurableSpace.comap Prod.snd (borel β) ≤ borel (α × β)
tactic: refine sup_le ?_ ?_
Theorem: PSigma.lex_iff
File: Mathlib/Data/Sigma/Lex.lean

Proof steps:
state_before: ι : Sort u_1
α : ι → Sort u_2
r r₁ r₂ : ι → ι → Prop
s s₁ s₂ : (i : ι) → α i → α i → Prop
a b : (i : ι) ×' α i
⊢ Lex r s a b ↔ r a.fst b.fst ∨ ∃ h, s b.fst (h ▸ a.snd) b.snd
state_after: case mp
ι : Sort u_1
α : ι → Sort u_2
r r₁ r₂ : ι → ι → Prop
s s₁ s₂ : (i : ι) → α i → α i → Prop
a b : (i : ι) ×' α i
⊢ Lex r s a b → r a.fst b.fst ∨ ∃ h, s b.fst (h ▸ a.snd) b.snd

case mpr
ι : Sort u_1
α : ι → Sort u_2
r r₁ r₂ : ι → ι → Prop
s s₁ s₂ : (i : ι) → α i → α i → Prop
a b : (i : ι) ×' α i
⊢ (r a.fst b.fst ∨ ∃ h, s b.fst (h ▸ a.snd) b.snd) → Lex r s a b
tactic: constructor
Theorem: Quiver.Symmetrify.lift_unique
File: Mathlib/Combinatorics/Quiver/Symmetric.lean

Proof steps:
state_before: U : Type u_1
V : Type u_2
W : Type u_3
inst✝⁴ : Quiver U
inst✝³ : Quiver V
inst✝² : Quiver W
V' : Type u_4
inst✝¹ : Quiver V'
inst✝ : HasReverse V'
φ : V ⥤q V'
Φ : Symmetrify V ⥤q V'
hΦ : of ⋙q Φ = φ
hΦinv : ∀ {X Y : Symmetrify V} (f : X ⟶ Y), Φ.map (reverse f) = reverse (Φ.map f)
⊢ Φ = lift φ
state_after: U : Type u_1
V : Type u_2
W : Type u_3
inst✝⁴ : Quiver U
inst✝³ : Quiver V
inst✝² : Quiver W
V' : Type u_4
inst✝¹ : Quiver V'
inst✝ : HasReverse V'
Φ : Symmetrify V ⥤q V'
hΦinv : ∀ {X Y : Symmetrify V} (f : X ⟶ Y), Φ.map (reverse f) = reverse (Φ.map f)
⊢ Φ = lift (of ⋙q Φ)
tactic: subst_vars
state_before: U : Type u_1
V : Type u_2
W : Type u_3
inst✝⁴ : Quiver U
inst✝³ : Quiver V
inst✝² : Quiver W
V' : Type u_4
inst✝¹ : Quiver V'
inst✝ : HasReverse V'
Φ : Symmetrify V ⥤q V'
hΦinv : ∀ {X Y : Symmetrify V} (f : X ⟶ Y), Φ.map (reverse f) = reverse (Φ.map f)
⊢ Φ = lift (of ⋙q Φ)
state_after: case h_obj
U : Type u_1
V : Type u_2
W : Type u_3
inst✝⁴ : Quiver U
inst✝³ : Quiver V
inst✝² : Quiver W
V' : Type u_4
inst✝¹ : Quiver V'
inst✝ : HasReverse V'
Φ : Symmetrify V ⥤q V'
hΦinv : ∀ {X Y : Symmetrify V} (f : X ⟶ Y), Φ.map (reverse f) = reverse (Φ.map f)
⊢ ∀ (X : Symmetrify V), Φ.obj X = (lift (of ⋙q Φ)).obj X

case h_map
U : Type u_1
V : Type u_2
W : Type u_3
inst✝⁴ : Quiver U
inst✝³ : Quiver V
inst✝² : Quiver W
V' : Type u_4
inst✝¹ : Quiver V'
inst✝ : HasReverse V'
Φ : Symmetrify V ⥤q V'
hΦinv : ∀ {X Y : Symmetrify V} (f : X ⟶ Y), Φ.map (reverse f) = reverse (Φ.map f)
⊢ ∀ (X Y : Symmetrify V) (f : X ⟶ Y), Φ.map f = Eq.recOn ⋯ (Eq.recOn ⋯ ((lift (of ⋙q Φ)).map f))
tactic: fapply Prefunctor.ext
Theorem: Orientation.oangle_map
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean

Proof steps:
state_before: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x y : V'
f : V ≃ₗᵢ[ℝ] V'
⊢ ((map (Fin 2) f.toLinearEquiv) o).oangle x y = o.oangle (f.symm x) (f.symm y)
state_after: no goals
tactic: simp [oangle, o.kahler_map]
Theorem: OrthogonalIdempotents.lift_of_isNilpotent_ker
File: Mathlib/RingTheory/Idempotents.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
inst✝² : Ring R
inst✝¹ : Ring S
f : R →+* S
I : Type u_3
e✝ : I → R
he✝ : OrthogonalIdempotents e✝
inst✝ : Finite I
h : ∀ x ∈ RingHom.ker f, IsNilpotent x
e : I → S
he : OrthogonalIdempotents e
he' : ∀ (i : I), e i ∈ f.range
⊢ ∃ e', OrthogonalIdempotents e' ∧ ⇑f ∘ e' = e
state_after: case intro
R : Type u_1
S : Type u_2
inst✝² : Ring R
inst✝¹ : Ring S
f : R →+* S
I : Type u_3
e✝ : I → R
he✝ : OrthogonalIdempotents e✝
inst✝ : Finite I
h : ∀ x ∈ RingHom.ker f, IsNilpotent x
e : I → S
he : OrthogonalIdempotents e
he' : ∀ (i : I), e i ∈ f.range
val✝ : Fintype I
⊢ ∃ e', OrthogonalIdempotents e' ∧ ⇑f ∘ e' = e
tactic: cases nonempty_fintype I
state_before: case intro
R : Type u_1
S : Type u_2
inst✝² : Ring R
inst✝¹ : Ring S
f : R →+* S
I : Type u_3
e✝ : I → R
he✝ : OrthogonalIdempotents e✝
inst✝ : Finite I
h : ∀ x ∈ RingHom.ker f, IsNilpotent x
e : I → S
he : OrthogonalIdempotents e
he' : ∀ (i : I), e i ∈ f.range
val✝ : Fintype I
⊢ ∃ e', OrthogonalIdempotents e' ∧ ⇑f ∘ e' = e
state_after: case intro.intro.intro
R : Type u_1
S : Type u_2
inst✝² : Ring R
inst✝¹ : Ring S
f : R →+* S
I : Type u_3
e✝ : I → R
he✝ : OrthogonalIdempotents e✝
inst✝ : Finite I
h : ∀ x ∈ RingHom.ker f, IsNilpotent x
e : I → S
he : OrthogonalIdempotents e
he' : ∀ (i : I), e i ∈ f.range
val✝ : Fintype I
e' : Fin (Fintype.card I) → R
h₁ : OrthogonalIdempotents e'
h₂ : ⇑f ∘ e' = e ∘ ⇑(Fintype.equivFin I).symm.toEmbedding
⊢ ∃ e', OrthogonalIdempotents e' ∧ ⇑f ∘ e' = e
tactic: obtain ⟨e', h₁, h₂⟩ := lift_of_isNilpotent_ker_aux f h
    (he.embedding (Fintype.equivFin I).symm.toEmbedding) (fun _ ↦ he' _)
state_before: case intro.intro.intro
R : Type u_1
S : Type u_2
inst✝² : Ring R
inst✝¹ : Ring S
f : R →+* S
I : Type u_3
e✝ : I → R
he✝ : OrthogonalIdempotents e✝
inst✝ : Finite I
h : ∀ x ∈ RingHom.ker f, IsNilpotent x
e : I → S
he : OrthogonalIdempotents e
he' : ∀ (i : I), e i ∈ f.range
val✝ : Fintype I
e' : Fin (Fintype.card I) → R
h₁ : OrthogonalIdempotents e'
h₂ : ⇑f ∘ e' = e ∘ ⇑(Fintype.equivFin I).symm.toEmbedding
⊢ ∃ e', OrthogonalIdempotents e' ∧ ⇑f ∘ e' = e
state_after: no goals
tactic: refine ⟨_, h₁.embedding (Fintype.equivFin I).toEmbedding,
    by ext x; simpa using congr_fun h₂ (Fintype.equivFin I x)⟩
Theorem: Complex.angle_exp_one
File: Mathlib/Analysis/Complex/Angle.lean

Proof steps:
state_before: a x✝ y : ℂ
x : ℝ
⊢ angle (cexp (↑x * I)) 1 = |toIocMod Real.two_pi_pos (-π) x|
state_after: no goals
tactic: simpa using angle_exp_exp x 0
Theorem: NormedAddGroupHom.sum_apply
File: Mathlib/Analysis/Normed/Group/Hom.lean

Proof steps:
state_before: V : Type u_1
V₁ : Type u_2
V₂ : Type u_3
V₃ : Type u_4
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f✝ g : NormedAddGroupHom V₁ V₂
ι : Type u_5
s : Finset ι
f : ι → NormedAddGroupHom V₁ V₂
v : V₁
⊢ (∑ i ∈ s, f i) v = ∑ i ∈ s, (f i) v
state_after: no goals
tactic: simp only [coe_sum, Finset.sum_apply]
Theorem: isEmpty_subtype
File: Mathlib/Logic/IsEmpty.lean

Proof steps:
state_before: α : Sort u_1
β : Sort u_2
γ : Sort u_3
p : α → Prop
⊢ IsEmpty (Subtype p) ↔ ∀ (x : α), ¬p x
state_after: no goals
tactic: simp only [← not_nonempty_iff, nonempty_subtype, not_exists]
Theorem: Nat.div_pos_iff
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
hb : b ≠ 0
⊢ 0 < a / b ↔ b ≤ a
state_after: no goals
tactic: rw [Nat.pos_iff_ne_zero, Nat.div_ne_zero_iff hb]
Theorem: List.reverse_cons'
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a : α
l : List α
⊢ (a :: l).reverse = l.reverse.concat a
state_after: no goals
tactic: simp only [reverse_cons, concat_eq_append]
Theorem: Polynomial.reverse_mul_X
File: Mathlib/Algebra/Polynomial/Reverse.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
f p : R[X]
⊢ (p * X).reverse = p.reverse
state_after: R : Type u_1
inst✝ : Semiring R
f p : R[X]
a✝ : Nontrivial R
⊢ (p * X).reverse = p.reverse
tactic: nontriviality R
state_before: R : Type u_1
inst✝ : Semiring R
f p : R[X]
a✝ : Nontrivial R
⊢ (p * X).reverse = p.reverse
state_after: case inl
R : Type u_1
inst✝ : Semiring R
f : R[X]
a✝ : Nontrivial R
⊢ (0 * X).reverse = reverse 0

case inr
R : Type u_1
inst✝ : Semiring R
f p : R[X]
a✝ : Nontrivial R
hp : p ≠ 0
⊢ (p * X).reverse = p.reverse
tactic: rcases eq_or_ne p 0 with rfl | hp