ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Polynomial.not_finite
File: Mathlib/RingTheory/Polynomial/Basic.lean

Proof steps:
state_before: R : Type u
S : Type u_1
inst✝¹ : Semiring R
inst✝ : Nontrivial R
⊢ ¬Module.Finite R R[X]
state_after: R : Type u
S : Type u_1
inst✝¹ : Semiring R
inst✝ : Nontrivial R
⊢ ¬∃ S, S.Finite ∧ Submodule.span R S = ⊤
tactic: rw [Module.finite_def, Submodule.fg_def]
state_before: R : Type u
S : Type u_1
inst✝¹ : Semiring R
inst✝ : Nontrivial R
⊢ ¬∃ S, S.Finite ∧ Submodule.span R S = ⊤
state_after: R : Type u
S : Type u_1
inst✝¹ : Semiring R
inst✝ : Nontrivial R
⊢ ∀ (S : Set R[X]), S.Finite → Submodule.span R S ≠ ⊤
tactic: push_neg
state_before: R : Type u
S : Type u_1
inst✝¹ : Semiring R
inst✝ : Nontrivial R
⊢ ∀ (S : Set R[X]), S.Finite → Submodule.span R S ≠ ⊤
state_after: R : Type u
S : Type u_1
inst✝¹ : Semiring R
inst✝ : Nontrivial R
s : Set R[X]
hs : s.Finite
contra : Submodule.span R s = ⊤
⊢ False
tactic: intro s hs contra
state_before: R : Type u
S : Type u_1
inst✝¹ : Semiring R
inst✝ : Nontrivial R
s : Set R[X]
hs : s.Finite
contra : Submodule.span R s = ⊤
⊢ False
state_after: case intro
R : Type u
S : Type u_1
inst✝¹ : Semiring R
inst✝ : Nontrivial R
s : Set R[X]
hs : s.Finite
contra : Submodule.span R s = ⊤
n : ℕ
hn : Submodule.span R s ≤ degreeLE R ↑n
⊢ False
tactic: rcases span_le_degreeLE_of_finite hs with ⟨n,hn⟩
state_before: case intro
R : Type u
S : Type u_1
inst✝¹ : Semiring R
inst✝ : Nontrivial R
s : Set R[X]
hs : s.Finite
contra : Submodule.span R s = ⊤
n : ℕ
hn : Submodule.span R s ≤ degreeLE R ↑n
⊢ False
state_after: case intro
R : Type u
S : Type u_1
inst✝¹ : Semiring R
inst✝ : Nontrivial R
s : Set R[X]
hs : s.Finite
contra : Submodule.span R s = ⊤
n : ℕ
hn : Submodule.span R s ≤ degreeLE R ↑n
this : X ^ (n + 1) ∈ degreeLE R ↑n
⊢ False
tactic: have : ((X : R[X]) ^ (n + 1)) ∈ Polynomial.degreeLE R ↑n := by
    rw [contra] at hn
    exact hn Submodule.mem_top
state_before: case intro
R : Type u
S : Type u_1
inst✝¹ : Semiring R
inst✝ : Nontrivial R
s : Set R[X]
hs : s.Finite
contra : Submodule.span R s = ⊤
n : ℕ
hn : Submodule.span R s ≤ degreeLE R ↑n
this : X ^ (n + 1) ∈ degreeLE R ↑n
⊢ False
state_after: case intro
R : Type u
S : Type u_1
inst✝¹ : Semiring R
inst✝ : Nontrivial R
s : Set R[X]
hs : s.Finite
contra : Submodule.span R s = ⊤
n : ℕ
hn : Submodule.span R s ≤ degreeLE R ↑n
this : 1 = 0
⊢ False
tactic: rw [mem_degreeLE, degree_X_pow, Nat.cast_le, add_le_iff_nonpos_right, nonpos_iff_eq_zero] at this
state_before: case intro
R : Type u
S : Type u_1
inst✝¹ : Semiring R
inst✝ : Nontrivial R
s : Set R[X]
hs : s.Finite
contra : Submodule.span R s = ⊤
n : ℕ
hn : Submodule.span R s ≤ degreeLE R ↑n
this : 1 = 0
⊢ False
state_after: no goals
tactic: exact one_ne_zero this
Theorem: UniformSpace.complete_of_convergent_controlled_sequences
File: Mathlib/Topology/UniformSpace/Cauchy.lean

Proof steps:
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
inst✝ : (𝓤 α).IsCountablyGenerated
U : ℕ → Set (α × α)
U_mem : ∀ (n : ℕ), U n ∈ 𝓤 α
HU : ∀ (u : ℕ → α), (∀ (N m n : ℕ), N ≤ m → N ≤ n → (u m, u n) ∈ U N) → ∃ a, Tendsto u atTop (𝓝 a)
⊢ CompleteSpace α
state_after: case intro.intro
α : Type u
β : Type v
uniformSpace : UniformSpace α
inst✝ : (𝓤 α).IsCountablyGenerated
U : ℕ → Set (α × α)
U_mem : ∀ (n : ℕ), U n ∈ 𝓤 α
HU : ∀ (u : ℕ → α), (∀ (N m n : ℕ), N ≤ m → N ≤ n → (u m, u n) ∈ U N) → ∃ a, Tendsto u atTop (𝓝 a)
U' : ℕ → Set (α × α)
hU' : ∀ {s : Set (α × α)}, s ∈ 𝓤 α ↔ ∃ i, U' i ⊆ s
⊢ CompleteSpace α
tactic: obtain ⟨U', -, hU'⟩ := (𝓤 α).exists_antitone_seq
state_before: case intro.intro
α : Type u
β : Type v
uniformSpace : UniformSpace α
inst✝ : (𝓤 α).IsCountablyGenerated
U : ℕ → Set (α × α)
U_mem : ∀ (n : ℕ), U n ∈ 𝓤 α
HU : ∀ (u : ℕ → α), (∀ (N m n : ℕ), N ≤ m → N ≤ n → (u m, u n) ∈ U N) → ∃ a, Tendsto u atTop (𝓝 a)
U' : ℕ → Set (α × α)
hU' : ∀ {s : Set (α × α)}, s ∈ 𝓤 α ↔ ∃ i, U' i ⊆ s
⊢ CompleteSpace α
state_after: case intro.intro
α : Type u
β : Type v
uniformSpace : UniformSpace α
inst✝ : (𝓤 α).IsCountablyGenerated
U : ℕ → Set (α × α)
U_mem : ∀ (n : ℕ), U n ∈ 𝓤 α
HU : ∀ (u : ℕ → α), (∀ (N m n : ℕ), N ≤ m → N ≤ n → (u m, u n) ∈ U N) → ∃ a, Tendsto u atTop (𝓝 a)
U' : ℕ → Set (α × α)
hU' : ∀ {s : Set (α × α)}, s ∈ 𝓤 α ↔ ∃ i, U' i ⊆ s
Hmem : ∀ (n : ℕ), U n ∩ U' n ∈ 𝓤 α
⊢ CompleteSpace α
tactic: have Hmem : ∀ n, U n ∩ U' n ∈ 𝓤 α := fun n => inter_mem (U_mem n) (hU'.2 ⟨n, Subset.refl _⟩)
state_before: case intro.intro
α : Type u
β : Type v
uniformSpace : UniformSpace α
inst✝ : (𝓤 α).IsCountablyGenerated
U : ℕ → Set (α × α)
U_mem : ∀ (n : ℕ), U n ∈ 𝓤 α
HU : ∀ (u : ℕ → α), (∀ (N m n : ℕ), N ≤ m → N ≤ n → (u m, u n) ∈ U N) → ∃ a, Tendsto u atTop (𝓝 a)
U' : ℕ → Set (α × α)
hU' : ∀ {s : Set (α × α)}, s ∈ 𝓤 α ↔ ∃ i, U' i ⊆ s
Hmem : ∀ (n : ℕ), U n ∩ U' n ∈ 𝓤 α
⊢ CompleteSpace α
state_after: case intro.intro.refine_1
α : Type u
β : Type v
uniformSpace : UniformSpace α
inst✝ : (𝓤 α).IsCountablyGenerated
U : ℕ → Set (α × α)
U_mem : ∀ (n : ℕ), U n ∈ 𝓤 α
HU : ∀ (u : ℕ → α), (∀ (N m n : ℕ), N ≤ m → N ≤ n → (u m, u n) ∈ U N) → ∃ a, Tendsto u atTop (𝓝 a)
U' : ℕ → Set (α × α)
hU' : ∀ {s : Set (α × α)}, s ∈ 𝓤 α ↔ ∃ i, U' i ⊆ s
Hmem : ∀ (n : ℕ), U n ∩ U' n ∈ 𝓤 α
f✝ : Filter α
hf : Cauchy f✝
N m n : ℕ
hm : N ≤ m
hn : N ≤ n
⊢ (SequentiallyComplete.seq hf Hmem m, SequentiallyComplete.seq hf Hmem n) ∈ U N

case intro.intro.refine_2
α : Type u
β : Type v
uniformSpace : UniformSpace α
inst✝ : (𝓤 α).IsCountablyGenerated
U : ℕ → Set (α × α)
U_mem : ∀ (n : ℕ), U n ∈ 𝓤 α
HU : ∀ (u : ℕ → α), (∀ (N m n : ℕ), N ≤ m → N ≤ n → (u m, u n) ∈ U N) → ∃ a, Tendsto u atTop (𝓝 a)
U' : ℕ → Set (α × α)
hU' : ∀ {s : Set (α × α)}, s ∈ 𝓤 α ↔ ∃ i, U' i ⊆ s
Hmem : ∀ (n : ℕ), U n ∩ U' n ∈ 𝓤 α
f✝ : Filter α
hf : Cauchy f✝
s : Set (α × α)
hs : s ∈ 𝓤 α
⊢ ∃ n, U n ∩ U' n ⊆ s
tactic: refine ⟨fun hf => (HU (seq hf Hmem) fun N m n hm hn => ?_).imp <|
    le_nhds_of_seq_tendsto_nhds _ _ fun s hs => ?_⟩
Theorem: CategoryTheory.OverPresheafAux.YonedaCollection.map₁_map₂
File: Mathlib/CategoryTheory/Comma/Presheaf.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
A : Cᵒᵖ ⥤ Type v
F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
X : C
G : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
η : F ⟶ G
Y : C
f : X ⟶ Y
p : YonedaCollection F Y
⊢ map₂ G f (map₁ η p) = map₁ η (map₂ F f p)
state_after: case h.w.h.h
C : Type u
inst✝ : Category.{v, u} C
A : Cᵒᵖ ⥤ Type v
F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
X : C
G : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
η : F ⟶ G
Y : C
f : X ⟶ Y
p : YonedaCollection F Y
x✝ : Cᵒᵖ
a✝ : (yoneda.obj X).obj x✝
⊢ (map₂ G f (map₁ η p)).fst.app x✝ a✝ = (map₁ η (map₂ F f p)).fst.app x✝ a✝

case h'
C : Type u
inst✝ : Category.{v, u} C
A : Cᵒᵖ ⥤ Type v
F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
X : C
G : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
η : F ⟶ G
Y : C
f : X ⟶ Y
p : YonedaCollection F Y
⊢ G.map (eqToHom ⋯) (map₁ η (map₂ F f p)).snd = (map₂ G f (map₁ η p)).snd
tactic: ext
state_before: case h.w.h.h
C : Type u
inst✝ : Category.{v, u} C
A : Cᵒᵖ ⥤ Type v
F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
X : C
G : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
η : F ⟶ G
Y : C
f : X ⟶ Y
p : YonedaCollection F Y
x✝ : Cᵒᵖ
a✝ : (yoneda.obj X).obj x✝
⊢ (map₂ G f (map₁ η p)).fst.app x✝ a✝ = (map₁ η (map₂ F f p)).fst.app x✝ a✝

case h'
C : Type u
inst✝ : Category.{v, u} C
A : Cᵒᵖ ⥤ Type v
F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
X : C
G : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
η : F ⟶ G
Y : C
f : X ⟶ Y
p : YonedaCollection F Y
⊢ G.map (eqToHom ⋯) (map₁ η (map₂ F f p)).snd = (map₂ G f (map₁ η p)).snd
state_after: no goals
tactic: all_goals simp
Theorem: ContDiffOn.differentiableOn_iteratedDerivWithin
File: Mathlib/Analysis/Calculus/IteratedDeriv/Defs.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n✝ : ℕ
f : 𝕜 → F
s : Set 𝕜
x✝ : 𝕜
n : ℕ∞
m : ℕ
h : ContDiffOn 𝕜 n f s
hmn : ↑m < n
hs : UniqueDiffOn 𝕜 s
x : 𝕜
hx : x ∈ s
⊢ UniqueDiffOn 𝕜 (insert x s)
state_after: no goals
tactic: rwa [insert_eq_of_mem hx]
Theorem: Set.image_image2_distrib_left
File: Mathlib/Data/Set/NAry.lean

Proof steps:
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
f f'✝ : α → β → γ
g✝ g'✝ : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
g : γ → δ
f' : α' → β → δ
g' : α → α'
h_distrib : ∀ (a : α) (b : β), g (f a b) = f' (g' a) b
⊢ image2 f' (g' '' s) ((fun b => b) '' t) = image2 f' (g' '' s) t
state_after: no goals
tactic: rw [image_id']
Theorem: BoxIntegral.Prepartition.IsPartition.compl_eq_bot
File: Mathlib/Analysis/BoxIntegral/Partition/Split.lean

Proof steps:
state_before: ι : Type u_1
M : Type u_2
n : ℕ
I J : Box ι
i : ι
x : ℝ
inst✝ : Finite ι
π : Prepartition I
h : π.IsPartition
⊢ π.compl = ⊥
state_after: no goals
tactic: rw [← iUnion_eq_empty, iUnion_compl, h.iUnion_eq, diff_self]
Theorem: NumberField.InfinitePlace.nrRealPlaces_eq_one_of_finrank_eq_one
File: Mathlib/NumberTheory/NumberField/Embeddings.lean

Proof steps:
state_before: k : Type u_1
inst✝³ : Field k
K : Type u_2
inst✝² : Field K
F : Type u_3
inst✝¹ : Field F
inst✝ : NumberField K
h : finrank ℚ K = 1
⊢ NrRealPlaces K = 1
state_after: k : Type u_1
inst✝³ : Field k
K : Type u_2
inst✝² : Field K
F : Type u_3
inst✝¹ : Field F
inst✝ : NumberField K
h : finrank ℚ K = 1
this : NrRealPlaces K + 2 * NrComplexPlaces K = finrank ℚ K
⊢ NrRealPlaces K = 1
tactic: have := card_add_two_mul_card_eq_rank K
state_before: k : Type u_1
inst✝³ : Field k
K : Type u_2
inst✝² : Field K
F : Type u_3
inst✝¹ : Field F
inst✝ : NumberField K
h : finrank ℚ K = 1
this : NrRealPlaces K + 2 * NrComplexPlaces K = finrank ℚ K
⊢ NrRealPlaces K = 1
state_after: no goals
tactic: rwa [nrComplexPlaces_eq_zero_of_finrank_eq_one h, h, mul_zero, add_zero] at this
Theorem: zeta_nat_eq_tsum_of_gt_one
File: Mathlib/NumberTheory/LSeries/RiemannZeta.lean

Proof steps:
state_before: k : ℕ
hk : 1 < k
⊢ riemannZeta ↑k = ∑' (n : ℕ), 1 / ↑n ^ k
state_after: no goals
tactic: simp only [zeta_eq_tsum_one_div_nat_cpow
      (by rwa [← ofReal_natCast, ofReal_re, ← Nat.cast_one, Nat.cast_lt] : 1 < re k),
    cpow_natCast]
Theorem: lp.coeFn_sum
File: Mathlib/Analysis/Normed/Lp/lpSpace.lean

Proof steps:
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
ι : Type u_3
f : ι → ↥(lp E p)
s : Finset ι
⊢ ↑(∑ i ∈ s, f i) = ∑ i ∈ s, ↑(f i)
state_after: no goals
tactic: simp
Theorem: AffineMap.pi_eq_zero
File: Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean

Proof steps:
state_before: R : Type u_1
k : Type u_2
V1 : Type u_3
P1 : Type u_4
V2 : Type u_5
P2 : Type u_6
V3 : Type u_7
P3 : Type u_8
inst✝¹² : Ring k
inst✝¹¹ : AddCommGroup V1
inst✝¹⁰ : AffineSpace V1 P1
inst✝⁹ : AddCommGroup V2
inst✝⁸ : AffineSpace V2 P2
inst✝⁷ : AddCommGroup V3
inst✝⁶ : AffineSpace V3 P3
inst✝⁵ : Module k V1
inst✝⁴ : Module k V2
inst✝³ : Module k V3
ι : Type u_9
φv : ι → Type u_10
φp : ι → Type u_11
inst✝² : (i : ι) → AddCommGroup (φv i)
inst✝¹ : (i : ι) → Module k (φv i)
inst✝ : (i : ι) → AffineSpace (φv i) (φp i)
fp : (i : ι) → P1 →ᵃ[k] φp i
fv : (i : ι) → P1 →ᵃ[k] φv i
f' : ι → P1 →ᵃ[k] P2
⊢ pi fv = 0 ↔ ∀ (i : ι), fv i = 0
state_after: R : Type u_1
k : Type u_2
V1 : Type u_3
P1 : Type u_4
V2 : Type u_5
P2 : Type u_6
V3 : Type u_7
P3 : Type u_8
inst✝¹² : Ring k
inst✝¹¹ : AddCommGroup V1
inst✝¹⁰ : AffineSpace V1 P1
inst✝⁹ : AddCommGroup V2
inst✝⁸ : AffineSpace V2 P2
inst✝⁷ : AddCommGroup V3
inst✝⁶ : AffineSpace V3 P3
inst✝⁵ : Module k V1
inst✝⁴ : Module k V2
inst✝³ : Module k V3
ι : Type u_9
φv : ι → Type u_10
φp : ι → Type u_11
inst✝² : (i : ι) → AddCommGroup (φv i)
inst✝¹ : (i : ι) → Module k (φv i)
inst✝ : (i : ι) → AffineSpace (φv i) (φp i)
fp : (i : ι) → P1 →ᵃ[k] φp i
fv : (i : ι) → P1 →ᵃ[k] φv i
f' : ι → P1 →ᵃ[k] P2
⊢ (∀ (p : P1) (a : ι), (fv a) p = 0 p a) ↔ ∀ (i : ι) (p : P1), (fv i) p = 0 p
tactic: simp only [AffineMap.ext_iff, Function.funext_iff, pi_apply]
state_before: R : Type u_1
k : Type u_2
V1 : Type u_3
P1 : Type u_4
V2 : Type u_5
P2 : Type u_6
V3 : Type u_7
P3 : Type u_8
inst✝¹² : Ring k
inst✝¹¹ : AddCommGroup V1
inst✝¹⁰ : AffineSpace V1 P1
inst✝⁹ : AddCommGroup V2
inst✝⁸ : AffineSpace V2 P2
inst✝⁷ : AddCommGroup V3
inst✝⁶ : AffineSpace V3 P3
inst✝⁵ : Module k V1
inst✝⁴ : Module k V2
inst✝³ : Module k V3
ι : Type u_9
φv : ι → Type u_10
φp : ι → Type u_11
inst✝² : (i : ι) → AddCommGroup (φv i)
inst✝¹ : (i : ι) → Module k (φv i)
inst✝ : (i : ι) → AffineSpace (φv i) (φp i)
fp : (i : ι) → P1 →ᵃ[k] φp i
fv : (i : ι) → P1 →ᵃ[k] φv i
f' : ι → P1 →ᵃ[k] P2
⊢ (∀ (p : P1) (a : ι), (fv a) p = 0 p a) ↔ ∀ (i : ι) (p : P1), (fv i) p = 0 p
state_after: no goals
tactic: exact forall_comm
Theorem: Convex.combo_self
File: Mathlib/Algebra/Module/Defs.lean

Proof steps:
state_before: α : Type u_1
R : Type u_2
k : Type u_3
S : Type u_4
M : Type u_5
M₂ : Type u_6
M₃ : Type u_7
ι : Type u_8
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
r s : R
x✝ y : M
a b : R
h : a + b = 1
x : M
⊢ a • x + b • x = x
state_after: no goals
tactic: rw [← add_smul, h, one_smul]
Theorem: WeierstrassCurve.Affine.map_polynomial
File: Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
W : Affine R
S : Type v
inst✝ : CommRing S
f : R →+* S
⊢ (map W f).toAffine.polynomial = Polynomial.map (mapRingHom f) W.polynomial
state_after: R : Type u
inst✝¹ : CommRing R
W : Affine R
S : Type v
inst✝ : CommRing S
f : R →+* S
⊢ Y ^ 2 + C (C (map W f).toAffine.a₁ * X + C (map W f).toAffine.a₃) * Y -
      C (X ^ 3 + C (map W f).toAffine.a₂ * X ^ 2 + C (map W f).toAffine.a₄ * X + C (map W f).toAffine.a₆) =
    Polynomial.map (mapRingHom f)
      (Y ^ 2 + C (C W.a₁ * X + C W.a₃) * Y - C (X ^ 3 + C W.a₂ * X ^ 2 + C W.a₄ * X + C W.a₆))
tactic: simp only [polynomial]
state_before: R : Type u
inst✝¹ : CommRing R
W : Affine R
S : Type v
inst✝ : CommRing S
f : R →+* S
⊢ Y ^ 2 + C (C (map W f).toAffine.a₁ * X + C (map W f).toAffine.a₃) * Y -
      C (X ^ 3 + C (map W f).toAffine.a₂ * X ^ 2 + C (map W f).toAffine.a₄ * X + C (map W f).toAffine.a₆) =
    Polynomial.map (mapRingHom f)
      (Y ^ 2 + C (C W.a₁ * X + C W.a₃) * Y - C (X ^ 3 + C W.a₂ * X ^ 2 + C W.a₄ * X + C W.a₆))
state_after: no goals
tactic: map_simp
Theorem: Finset.inf_sdiff_right
File: Mathlib/Data/Finset/Lattice.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : BooleanAlgebra α
s : Finset ι
hs : s.Nonempty
f : ι → α
a : α
⊢ (s.inf fun b => f b \ a) = s.inf f \ a
state_after: no goals
tactic: induction hs using Finset.Nonempty.cons_induction with
  | singleton => rw [inf_singleton, inf_singleton]
  | cons _ _ _ _ ih => rw [inf_cons, inf_cons, ih, inf_sdiff]
Theorem: Partrec.none
File: Mathlib/Computability/Partrec.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
n : ℕ
⊢ Part.none = (↑(decode n)).bind fun a => map encode ((fun x => Part.none) a)
state_after: no goals
tactic: cases decode (α := α) n <;> simp
Theorem: Real.cos_nonneg_of_mem_Icc
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

Proof steps:
state_before: x : ℝ
hx : x ∈ Icc (-(π / 2)) (π / 2)
⊢ 0 ≤ x + π / 2
state_after: no goals
tactic: linarith [hx.1]
state_before: x : ℝ
hx : x ∈ Icc (-(π / 2)) (π / 2)
⊢ x + π / 2 ≤ π
state_after: no goals
tactic: linarith [hx.2]
Theorem: Set.indicator_zero
File: Mathlib/Algebra/Group/Indicator.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝¹ : One M
inst✝ : One N
s✝ t : Set α
f g : α → M
a : α
s : Set α
⊢ Disjoint (mulSupport fun x => 1) s
state_after: no goals
tactic: simp only [mulSupport_one, empty_disjoint]
Theorem: MeasureTheory.tilted_apply'
File: Mathlib/MeasureTheory/Measure/Tilted.lean

Proof steps:
state_before: α : Type u_1
mα : MeasurableSpace α
μ✝ : Measure α
f✝ : α → ℝ
μ : Measure α
f : α → ℝ
s : Set α
hs : MeasurableSet s
⊢ (μ.tilted f) s = ∫⁻ (a : α) in s, ENNReal.ofReal (rexp (f a) / ∫ (x : α), rexp (f x) ∂μ) ∂μ
state_after: no goals
tactic: rw [Measure.tilted, withDensity_apply _ hs]
Theorem: Int.fract_add_int
File: Mathlib/Algebra/Order/Floor.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a : α
m : ℤ
⊢ fract (a + ↑m) = fract a
state_after: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a : α
m : ℤ
⊢ a + ↑m - ↑⌊a + ↑m⌋ = fract a
tactic: rw [fract]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a : α
m : ℤ
⊢ a + ↑m - ↑⌊a + ↑m⌋ = fract a
state_after: no goals
tactic: simp
Theorem: CategoryTheory.Limits.Types.coequalizer_preimage_image_eq_of_preimage_eq
File: Mathlib/CategoryTheory/Limits/Shapes/Types.lean

Proof steps:
state_before: X Y Z : Type u
f g : X ⟶ Y
π : Y ⟶ Z
e : f ≫ π = g ≫ π
h : IsColimit (Cofork.ofπ π e)
U : Set Y
H : f ⁻¹' U = g ⁻¹' U
⊢ π ⁻¹' (π '' U) = U
state_after: X Y Z : Type u
f g : X ⟶ Y
π : Y ⟶ Z
e : f ≫ π = g ≫ π
h : IsColimit (Cofork.ofπ π e)
U : Set Y
H : f ⁻¹' U = g ⁻¹' U
lem : ∀ (x y : Y), CoequalizerRel f g x y → (x ∈ U ↔ y ∈ U)
⊢ π ⁻¹' (π '' U) = U
tactic: have lem : ∀ x y, CoequalizerRel f g x y → (x ∈ U ↔ y ∈ U) := by
    rintro _ _ ⟨x⟩
    change x ∈ f ⁻¹' U ↔ x ∈ g ⁻¹' U
    rw [H]
state_before: X Y Z : Type u
f g : X ⟶ Y
π : Y ⟶ Z
e : f ≫ π = g ≫ π
h : IsColimit (Cofork.ofπ π e)
U : Set Y
H : f ⁻¹' U = g ⁻¹' U
lem : ∀ (x y : Y), CoequalizerRel f g x y → (x ∈ U ↔ y ∈ U)
⊢ π ⁻¹' (π '' U) = U
state_after: X Y Z : Type u
f g : X ⟶ Y
π : Y ⟶ Z
e : f ≫ π = g ≫ π
h : IsColimit (Cofork.ofπ π e)
U : Set Y
H : f ⁻¹' U = g ⁻¹' U
lem : ∀ (x y : Y), CoequalizerRel f g x y → (x ∈ U ↔ y ∈ U)
eqv : _root_.Equivalence fun x y => x ∈ U ↔ y ∈ U
⊢ π ⁻¹' (π '' U) = U
tactic: have eqv : _root_.Equivalence fun x y => x ∈ U ↔ y ∈ U :=
    { refl := by tauto
      symm := by tauto
      trans := by tauto }
state_before: X Y Z : Type u
f g : X ⟶ Y
π : Y ⟶ Z
e : f ≫ π = g ≫ π
h : IsColimit (Cofork.ofπ π e)
U : Set Y
H : f ⁻¹' U = g ⁻¹' U
lem : ∀ (x y : Y), CoequalizerRel f g x y → (x ∈ U ↔ y ∈ U)
eqv : _root_.Equivalence fun x y => x ∈ U ↔ y ∈ U
⊢ π ⁻¹' (π '' U) = U
state_after: case h
X Y Z : Type u
f g : X ⟶ Y
π : Y ⟶ Z
e : f ≫ π = g ≫ π
h : IsColimit (Cofork.ofπ π e)
U : Set Y
H : f ⁻¹' U = g ⁻¹' U
lem : ∀ (x y : Y), CoequalizerRel f g x y → (x ∈ U ↔ y ∈ U)
eqv : _root_.Equivalence fun x y => x ∈ U ↔ y ∈ U
x✝ : Y
⊢ x✝ ∈ π ⁻¹' (π '' U) ↔ x✝ ∈ U
tactic: ext
state_before: case h
X Y Z : Type u
f g : X ⟶ Y
π : Y ⟶ Z
e : f ≫ π = g ≫ π
h : IsColimit (Cofork.ofπ π e)
U : Set Y
H : f ⁻¹' U = g ⁻¹' U
lem : ∀ (x y : Y), CoequalizerRel f g x y → (x ∈ U ↔ y ∈ U)
eqv : _root_.Equivalence fun x y => x ∈ U ↔ y ∈ U
x✝ : Y
⊢ x✝ ∈ π ⁻¹' (π '' U) ↔ x✝ ∈ U
state_after: case h.mp
X Y Z : Type u
f g : X ⟶ Y
π : Y ⟶ Z
e : f ≫ π = g ≫ π
h : IsColimit (Cofork.ofπ π e)
U : Set Y
H : f ⁻¹' U = g ⁻¹' U
lem : ∀ (x y : Y), CoequalizerRel f g x y → (x ∈ U ↔ y ∈ U)
eqv : _root_.Equivalence fun x y => x ∈ U ↔ y ∈ U
x✝ : Y
⊢ x✝ ∈ π ⁻¹' (π '' U) → x✝ ∈ U

case h.mpr
X Y Z : Type u
f g : X ⟶ Y
π : Y ⟶ Z
e : f ≫ π = g ≫ π
h : IsColimit (Cofork.ofπ π e)
U : Set Y
H : f ⁻¹' U = g ⁻¹' U
lem : ∀ (x y : Y), CoequalizerRel f g x y → (x ∈ U ↔ y ∈ U)
eqv : _root_.Equivalence fun x y => x ∈ U ↔ y ∈ U
x✝ : Y
⊢ x✝ ∈ U → x✝ ∈ π ⁻¹' (π '' U)
tactic: constructor
Theorem: CategoryTheory.coalgebraToOver_map
File: Mathlib/CategoryTheory/Monad/Products.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X : C
inst✝ : HasBinaryProducts C
X✝ Y✝ : (prodComonad X).Coalgebra
f : X✝ ⟶ Y✝
⊢ f.f ≫ ((fun A => Over.mk (A.a ≫ prod.fst)) Y✝).hom = ((fun A => Over.mk (A.a ≫ prod.fst)) X✝).hom
state_after: C : Type u
inst✝¹ : Category.{v, u} C
X : C
inst✝ : HasBinaryProducts C
X✝ Y✝ : (prodComonad X).Coalgebra
f : X✝ ⟶ Y✝
⊢ X✝.a ≫ (prodComonad X).map f.f ≫ prod.fst = ((fun A => Over.mk (A.a ≫ prod.fst)) X✝).hom
tactic: rw [Over.mk_hom, ← f.h_assoc]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X : C
inst✝ : HasBinaryProducts C
X✝ Y✝ : (prodComonad X).Coalgebra
f : X✝ ⟶ Y✝
⊢ X✝.a ≫ (prodComonad X).map f.f ≫ prod.fst = ((fun A => Over.mk (A.a ≫ prod.fst)) X✝).hom
state_after: C : Type u
inst✝¹ : Category.{v, u} C
X : C
inst✝ : HasBinaryProducts C
X✝ Y✝ : (prodComonad X).Coalgebra
f : X✝ ⟶ Y✝
⊢ X✝.a ≫ prod.map (𝟙 X) f.f ≫ prod.fst = X✝.a ≫ prod.fst
tactic: dsimp
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X : C
inst✝ : HasBinaryProducts C
X✝ Y✝ : (prodComonad X).Coalgebra
f : X✝ ⟶ Y✝
⊢ X✝.a ≫ prod.map (𝟙 X) f.f ≫ prod.fst = X✝.a ≫ prod.fst
state_after: no goals
tactic: simp
Theorem: FinBddDistLat.Iso.mk_hom_toLatticeHom_toSupHom_toFun
File: Mathlib/Order/Category/FinBddDistLat.lean

Proof steps:
state_before: α β : FinBddDistLat
e : ↑α.toBddDistLat.toDistLat ≃o ↑β.toBddDistLat.toDistLat
⊢ ((let __src := { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ };
      { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯, map_top' := ⋯, map_bot' := ⋯ }) ≫
      let __src := { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯ };
      { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯, map_top' := ⋯, map_bot' := ⋯ }) =
    𝟙 α
state_after: case w
α β : FinBddDistLat
e : ↑α.toBddDistLat.toDistLat ≃o ↑β.toBddDistLat.toDistLat
x✝ : (forget FinBddDistLat).obj α
⊢ ((let __src := { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ };
        { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯, map_top' := ⋯, map_bot' := ⋯ }) ≫
        let __src := { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯ };
        { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯, map_top' := ⋯, map_bot' := ⋯ })
      x✝ =
    (𝟙 α) x✝
tactic: ext
state_before: case w
α β : FinBddDistLat
e : ↑α.toBddDistLat.toDistLat ≃o ↑β.toBddDistLat.toDistLat
x✝ : (forget FinBddDistLat).obj α
⊢ ((let __src := { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ };
        { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯, map_top' := ⋯, map_bot' := ⋯ }) ≫
        let __src := { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯ };
        { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯, map_top' := ⋯, map_bot' := ⋯ })
      x✝ =
    (𝟙 α) x✝
state_after: no goals
tactic: exact e.symm_apply_apply _
state_before: α β : FinBddDistLat
e : ↑α.toBddDistLat.toDistLat ≃o ↑β.toBddDistLat.toDistLat
⊢ ((let __src := { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯ };
      { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯, map_top' := ⋯, map_bot' := ⋯ }) ≫
      let __src := { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ };
      { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯, map_top' := ⋯, map_bot' := ⋯ }) =
    𝟙 β
state_after: case w
α β : FinBddDistLat
e : ↑α.toBddDistLat.toDistLat ≃o ↑β.toBddDistLat.toDistLat
x✝ : (forget FinBddDistLat).obj β
⊢ ((let __src := { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯ };
        { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯, map_top' := ⋯, map_bot' := ⋯ }) ≫
        let __src := { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ };
        { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯, map_top' := ⋯, map_bot' := ⋯ })
      x✝ =
    (𝟙 β) x✝
tactic: ext
state_before: case w
α β : FinBddDistLat
e : ↑α.toBddDistLat.toDistLat ≃o ↑β.toBddDistLat.toDistLat
x✝ : (forget FinBddDistLat).obj β
⊢ ((let __src := { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯ };
        { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯, map_top' := ⋯, map_bot' := ⋯ }) ≫
        let __src := { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ };
        { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯, map_top' := ⋯, map_bot' := ⋯ })
      x✝ =
    (𝟙 β) x✝
state_after: no goals
tactic: exact e.apply_symm_apply _
Theorem: Int.le_iff_eq_or_lt
File: Mathlib/Data/Int/Defs.lean

Proof steps:
state_before: a✝ b✝ c✝ d m n a b c : ℤ
⊢ a ≤ b ↔ a = b ∨ a < b
state_after: a✝ b✝ c✝ d m n a b c : ℤ
⊢ a ≤ b ↔ a ≤ b ∧ (b ≤ a ∨ ¬b ≤ a)
tactic: rw [Int.le_antisymm_iff, Int.lt_iff_le_not_le, ← and_or_left]
state_before: a✝ b✝ c✝ d m n a b c : ℤ
⊢ a ≤ b ↔ a ≤ b ∧ (b ≤ a ∨ ¬b ≤ a)
state_after: no goals
tactic: simp [em]