ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Int.ediv_eq_zero_of_lt_abs
File: Mathlib/Algebra/Order/Group/Int.lean

Proof steps:
state_before: a b : ℤ
H1 : 0 ≤ a
H2✝ : a < |b|
n : ℕ
H2 : a < ↑-[n+1].natAbs
⊢ -(a / -[n+1]) = -0
state_after: a b : ℤ
H1 : 0 ≤ a
H2✝ : a < |b|
n : ℕ
H2 : a < ↑-[n+1].natAbs
⊢ a / - -[n+1] = -0
tactic: rw [← Int.ediv_neg]
state_before: a b : ℤ
H1 : 0 ≤ a
H2✝ : a < |b|
n : ℕ
H2 : a < ↑-[n+1].natAbs
⊢ a / - -[n+1] = -0
state_after: no goals
tactic: exact ediv_eq_zero_of_lt H1 H2
Theorem: HurwitzZeta.completedHurwitzZetaEven₀_one_sub
File: Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean

Proof steps:
state_before: a : UnitAddCircle
s : ℂ
⊢ completedHurwitzZetaEven₀ a (1 - s) = completedCosZeta₀ a s
state_after: no goals
tactic: rw [completedHurwitzZetaEven₀, completedCosZeta₀, sub_div,
    (by norm_num : (1 / 2 : ℂ) = ↑(1 / 2 : ℝ)),
    (by rfl : (1 / 2 : ℝ) = (hurwitzEvenFEPair a).k),
    (hurwitzEvenFEPair a).functional_equation₀ (s / 2),
    (by rfl : (hurwitzEvenFEPair a).ε = 1),
    one_smul]
Theorem: UpperHalfPlane.exists_SL2_smul_eq_of_apply_zero_one_eq_zero
File: Mathlib/Analysis/Complex/UpperHalfPlane/Basic.lean

Proof steps:
state_before: g : SL(2, ℝ)
hc : ↑↑g 1 0 = 0
⊢ ∃ u v, (fun x => g • x) = (fun x => v +ᵥ x) ∘ fun x => u • x
state_after: case intro.intro.intro
a b : ℝ
ha : a ≠ 0
hc : ↑↑⟨!![a, b; 0, a⁻¹], ⋯⟩ 1 0 = 0
⊢ ∃ u v, (fun x => ⟨!![a, b; 0, a⁻¹], ⋯⟩ • x) = (fun x => v +ᵥ x) ∘ fun x => u • x
tactic: obtain ⟨a, b, ha, rfl⟩ := g.fin_two_exists_eq_mk_of_apply_zero_one_eq_zero hc
state_before: case intro.intro.intro
a b : ℝ
ha : a ≠ 0
hc : ↑↑⟨!![a, b; 0, a⁻¹], ⋯⟩ 1 0 = 0
⊢ ∃ u v, (fun x => ⟨!![a, b; 0, a⁻¹], ⋯⟩ • x) = (fun x => v +ᵥ x) ∘ fun x => u • x
state_after: case intro.intro.intro
a b : ℝ
ha : a ≠ 0
hc : ↑↑⟨!![a, b; 0, a⁻¹], ⋯⟩ 1 0 = 0
⊢ (fun x => ⟨!![a, b; 0, a⁻¹], ⋯⟩ • x) = (fun x => b * a +ᵥ x) ∘ fun x => ⟨a * a, ⋯⟩ • x
tactic: refine ⟨⟨_, mul_self_pos.mpr ha⟩, b * a, ?_⟩
state_before: case intro.intro.intro
a b : ℝ
ha : a ≠ 0
hc : ↑↑⟨!![a, b; 0, a⁻¹], ⋯⟩ 1 0 = 0
⊢ (fun x => ⟨!![a, b; 0, a⁻¹], ⋯⟩ • x) = (fun x => b * a +ᵥ x) ∘ fun x => ⟨a * a, ⋯⟩ • x
state_after: case intro.intro.intro.h.mk
a b : ℝ
ha : a ≠ 0
hc : ↑↑⟨!![a, b; 0, a⁻¹], ⋯⟩ 1 0 = 0
z : ℂ
hz : 0 < z.im
⊢ ⟨!![a, b; 0, a⁻¹], ⋯⟩ • ⟨z, hz⟩ = ((fun x => b * a +ᵥ x) ∘ fun x => ⟨a * a, ⋯⟩ • x) ⟨z, hz⟩
tactic: ext1 ⟨z, hz⟩
state_before: case intro.intro.intro.h.mk
a b : ℝ
ha : a ≠ 0
hc : ↑↑⟨!![a, b; 0, a⁻¹], ⋯⟩ 1 0 = 0
z : ℂ
hz : 0 < z.im
⊢ ⟨!![a, b; 0, a⁻¹], ⋯⟩ • ⟨z, hz⟩ = ((fun x => b * a +ᵥ x) ∘ fun x => ⟨a * a, ⋯⟩ • x) ⟨z, hz⟩
state_after: case intro.intro.intro.h.mk.h
a b : ℝ
ha : a ≠ 0
hc : ↑↑⟨!![a, b; 0, a⁻¹], ⋯⟩ 1 0 = 0
z : ℂ
hz : 0 < z.im
⊢ ↑(⟨!![a, b; 0, a⁻¹], ⋯⟩ • ⟨z, hz⟩) = ↑(((fun x => b * a +ᵥ x) ∘ fun x => ⟨a * a, ⋯⟩ • x) ⟨z, hz⟩)
tactic: ext1
state_before: case intro.intro.intro.h.mk.h
a b : ℝ
ha : a ≠ 0
hc : ↑↑⟨!![a, b; 0, a⁻¹], ⋯⟩ 1 0 = 0
z : ℂ
hz : 0 < z.im
⊢ ↑(⟨!![a, b; 0, a⁻¹], ⋯⟩ • ⟨z, hz⟩) = ↑(((fun x => b * a +ᵥ x) ∘ fun x => ⟨a * a, ⋯⟩ • x) ⟨z, hz⟩)
state_after: case intro.intro.intro.h.mk.h
a b : ℝ
ha : a ≠ 0
hc : ↑↑⟨!![a, b; 0, a⁻¹], ⋯⟩ 1 0 = 0
z : ℂ
hz : 0 < z.im
⊢ ↑a * z * ↑a + ↑b * ↑a = ↑b * ↑a + ↑a * ↑a * z
tactic: suffices ↑a * z * a + b * a = b * a + a * a * z by
    -- Porting note: added `coeToGL` and merged `rw` and `simpa`
    simpa [coeToGL, specialLinearGroup_apply, add_mul]
state_before: case intro.intro.intro.h.mk.h
a b : ℝ
ha : a ≠ 0
hc : ↑↑⟨!![a, b; 0, a⁻¹], ⋯⟩ 1 0 = 0
z : ℂ
hz : 0 < z.im
⊢ ↑a * z * ↑a + ↑b * ↑a = ↑b * ↑a + ↑a * ↑a * z
state_after: no goals
tactic: ring
Theorem: geom_sum_pos_iff
File: Mathlib/Algebra/GeomSum.lean

Proof steps:
state_before: α : Type u
β : Type u_1
n : ℕ
x : α
inst✝ : LinearOrderedRing α
hn : n ≠ 0
⊢ 0 < ∑ i ∈ range n, x ^ i ↔ Odd n ∨ 0 < x + 1
state_after: case refine_1
α : Type u
β : Type u_1
n : ℕ
x : α
inst✝ : LinearOrderedRing α
hn : n ≠ 0
h : 0 < ∑ i ∈ range n, x ^ i
⊢ Odd n ∨ 0 < x + 1

case refine_2
α : Type u
β : Type u_1
n : ℕ
x : α
inst✝ : LinearOrderedRing α
hn : n ≠ 0
⊢ Odd n ∨ 0 < x + 1 → 0 < ∑ i ∈ range n, x ^ i
tactic: refine ⟨fun h => ?_, ?_⟩
Theorem: Stream'.WSeq.mem_cons_iff
File: Mathlib/Data/Seq/WSeq.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
b a : α
⊢ some (b, s) ∈ (cons b s).destruct
state_after: no goals
tactic: simp [ret_mem]
Theorem: Polynomial.natDegree_sub_C
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✝ : Ring R
p q : R[X]
a : R
⊢ (p - C a).natDegree = p.natDegree
state_after: no goals
tactic: rw [sub_eq_add_neg, ← C_neg, natDegree_add_C]
Theorem: Rat.pow_def
File: Mathlib/Data/Rat/Defs.lean

Proof steps:
state_before: q✝ q : ℚ
n : ℕ
⊢ q.den ^ n ≠ 0
state_after: no goals
tactic: simp [Nat.pow_eq_zero]
state_before: q✝ q : ℚ
n : ℕ
⊢ (q.num ^ n).natAbs.Coprime (q.den ^ n)
state_after: q✝ q : ℚ
n : ℕ
⊢ (q.num.natAbs ^ n).Coprime (q.den ^ n)
tactic: rw [Int.natAbs_pow]
state_before: q✝ q : ℚ
n : ℕ
⊢ (q.num.natAbs ^ n).Coprime (q.den ^ n)
state_after: no goals
tactic: exact q.reduced.pow _ _
Theorem: List.cons_head?_tail
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a : α
h : a ∈ [].head?
⊢ a :: [].tail = []
state_after: no goals
tactic: contradiction
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
b : α
l : List α
a : α
h : a ∈ (b :: l).head?
⊢ a :: (b :: l).tail = b :: l
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
b : α
l : List α
a : α
h : b = a
⊢ a :: (b :: l).tail = b :: l
tactic: simp? at h says simp only [head?_cons, Option.mem_def, Option.some.injEq] at h
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
b : α
l : List α
a : α
h : b = a
⊢ a :: (b :: l).tail = b :: l
state_after: no goals
tactic: simp [h]
Theorem: CategoryTheory.WithInitial.mapComp_hom_app
File: Mathlib/CategoryTheory/WithTerminal.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
E : Type u_2
inst✝¹ : Category.{?u.258557, u_1} D
inst✝ : Category.{?u.258561, u_2} E
F : C ⥤ D
G : D ⥤ E
⊢ ∀ {X Y : WithInitial C} (f : X ⟶ Y),
    (map (F ⋙ G)).map f ≫
        ((fun X =>
              match X with
              | of x => Iso.refl ((map (F ⋙ G)).obj (of x))
              | star => Iso.refl ((map (F ⋙ G)).obj star))
            Y).hom =
      ((fun X =>
              match X with
              | of x => Iso.refl ((map (F ⋙ G)).obj (of x))
              | star => Iso.refl ((map (F ⋙ G)).obj star))
            X).hom ≫
        (map F ⋙ map G).map f
state_after: no goals
tactic: aesop_cat
Theorem: orderOf_le_of_pow_eq_one
File: Mathlib/GroupTheory/OrderOfElement.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n m : ℕ
hn : 0 < n
h : x ^ n = 1
⊢ IsPeriodicPt (fun x_1 => x * x_1) n 1
state_after: no goals
tactic: rwa [isPeriodicPt_mul_iff_pow_eq_one]
Theorem: ProbabilityTheory.IdentDistrib.ae_snd
File: Mathlib/Probability/IdentDistrib.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
μ : Measure α
ν : Measure β
f : α → γ
g : β → γ
h : IdentDistrib f g μ ν
p : γ → Prop
pmeas : MeasurableSet {x | p x}
hp : ∀ᵐ (x : α) ∂μ, p (f x)
⊢ ∀ᵐ (x : β) ∂ν, p (g x)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
μ : Measure α
ν : Measure β
f : α → γ
g : β → γ
h : IdentDistrib f g μ ν
p : γ → Prop
pmeas : MeasurableSet {x | p x}
hp : ∀ᵐ (x : α) ∂μ, p (f x)
⊢ ∀ᵐ (y : γ) ∂Measure.map g ν, p y
tactic: apply (ae_map_iff h.aemeasurable_snd pmeas).1
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
μ : Measure α
ν : Measure β
f : α → γ
g : β → γ
h : IdentDistrib f g μ ν
p : γ → Prop
pmeas : MeasurableSet {x | p x}
hp : ∀ᵐ (x : α) ∂μ, p (f x)
⊢ ∀ᵐ (y : γ) ∂Measure.map g ν, p y
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
μ : Measure α
ν : Measure β
f : α → γ
g : β → γ
h : IdentDistrib f g μ ν
p : γ → Prop
pmeas : MeasurableSet {x | p x}
hp : ∀ᵐ (x : α) ∂μ, p (f x)
⊢ ∀ᵐ (y : γ) ∂Measure.map f μ, p y
tactic: rw [← h.map_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
μ : Measure α
ν : Measure β
f : α → γ
g : β → γ
h : IdentDistrib f g μ ν
p : γ → Prop
pmeas : MeasurableSet {x | p x}
hp : ∀ᵐ (x : α) ∂μ, p (f x)
⊢ ∀ᵐ (y : γ) ∂Measure.map f μ, p y
state_after: no goals
tactic: exact (ae_map_iff h.aemeasurable_fst pmeas).2 hp
Theorem: Set.Nat.card_coe_set_eq
File: Mathlib/Data/Set/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s✝ t s : Set α
⊢ Nat.card ↑s = s.ncard
state_after: case inl
α : Type u_1
β : Type u_2
s✝ t s : Set α
h : s.Finite
⊢ Nat.card ↑s = s.ncard

case inr
α : Type u_1
β : Type u_2
s✝ t s : Set α
h : s.Infinite
⊢ Nat.card ↑s = s.ncard
tactic: obtain (h | h) := s.finite_or_infinite
state_before: case inr
α : Type u_1
β : Type u_2
s✝ t s : Set α
h : s.Infinite
⊢ Nat.card ↑s = s.ncard
state_after: case inr
α : Type u_1
β : Type u_2
s✝ t s : Set α
h : s.Infinite
this : Infinite ↑s
⊢ Nat.card ↑s = s.ncard
tactic: have := infinite_coe_iff.2 h
state_before: case inr
α : Type u_1
β : Type u_2
s✝ t s : Set α
h : s.Infinite
this : Infinite ↑s
⊢ Nat.card ↑s = s.ncard
state_after: no goals
tactic: rw [ncard, h.encard_eq, Nat.card_eq_zero_of_infinite, ENat.toNat_top]
Theorem: CategoryTheory.IsSplitCoequalizer.map_leftSection
File: Mathlib/CategoryTheory/Limits/Shapes/SplitCoequalizer.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
G : C ⥤ D
X Y : C
f g : X ⟶ Y
Z : C
π : Y ⟶ Z
q : IsSplitCoequalizer f g π
F : C ⥤ D
⊢ F.map f ≫ F.map π = F.map g ≫ F.map π
state_after: no goals
tactic: rw [← F.map_comp, q.condition, F.map_comp]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
G : C ⥤ D
X Y : C
f g : X ⟶ Y
Z : C
π : Y ⟶ Z
q : IsSplitCoequalizer f g π
F : C ⥤ D
⊢ F.map q.rightSection ≫ F.map π = 𝟙 (F.obj Z)
state_after: no goals
tactic: rw [← F.map_comp, q.rightSection_π, F.map_id]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
G : C ⥤ D
X Y : C
f g : X ⟶ Y
Z : C
π : Y ⟶ Z
q : IsSplitCoequalizer f g π
F : C ⥤ D
⊢ F.map q.leftSection ≫ F.map g = 𝟙 (F.obj Y)
state_after: no goals
tactic: rw [← F.map_comp, q.leftSection_bottom, F.map_id]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
G : C ⥤ D
X Y : C
f g : X ⟶ Y
Z : C
π : Y ⟶ Z
q : IsSplitCoequalizer f g π
F : C ⥤ D
⊢ F.map q.leftSection ≫ F.map f = F.map π ≫ F.map q.rightSection
state_after: no goals
tactic: rw [← F.map_comp, q.leftSection_top, F.map_comp]
Theorem: eq_of_prime_pow_eq'
File: Mathlib/Algebra/Associated/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R : Type u_5
inst✝¹ : CancelCommMonoidWithZero R
inst✝ : Unique Rˣ
p₁ p₂ : R
k₁ k₂ : ℕ
hp₁ : Prime p₁
hp₂ : Prime p₂
hk₁ : 0 < k₂
h : p₁ ^ k₁ = p₂ ^ k₂
⊢ p₁ = p₂
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R : Type u_5
inst✝¹ : CancelCommMonoidWithZero R
inst✝ : Unique Rˣ
p₁ p₂ : R
k₁ k₂ : ℕ
hp₁ : Prime p₁
hp₂ : Prime p₂
hk₁ : 0 < k₂
h : p₁ ^ k₁ ~ᵤ p₂ ^ k₂
⊢ p₁ ~ᵤ p₂
tactic: rw [← associated_iff_eq] at h ⊢
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R : Type u_5
inst✝¹ : CancelCommMonoidWithZero R
inst✝ : Unique Rˣ
p₁ p₂ : R
k₁ k₂ : ℕ
hp₁ : Prime p₁
hp₂ : Prime p₂
hk₁ : 0 < k₂
h : p₁ ^ k₁ ~ᵤ p₂ ^ k₂
⊢ p₁ ~ᵤ p₂
state_after: no goals
tactic: apply h.of_pow_associated_of_prime' hp₁ hp₂ hk₁
Theorem: CategoryTheory.Subgroupoid.Map.arrows_iff
File: Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Groupoid C
S✝ : Subgroupoid C
D : Type u_1
inst✝ : Groupoid D
φ : C ⥤ D
hφ : Function.Injective φ.obj
S : Subgroupoid C
c d : D
f : c ⟶ d
⊢ Arrows φ hφ S c d f ↔
    ∃ a b g, ∃ (ha : φ.obj a = c) (hb : φ.obj b = d) (_ : g ∈ S.arrows a b), f = eqToHom ⋯ ≫ φ.map g ≫ eqToHom hb
state_after: case mp
C : Type u
inst✝¹ : Groupoid C
S✝ : Subgroupoid C
D : Type u_1
inst✝ : Groupoid D
φ : C ⥤ D
hφ : Function.Injective φ.obj
S : Subgroupoid C
c d : D
f : c ⟶ d
⊢ Arrows φ hφ S c d f →
    ∃ a b g, ∃ (ha : φ.obj a = c) (hb : φ.obj b = d) (_ : g ∈ S.arrows a b), f = eqToHom ⋯ ≫ φ.map g ≫ eqToHom hb

case mpr
C : Type u
inst✝¹ : Groupoid C
S✝ : Subgroupoid C
D : Type u_1
inst✝ : Groupoid D
φ : C ⥤ D
hφ : Function.Injective φ.obj
S : Subgroupoid C
c d : D
f : c ⟶ d
⊢ (∃ a b g, ∃ (ha : φ.obj a = c) (hb : φ.obj b = d) (_ : g ∈ S.arrows a b), f = eqToHom ⋯ ≫ φ.map g ≫ eqToHom hb) →
    Arrows φ hφ S c d f
tactic: constructor
Theorem: Real.hasDerivAt_rpow_const
File: Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean

Proof steps:
state_before: z x✝ y x p : ℝ
h : x ≠ 0 ∨ 1 ≤ p
⊢ HasDerivAt (fun x => x ^ p) (p * x ^ (p - 1)) x
state_after: case inl
z x✝ y x p : ℝ
h : x ≠ 0 ∨ 1 ≤ p
hx : x ≠ 0
⊢ HasDerivAt (fun x => x ^ p) (p * x ^ (p - 1)) x

case inr
z x y p : ℝ
h : 0 ≠ 0 ∨ 1 ≤ p
⊢ HasDerivAt (fun x => x ^ p) (p * 0 ^ (p - 1)) 0
tactic: rcases ne_or_eq x 0 with (hx | rfl)
state_before: case inr
z x y p : ℝ
h : 0 ≠ 0 ∨ 1 ≤ p
⊢ HasDerivAt (fun x => x ^ p) (p * 0 ^ (p - 1)) 0
state_after: case inr
z x y p : ℝ
h : 1 ≤ p
⊢ HasDerivAt (fun x => x ^ p) (p * 0 ^ (p - 1)) 0
tactic: replace h : 1 ≤ p := h.neg_resolve_left rfl
state_before: case inr
z x y p : ℝ
h : 1 ≤ p
⊢ HasDerivAt (fun x => x ^ p) (p * 0 ^ (p - 1)) 0
state_after: case inr.hf
z x y p : ℝ
h : 1 ≤ p
⊢ ContinuousAt (fun x => x ^ p) 0

case inr.hg
z x y p : ℝ
h : 1 ≤ p
⊢ ContinuousAt (fun x => p * x ^ (p - 1)) 0
tactic: apply hasDerivAt_of_hasDerivAt_of_ne fun x hx =>
    (hasStrictDerivAt_rpow_const_of_ne hx p).hasDerivAt
state_before: case inr.hf
z x y p : ℝ
h : 1 ≤ p
⊢ ContinuousAt (fun x => x ^ p) 0

case inr.hg
z x y p : ℝ
h : 1 ≤ p
⊢ ContinuousAt (fun x => p * x ^ (p - 1)) 0
state_after: no goals
tactic: exacts [continuousAt_id.rpow_const (Or.inr (zero_le_one.trans h)),
    continuousAt_const.mul (continuousAt_id.rpow_const (Or.inr (sub_nonneg.2 h)))]
Theorem: PiLp.edist_comm
File: Mathlib/Analysis/Normed/Lp/PiLp.lean

Proof steps:
state_before: p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β : ι → Type u_4
inst✝¹ : Fintype ι
inst✝ : (i : ι) → PseudoEMetricSpace (β i)
f g : PiLp p β
⊢ edist f g = edist g f
state_after: case inl
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β : ι → Type u_4
inst✝¹ : Fintype ι
inst✝ : (i : ι) → PseudoEMetricSpace (β i)
f g : PiLp 0 β
⊢ edist f g = edist g f

case inr.inl
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β : ι → Type u_4
inst✝¹ : Fintype ι
inst✝ : (i : ι) → PseudoEMetricSpace (β i)
f g : PiLp ⊤ β
⊢ edist f g = edist g f

case inr.inr
p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β : ι → Type u_4
inst✝¹ : Fintype ι
inst✝ : (i : ι) → PseudoEMetricSpace (β i)
f g : PiLp p β
h : 0 < p.toReal
⊢ edist f g = edist g f
tactic: rcases p.trichotomy with (rfl | rfl | h)
Theorem: List.rdropWhile_prefix
File: Mathlib/Data/List/DropRight.lean

Proof steps:
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
⊢ rdropWhile p l <+: l
state_after: α : Type u_1
p : α → Bool
l : List α
n : ℕ
⊢ dropWhile p l.reverse <:+ l.reverse
tactic: rw [← reverse_suffix, rdropWhile, reverse_reverse]
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
⊢ dropWhile p l.reverse <:+ l.reverse
state_after: no goals
tactic: exact dropWhile_suffix _
Theorem: BoxIntegral.norm_integral_le_of_norm_le
File: Mathlib/Analysis/BoxIntegral/Basic.lean

Proof steps:
state_before: ι : Type u
E : Type v
F : Type w
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝¹ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
g : (ι → ℝ) → ℝ
hle : ∀ x ∈ Box.Icc I, ‖f x‖ ≤ g x
μ : Measure (ι → ℝ)
inst✝ : IsLocallyFiniteMeasure μ
hg : Integrable I l g μ.toBoxAdditive.toSMul
⊢ ‖integral I l f μ.toBoxAdditive.toSMul‖ ≤ integral I l g μ.toBoxAdditive.toSMul
state_after: case pos
ι : Type u
E : Type v
F : Type w
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝¹ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
g : (ι → ℝ) → ℝ
hle : ∀ x ∈ Box.Icc I, ‖f x‖ ≤ g x
μ : Measure (ι → ℝ)
inst✝ : IsLocallyFiniteMeasure μ
hg : Integrable I l g μ.toBoxAdditive.toSMul
hfi : Integrable I l f μ.toBoxAdditive.toSMul
⊢ ‖integral I l f μ.toBoxAdditive.toSMul‖ ≤ integral I l g μ.toBoxAdditive.toSMul

case neg
ι : Type u
E : Type v
F : Type w
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝¹ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
g : (ι → ℝ) → ℝ
hle : ∀ x ∈ Box.Icc I, ‖f x‖ ≤ g x
μ : Measure (ι → ℝ)
inst✝ : IsLocallyFiniteMeasure μ
hg : Integrable I l g μ.toBoxAdditive.toSMul
hfi : ¬Integrable I l f μ.toBoxAdditive.toSMul
⊢ ‖integral I l f μ.toBoxAdditive.toSMul‖ ≤ integral I l g μ.toBoxAdditive.toSMul
tactic: by_cases hfi : Integrable.{u, v, v} I l f μ.toBoxAdditive.toSMul
Theorem: isPathConnected_compl_of_isPathConnected_compl_zero
File: Mathlib/Analysis/Convex/Topology.lean

Proof steps:
state_before: ι : Type u_1
𝕜 : Type u_2
E✝ : Type u_3
E : Type u_4
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
inst✝² : TopologicalSpace E
inst✝¹ : TopologicalAddGroup E
inst✝ : ContinuousSMul ℝ E
p q : Submodule ℝ E
hpq : IsCompl p q
hpc : IsPathConnected {0}ᶜ
⊢ IsPathConnected (↑q)ᶜ
state_after: ι : Type u_1
𝕜 : Type u_2
E✝ : Type u_3
E : Type u_4
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
inst✝² : TopologicalSpace E
inst✝¹ : TopologicalAddGroup E
inst✝ : ContinuousSMul ℝ E
p q : Submodule ℝ E
hpq : IsCompl p q
hpc : {0}ᶜ.Nonempty ∧ ∀ x ∈ {0}ᶜ, ∀ y ∈ {0}ᶜ, JoinedIn {0}ᶜ x y
⊢ (↑q)ᶜ.Nonempty ∧ ∀ x ∈ (↑q)ᶜ, ∀ y ∈ (↑q)ᶜ, JoinedIn (↑q)ᶜ x y
tactic: rw [isPathConnected_iff] at hpc ⊢
state_before: ι : Type u_1
𝕜 : Type u_2
E✝ : Type u_3
E : Type u_4
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
inst✝² : TopologicalSpace E
inst✝¹ : TopologicalAddGroup E
inst✝ : ContinuousSMul ℝ E
p q : Submodule ℝ E
hpq : IsCompl p q
hpc : {0}ᶜ.Nonempty ∧ ∀ x ∈ {0}ᶜ, ∀ y ∈ {0}ᶜ, JoinedIn {0}ᶜ x y
⊢ (↑q)ᶜ.Nonempty ∧ ∀ x ∈ (↑q)ᶜ, ∀ y ∈ (↑q)ᶜ, JoinedIn (↑q)ᶜ x y
state_after: case left
ι : Type u_1
𝕜 : Type u_2
E✝ : Type u_3
E : Type u_4
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
inst✝² : TopologicalSpace E
inst✝¹ : TopologicalAddGroup E
inst✝ : ContinuousSMul ℝ E
p q : Submodule ℝ E
hpq : IsCompl p q
hpc : {0}ᶜ.Nonempty ∧ ∀ x ∈ {0}ᶜ, ∀ y ∈ {0}ᶜ, JoinedIn {0}ᶜ x y
⊢ (↑q)ᶜ.Nonempty

case right
ι : Type u_1
𝕜 : Type u_2
E✝ : Type u_3
E : Type u_4
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
inst✝² : TopologicalSpace E
inst✝¹ : TopologicalAddGroup E
inst✝ : ContinuousSMul ℝ E
p q : Submodule ℝ E
hpq : IsCompl p q
hpc : {0}ᶜ.Nonempty ∧ ∀ x ∈ {0}ᶜ, ∀ y ∈ {0}ᶜ, JoinedIn {0}ᶜ x y
⊢ ∀ x ∈ (↑q)ᶜ, ∀ y ∈ (↑q)ᶜ, JoinedIn (↑q)ᶜ x y
tactic: constructor
Theorem: SimpleGraph.Walk.IsEulerian.isTrail
File: Mathlib/Combinatorics/SimpleGraph/Trails.lean

Proof steps:
state_before: V : Type u_1
G : SimpleGraph V
inst✝ : DecidableEq V
u v : V
p : G.Walk u v
h : p.IsEulerian
⊢ p.IsTrail
state_after: V : Type u_1
G : SimpleGraph V
inst✝ : DecidableEq V
u v : V
p : G.Walk u v
h : p.IsEulerian
⊢ ∀ (a : Sym2 V), List.count a p.edges ≤ 1
tactic: rw [isTrail_def, List.nodup_iff_count_le_one]
state_before: V : Type u_1
G : SimpleGraph V
inst✝ : DecidableEq V
u v : V
p : G.Walk u v
h : p.IsEulerian
⊢ ∀ (a : Sym2 V), List.count a p.edges ≤ 1
state_after: V : Type u_1
G : SimpleGraph V
inst✝ : DecidableEq V
u v : V
p : G.Walk u v
h : p.IsEulerian
e : Sym2 V
⊢ List.count e p.edges ≤ 1
tactic: intro e
state_before: V : Type u_1
G : SimpleGraph V
inst✝ : DecidableEq V
u v : V
p : G.Walk u v
h : p.IsEulerian
e : Sym2 V
⊢ List.count e p.edges ≤ 1
state_after: case pos
V : Type u_1
G : SimpleGraph V
inst✝ : DecidableEq V
u v : V
p : G.Walk u v
h : p.IsEulerian
e : Sym2 V
he : e ∈ p.edges
⊢ List.count e p.edges ≤ 1

case neg
V : Type u_1
G : SimpleGraph V
inst✝ : DecidableEq V
u v : V
p : G.Walk u v
h : p.IsEulerian
e : Sym2 V
he : e ∉ p.edges
⊢ List.count e p.edges ≤ 1
tactic: by_cases he : e ∈ p.edges
Theorem: CliffordAlgebra.involute_eq_of_mem_odd
File: Mathlib/LinearAlgebra/CliffordAlgebra/Conjugation.lean

Proof steps:
state_before: R : Type u_1
inst✝² : CommRing R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
x : CliffordAlgebra Q
h : x ∈ evenOdd Q 1
⊢ involute x = -x
state_after: no goals
tactic: induction x, h using odd_induction with
  | ι m => exact involute_ι _
  | add x y _hx _hy ihx ihy =>
    rw [map_add, ihx, ihy, neg_add]
  | ι_mul_ι_mul m₁ m₂ x _hx ihx =>
    rw [map_mul, map_mul, involute_ι, involute_ι, ihx, neg_mul_neg, mul_neg]
Theorem: edist_neg_neg
File: Mathlib/Topology/MetricSpace/IsometricSMul.lean

Proof steps:
state_before: M : Type u
G : Type v
X : Type w
inst✝⁶ : PseudoEMetricSpace X
inst✝⁵ : Group G
inst✝⁴ : MulAction G X
inst✝³ : IsometricSMul G X
inst✝² : PseudoEMetricSpace G
inst✝¹ : IsometricSMul G G
inst✝ : IsometricSMul Gᵐᵒᵖ G
a b : G
⊢ edist a⁻¹ b⁻¹ = edist a b
state_after: no goals
tactic: rw [← edist_mul_left a, ← edist_mul_right _ _ b, mul_right_inv, one_mul, inv_mul_cancel_right,
    edist_comm]
Theorem: List.zip_swap
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 α
⊢ map Prod.swap (l₁.zip []) = [].zip l₁
state_after: α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
l₁ : List α
⊢ map Prod.swap [] = [].zip l₁
tactic: rw [zip_nil_right]
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
l₁ : List α
⊢ map Prod.swap [] = [].zip l₁
state_after: no goals
tactic: rfl
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
a : α
l₁ : List α
b : β
l₂ : List β
⊢ map Prod.swap ((a :: l₁).zip (b :: l₂)) = (b :: l₂).zip (a :: l₁)
state_after: no goals
tactic: simp only [zip_cons_cons, map_cons, zip_swap l₁ l₂, Prod.swap_prod_mk]
Theorem: RingHom.finitePresentation_holdsForLocalizationAway
File: Mathlib/RingTheory/RingHom/FinitePresentation.lean

Proof steps:
state_before: ⊢ HoldsForLocalizationAway @FinitePresentation
state_after: R S : Type u_1
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : Algebra R S
r : R
inst✝ : IsLocalization.Away r S
⊢ (algebraMap R S).FinitePresentation
tactic: introv R _
state_before: R S : Type u_1
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : Algebra R S
r : R
inst✝ : IsLocalization.Away r S
⊢ (algebraMap R S).FinitePresentation
state_after: R S : Type u_1
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : Algebra R S
r : R
inst✝ : IsLocalization.Away r S
⊢ Algebra.FinitePresentation R S
tactic: suffices Algebra.FinitePresentation R S by
    rw [RingHom.FinitePresentation]
    convert this; ext;
    rw [Algebra.smul_def]; rfl
state_before: R S : Type u_1
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : Algebra R S
r : R
inst✝ : IsLocalization.Away r S
⊢ Algebra.FinitePresentation R S
state_after: no goals
tactic: exact IsLocalization.Away.finitePresentation r