ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Prod.eq_iff_fst_eq_snd_eq
File: Mathlib/Data/Prod/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
p₁ : α
p₂ : β
q₁ : α
q₂ : β
⊢ (p₁, p₂) = (q₁, q₂) ↔ (p₁, p₂).fst = (q₁, q₂).fst ∧ (p₁, p₂).snd = (q₁, q₂).snd
state_after: no goals
tactic: simp
Theorem: eq_div_iff_mul_eq''
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✝ : CommGroup G
a b c d : G
⊢ a = b / c ↔ c * a = b
state_after: no goals
tactic: rw [eq_div_iff_mul_eq', mul_comm]
Theorem: Mathlib.Tactic.ComputeDegree.coeff_add_of_eq
File: Mathlib/Tactic/ComputeDegree.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
n : ℕ
a b : R
f g : R[X]
h_add_left : f.coeff n = a
h_add_right : g.coeff n = b
⊢ (f + g).coeff n = a + b
state_after: R : Type u_1
inst✝ : Semiring R
n : ℕ
f g : R[X]
⊢ (f + g).coeff n = f.coeff n + g.coeff n
tactic: subst ‹_› ‹_›
state_before: R : Type u_1
inst✝ : Semiring R
n : ℕ
f g : R[X]
⊢ (f + g).coeff n = f.coeff n + g.coeff n
state_after: no goals
tactic: apply coeff_add
Theorem: CategoryTheory.ChosenFiniteProducts.whiskerRight_snd
File: Mathlib/CategoryTheory/ChosenFiniteProducts.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ChosenFiniteProducts C
X₁ X₂ : C
f : X₁ ⟶ X₂
Y : C
⊢ snd X₁ Y ≫ 𝟙 Y = snd X₁ Y
state_after: no goals
tactic: simp
Theorem: NormedRing.inverse_add_norm_diff_first_order
File: Mathlib/Analysis/Normed/Ring/Units.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
x : Rˣ
⊢ (fun t => inverse (↑x + t) - ↑x⁻¹) =O[𝓝 0] fun t => ‖t‖
state_after: no goals
tactic: simpa using inverse_add_norm_diff_nth_order x 1
Theorem: Complex.mem_slitPlane_of_norm_lt_one
File: Mathlib/Analysis/Complex/Basic.lean

Proof steps:
state_before: z : ℂ
hz : ‖z‖ < 1
⊢ 1 + z ∈ Metric.ball 1 1
state_after: no goals
tactic: simpa
Theorem: Multiset.toFinset_add
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ t✝ s t : Multiset α
⊢ ∀ (a : α), a ∈ (s + t).toFinset ↔ a ∈ s.toFinset ∪ t.toFinset
state_after: no goals
tactic: simp
Theorem: aemeasurable_restrict_iff_comap_subtype
File: Mathlib/MeasureTheory/Measure/AEMeasurable.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
R : Type u_6
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
f✝ g : α → β
μ✝ ν : Measure α
s : Set α
hs : MeasurableSet s
μ : Measure α
f : α → β
⊢ AEMeasurable f (μ.restrict s) ↔ AEMeasurable (f ∘ Subtype.val) (Measure.comap Subtype.val μ)
state_after: no goals
tactic: rw [← map_comap_subtype_coe hs, (MeasurableEmbedding.subtype_coe hs).aemeasurable_map_iff]
Theorem: Finset.truncatedSup_singleton
File: Mathlib/Combinatorics/SetFamily/AhlswedeZhang.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : SemilatticeSup α
inst✝⁴ : OrderTop α
inst✝³ : DecidableRel fun x x_1 => x ≤ x_1
inst✝² : SemilatticeSup β
inst✝¹ : BoundedOrder β
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s t : Finset α
a✝ b✝ b a : α
⊢ {b}.truncatedSup a = if a ≤ b then b else ⊤
state_after: α : Type u_1
β : Type u_2
inst✝⁵ : SemilatticeSup α
inst✝⁴ : OrderTop α
inst✝³ : DecidableRel fun x x_1 => x ≤ x_1
inst✝² : SemilatticeSup β
inst✝¹ : BoundedOrder β
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s t : Finset α
a✝ b✝ b a : α
⊢ (if h : a ≤ b then (filter (fun b => a ≤ b) {b}).sup' ⋯ fun x => x else ⊤) = if a ≤ b then b else ⊤
tactic: simp [truncatedSup]
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : SemilatticeSup α
inst✝⁴ : OrderTop α
inst✝³ : DecidableRel fun x x_1 => x ≤ x_1
inst✝² : SemilatticeSup β
inst✝¹ : BoundedOrder β
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s t : Finset α
a✝ b✝ b a : α
⊢ (if h : a ≤ b then (filter (fun b => a ≤ b) {b}).sup' ⋯ fun x => x else ⊤) = if a ≤ b then b else ⊤
state_after: no goals
tactic: split_ifs <;> simp [Finset.filter_true_of_mem, *]
Theorem: Set.enumerate_eq_none
File: Mathlib/Data/Set/Enumerate.lean

Proof steps:
state_before: α : Type u_1
sel : Set α → Option α
s : Set α
n m : ℕ
h : enumerate sel s (n + 1) = none
hm : n + 1 ≤ m
⊢ enumerate sel s m = none
state_after: case none
α : Type u_1
sel : Set α → Option α
s : Set α
n m : ℕ
h : enumerate sel s (n + 1) = none
hm : n + 1 ≤ m
hs : sel s = none
⊢ enumerate sel s m = none

case some
α : Type u_1
sel : Set α → Option α
s : Set α
n m : ℕ
h : enumerate sel s (n + 1) = none
hm : n + 1 ≤ m
val✝ : α
hs : sel s = some val✝
⊢ enumerate sel s m = none
tactic: cases hs : sel s
Theorem: continuousOn_iff'
File: Mathlib/Topology/ContinuousOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝³ : (i : ι) → TopologicalSpace (π i)
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
this : ∀ (t : Set β), IsOpen (s.restrict f ⁻¹' t) ↔ ∃ u, IsOpen u ∧ f ⁻¹' t ∩ s = u ∩ s
⊢ ContinuousOn f s ↔ ∀ (t : Set β), IsOpen t → ∃ u, IsOpen u ∧ f ⁻¹' t ∩ s = u ∩ s
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝³ : (i : ι) → TopologicalSpace (π i)
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
this : ∀ (t : Set β), IsOpen (s.restrict f ⁻¹' t) ↔ ∃ u, IsOpen u ∧ f ⁻¹' t ∩ s = u ∩ s
⊢ (∀ (s_1 : Set β), IsOpen s_1 → IsOpen (s.restrict f ⁻¹' s_1)) ↔
    ∀ (t : Set β), IsOpen t → ∃ u, IsOpen u ∧ f ⁻¹' t ∩ s = u ∩ s
tactic: rw [continuousOn_iff_continuous_restrict, continuous_def]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝³ : (i : ι) → TopologicalSpace (π i)
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
this : ∀ (t : Set β), IsOpen (s.restrict f ⁻¹' t) ↔ ∃ u, IsOpen u ∧ f ⁻¹' t ∩ s = u ∩ s
⊢ (∀ (s_1 : Set β), IsOpen s_1 → IsOpen (s.restrict f ⁻¹' s_1)) ↔
    ∀ (t : Set β), IsOpen t → ∃ u, IsOpen u ∧ f ⁻¹' t ∩ s = u ∩ s
state_after: no goals
tactic: simp only [this]
Theorem: Set.Infinite.exists_subset_ncard_eq
File: Mathlib/Data/Set/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s✝ t : Set α
f : α → β
s : Set α
hs : s.Infinite
k : ℕ
⊢ ∃ t ⊆ s, t.Finite ∧ t.ncard = k
state_after: α : Type u_1
β : Type u_2
s✝ t : Set α
f : α → β
s : Set α
hs : s.Infinite
k : ℕ
this : Infinite ↑s
⊢ ∃ t ⊆ s, t.Finite ∧ t.ncard = k
tactic: have := hs.to_subtype
state_before: α : Type u_1
β : Type u_2
s✝ t : Set α
f : α → β
s : Set α
hs : s.Infinite
k : ℕ
this : Infinite ↑s
⊢ ∃ t ⊆ s, t.Finite ∧ t.ncard = k
state_after: case intro.intro
α : Type u_1
β : Type u_2
s✝ t : Set α
f : α → β
s : Set α
hs : s.Infinite
this : Infinite ↑s
t' : Finset ↑s
⊢ ∃ t ⊆ s, t.Finite ∧ t.ncard = t'.card
tactic: obtain ⟨t', -, rfl⟩ := @Infinite.exists_subset_card_eq s univ infinite_univ k
state_before: case intro.intro
α : Type u_1
β : Type u_2
s✝ t : Set α
f : α → β
s : Set α
hs : s.Infinite
this : Infinite ↑s
t' : Finset ↑s
⊢ ∃ t ⊆ s, t.Finite ∧ t.ncard = t'.card
state_after: case intro.intro
α : Type u_1
β : Type u_2
s✝ t : Set α
f : α → β
s : Set α
hs : s.Infinite
this : Infinite ↑s
t' : Finset ↑s
⊢ (Subtype.val '' ↑t').ncard = t'.card
tactic: refine ⟨Subtype.val '' (t' : Set s), by simp, Finite.image _ (by simp), ?_⟩
state_before: case intro.intro
α : Type u_1
β : Type u_2
s✝ t : Set α
f : α → β
s : Set α
hs : s.Infinite
this : Infinite ↑s
t' : Finset ↑s
⊢ (Subtype.val '' ↑t').ncard = t'.card
state_after: case intro.intro
α : Type u_1
β : Type u_2
s✝ t : Set α
f : α → β
s : Set α
hs : s.Infinite
this : Infinite ↑s
t' : Finset ↑s
⊢ (↑t').ncard = t'.card
tactic: rw [ncard_image_of_injective _ Subtype.coe_injective]
state_before: case intro.intro
α : Type u_1
β : Type u_2
s✝ t : Set α
f : α → β
s : Set α
hs : s.Infinite
this : Infinite ↑s
t' : Finset ↑s
⊢ (↑t').ncard = t'.card
state_after: no goals
tactic: simp
Theorem: Nat.leRec_trans
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m✝ n✝ k✝ : ℕ
p q : ℕ → Prop
n m k : ℕ
motive : (m : ℕ) → n ≤ m → Sort u_1
refl : motive n ⋯
le_succ_of_le : ⦃k : ℕ⦄ → (h : n ≤ k) → motive k h → motive (k + 1) ⋯
hnm : n ≤ m
hmk : m ≤ k
⊢ leRec refl le_succ_of_le ⋯ = leRec (leRec refl (fun x h => le_succ_of_le h) hnm) (fun x h => le_succ_of_le ⋯) hmk
state_after: no goals
tactic: induction hmk with
  | refl => rw [leRec_self]
  | step hmk ih => rw [leRec_succ _ _ (Nat.le_trans hnm hmk), ih, leRec_succ]
Theorem: image_extremePoints
File: Mathlib/Analysis/Convex/Extreme.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
ι : Type u_4
π : ι → Type u_5
L : Type u_6
inst✝⁶ : OrderedRing 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : AddCommGroup F
inst✝² : Module 𝕜 F
inst✝¹ : EquivLike L E F
inst✝ : LinearEquivClass L 𝕜 E F
f : L
s : Set E
⊢ ⇑f '' extremePoints 𝕜 s = extremePoints 𝕜 (⇑f '' s)
state_after: case h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
ι : Type u_4
π : ι → Type u_5
L : Type u_6
inst✝⁶ : OrderedRing 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : AddCommGroup F
inst✝² : Module 𝕜 F
inst✝¹ : EquivLike L E F
inst✝ : LinearEquivClass L 𝕜 E F
f : L
s : Set E
b : F
⊢ b ∈ ⇑f '' extremePoints 𝕜 s ↔ b ∈ extremePoints 𝕜 (⇑f '' s)
tactic: ext b
state_before: case h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
ι : Type u_4
π : ι → Type u_5
L : Type u_6
inst✝⁶ : OrderedRing 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : AddCommGroup F
inst✝² : Module 𝕜 F
inst✝¹ : EquivLike L E F
inst✝ : LinearEquivClass L 𝕜 E F
f : L
s : Set E
b : F
⊢ b ∈ ⇑f '' extremePoints 𝕜 s ↔ b ∈ extremePoints 𝕜 (⇑f '' s)
state_after: case h.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
ι : Type u_4
π : ι → Type u_5
L : Type u_6
inst✝⁶ : OrderedRing 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : AddCommGroup F
inst✝² : Module 𝕜 F
inst✝¹ : EquivLike L E F
inst✝ : LinearEquivClass L 𝕜 E F
f : L
s : Set E
a : E
⊢ f a ∈ ⇑f '' extremePoints 𝕜 s ↔ f a ∈ extremePoints 𝕜 (⇑f '' s)
tactic: obtain ⟨a, rfl⟩ := EquivLike.surjective f b
state_before: case h.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
ι : Type u_4
π : ι → Type u_5
L : Type u_6
inst✝⁶ : OrderedRing 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : AddCommGroup F
inst✝² : Module 𝕜 F
inst✝¹ : EquivLike L E F
inst✝ : LinearEquivClass L 𝕜 E F
f : L
s : Set E
a : E
⊢ f a ∈ ⇑f '' extremePoints 𝕜 s ↔ f a ∈ extremePoints 𝕜 (⇑f '' s)
state_after: case h.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
ι : Type u_4
π : ι → Type u_5
L : Type u_6
inst✝⁶ : OrderedRing 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : AddCommGroup F
inst✝² : Module 𝕜 F
inst✝¹ : EquivLike L E F
inst✝ : LinearEquivClass L 𝕜 E F
f : L
s : Set E
a : E
this : ∀ (x y : E), ⇑f '' openSegment 𝕜 x y = openSegment 𝕜 (f x) (f y)
⊢ f a ∈ ⇑f '' extremePoints 𝕜 s ↔ f a ∈ extremePoints 𝕜 (⇑f '' s)
tactic: have : ∀ x y, f '' openSegment 𝕜 x y = openSegment 𝕜 (f x) (f y) :=
    image_openSegment _ (LinearMapClass.linearMap f).toAffineMap
state_before: case h.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
ι : Type u_4
π : ι → Type u_5
L : Type u_6
inst✝⁶ : OrderedRing 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : AddCommGroup F
inst✝² : Module 𝕜 F
inst✝¹ : EquivLike L E F
inst✝ : LinearEquivClass L 𝕜 E F
f : L
s : Set E
a : E
this : ∀ (x y : E), ⇑f '' openSegment 𝕜 x y = openSegment 𝕜 (f x) (f y)
⊢ f a ∈ ⇑f '' extremePoints 𝕜 s ↔ f a ∈ extremePoints 𝕜 (⇑f '' s)
state_after: no goals
tactic: simp only [mem_extremePoints, (EquivLike.surjective f).forall,
    (EquivLike.injective f).mem_set_image, (EquivLike.injective f).eq_iff, ← this]
Theorem: EMetric.continuous_infEdist
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x y : α
s t : Set α
Φ : α → β
⊢ 1 ≠ ⊤
state_after: no goals
tactic: simp
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x y : α
s t : Set α
Φ : α → β
⊢ ∀ (x y : α), infEdist x s ≤ infEdist y s + 1 * edist x y
state_after: no goals
tactic: simp only [one_mul, infEdist_le_infEdist_add_edist, forall₂_true_iff]
Theorem: WeierstrassCurve.Jacobian.map_polynomialZ
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

Proof steps:
state_before: R : Type u
inst✝² : CommRing R
W' : Jacobian R
F : Type v
inst✝¹ : Field F
W : Jacobian F
S : Type u_1
inst✝ : CommRing S
f : R →+* S
P Q : Fin 3 → R
⊢ (map W' f).toJacobian.polynomialZ = (MvPolynomial.map f) W'.polynomialZ
state_after: no goals
tactic: simp [polynomialZ, map_polynomial, pderiv_map]
Theorem: Matrix.diagonal_map
File: Mathlib/Data/Matrix/Basic.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : DecidableEq n
inst✝¹ : Zero α
inst✝ : Zero β
f : α → β
h : f 0 = 0
d : n → α
⊢ (diagonal d).map f = diagonal fun m => f (d m)
state_after: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : DecidableEq n
inst✝¹ : Zero α
inst✝ : Zero β
f : α → β
h : f 0 = 0
d : n → α
i✝ j✝ : n
⊢ (diagonal d).map f i✝ j✝ = diagonal (fun m => f (d 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
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : DecidableEq n
inst✝¹ : Zero α
inst✝ : Zero β
f : α → β
h : f 0 = 0
d : n → α
i✝ j✝ : n
⊢ (diagonal d).map f i✝ j✝ = diagonal (fun m => f (d m)) i✝ j✝
state_after: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : DecidableEq n
inst✝¹ : Zero α
inst✝ : Zero β
f : α → β
h : f 0 = 0
d : n → α
i✝ j✝ : n
⊢ f (if i✝ = j✝ then d i✝ else 0) = if i✝ = j✝ then f (d i✝) else 0
tactic: simp only [diagonal_apply, map_apply]
state_before: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : DecidableEq n
inst✝¹ : Zero α
inst✝ : Zero β
f : α → β
h : f 0 = 0
d : n → α
i✝ j✝ : n
⊢ f (if i✝ = j✝ then d i✝ else 0) = if i✝ = j✝ then f (d i✝) else 0
state_after: no goals
tactic: split_ifs <;> simp [h]
Theorem: Cardinal.mul_lt_aleph0_iff_of_ne_zero
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α β : Type u
a b : Cardinal.{u_1}
ha : a ≠ 0
hb : b ≠ 0
⊢ a * b < ℵ₀ ↔ a < ℵ₀ ∧ b < ℵ₀
state_after: no goals
tactic: simp [mul_lt_aleph0_iff, ha, hb]
Theorem: AlgebraicGeometry.IsClosedImmersion.of_surjective_of_isAffine
File: Mathlib/AlgebraicGeometry/Morphisms/ClosedImmersion.lean

Proof steps:
state_before: X Y : Scheme
inst✝¹ : IsAffine X
inst✝ : IsAffine Y
f : X ⟶ Y
h : Function.Surjective ⇑(Scheme.Γ.map f.op)
⊢ IsClosedImmersion f
state_after: X Y : Scheme
inst✝¹ : IsAffine X
inst✝ : IsAffine Y
f : X ⟶ Y
h : Function.Surjective ⇑(Scheme.Γ.map f.op)
⊢ IsClosedImmersion (Spec.map (Scheme.Γ.map f.op))
tactic: rw [MorphismProperty.arrow_mk_iso_iff @IsClosedImmersion (arrowIsoSpecΓOfIsAffine f)]
state_before: X Y : Scheme
inst✝¹ : IsAffine X
inst✝ : IsAffine Y
f : X ⟶ Y
h : Function.Surjective ⇑(Scheme.Γ.map f.op)
⊢ IsClosedImmersion (Spec.map (Scheme.Γ.map f.op))
state_after: case h
X Y : Scheme
inst✝¹ : IsAffine X
inst✝ : IsAffine Y
f : X ⟶ Y
h : Function.Surjective ⇑(Scheme.Γ.map f.op)
⊢ Function.Surjective ⇑(Scheme.Γ.map f.op)
tactic: apply spec_of_surjective
state_before: case h
X Y : Scheme
inst✝¹ : IsAffine X
inst✝ : IsAffine Y
f : X ⟶ Y
h : Function.Surjective ⇑(Scheme.Γ.map f.op)
⊢ Function.Surjective ⇑(Scheme.Γ.map f.op)
state_after: no goals
tactic: exact h
Theorem: CategoryTheory.ShortComplex.LeftHomologyData.ofIsLimitKernelFork_i
File: Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.25254, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.LeftHomologyData
A : C
hf : S.f = 0
c : KernelFork S.g
hc : IsLimit c
⊢ ((hc.ofIsoLimit (Fork.ext (Iso.refl c.pt) ⋯)).lift (KernelFork.ofι S.f ⋯) ≫ 𝟙 c.pt) ≫ Fork.ι c = 0 ≫ Fork.ι c
state_after: C : Type u_1
inst✝¹ : Category.{?u.25254, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.LeftHomologyData
A : C
hf : S.f = 0
c : KernelFork S.g
hc : IsLimit c
⊢ ((hc.lift (KernelFork.ofι S.f ⋯) ≫ 𝟙 c.pt) ≫ 𝟙 c.pt) ≫ Fork.ι c = 0 ≫ Fork.ι c
tactic: dsimp
state_before: C : Type u_1
inst✝¹ : Category.{?u.25254, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.LeftHomologyData
A : C
hf : S.f = 0
c : KernelFork S.g
hc : IsLimit c
⊢ ((hc.lift (KernelFork.ofι S.f ⋯) ≫ 𝟙 c.pt) ≫ 𝟙 c.pt) ≫ Fork.ι c = 0 ≫ Fork.ι c
state_after: no goals
tactic: simp only [comp_id, zero_comp, Fork.IsLimit.lift_ι, Fork.ι_ofι, hf]
state_before: C : Type u_1
inst✝¹ : Category.{?u.25254, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.LeftHomologyData
A : C
hf : S.f = 0
c : KernelFork S.g
hc : IsLimit c
⊢ (hc.ofIsoLimit (Fork.ext (Iso.refl c.pt) ⋯)).lift (KernelFork.ofι S.f ⋯) ≫ Fork.ι c = 0 ≫ Fork.ι c
state_after: C : Type u_1
inst✝¹ : Category.{?u.25254, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.LeftHomologyData
A : C
hf : S.f = 0
c : KernelFork S.g
hc : IsLimit c
⊢ (hc.lift (KernelFork.ofι S.f ⋯) ≫ 𝟙 c.pt) ≫ Fork.ι c = 0 ≫ Fork.ι c
tactic: dsimp
state_before: C : Type u_1
inst✝¹ : Category.{?u.25254, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.LeftHomologyData
A : C
hf : S.f = 0
c : KernelFork S.g
hc : IsLimit c
⊢ (hc.lift (KernelFork.ofι S.f ⋯) ≫ 𝟙 c.pt) ≫ Fork.ι c = 0 ≫ Fork.ι c
state_after: no goals
tactic: simp only [comp_id, zero_comp, Fork.IsLimit.lift_ι, Fork.ι_ofι, hf]
Theorem: IsLowerSet.sdiff_of_isUpperSet
File: Mathlib/Order/UpperLower/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : LE α
inst✝ : LE β
s t : Set α
a : α
hs : IsLowerSet s
ht : IsUpperSet t
⊢ ∀ b ∈ s, ∀ c ∈ t, c ≤ b → b ∈ t
state_after: no goals
tactic: aesop
Theorem: IsCyclotomicExtension.singleton_one
File: Mathlib/NumberTheory/Cyclotomic/Basic.lean

Proof steps:
state_before: n : ℕ+
S T : Set ℕ+
A : Type u
B : Type v
K : Type w
L : Type z
inst✝⁵ : CommRing A
inst✝⁴ : CommRing B
inst✝³ : Algebra A B
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Algebra K L
h : IsCyclotomicExtension {1} A B
x : B
⊢ x ∈ ⊥
state_after: no goals
tactic: simpa [adjoin_singleton_one] using ((isCyclotomicExtension_iff _ _ _).1 h).2 x
Theorem: List.isPerm_iff
File: .lake/packages/batteries/Batteries/Data/List/Perm.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
⊢ [].isPerm [] = true ↔ [] ~ []
state_after: no goals
tactic: simp [isPerm, isEmpty]
state_before: α : Type u_1
inst✝ : DecidableEq α
head✝ : α
tail✝ : List α
⊢ [].isPerm (head✝ :: tail✝) = true ↔ [] ~ head✝ :: tail✝
state_after: no goals
tactic: simp [isPerm, isEmpty, Perm.nil_eq]
state_before: α : Type u_1
inst✝ : DecidableEq α
a : α
l₁ l₂ : List α
⊢ (a :: l₁).isPerm l₂ = true ↔ a :: l₁ ~ l₂
state_after: no goals
tactic: simp [isPerm, isPerm_iff, cons_perm_iff_perm_erase]
Theorem: Filter.principal_univ
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s t : Set α
⊢ ⊤ ≤ 𝓟 univ
state_after: no goals
tactic: simp only [le_principal_iff, mem_top, eq_self_iff_true]
Theorem: NonUnitalAlgHom.toAlgHom_zero
File: Mathlib/Algebra/Algebra/Unitization.lean

Proof steps:
state_before: S : Type u_1
R : Type u_2
A : Type u_3
inst✝¹² : CommSemiring S
inst✝¹¹ : CommSemiring R
inst✝¹⁰ : NonUnitalSemiring A
inst✝⁹ : Module R A
inst✝⁸ : SMulCommClass R A A
inst✝⁷ : IsScalarTower R A A
B : Type u_4
inst✝⁶ : Semiring B
inst✝⁵ : Algebra S B
inst✝⁴ : Algebra S R
inst✝³ : DistribMulAction S A
inst✝² : IsScalarTower S R A
C : Type u_5
inst✝¹ : Semiring C
inst✝ : Algebra R C
⊢ ⇑(NonUnitalAlgHom.toAlgHom 0) = fst
state_after: case h
S : Type u_1
R : Type u_2
A : Type u_3
inst✝¹² : CommSemiring S
inst✝¹¹ : CommSemiring R
inst✝¹⁰ : NonUnitalSemiring A
inst✝⁹ : Module R A
inst✝⁸ : SMulCommClass R A A
inst✝⁷ : IsScalarTower R A A
B : Type u_4
inst✝⁶ : Semiring B
inst✝⁵ : Algebra S B
inst✝⁴ : Algebra S R
inst✝³ : DistribMulAction S A
inst✝² : IsScalarTower S R A
C : Type u_5
inst✝¹ : Semiring C
inst✝ : Algebra R C
x✝ : Unitization R A
⊢ (NonUnitalAlgHom.toAlgHom 0) x✝ = x✝.fst
tactic: ext
state_before: case h
S : Type u_1
R : Type u_2
A : Type u_3
inst✝¹² : CommSemiring S
inst✝¹¹ : CommSemiring R
inst✝¹⁰ : NonUnitalSemiring A
inst✝⁹ : Module R A
inst✝⁸ : SMulCommClass R A A
inst✝⁷ : IsScalarTower R A A
B : Type u_4
inst✝⁶ : Semiring B
inst✝⁵ : Algebra S B
inst✝⁴ : Algebra S R
inst✝³ : DistribMulAction S A
inst✝² : IsScalarTower S R A
C : Type u_5
inst✝¹ : Semiring C
inst✝ : Algebra R C
x✝ : Unitization R A
⊢ (NonUnitalAlgHom.toAlgHom 0) x✝ = x✝.fst
state_after: no goals
tactic: simp
Theorem: Relation.reflTransGen_eq_reflGen
File: Mathlib/Logic/Relation.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
hr : Transitive r
⊢ ReflTransGen r = ReflGen r
state_after: no goals
tactic: rw [← reflGen_transGen, transGen_eq_self hr]
Theorem: Equiv.forall_congr'
File: Mathlib/Logic/Equiv/Defs.lean

Proof steps:
state_before: α : Sort u
β : Sort v
γ : Sort w
p : α → Prop
q : β → Prop
e : α ≃ β
h : ∀ (b : β), p (e.symm b) ↔ q b
⊢ (∀ (b : β), p (e.symm b)) ↔ ∀ (b : β), q b
state_after: no goals
tactic: simp [h]
Theorem: AddCon.orderIsoOp_symm_apply
File: Mathlib/GroupTheory/Congruence/Opposite.lean

Proof steps:
state_before: M : Type u_1
inst✝ : Mul M
c d : Con M
⊢ { toFun := op, invFun := unop, left_inv := ⋯, right_inv := ⋯ } c ≤
      { toFun := op, invFun := unop, left_inv := ⋯, right_inv := ⋯ } d ↔
    c ≤ d
state_after: M : Type u_1
inst✝ : Mul M
c d : Con M
⊢ (∀ {x y : Mᵐᵒᵖ},
      ({ toFun := op, invFun := unop, left_inv := ⋯, right_inv := ⋯ } c) x y →
        ({ toFun := op, invFun := unop, left_inv := ⋯, right_inv := ⋯ } d) x y) ↔
    ∀ {x y : M}, c x y → d x y
tactic: rw [le_def, le_def]
state_before: M : Type u_1
inst✝ : Mul M
c d : Con M
⊢ (∀ {x y : Mᵐᵒᵖ},
      ({ toFun := op, invFun := unop, left_inv := ⋯, right_inv := ⋯ } c) x y →
        ({ toFun := op, invFun := unop, left_inv := ⋯, right_inv := ⋯ } d) x y) ↔
    ∀ {x y : M}, c x y → d x y
state_after: no goals
tactic: constructor <;> intro h _ _ h' <;> exact h h'