ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: HasCompactSupport.comp₂_left
File: Mathlib/Topology/Support.lean

Proof steps:
state_before: X : Type u_1
α : Type u_2
α' : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
M : Type u_7
E : Type u_8
R : Type u_9
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace α'
inst✝² : One β
inst✝¹ : One γ
inst✝ : One δ
g : β → γ
f : α → β
f₂ : α → γ
m : β → γ → δ
x : α
hf : HasCompactMulSupport f
hf₂ : HasCompactMulSupport f₂
hm : m 1 1 = 1
⊢ HasCompactMulSupport fun x => m (f x) (f₂ x)
state_after: X : Type u_1
α : Type u_2
α' : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
M : Type u_7
E : Type u_8
R : Type u_9
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace α'
inst✝² : One β
inst✝¹ : One γ
inst✝ : One δ
g : β → γ
f : α → β
f₂ : α → γ
m : β → γ → δ
x : α
hf : f =ᶠ[coclosedCompact α] 1
hf₂ : f₂ =ᶠ[coclosedCompact α] 1
hm : m 1 1 = 1
⊢ (fun x => m (f x) (f₂ x)) =ᶠ[coclosedCompact α] 1
tactic: rw [hasCompactMulSupport_iff_eventuallyEq] at hf hf₂ ⊢
state_before: X : Type u_1
α : Type u_2
α' : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
M : Type u_7
E : Type u_8
R : Type u_9
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace α'
inst✝² : One β
inst✝¹ : One γ
inst✝ : One δ
g : β → γ
f : α → β
f₂ : α → γ
m : β → γ → δ
x : α
hf : f =ᶠ[coclosedCompact α] 1
hf₂ : f₂ =ᶠ[coclosedCompact α] 1
hm : m 1 1 = 1
⊢ (fun x => m (f x) (f₂ x)) =ᶠ[coclosedCompact α] 1
state_after: no goals
tactic: filter_upwards [hf, hf₂] using fun x (hx : f x = (1 : α → β) x) (hx₂ : f₂ x = (1 : α → γ) x) => by
    simp only [hx, hx₂, Pi.one_apply, hm]
Theorem: Finset.sum_smul_vsub_eq_weightedVSubOfPoint_sub
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_4
s : Finset ι
ι₂ : Type u_5
s₂ : Finset ι₂
w : ι → k
p₁ p₂ : ι → P
b : P
⊢ ∑ i ∈ s, w i • (p₁ i -ᵥ p₂ i) = (s.weightedVSubOfPoint p₁ b) w - (s.weightedVSubOfPoint p₂ b) w
state_after: no goals
tactic: simp_rw [weightedVSubOfPoint_apply, ← sum_sub_distrib, ← smul_sub, vsub_sub_vsub_cancel_right]
Theorem: CategoryTheory.PreGaloisCategory.comp_autMap_apply
File: Mathlib/CategoryTheory/Galois/GaloisObjects.lean

Proof steps:
state_before: C : Type u₁
inst✝⁴ : Category.{u₂, u₁} C
inst✝³ : GaloisCategory C
F : C ⥤ FintypeCat
inst✝² : FiberFunctor F
A B : C
inst✝¹ : IsConnected A
inst✝ : IsGalois B
f : A ⟶ B
σ : Aut A
a : ↑(F.obj A)
⊢ F.map (autMap f σ).hom (F.map f a) = F.map f (F.map σ.hom a)
state_after: no goals
tactic: simpa [-comp_autMap] using congrFun (F.congr_map (comp_autMap f σ)) a
Theorem: EMetric.subset_countable_closure_of_compact
File: Mathlib/Topology/EMetricSpace/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
X : Type u_1
inst✝ : PseudoEMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ≥0∞
s✝ t s : Set α
hs : IsCompact s
⊢ ∃ t ⊆ s, t.Countable ∧ s ⊆ closure t
state_after: α : Type u
β : Type v
X : Type u_1
inst✝ : PseudoEMetricSpace α
x y z : α
ε✝ ε₁ ε₂ : ℝ≥0∞
s✝ t s : Set α
hs : IsCompact s
ε : ℝ≥0∞
hε : ε > 0
⊢ ∃ t, t.Countable ∧ s ⊆ ⋃ x ∈ t, closedBall x ε
tactic: refine subset_countable_closure_of_almost_dense_set s fun ε hε => ?_
state_before: α : Type u
β : Type v
X : Type u_1
inst✝ : PseudoEMetricSpace α
x y z : α
ε✝ ε₁ ε₂ : ℝ≥0∞
s✝ t s : Set α
hs : IsCompact s
ε : ℝ≥0∞
hε : ε > 0
⊢ ∃ t, t.Countable ∧ s ⊆ ⋃ x ∈ t, closedBall x ε
state_after: case intro.intro.intro
α : Type u
β : Type v
X : Type u_1
inst✝ : PseudoEMetricSpace α
x y z : α
ε✝ ε₁ ε₂ : ℝ≥0∞
s✝ t✝ s : Set α
hs : IsCompact s
ε : ℝ≥0∞
hε : ε > 0
t : Set α
htf : t.Finite
hst : s ⊆ ⋃ y ∈ t, ball y ε
⊢ ∃ t, t.Countable ∧ s ⊆ ⋃ x ∈ t, closedBall x ε
tactic: rcases totallyBounded_iff'.1 hs.totallyBounded ε hε with ⟨t, -, htf, hst⟩
state_before: case intro.intro.intro
α : Type u
β : Type v
X : Type u_1
inst✝ : PseudoEMetricSpace α
x y z : α
ε✝ ε₁ ε₂ : ℝ≥0∞
s✝ t✝ s : Set α
hs : IsCompact s
ε : ℝ≥0∞
hε : ε > 0
t : Set α
htf : t.Finite
hst : s ⊆ ⋃ y ∈ t, ball y ε
⊢ ∃ t, t.Countable ∧ s ⊆ ⋃ x ∈ t, closedBall x ε
state_after: no goals
tactic: exact ⟨t, htf.countable, hst.trans <| iUnion₂_mono fun _ _ => ball_subset_closedBall⟩
Theorem: CategoryTheory.MonoidalCategory.associator_inv_naturality
File: Mathlib/CategoryTheory/Monoidal/Category.lean

Proof steps:
state_before: C✝ : Type u
𝒞 : Category.{v, u} C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : MonoidalCategory C
U V W X✝ Y✝ Z✝ X Y Z X' Y' Z' : C
f : X ⟶ X'
g : Y ⟶ Y'
h : Z ⟶ Z'
⊢ (f ⊗ g ⊗ h) ≫ (α_ X' Y' Z').inv = (α_ X Y Z).inv ≫ ((f ⊗ g) ⊗ h)
state_after: no goals
tactic: simp [tensorHom_def]
Theorem: CategoryTheory.Subobject.ofLE_refl
File: Mathlib/CategoryTheory/Subobject/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X✝ Y Z : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
B : C
X : Subobject B
⊢ X.ofLE X ⋯ = 𝟙 (underlying.obj X)
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X✝ Y Z : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
B : C
X : Subobject B
⊢ X.ofLE X ⋯ ≫ X.arrow = 𝟙 (underlying.obj X) ≫ X.arrow
tactic: apply (cancel_mono X.arrow).mp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X✝ Y Z : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
B : C
X : Subobject B
⊢ X.ofLE X ⋯ ≫ X.arrow = 𝟙 (underlying.obj X) ≫ X.arrow
state_after: no goals
tactic: simp
Theorem: mul_eq_of_eq_mul_inv
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n : ℤ
h : a = c * b⁻¹
⊢ a * b = c
state_after: no goals
tactic: simp [h]
Theorem: MeasureTheory.Measure.map_map
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
f✝ : α → β
g : β → γ
f : α → β
hg : Measurable g
hf : Measurable f
s : Set γ
hs : MeasurableSet s
⊢ (map g (map f μ)) s = (map (g ∘ f) μ) s
state_after: no goals
tactic: simp [hf, hg, hs, hg hs, hg.comp hf, ← preimage_comp]
Theorem: SimpleGraph.iUnion_connectedComponentSupp
File: Mathlib/Combinatorics/SimpleGraph/Path.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G✝ : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
G : SimpleGraph V
⊢ ⋃ c, c.supp = Set.univ
state_after: V : Type u
V' : Type v
V'' : Type w
G✝ : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
G : SimpleGraph V
v : V
⊢ (↑(G.connectedComponentMk v) ∈ Set.range fun c => c.supp) ∧ v ∈ ↑(G.connectedComponentMk v)
tactic: refine Set.eq_univ_of_forall fun v ↦ ⟨G.connectedComponentMk v, ?_⟩
state_before: V : Type u
V' : Type v
V'' : Type w
G✝ : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
G : SimpleGraph V
v : V
⊢ (↑(G.connectedComponentMk v) ∈ Set.range fun c => c.supp) ∧ v ∈ ↑(G.connectedComponentMk v)
state_after: V : Type u
V' : Type v
V'' : Type w
G✝ : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
G : SimpleGraph V
v : V
⊢ (∃ y, y.supp = ↑(G.connectedComponentMk v)) ∧ v ∈ G.connectedComponentMk v
tactic: simp only [Set.mem_range, SetLike.mem_coe]
state_before: V : Type u
V' : Type v
V'' : Type w
G✝ : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
G : SimpleGraph V
v : V
⊢ (∃ y, y.supp = ↑(G.connectedComponentMk v)) ∧ v ∈ G.connectedComponentMk v
state_after: no goals
tactic: exact ⟨by use G.connectedComponentMk v; exact rfl, rfl⟩
Theorem: AddAction.stabilizer_op_addSubgroup
File: Mathlib/Algebra/Pointwise/Stabilizer.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
α : Type u_3
inst✝² : Group G
inst✝¹ : Group H
inst✝ : MulAction G α
a : G
s : Subgroup G
⊢ stabilizer Gᵐᵒᵖ ↑s = s.op
state_after: G : Type u_1
H : Type u_2
α : Type u_3
inst✝² : Group G
inst✝¹ : Group H
inst✝ : MulAction G α
a : G
s : Subgroup G
⊢ ∀ (x : Gᵐᵒᵖ), (∀ (b : G), x • b ∈ ↑s ↔ b ∈ ↑s) ↔ x ∈ s.op
tactic: simp_rw [SetLike.ext_iff, mem_stabilizer_set]
state_before: G : Type u_1
H : Type u_2
α : Type u_3
inst✝² : Group G
inst✝¹ : Group H
inst✝ : MulAction G α
a : G
s : Subgroup G
⊢ ∀ (x : Gᵐᵒᵖ), (∀ (b : G), x • b ∈ ↑s ↔ b ∈ ↑s) ↔ x ∈ s.op
state_after: G : Type u_1
H : Type u_2
α : Type u_3
inst✝² : Group G
inst✝¹ : Group H
inst✝ : MulAction G α
a : G
s : Subgroup G
⊢ ∀ (x : Gᵐᵒᵖ), (∀ (b : G), b * unop x ∈ s ↔ b ∈ s) ↔ unop x ∈ s
tactic: simp? says simp only [smul_eq_mul_unop, SetLike.mem_coe, Subgroup.mem_op]
state_before: G : Type u_1
H : Type u_2
α : Type u_3
inst✝² : Group G
inst✝¹ : Group H
inst✝ : MulAction G α
a : G
s : Subgroup G
⊢ ∀ (x : Gᵐᵒᵖ), (∀ (b : G), b * unop x ∈ s ↔ b ∈ s) ↔ unop x ∈ s
state_after: G : Type u_1
H : Type u_2
α : Type u_3
inst✝² : Group G
inst✝¹ : Group H
inst✝ : MulAction G α
a✝ : G
s : Subgroup G
a : Gᵐᵒᵖ
h : ∀ (b : G), b * unop a ∈ s ↔ b ∈ s
⊢ unop a ∈ s
tactic: refine fun a ↦ ⟨fun h ↦ ?_, fun ha b ↦ s.mul_mem_cancel_right ha⟩
state_before: G : Type u_1
H : Type u_2
α : Type u_3
inst✝² : Group G
inst✝¹ : Group H
inst✝ : MulAction G α
a✝ : G
s : Subgroup G
a : Gᵐᵒᵖ
h : ∀ (b : G), b * unop a ∈ s ↔ b ∈ s
⊢ unop a ∈ s
state_after: no goals
tactic: simpa only [op_smul_eq_mul, SetLike.mem_coe, one_mul] using (h 1).2 s.one_mem
Theorem: ZMod.cast_add_eq_ite
File: Mathlib/Data/ZMod/Basic.lean

Proof steps:
state_before: n✝ : ℕ
R : Type u_1
inst✝ : Ring R
n : ℕ
a b : ZMod n
⊢ (a + b).cast = if ↑n ≤ a.cast + b.cast then a.cast + b.cast - ↑n else a.cast + b.cast
state_after: case zero
n : ℕ
R : Type u_1
inst✝ : Ring R
a b : ZMod 0
⊢ (a + b).cast = if ↑0 ≤ a.cast + b.cast then a.cast + b.cast - ↑0 else a.cast + b.cast

case succ
n✝ : ℕ
R : Type u_1
inst✝ : Ring R
n : ℕ
a b : ZMod (n + 1)
⊢ (a + b).cast = if ↑(n + 1) ≤ a.cast + b.cast then a.cast + b.cast - ↑(n + 1) else a.cast + b.cast
tactic: cases' n with n
state_before: case succ
n✝ : ℕ
R : Type u_1
inst✝ : Ring R
n : ℕ
a b : ZMod (n + 1)
⊢ (a + b).cast = if ↑(n + 1) ≤ a.cast + b.cast then a.cast + b.cast - ↑(n + 1) else a.cast + b.cast
state_after: case succ
n✝ : ℕ
R : Type u_1
inst✝ : Ring R
n : ℕ
a b : Fin (n + 1)
⊢ (a + b).cast = if ↑(n + 1) ≤ cast a + cast b then cast a + cast b - ↑(n + 1) else cast a + cast b
tactic: change Fin (n + 1) at a b
state_before: case succ
n✝ : ℕ
R : Type u_1
inst✝ : Ring R
n : ℕ
a b : Fin (n + 1)
⊢ (a + b).cast = if ↑(n + 1) ≤ cast a + cast b then cast a + cast b - ↑(n + 1) else cast a + cast b
state_after: case succ
n✝ : ℕ
R : Type u_1
inst✝ : Ring R
n : ℕ
a b : Fin (n + 1)
⊢ ↑↑(a + b) = if ↑(n + 1) ≤ ↑↑a + ↑↑b then cast a + cast b - ↑(n + 1) else cast a + cast b
tactic: change ((((a + b) : Fin (n + 1)) : ℕ) : ℤ) = if ((n + 1 : ℕ) : ℤ) ≤ (a : ℕ) + b then _ else _
state_before: case succ
n✝ : ℕ
R : Type u_1
inst✝ : Ring R
n : ℕ
a b : Fin (n + 1)
⊢ ↑↑(a + b) = if ↑(n + 1) ≤ ↑↑a + ↑↑b then cast a + cast b - ↑(n + 1) else cast a + cast b
state_after: case succ
n✝ : ℕ
R : Type u_1
inst✝ : Ring R
n : ℕ
a b : Fin (n + 1)
⊢ ↑(if n + 1 ≤ ↑a + ↑b then ↑a + ↑b - (n + 1) else ↑a + ↑b) =
    if ↑n + 1 ≤ ↑↑a + ↑↑b then cast a + cast b - (↑n + 1) else cast a + cast b
tactic: simp only [Fin.val_add_eq_ite, Int.ofNat_succ, Int.ofNat_le]
state_before: case succ
n✝ : ℕ
R : Type u_1
inst✝ : Ring R
n : ℕ
a b : Fin (n + 1)
⊢ ↑(if n + 1 ≤ ↑a + ↑b then ↑a + ↑b - (n + 1) else ↑a + ↑b) =
    if ↑n + 1 ≤ ↑↑a + ↑↑b then cast a + cast b - (↑n + 1) else cast a + cast b
state_after: case succ
n✝ : ℕ
R : Type u_1
inst✝ : Ring R
n : ℕ
a b : Fin (n + 1)
⊢ ↑(if n + 1 ≤ ↑a + ↑b then ↑a + ↑b - (n + 1) else ↑a + ↑b) =
    if n + 1 ≤ ↑a + ↑b then cast a + cast b - ↑(n + 1) else cast a + cast b
tactic: norm_cast
state_before: case succ
n✝ : ℕ
R : Type u_1
inst✝ : Ring R
n : ℕ
a b : Fin (n + 1)
⊢ ↑(if n + 1 ≤ ↑a + ↑b then ↑a + ↑b - (n + 1) else ↑a + ↑b) =
    if n + 1 ≤ ↑a + ↑b then cast a + cast b - ↑(n + 1) else cast a + cast b
state_after: case pos
n✝ : ℕ
R : Type u_1
inst✝ : Ring R
n : ℕ
a b : Fin (n + 1)
h : n + 1 ≤ ↑a + ↑b
⊢ ↑(↑a + ↑b - (n + 1)) = cast a + cast b - ↑(n + 1)

case neg
n✝ : ℕ
R : Type u_1
inst✝ : Ring R
n : ℕ
a b : Fin (n + 1)
h : ¬n + 1 ≤ ↑a + ↑b
⊢ ↑(↑a + ↑b) = cast a + cast b
tactic: split_ifs with h
Theorem: Nat.le_self_pow
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a✝ b c d m n k : ℕ
p q : ℕ → Prop
hn : n ≠ 0
a : ℕ
⊢ a + 1 ≤ (a + 1) ^ n
state_after: no goals
tactic: simpa using Nat.pow_le_pow_right a.succ_pos (Nat.one_le_iff_ne_zero.2 hn)
Theorem: SimpleGraph.Reachable.dist_eq_zero_iff
File: Mathlib/Combinatorics/SimpleGraph/Metric.lean

Proof steps:
state_before: V : Type u_1
G : SimpleGraph V
u v w : V
hr : G.Reachable u v
⊢ G.dist u v = 0 ↔ u = v
state_after: no goals
tactic: simp [hr]
Theorem: Finmap.lookup_union_left_of_not_in
File: Mathlib/Data/Finmap.lean

Proof steps:
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
s₁ s₂ : Finmap β
h : a ∉ s₂
⊢ lookup a (s₁ ∪ s₂) = lookup a s₁
state_after: case pos
α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
s₁ s₂ : Finmap β
h : a ∉ s₂
h' : a ∈ s₁
⊢ lookup a (s₁ ∪ s₂) = lookup a s₁

case neg
α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
s₁ s₂ : Finmap β
h : a ∉ s₂
h' : a ∉ s₁
⊢ lookup a (s₁ ∪ s₂) = lookup a s₁
tactic: by_cases h' : a ∈ s₁
Theorem: PerfectClosure.R.sound
File: Mathlib/FieldTheory/PerfectClosure.lean

Proof steps:
state_before: K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
m n : ℕ
x y : K
H : (⇑(frobenius K p))^[m] x = y
⊢ mk K p (n, x) = mk K p (m + n, y)
state_after: K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
m n : ℕ
x : K
⊢ mk K p (n, x) = mk K p (m + n, (⇑(frobenius K p))^[m] x)
tactic: subst H
state_before: K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
m n : ℕ
x : K
⊢ mk K p (n, x) = mk K p (m + n, (⇑(frobenius K p))^[m] x)
state_after: case zero
K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
n : ℕ
x : K
⊢ mk K p (n, x) = mk K p (0 + n, (⇑(frobenius K p))^[0] x)

case succ
K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
n : ℕ
x : K
m : ℕ
ih : mk K p (n, x) = mk K p (m + n, (⇑(frobenius K p))^[m] x)
⊢ mk K p (n, x) = mk K p (m + 1 + n, (⇑(frobenius K p))^[m + 1] x)
tactic: induction' m with m ih
state_before: case succ
K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
n : ℕ
x : K
m : ℕ
ih : mk K p (n, x) = mk K p (m + n, (⇑(frobenius K p))^[m] x)
⊢ mk K p (n, x) = mk K p (m + 1 + n, (⇑(frobenius K p))^[m + 1] x)
state_after: case succ
K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
n : ℕ
x : K
m : ℕ
ih : mk K p (n, x) = mk K p (m + n, (⇑(frobenius K p))^[m] x)
⊢ mk K p (m + n, (⇑(frobenius K p))^[m] x) = mk K p ((m + n).succ, (⇑(frobenius K p) ∘ (⇑(frobenius K p))^[m]) x)
tactic: rw [ih, Nat.succ_add, iterate_succ']
state_before: case succ
K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
n : ℕ
x : K
m : ℕ
ih : mk K p (n, x) = mk K p (m + n, (⇑(frobenius K p))^[m] x)
⊢ mk K p (m + n, (⇑(frobenius K p))^[m] x) = mk K p ((m + n).succ, (⇑(frobenius K p) ∘ (⇑(frobenius K p))^[m]) x)
state_after: case succ.a
K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
n : ℕ
x : K
m : ℕ
ih : mk K p (n, x) = mk K p (m + n, (⇑(frobenius K p))^[m] x)
⊢ R K p (m + n, (⇑(frobenius K p))^[m] x) ((m + n).succ, (⇑(frobenius K p) ∘ (⇑(frobenius K p))^[m]) x)
tactic: apply Quot.sound
state_before: case succ.a
K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
n : ℕ
x : K
m : ℕ
ih : mk K p (n, x) = mk K p (m + n, (⇑(frobenius K p))^[m] x)
⊢ R K p (m + n, (⇑(frobenius K p))^[m] x) ((m + n).succ, (⇑(frobenius K p) ∘ (⇑(frobenius K p))^[m]) x)
state_after: no goals
tactic: apply R.intro
Theorem: MeasureTheory.hasFiniteIntegral_smul_iff
File: Mathlib/MeasureTheory/Function/L1Space.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝⁵ : MeasurableSpace δ
inst✝⁴ : NormedAddCommGroup β
inst✝³ : NormedAddCommGroup γ
𝕜 : Type u_5
inst✝² : NormedRing 𝕜
inst✝¹ : MulActionWithZero 𝕜 β
inst✝ : BoundedSMul 𝕜 β
c : 𝕜
hc : IsUnit c
f : α → β
⊢ HasFiniteIntegral (c • f) μ ↔ HasFiniteIntegral f μ
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝⁵ : MeasurableSpace δ
inst✝⁴ : NormedAddCommGroup β
inst✝³ : NormedAddCommGroup γ
𝕜 : Type u_5
inst✝² : NormedRing 𝕜
inst✝¹ : MulActionWithZero 𝕜 β
inst✝ : BoundedSMul 𝕜 β
f : α → β
c : 𝕜ˣ
⊢ HasFiniteIntegral (↑c • f) μ ↔ HasFiniteIntegral f μ
tactic: obtain ⟨c, rfl⟩ := hc
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝⁵ : MeasurableSpace δ
inst✝⁴ : NormedAddCommGroup β
inst✝³ : NormedAddCommGroup γ
𝕜 : Type u_5
inst✝² : NormedRing 𝕜
inst✝¹ : MulActionWithZero 𝕜 β
inst✝ : BoundedSMul 𝕜 β
f : α → β
c : 𝕜ˣ
⊢ HasFiniteIntegral (↑c • f) μ ↔ HasFiniteIntegral f μ
state_after: case intro.mp
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝⁵ : MeasurableSpace δ
inst✝⁴ : NormedAddCommGroup β
inst✝³ : NormedAddCommGroup γ
𝕜 : Type u_5
inst✝² : NormedRing 𝕜
inst✝¹ : MulActionWithZero 𝕜 β
inst✝ : BoundedSMul 𝕜 β
f : α → β
c : 𝕜ˣ
⊢ HasFiniteIntegral (↑c • f) μ → HasFiniteIntegral f μ

case intro.mpr
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝⁵ : MeasurableSpace δ
inst✝⁴ : NormedAddCommGroup β
inst✝³ : NormedAddCommGroup γ
𝕜 : Type u_5
inst✝² : NormedRing 𝕜
inst✝¹ : MulActionWithZero 𝕜 β
inst✝ : BoundedSMul 𝕜 β
f : α → β
c : 𝕜ˣ
⊢ HasFiniteIntegral f μ → HasFiniteIntegral (↑c • f) μ
tactic: constructor
state_before: case intro.mpr
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝⁵ : MeasurableSpace δ
inst✝⁴ : NormedAddCommGroup β
inst✝³ : NormedAddCommGroup γ
𝕜 : Type u_5
inst✝² : NormedRing 𝕜
inst✝¹ : MulActionWithZero 𝕜 β
inst✝ : BoundedSMul 𝕜 β
f : α → β
c : 𝕜ˣ
⊢ HasFiniteIntegral f μ → HasFiniteIntegral (↑c • f) μ
state_after: no goals
tactic: exact HasFiniteIntegral.smul _
Theorem: GenContFract.IntFractPair.coe_of_rat_eq
File: Mathlib/Algebra/ContinuedFractions/Computation/TerminatesIffRat.lean

Proof steps:
state_before: K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
q : ℚ
v_eq_q : v = ↑q
n : ℕ
⊢ mapFr Rat.cast (IntFractPair.of q) = IntFractPair.of v
state_after: no goals
tactic: simp [IntFractPair.of, v_eq_q]
Theorem: Finset.map_nsmul_piAntidiag
File: Mathlib/Algebra/Order/Antidiag/Pi.lean

Proof steps:
state_before: ι : Type u_1
μ : Type u_2
μ' : Type u_3
inst✝ : DecidableEq ι
s : Finset ι
m n : ℕ
hn : n ≠ 0
⊢ map { toFun := fun x => n • x, inj' := ⋯ } (s.piAntidiag m) =
    filter (fun f => ∀ i ∈ s, n ∣ f i) (s.piAntidiag (n * m))
state_after: no goals
tactic: classical rw [map_eq_image]; exact nsmul_piAntidiag _ _ hn
Theorem: CategoryTheory.MonoOver.inf_map_app
File: Mathlib/CategoryTheory/Subobject/Lattice.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : HasPullbacks C
A : C
X✝ Y✝ : MonoOver A
k : X✝ ⟶ Y✝
g : MonoOver A
⊢ ((fun f => pullback f.arrow ⋙ map f.arrow) X✝).obj g ⟶ ((fun f => pullback f.arrow ⋙ map f.arrow) Y✝).obj g
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : HasPullbacks C
A : C
X✝ Y✝ : MonoOver A
k : X✝ ⟶ Y✝
g : MonoOver A
⊢ (((fun f => pullback f.arrow ⋙ map f.arrow) X✝).obj g).obj.left ⟶
    (((fun f => pullback f.arrow ⋙ map f.arrow) Y✝).obj g).obj.left

C : Type u₁
inst✝² : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : HasPullbacks C
A : C
X✝ Y✝ : MonoOver A
k : X✝ ⟶ Y✝
g : MonoOver A
⊢ ?m.18614 ≫ (((fun f => pullback f.arrow ⋙ map f.arrow) Y✝).obj g).arrow =
    (((fun f => pullback f.arrow ⋙ map f.arrow) X✝).obj g).arrow
tactic: apply homMk _ _
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : HasPullbacks C
A : C
X✝ Y✝ : MonoOver A
k : X✝ ⟶ Y✝
g : MonoOver A
⊢ pullback.lift (pullback.fst ((forget A).obj g).hom X✝.arrow) (pullback.snd ((forget A).obj g).hom X✝.arrow ≫ k.left)
        ⋯ ≫
      (((fun f => pullback f.arrow ⋙ map f.arrow) Y✝).obj g).arrow =
    (((fun f => pullback f.arrow ⋙ map f.arrow) X✝).obj g).arrow
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : HasPullbacks C
A : C
X✝ Y✝ : MonoOver A
k : X✝ ⟶ Y✝
g : MonoOver A
⊢ pullback.lift (pullback.fst g.arrow X✝.arrow) (pullback.snd g.arrow X✝.arrow ≫ k.left) ⋯ ≫
      pullback.snd g.arrow Y✝.arrow ≫ Y✝.arrow =
    pullback.snd g.arrow X✝.arrow ≫ X✝.arrow
tactic: dsimp
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : HasPullbacks C
A : C
X✝ Y✝ : MonoOver A
k : X✝ ⟶ Y✝
g : MonoOver A
⊢ pullback.lift (pullback.fst g.arrow X✝.arrow) (pullback.snd g.arrow X✝.arrow ≫ k.left) ⋯ ≫
      pullback.snd g.arrow Y✝.arrow ≫ Y✝.arrow =
    pullback.snd g.arrow X✝.arrow ≫ X✝.arrow
state_after: no goals
tactic: rw [pullback.lift_snd_assoc, assoc, w k]
Theorem: List.forall₂_drop_append
File: Mathlib/Data/List/Forall2.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
l : List α
l₁ l₂ : List β
h : Forall₂ R l (l₁ ++ l₂)
⊢ Forall₂ R (drop l₁.length l) l₂
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
l : List α
l₁ l₂ : List β
h : Forall₂ R l (l₁ ++ l₂)
h' : Forall₂ R (drop l₁.length l) (drop l₁.length (l₁ ++ l₂))
⊢ Forall₂ R (drop l₁.length l) l₂
tactic: have h' : Forall₂ R (drop (length l₁) l) (drop (length l₁) (l₁ ++ l₂)) :=
    forall₂_drop (length l₁) h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
l : List α
l₁ l₂ : List β
h : Forall₂ R l (l₁ ++ l₂)
h' : Forall₂ R (drop l₁.length l) (drop l₁.length (l₁ ++ l₂))
⊢ Forall₂ R (drop l₁.length l) l₂
state_after: no goals
tactic: rwa [drop_left] at h'
Theorem: padicNorm.sub
File: Mathlib/NumberTheory/Padics/PadicNorm.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ
⊢ padicNorm p (q - r) ≤ max (padicNorm p q) (padicNorm p r)
state_after: p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ
⊢ padicNorm p (q + -r) ≤ max (padicNorm p q) (padicNorm p (-r))
tactic: rw [sub_eq_add_neg, ← padicNorm.neg r]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ
⊢ padicNorm p (q + -r) ≤ max (padicNorm p q) (padicNorm p (-r))
state_after: no goals
tactic: exact padicNorm.nonarchimedean