ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.Functor.LeftExtension.coconeAt_ι_app
File: Mathlib/CategoryTheory/Functor/KanExtension/Pointwise.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
H : Type u_3
inst✝² : Category.{?u.2943, u_1} C
inst✝¹ : Category.{?u.2947, u_2} D
inst✝ : Category.{?u.2951, u_3} H
L : C ⥤ D
F : C ⥤ H
E : L.LeftExtension F
Y : D
g₁ g₂ : CostructuredArrow L Y
φ : g₁ ⟶ g₂
⊢ (CostructuredArrow.proj L Y ⋙ F).map φ ≫ (fun g => E.hom.app g.left ≫ E.right.map g.hom) g₂ =
    (fun g => E.hom.app g.left ≫ E.right.map g.hom) g₁ ≫ ((const (CostructuredArrow L Y)).obj (E.right.obj Y)).map φ
state_after: C : Type u_1
D : Type u_2
H : Type u_3
inst✝² : Category.{?u.2943, u_1} C
inst✝¹ : Category.{?u.2947, u_2} D
inst✝ : Category.{?u.2951, u_3} H
L : C ⥤ D
F : C ⥤ H
E : L.LeftExtension F
Y : D
g₁ g₂ : CostructuredArrow L Y
φ : g₁ ⟶ g₂
⊢ F.map φ.left ≫ E.hom.app g₂.left ≫ E.right.map g₂.hom = (E.hom.app g₁.left ≫ E.right.map g₁.hom) ≫ 𝟙 (E.right.obj Y)
tactic: dsimp
state_before: C : Type u_1
D : Type u_2
H : Type u_3
inst✝² : Category.{?u.2943, u_1} C
inst✝¹ : Category.{?u.2947, u_2} D
inst✝ : Category.{?u.2951, u_3} H
L : C ⥤ D
F : C ⥤ H
E : L.LeftExtension F
Y : D
g₁ g₂ : CostructuredArrow L Y
φ : g₁ ⟶ g₂
⊢ F.map φ.left ≫ E.hom.app g₂.left ≫ E.right.map g₂.hom = (E.hom.app g₁.left ≫ E.right.map g₁.hom) ≫ 𝟙 (E.right.obj Y)
state_after: C : Type u_1
D : Type u_2
H : Type u_3
inst✝² : Category.{?u.2943, u_1} C
inst✝¹ : Category.{?u.2947, u_2} D
inst✝ : Category.{?u.2951, u_3} H
L : C ⥤ D
F : C ⥤ H
E : L.LeftExtension F
Y : D
g₁ g₂ : CostructuredArrow L Y
φ : g₁ ⟶ g₂
⊢ F.map φ.left ≫ E.hom.app g₂.left ≫ E.right.map g₂.hom =
    (E.hom.app g₁.left ≫ E.right.map (L.map φ.left ≫ g₂.hom)) ≫ 𝟙 (E.right.obj Y)
tactic: rw [← CostructuredArrow.w φ]
state_before: C : Type u_1
D : Type u_2
H : Type u_3
inst✝² : Category.{?u.2943, u_1} C
inst✝¹ : Category.{?u.2947, u_2} D
inst✝ : Category.{?u.2951, u_3} H
L : C ⥤ D
F : C ⥤ H
E : L.LeftExtension F
Y : D
g₁ g₂ : CostructuredArrow L Y
φ : g₁ ⟶ g₂
⊢ F.map φ.left ≫ E.hom.app g₂.left ≫ E.right.map g₂.hom =
    (E.hom.app g₁.left ≫ E.right.map (L.map φ.left ≫ g₂.hom)) ≫ 𝟙 (E.right.obj Y)
state_after: no goals
tactic: simp only [assoc, NatTrans.naturality_assoc, Functor.comp_map,
          Functor.map_comp, comp_id]
Theorem: MeasureTheory.Measure.haar.is_left_invariant_haarContent
File: Mathlib/MeasureTheory/Measure/Haar/Basic.lean

Proof steps:
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
g : G
K : Compacts G
⊢ (fun s => ↑((haarContent K₀).toFun s)) (Compacts.map (fun b => g * b) ⋯ K) = (fun s => ↑((haarContent K₀).toFun s)) K
state_after: no goals
tactic: simpa only [ENNReal.coe_inj, ← NNReal.coe_inj, haarContent_apply] using
    is_left_invariant_chaar g K
Theorem: Nat.le_minFac
File: Mathlib/Data/Nat/Prime/Defs.lean

Proof steps:
state_before: n✝ m n : ℕ
h : n = 1 ∨ m ≤ n.minFac
p : ℕ
pp : Prime p
d : p ∣ n
⊢ n = 1 → m ≤ p
state_after: n m p : ℕ
pp : Prime p
h : 1 = 1 ∨ m ≤ minFac 1
d : p ∣ 1
⊢ m ≤ p
tactic: rintro rfl
state_before: n m p : ℕ
pp : Prime p
h : 1 = 1 ∨ m ≤ minFac 1
d : p ∣ 1
⊢ m ≤ p
state_after: no goals
tactic: cases pp.not_dvd_one d
Theorem: Equiv.equivCongr_trans
File: Mathlib/Logic/Equiv/Defs.lean

Proof steps:
state_before: α : Sort u
β : Sort v
γ : Sort w
δ : Sort u_1
ε : Sort u_2
ζ : Sort u_3
ab : α ≃ β
de : δ ≃ ε
bc : β ≃ γ
ef : ε ≃ ζ
⊢ (ab.equivCongr de).trans (bc.equivCongr ef) = (ab.trans bc).equivCongr (de.trans ef)
state_after: case H.H
α : Sort u
β : Sort v
γ : Sort w
δ : Sort u_1
ε : Sort u_2
ζ : Sort u_3
ab : α ≃ β
de : δ ≃ ε
bc : β ≃ γ
ef : ε ≃ ζ
x✝¹ : α ≃ δ
x✝ : γ
⊢ (((ab.equivCongr de).trans (bc.equivCongr ef)) x✝¹) x✝ = (((ab.trans bc).equivCongr (de.trans ef)) x✝¹) x✝
tactic: ext
state_before: case H.H
α : Sort u
β : Sort v
γ : Sort w
δ : Sort u_1
ε : Sort u_2
ζ : Sort u_3
ab : α ≃ β
de : δ ≃ ε
bc : β ≃ γ
ef : ε ≃ ζ
x✝¹ : α ≃ δ
x✝ : γ
⊢ (((ab.equivCongr de).trans (bc.equivCongr ef)) x✝¹) x✝ = (((ab.trans bc).equivCongr (de.trans ef)) x✝¹) x✝
state_after: no goals
tactic: rfl
Theorem: Matrix.row_vecMul
File: Mathlib/Data/Matrix/RowCol.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
inst✝¹ : Fintype m
inst✝ : NonUnitalNonAssocSemiring α
M : Matrix m n α
v : m → α
⊢ row ι (v ᵥ* M) = row ι v * M
state_after: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
inst✝¹ : Fintype m
inst✝ : NonUnitalNonAssocSemiring α
M : Matrix m n α
v : m → α
i✝ : ι
j✝ : n
⊢ row ι (v ᵥ* M) i✝ j✝ = (row ι v * M) i✝ j✝
tactic: ext
state_before: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
inst✝¹ : Fintype m
inst✝ : NonUnitalNonAssocSemiring α
M : Matrix m n α
v : m → α
i✝ : ι
j✝ : n
⊢ row ι (v ᵥ* M) i✝ j✝ = (row ι v * M) i✝ j✝
state_after: no goals
tactic: rfl
Theorem: CliffordAlgebra.reverse_prod_map_ι
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
⊢ reverse (List.map ⇑(ι Q) []).prod = (List.map ⇑(ι Q) []).reverse.prod
state_after: no goals
tactic: simp
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 : M
xs : List M
⊢ reverse (List.map (⇑(ι Q)) (x :: xs)).prod = (List.map (⇑(ι Q)) (x :: xs)).reverse.prod
state_after: no goals
tactic: simp [reverse_prod_map_ι xs]
Theorem: CategoryTheory.IsFiltered.tulip
File: Mathlib/CategoryTheory/Filtered/Basic.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : IsFilteredOrEmpty C
j₁ j₂ j₃ k₁ k₂ l : C
f₁ : j₁ ⟶ k₁
f₂ : j₂ ⟶ k₁
f₃ : j₂ ⟶ k₂
f₄ : j₃ ⟶ k₂
g₁ : j₁ ⟶ l
g₂ : j₃ ⟶ l
⊢ ∃ s α β γ, f₁ ≫ α = g₁ ≫ β ∧ f₂ ≫ α = f₃ ≫ γ ∧ f₄ ≫ γ = g₂ ≫ β
state_after: case intro.intro.intro
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : IsFilteredOrEmpty C
j₁ j₂ j₃ k₁ k₂ l : C
f₁ : j₁ ⟶ k₁
f₂ : j₂ ⟶ k₁
f₃ : j₂ ⟶ k₂
f₄ : j₃ ⟶ k₂
g₁ : j₁ ⟶ l
g₂ : j₃ ⟶ l
l' : C
k₁l : k₁ ⟶ l'
k₂l : k₂ ⟶ l'
hl : f₂ ≫ k₁l = f₃ ≫ k₂l
⊢ ∃ s α β γ, f₁ ≫ α = g₁ ≫ β ∧ f₂ ≫ α = f₃ ≫ γ ∧ f₄ ≫ γ = g₂ ≫ β
tactic: obtain ⟨l', k₁l, k₂l, hl⟩ := span f₂ f₃
state_before: case intro.intro.intro
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : IsFilteredOrEmpty C
j₁ j₂ j₃ k₁ k₂ l : C
f₁ : j₁ ⟶ k₁
f₂ : j₂ ⟶ k₁
f₃ : j₂ ⟶ k₂
f₄ : j₃ ⟶ k₂
g₁ : j₁ ⟶ l
g₂ : j₃ ⟶ l
l' : C
k₁l : k₁ ⟶ l'
k₂l : k₂ ⟶ l'
hl : f₂ ≫ k₁l = f₃ ≫ k₂l
⊢ ∃ s α β γ, f₁ ≫ α = g₁ ≫ β ∧ f₂ ≫ α = f₃ ≫ γ ∧ f₄ ≫ γ = g₂ ≫ β
state_after: case intro.intro.intro.intro.intro.intro.intro
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : IsFilteredOrEmpty C
j₁ j₂ j₃ k₁ k₂ l : C
f₁ : j₁ ⟶ k₁
f₂ : j₂ ⟶ k₁
f₃ : j₂ ⟶ k₂
f₄ : j₃ ⟶ k₂
g₁ : j₁ ⟶ l
g₂ : j₃ ⟶ l
l' : C
k₁l : k₁ ⟶ l'
k₂l : k₂ ⟶ l'
hl : f₂ ≫ k₁l = f₃ ≫ k₂l
s : C
ls : l ⟶ s
l's : l' ⟶ s
hs₁ : g₁ ≫ ls = (f₁ ≫ k₁l) ≫ l's
hs₂ : g₂ ≫ ls = (f₄ ≫ k₂l) ≫ l's
⊢ ∃ s α β γ, f₁ ≫ α = g₁ ≫ β ∧ f₂ ≫ α = f₃ ≫ γ ∧ f₄ ≫ γ = g₂ ≫ β
tactic: obtain ⟨s, ls, l's, hs₁, hs₂⟩ := bowtie g₁ (f₁ ≫ k₁l) g₂ (f₄ ≫ k₂l)
state_before: case intro.intro.intro.intro.intro.intro.intro
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : IsFilteredOrEmpty C
j₁ j₂ j₃ k₁ k₂ l : C
f₁ : j₁ ⟶ k₁
f₂ : j₂ ⟶ k₁
f₃ : j₂ ⟶ k₂
f₄ : j₃ ⟶ k₂
g₁ : j₁ ⟶ l
g₂ : j₃ ⟶ l
l' : C
k₁l : k₁ ⟶ l'
k₂l : k₂ ⟶ l'
hl : f₂ ≫ k₁l = f₃ ≫ k₂l
s : C
ls : l ⟶ s
l's : l' ⟶ s
hs₁ : g₁ ≫ ls = (f₁ ≫ k₁l) ≫ l's
hs₂ : g₂ ≫ ls = (f₄ ≫ k₂l) ≫ l's
⊢ ∃ s α β γ, f₁ ≫ α = g₁ ≫ β ∧ f₂ ≫ α = f₃ ≫ γ ∧ f₄ ≫ γ = g₂ ≫ β
state_after: no goals
tactic: refine ⟨s, k₁l ≫ l's, ls, k₂l ≫ l's, ?_, by simp only [← Category.assoc, hl], ?_⟩ <;>
    simp only [hs₁, hs₂, Category.assoc]
Theorem: EReal.continuousAt_add_bot_bot
File: Mathlib/Topology/Instances/EReal.lean

Proof steps:
state_before: α : Type u_1
inst✝ : TopologicalSpace α
⊢ ContinuousAt (fun p => p.1 + p.2) (⊥, ⊥)
state_after: α : Type u_1
inst✝ : TopologicalSpace α
⊢ ∀ (x : ℝ), ∀ᶠ (a : EReal × EReal) in 𝓝 (⊥, ⊥), a.1 + a.2 < ↑x
tactic: simp only [ContinuousAt, tendsto_nhds_bot_iff_real, bot_add]
state_before: α : Type u_1
inst✝ : TopologicalSpace α
⊢ ∀ (x : ℝ), ∀ᶠ (a : EReal × EReal) in 𝓝 (⊥, ⊥), a.1 + a.2 < ↑x
state_after: α : Type u_1
inst✝ : TopologicalSpace α
r : ℝ
x✝ : EReal × EReal
h : x✝.1 < ↑0 ∧ x✝.2 < ↑r
⊢ x✝.1 + x✝.2 < ↑r
tactic: refine fun r ↦ ((gt_mem_nhds (bot_lt_coe 0)).prod_nhds
    (gt_mem_nhds <| bot_lt_coe r)).mono fun _ h ↦ ?_
state_before: α : Type u_1
inst✝ : TopologicalSpace α
r : ℝ
x✝ : EReal × EReal
h : x✝.1 < ↑0 ∧ x✝.2 < ↑r
⊢ x✝.1 + x✝.2 < ↑r
state_after: no goals
tactic: simpa only [coe_zero, zero_add] using add_lt_add h.1 h.2
Theorem: Finset.zero_smul_subset
File: Mathlib/Data/Finset/Pointwise.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : Zero α
inst✝² : Zero β
inst✝¹ : SMulWithZero α β
inst✝ : DecidableEq β
s : Finset α
t✝ t : Finset β
⊢ 0 • t ⊆ 0
state_after: no goals
tactic: simp [subset_iff, mem_smul]
Theorem: PNat.XgcdType.start_isSpecial
File: Mathlib/Data/PNat/Xgcd.lean

Proof steps:
state_before: u : XgcdType
a b : ℕ+
⊢ (start a b).IsSpecial
state_after: no goals
tactic: dsimp [start, IsSpecial]
Theorem: List.dProdIndex_eq_map_sum
File: Mathlib/Algebra/GradedMonoid.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
A : ι → Type u_3
inst✝¹ : AddMonoid ι
inst✝ : GradedMonoid.GMonoid A
l : List α
fι : α → ι
⊢ l.dProdIndex fι = (map fι l).sum
state_after: no goals
tactic: match l with
  | [] => simp
  | head::tail => simp [List.dProdIndex_eq_map_sum tail fι]
Theorem: SetTheory.PGame.Domineering.card_of_mem_left
File: Mathlib/SetTheory/Game/Domineering.lean

Proof steps:
state_before: b : Board
m : ℤ × ℤ
h : m ∈ left b
⊢ 2 ≤ Finset.card b
state_after: b : Board
m : ℤ × ℤ
h : m ∈ left b
w₁ : m ∈ b
⊢ 2 ≤ Finset.card b
tactic: have w₁ : m ∈ b := (Finset.mem_inter.1 h).1
state_before: b : Board
m : ℤ × ℤ
h : m ∈ left b
w₁ : m ∈ b
⊢ 2 ≤ Finset.card b
state_after: b : Board
m : ℤ × ℤ
h : m ∈ left b
w₁ : m ∈ b
w₂ : (m.1, m.2 - 1) ∈ Finset.erase b m
⊢ 2 ≤ Finset.card b
tactic: have w₂ : (m.1, m.2 - 1) ∈ b.erase m := snd_pred_mem_erase_of_mem_left h
state_before: b : Board
m : ℤ × ℤ
h : m ∈ left b
w₁ : m ∈ b
w₂ : (m.1, m.2 - 1) ∈ Finset.erase b m
⊢ 2 ≤ Finset.card b
state_after: b : Board
m : ℤ × ℤ
h : m ∈ left b
w₁ : m ∈ b
w₂ : (m.1, m.2 - 1) ∈ Finset.erase b m
i₁ : (Finset.erase b m).card < Finset.card b
⊢ 2 ≤ Finset.card b
tactic: have i₁ := Finset.card_erase_lt_of_mem w₁
state_before: b : Board
m : ℤ × ℤ
h : m ∈ left b
w₁ : m ∈ b
w₂ : (m.1, m.2 - 1) ∈ Finset.erase b m
i₁ : (Finset.erase b m).card < Finset.card b
⊢ 2 ≤ Finset.card b
state_after: b : Board
m : ℤ × ℤ
h : m ∈ left b
w₁ : m ∈ b
w₂ : (m.1, m.2 - 1) ∈ Finset.erase b m
i₁ : (Finset.erase b m).card < Finset.card b
i₂ : 0 < (Finset.erase b m).card
⊢ 2 ≤ Finset.card b
tactic: have i₂ := Nat.lt_of_le_of_lt (Nat.zero_le _) (Finset.card_erase_lt_of_mem w₂)
state_before: b : Board
m : ℤ × ℤ
h : m ∈ left b
w₁ : m ∈ b
w₂ : (m.1, m.2 - 1) ∈ Finset.erase b m
i₁ : (Finset.erase b m).card < Finset.card b
i₂ : 0 < (Finset.erase b m).card
⊢ 2 ≤ Finset.card b
state_after: no goals
tactic: exact Nat.lt_of_le_of_lt i₂ i₁
Theorem: Batteries.RBNode.Balanced.balLeft
File: .lake/packages/batteries/Batteries/Data/RBMap/WF.lean

Proof steps:
state_before: α✝ : Type u_1
l : RBNode α✝
v : α✝
r : RBNode α✝
cr : RBColor
n : Nat
hl : RedRed True l n
hr : r.Balanced cr (n + 1)
⊢ RedRed (cr = red) (l.balLeft v r) (n + 1)
state_after: α✝ : Type u_1
l : RBNode α✝
v : α✝
r : RBNode α✝
cr : RBColor
n : Nat
hl : RedRed True l n
hr : r.Balanced cr (n + 1)
⊢ RedRed (cr = red)
    (match l with
    | node red a x b => node red (node black a x b) v r
    | l =>
      match r with
      | node black a y b => l.balance2 v (node red a y b)
      | node red (node black a y b) z c => node red (node black l v a) y (b.balance2 z c.setRed)
      | r => node red l v r)
    (n + 1)
tactic: unfold balLeft
state_before: α✝ : Type u_1
l : RBNode α✝
v : α✝
r : RBNode α✝
cr : RBColor
n : Nat
hl : RedRed True l n
hr : r.Balanced cr (n + 1)
⊢ RedRed (cr = red)
    (match l with
    | node red a x b => node red (node black a x b) v r
    | l =>
      match r with
      | node black a y b => l.balance2 v (node red a y b)
      | node red (node black a y b) z c => node red (node black l v a) y (b.balance2 z c.setRed)
      | r => node red l v r)
    (n + 1)
state_after: case h_1
α✝ : Type u_1
v : α✝
r : RBNode α✝
cr : RBColor
n : Nat
hr : r.Balanced cr (n + 1)
l✝ a✝ : RBNode α✝
x✝ : α✝
b✝ : RBNode α✝
hl : RedRed True (node red a✝ x✝ b✝) n
⊢ RedRed (cr = red) (node red (node black a✝ x✝ b✝) v r) (n + 1)

case h_2
α✝ : Type u_1
l : RBNode α✝
v : α✝
r : RBNode α✝
cr : RBColor
n : Nat
hl : RedRed True l n
hr : r.Balanced cr (n + 1)
l✝ : RBNode α✝
x✝ : ∀ (a : RBNode α✝) (x : α✝) (b : RBNode α✝), l = node red a x b → False
⊢ RedRed (cr = red)
    (match r with
    | node black a y b => l.balance2 v (node red a y b)
    | node red (node black a y b) z c => node red (node black l v a) y (b.balance2 z c.setRed)
    | r => node red l v r)
    (n + 1)
tactic: split
Theorem: Convex.affine_image
File: Mathlib/Analysis/Convex/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s t : Set E
f : E →ᵃ[𝕜] F
hs : Convex 𝕜 s
⊢ Convex 𝕜 (⇑f '' s)
state_after: case intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s t : Set E
f : E →ᵃ[𝕜] F
hs : Convex 𝕜 s
x : E
hx : x ∈ s
⊢ StarConvex 𝕜 (f x) (⇑f '' s)
tactic: rintro _ ⟨x, hx, rfl⟩
state_before: case intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s t : Set E
f : E →ᵃ[𝕜] F
hs : Convex 𝕜 s
x : E
hx : x ∈ s
⊢ StarConvex 𝕜 (f x) (⇑f '' s)
state_after: no goals
tactic: exact (hs hx).affine_image _
Theorem: SimpleGraph.Walk.toSubgraph_rotate
File: Mathlib/Combinatorics/SimpleGraph/Connectivity/Subgraph.lean

Proof steps:
state_before: V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
u v w : V
inst✝ : DecidableEq V
c : G.Walk v v
h : u ∈ c.support
⊢ (c.rotate h).toSubgraph = c.toSubgraph
state_after: no goals
tactic: rw [rotate, toSubgraph_append, sup_comm, ← toSubgraph_append, take_spec]
Theorem: Nat.mul_ofDigits
File: Mathlib/Data/Nat/Digits.lean

Proof steps:
state_before: n✝ n b : ℕ
l : List ℕ
⊢ n * ofDigits b l = ofDigits b (List.map (fun x => n * x) l)
state_after: no goals
tactic: induction l with
  | nil => rfl
  | cons hd tl ih =>
    rw [List.map_cons, ofDigits_cons, ofDigits_cons, ← ih]
    ring
Theorem: Cardinal.isStrongLimit_aleph0
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

Proof steps:
state_before: α : Type u_1
r : α → α → Prop
x : Cardinal.{u_2}
hx : x < ℵ₀
⊢ 2 ^ x < ℵ₀
state_after: case intro
α : Type u_1
r : α → α → Prop
n : ℕ
hx : ↑n < ℵ₀
⊢ 2 ^ ↑n < ℵ₀
tactic: rcases lt_aleph0.1 hx with ⟨n, rfl⟩
state_before: case intro
α : Type u_1
r : α → α → Prop
n : ℕ
hx : ↑n < ℵ₀
⊢ 2 ^ ↑n < ℵ₀
state_after: no goals
tactic: exact mod_cast nat_lt_aleph0 (2 ^ n)
Theorem: CochainComplex.shiftShortComplexFunctorIso_inv_app_τ₃
File: Mathlib/Algebra/Homology/HomotopyCategory/ShiftSequence.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.71408, u_1} C
inst✝ : Preadditive C
n i i' : ℤ
hi : n + i = i'
⊢ n + (up ℤ).prev i = (up ℤ).prev i'
state_after: C : Type u_1
inst✝¹ : Category.{?u.71408, u_1} C
inst✝ : Preadditive C
n i i' : ℤ
hi : n + i = i'
⊢ n + (i - 1) = i' - 1
tactic: simp only [prev]
state_before: C : Type u_1
inst✝¹ : Category.{?u.71408, u_1} C
inst✝ : Preadditive C
n i i' : ℤ
hi : n + i = i'
⊢ n + (i - 1) = i' - 1
state_after: no goals
tactic: omega
state_before: C : Type u_1
inst✝¹ : Category.{?u.71408, u_1} C
inst✝ : Preadditive C
n i i' : ℤ
hi : n + i = i'
⊢ n + (up ℤ).next i = (up ℤ).next i'
state_after: C : Type u_1
inst✝¹ : Category.{?u.71408, u_1} C
inst✝ : Preadditive C
n i i' : ℤ
hi : n + i = i'
⊢ n + (i + 1) = i' + 1
tactic: simp only [next]
state_before: C : Type u_1
inst✝¹ : Category.{?u.71408, u_1} C
inst✝ : Preadditive C
n i i' : ℤ
hi : n + i = i'
⊢ n + (i + 1) = i' + 1
state_after: no goals
tactic: omega
Theorem: Module.Flat.iff_lTensor_injective'
File: Mathlib/RingTheory/Flat/Basic.lean

Proof steps:
state_before: R : Type u
M : Type v
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
⊢ Flat R M ↔ ∀ (I : Ideal R), Function.Injective ⇑(lTensor M (Submodule.subtype I))
state_after: no goals
tactic: simpa [← comm_comp_rTensor_comp_comm_eq] using Module.Flat.iff_rTensor_injective' R M
Theorem: Multiset.stronglyMeasurable_prod
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝³ : Countable ι
f g : α → β
M : Type u_5
inst✝² : CommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousMul M
m : MeasurableSpace α
s : Multiset (α → M)
hs : ∀ f ∈ s, StronglyMeasurable f
⊢ StronglyMeasurable fun x => (Multiset.map (fun f => f x) s).prod
state_after: no goals
tactic: simpa only [← Pi.multiset_prod_apply] using s.stronglyMeasurable_prod' hs
Theorem: mul_mem_cancel_left
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁷ : Group G
inst✝⁶ : Group G'
inst✝⁵ : Group G''
A : Type u_4
inst✝⁴ : AddGroup A
M : Type u_5
S : Type u_6
inst✝³ : DivInvMonoid M
inst✝² : SetLike S M
hSM : SubgroupClass S M
H K : S
inst✝¹ : SetLike S G
inst✝ : SubgroupClass S G
x y : G
h : x ∈ H
hab : x * y ∈ H
⊢ y ∈ H
state_after: no goals
tactic: simpa using mul_mem (inv_mem h) hab
Theorem: MeasureTheory.cylinder_mem_measurableCylinders
File: Mathlib/MeasureTheory/Constructions/Cylinders.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
inst✝ : (i : ι) → MeasurableSpace (α i)
s✝ t : Set ((i : ι) → α i)
s : Finset ι
S : Set ((i : { x // x ∈ s }) → α ↑i)
hS : MeasurableSet S
⊢ cylinder s S ∈ measurableCylinders α
state_after: ι : Type u_1
α : ι → Type u_2
inst✝ : (i : ι) → MeasurableSpace (α i)
s✝ t : Set ((i : ι) → α i)
s : Finset ι
S : Set ((i : { x // x ∈ s }) → α ↑i)
hS : MeasurableSet S
⊢ ∃ s_1 S_1, MeasurableSet S_1 ∧ cylinder s S = cylinder s_1 S_1
tactic: rw [mem_measurableCylinders]
state_before: ι : Type u_1
α : ι → Type u_2
inst✝ : (i : ι) → MeasurableSpace (α i)
s✝ t : Set ((i : ι) → α i)
s : Finset ι
S : Set ((i : { x // x ∈ s }) → α ↑i)
hS : MeasurableSet S
⊢ ∃ s_1 S_1, MeasurableSet S_1 ∧ cylinder s S = cylinder s_1 S_1
state_after: no goals
tactic: exact ⟨s, S, hS, rfl⟩
Theorem: CircleDeg1Lift.transnumAuxSeq_dist_lt
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

Proof steps:
state_before: f g : CircleDeg1Lift
n : ℕ
⊢ dist (f.transnumAuxSeq n) (f.transnumAuxSeq (n + 1)) < 1 / 2 / 2 ^ n
state_after: f g : CircleDeg1Lift
n : ℕ
this : 0 < 2 ^ (n + 1)
⊢ dist (f.transnumAuxSeq n) (f.transnumAuxSeq (n + 1)) < 1 / 2 / 2 ^ n
tactic: have : 0 < (2 ^ (n + 1) : ℝ) := pow_pos zero_lt_two _
state_before: f g : CircleDeg1Lift
n : ℕ
this : 0 < 2 ^ (n + 1)
⊢ dist (f.transnumAuxSeq n) (f.transnumAuxSeq (n + 1)) < 1 / 2 / 2 ^ n
state_after: f g : CircleDeg1Lift
n : ℕ
this : 0 < 2 ^ (n + 1)
⊢ dist (f.transnumAuxSeq n) (f.transnumAuxSeq (n + 1)) < 1 / |2 ^ (n + 1)|
tactic: rw [div_div, ← pow_succ', ← abs_of_pos this]
state_before: f g : CircleDeg1Lift
n : ℕ
this : 0 < 2 ^ (n + 1)
⊢ dist (f.transnumAuxSeq n) (f.transnumAuxSeq (n + 1)) < 1 / |2 ^ (n + 1)|
state_after: f g : CircleDeg1Lift
n : ℕ
this : 0 < |2 ^ (n + 1)|
⊢ dist (f.transnumAuxSeq n) (f.transnumAuxSeq (n + 1)) < 1 / |2 ^ (n + 1)|
tactic: replace := abs_pos.2 (ne_of_gt this)
state_before: f g : CircleDeg1Lift
n : ℕ
this : 0 < |2 ^ (n + 1)|
⊢ dist (f.transnumAuxSeq n) (f.transnumAuxSeq (n + 1)) < 1 / |2 ^ (n + 1)|
state_after: case h.e'_3
f g : CircleDeg1Lift
n : ℕ
this : 0 < |2 ^ (n + 1)|
⊢ dist (f.transnumAuxSeq n) (f.transnumAuxSeq (n + 1)) =
    dist ((f ^ 2 ^ n) 0 + (f ^ 2 ^ n) 0) ((f ^ 2 ^ n) ((f ^ 2 ^ n) 0)) / |2 ^ (n + 1)|
tactic: convert (div_lt_div_right this).2 ((f ^ 2 ^ n).dist_map_map_zero_lt (f ^ 2 ^ n)) using 1
state_before: case h.e'_3
f g : CircleDeg1Lift
n : ℕ
this : 0 < |2 ^ (n + 1)|
⊢ dist (f.transnumAuxSeq n) (f.transnumAuxSeq (n + 1)) =
    dist ((f ^ 2 ^ n) 0 + (f ^ 2 ^ n) 0) ((f ^ 2 ^ n) ((f ^ 2 ^ n) 0)) / |2 ^ (n + 1)|
state_after: case h.e'_3
f g : CircleDeg1Lift
n : ℕ
this : 0 < |2 ^ (n + 1)|
⊢ |(f ^ 2 ^ n) 0 / 2 ^ n - (f ^ 2 ^ (n + 1)) 0 / 2 ^ (n + 1)| =
    |(f ^ 2 ^ n) 0 + (f ^ 2 ^ n) 0 - (f ^ 2 ^ n) ((f ^ 2 ^ n) 0)| / |2 ^ (n + 1)|
tactic: simp_rw [transnumAuxSeq, Real.dist_eq]
state_before: case h.e'_3
f g : CircleDeg1Lift
n : ℕ
this : 0 < |2 ^ (n + 1)|
⊢ |(f ^ 2 ^ n) 0 / 2 ^ n - (f ^ 2 ^ (n + 1)) 0 / 2 ^ (n + 1)| =
    |(f ^ 2 ^ n) 0 + (f ^ 2 ^ n) 0 - (f ^ 2 ^ n) ((f ^ 2 ^ n) 0)| / |2 ^ (n + 1)|
state_after: no goals
tactic: rw [← abs_div, sub_div, pow_succ, pow_succ', ← two_mul, mul_div_mul_left _ _ (two_ne_zero' ℝ),
    pow_mul, sq, mul_apply]
Theorem: CategoryTheory.Limits.IsColimit.uniq_cocone_morphism
File: Mathlib/CategoryTheory/Limits/IsLimit.lean

Proof steps:
state_before: J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
s t : Cocone F
h : IsColimit t
f f' : t ⟶ s
⊢ ∀ {g : t ⟶ s}, g = h.descCoconeMorphism s
state_after: J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
s t : Cocone F
h : IsColimit t
f f' g : t ⟶ s
⊢ g = h.descCoconeMorphism s
tactic: intro g
state_before: J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
s t : Cocone F
h : IsColimit t
f f' g : t ⟶ s
⊢ g = h.descCoconeMorphism s
state_after: case w
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
s t : Cocone F
h : IsColimit t
f f' g : t ⟶ s
⊢ g.hom = (h.descCoconeMorphism s).hom
tactic: ext
state_before: case w
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
s t : Cocone F
h : IsColimit t
f f' g : t ⟶ s
⊢ g.hom = (h.descCoconeMorphism s).hom
state_after: no goals
tactic: exact h.uniq _ _ g.w