ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: LieSubmodule.lie_coe_mem_lie
File: Mathlib/Algebra/Lie/IdealOperations.lean

Proof steps:
state_before: R : Type u
L : Type v
M : Type w
M₂ : Type w₁
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
N N' : LieSubmodule R L M
I J : LieIdeal R L
N₂ : LieSubmodule R L M₂
x : ↥I
m : ↥N
⊢ ⁅↑x, ↑m⁆ ∈ ⁅I, N⁆
state_after: R : Type u
L : Type v
M : Type w
M₂ : Type w₁
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
N N' : LieSubmodule R L M
I J : LieIdeal R L
N₂ : LieSubmodule R L M₂
x : ↥I
m : ↥N
⊢ ⁅↑x, ↑m⁆ ∈ lieSpan R L {m | ∃ x n, ⁅↑x, ↑n⁆ = m}
tactic: rw [lieIdeal_oper_eq_span]
state_before: R : Type u
L : Type v
M : Type w
M₂ : Type w₁
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
N N' : LieSubmodule R L M
I J : LieIdeal R L
N₂ : LieSubmodule R L M₂
x : ↥I
m : ↥N
⊢ ⁅↑x, ↑m⁆ ∈ lieSpan R L {m | ∃ x n, ⁅↑x, ↑n⁆ = m}
state_after: case a
R : Type u
L : Type v
M : Type w
M₂ : Type w₁
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
N N' : LieSubmodule R L M
I J : LieIdeal R L
N₂ : LieSubmodule R L M₂
x : ↥I
m : ↥N
⊢ ⁅↑x, ↑m⁆ ∈ {m | ∃ x n, ⁅↑x, ↑n⁆ = m}
tactic: apply subset_lieSpan
state_before: case a
R : Type u
L : Type v
M : Type w
M₂ : Type w₁
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
N N' : LieSubmodule R L M
I J : LieIdeal R L
N₂ : LieSubmodule R L M₂
x : ↥I
m : ↥N
⊢ ⁅↑x, ↑m⁆ ∈ {m | ∃ x n, ⁅↑x, ↑n⁆ = m}
state_after: no goals
tactic: use x, m
Theorem: Submodule.sup_orthogonal_of_completeSpace
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : _root_.RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : HasOrthogonalProjection K
⊢ K ⊔ Kᗮ = ⊤
state_after: case h.e'_2.h.e'_4
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : _root_.RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : HasOrthogonalProjection K
⊢ Kᗮ = Kᗮ ⊓ ⊤
tactic: convert Submodule.sup_orthogonal_inf_of_completeSpace (le_top : K ≤ ⊤) using 2
state_before: case h.e'_2.h.e'_4
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : _root_.RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : HasOrthogonalProjection K
⊢ Kᗮ = Kᗮ ⊓ ⊤
state_after: no goals
tactic: simp
Theorem: Basis.orientation_neg_single
File: Mathlib/LinearAlgebra/Orientation.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : LinearOrderedCommRing R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
ι : Type u_3
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
e : Basis ι R M
i : ι
⊢ (e.unitsSMul (Function.update 1 i (-1))).orientation = -e.orientation
state_after: R : Type u_1
inst✝⁴ : LinearOrderedCommRing R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
ι : Type u_3
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
e : Basis ι R M
i : ι
⊢ (-1 * ∏ x ∈ Finset.univ \ {i}, 1 x)⁻¹ • e.orientation = -e.orientation
tactic: rw [orientation_unitsSMul, Finset.prod_update_of_mem (Finset.mem_univ _)]
state_before: R : Type u_1
inst✝⁴ : LinearOrderedCommRing R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
ι : Type u_3
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
e : Basis ι R M
i : ι
⊢ (-1 * ∏ x ∈ Finset.univ \ {i}, 1 x)⁻¹ • e.orientation = -e.orientation
state_after: no goals
tactic: simp
Theorem: IsCoprime.of_mul_add_left_right
File: Mathlib/RingTheory/Coprime/Basic.lean

Proof steps:
state_before: R : Type u
inst✝ : CommSemiring R
x y z : R
h : IsCoprime x (x * z + y)
⊢ IsCoprime x y
state_after: R : Type u
inst✝ : CommSemiring R
x y z : R
h : IsCoprime x (y + x * z)
⊢ IsCoprime x y
tactic: rw [add_comm] at h
state_before: R : Type u
inst✝ : CommSemiring R
x y z : R
h : IsCoprime x (y + x * z)
⊢ IsCoprime x y
state_after: no goals
tactic: exact h.of_add_mul_left_right
Theorem: HurwitzZeta.hurwitzZetaOdd_eq
File: Mathlib/NumberTheory/LSeries/HurwitzZeta.lean

Proof steps:
state_before: a : UnitAddCircle
s : ℂ
⊢ hurwitzZetaOdd a s = (hurwitzZeta a s - hurwitzZeta (-a) s) / 2
state_after: a : UnitAddCircle
s : ℂ
⊢ hurwitzZetaOdd a s = (hurwitzZetaEven a s + hurwitzZetaOdd a s - (hurwitzZetaEven a s + -hurwitzZetaOdd a s)) / 2
tactic: simp only [hurwitzZeta, hurwitzZetaEven_neg, hurwitzZetaOdd_neg]
state_before: a : UnitAddCircle
s : ℂ
⊢ hurwitzZetaOdd a s = (hurwitzZetaEven a s + hurwitzZetaOdd a s - (hurwitzZetaEven a s + -hurwitzZetaOdd a s)) / 2
state_after: no goals
tactic: ring_nf
Theorem: LieEquiv.symm_symm
File: Mathlib/Algebra/Lie/Basic.lean

Proof steps:
state_before: R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieRing L₂
inst✝³ : LieRing L₃
inst✝² : LieAlgebra R L₁
inst✝¹ : LieAlgebra R L₂
inst✝ : LieAlgebra R L₃
e : L₁ ≃ₗ⁅R⁆ L₂
⊢ e.symm.symm = e
state_after: case h
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieRing L₂
inst✝³ : LieRing L₃
inst✝² : LieAlgebra R L₁
inst✝¹ : LieAlgebra R L₂
inst✝ : LieAlgebra R L₃
e : L₁ ≃ₗ⁅R⁆ L₂
x✝ : L₁
⊢ e.symm.symm x✝ = e x✝
tactic: ext
state_before: case h
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieRing L₂
inst✝³ : LieRing L₃
inst✝² : LieAlgebra R L₁
inst✝¹ : LieAlgebra R L₂
inst✝ : LieAlgebra R L₃
e : L₁ ≃ₗ⁅R⁆ L₂
x✝ : L₁
⊢ e.symm.symm x✝ = e x✝
state_after: no goals
tactic: rfl
Theorem: NNReal.coe_eq_one
File: Mathlib/Data/NNReal/Basic.lean

Proof steps:
state_before: r r₁ r₂ : ℝ≥0
x y : ℝ
⊢ ↑r = 1 ↔ r = 1
state_after: no goals
tactic: rw [← coe_one, coe_inj]
Theorem: Finset.card_div_mul_le_card_div_mul_card_mul
File: Mathlib/Combinatorics/Additive/PluenneckeRuzsa.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : CommGroup α
inst✝ : DecidableEq α
A✝ B✝ C✝ A B C : Finset α
⊢ (A / C).card * B.card ≤ (A / B).card * (B * C).card
state_after: α : Type u_1
inst✝¹ : CommGroup α
inst✝ : DecidableEq α
A✝ B✝ C✝ A B C : Finset α
⊢ (A * C⁻¹).card * B.card ≤ (A / B).card * (B / C⁻¹).card
tactic: rw [← div_inv_eq_mul, div_eq_mul_inv]
state_before: α : Type u_1
inst✝¹ : CommGroup α
inst✝ : DecidableEq α
A✝ B✝ C✝ A B C : Finset α
⊢ (A * C⁻¹).card * B.card ≤ (A / B).card * (B / C⁻¹).card
state_after: no goals
tactic: exact ruzsa_triangle_inequality_mul_div_div _ _ _
Theorem: CategoryTheory.ShortComplex.FunctorEquivalence.inverse_obj_X₃
File: Mathlib/Algebra/Homology/ShortComplex/FunctorEquivalence.lean

Proof steps:
state_before: J : Type u_1
C : Type u_2
inst✝² : Category.{?u.17393, u_1} J
inst✝¹ : Category.{?u.17397, u_2} C
inst✝ : HasZeroMorphisms C
F : J ⥤ ShortComplex C
⊢ whiskerLeft F π₁Toπ₂ ≫ whiskerLeft F π₂Toπ₃ = 0
state_after: no goals
tactic: aesop_cat
state_before: J : Type u_1
C : Type u_2
inst✝² : Category.{?u.17393, u_1} J
inst✝¹ : Category.{?u.17397, u_2} C
inst✝ : HasZeroMorphisms C
X✝ Y✝ : J ⥤ ShortComplex C
φ : X✝ ⟶ Y✝
⊢ whiskerRight φ π₁ ≫ ((fun F => mk (whiskerLeft F π₁Toπ₂) (whiskerLeft F π₂Toπ₃) ⋯) Y✝).f =
    ((fun F => mk (whiskerLeft F π₁Toπ₂) (whiskerLeft F π₂Toπ₃) ⋯) X✝).f ≫ whiskerRight φ π₂
state_after: no goals
tactic: aesop_cat
state_before: J : Type u_1
C : Type u_2
inst✝² : Category.{?u.17393, u_1} J
inst✝¹ : Category.{?u.17397, u_2} C
inst✝ : HasZeroMorphisms C
X✝ Y✝ : J ⥤ ShortComplex C
φ : X✝ ⟶ Y✝
⊢ whiskerRight φ π₂ ≫ ((fun F => mk (whiskerLeft F π₁Toπ₂) (whiskerLeft F π₂Toπ₃) ⋯) Y✝).g =
    ((fun F => mk (whiskerLeft F π₁Toπ₂) (whiskerLeft F π₂Toπ₃) ⋯) X✝).g ≫ whiskerRight φ π₃
state_after: no goals
tactic: aesop_cat
Theorem: AffineSubspace.direction_mk'
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.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
inst✝ : AffineSpace V P
p : P
direction : Submodule k V
⊢ (mk' p direction).direction = direction
state_after: case h
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p : P
direction : Submodule k V
v : V
⊢ v ∈ (mk' p direction).direction ↔ v ∈ direction
tactic: ext v
state_before: case h
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p : P
direction : Submodule k V
v : V
⊢ v ∈ (mk' p direction).direction ↔ v ∈ direction
state_after: case h
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p : P
direction : Submodule k V
v : V
⊢ (∃ p1 ∈ mk' p direction, ∃ p2 ∈ mk' p direction, v = p1 -ᵥ p2) ↔ v ∈ direction
tactic: rw [mem_direction_iff_eq_vsub (mk'_nonempty _ _)]
state_before: case h
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p : P
direction : Submodule k V
v : V
⊢ (∃ p1 ∈ mk' p direction, ∃ p2 ∈ mk' p direction, v = p1 -ᵥ p2) ↔ v ∈ direction
state_after: case h.mp
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p : P
direction : Submodule k V
v : V
⊢ (∃ p1 ∈ mk' p direction, ∃ p2 ∈ mk' p direction, v = p1 -ᵥ p2) → v ∈ direction

case h.mpr
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p : P
direction : Submodule k V
v : V
⊢ v ∈ direction → ∃ p1 ∈ mk' p direction, ∃ p2 ∈ mk' p direction, v = p1 -ᵥ p2
tactic: constructor
Theorem: Matroid.Restriction.of_subset
File: Mathlib/Data/Matroid/Restrict.lean

Proof steps:
state_before: α : Type u_1
M✝ : Matroid α
R I J X Y : Set α
N : Matroid α
R' : Set α
M : Matroid α
h : R ⊆ R'
⊢ M ↾ R ≤r M ↾ R'
state_after: α : Type u_1
M✝ : Matroid α
R I J X Y : Set α
N : Matroid α
R' : Set α
M : Matroid α
h : R ⊆ R'
⊢ M ↾ R' ↾ R ≤r M ↾ R'
tactic: rw [← restrict_restrict_eq M h]
state_before: α : Type u_1
M✝ : Matroid α
R I J X Y : Set α
N : Matroid α
R' : Set α
M : Matroid α
h : R ⊆ R'
⊢ M ↾ R' ↾ R ≤r M ↾ R'
state_after: no goals
tactic: exact restrict_restriction _ _ h
Theorem: List.rtakeWhile_concat
File: Mathlib/Data/List/DropRight.lean

Proof steps:
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
x : α
⊢ rtakeWhile p (l ++ [x]) = if p x = true then rtakeWhile p l ++ [x] else []
state_after: α : Type u_1
p : α → Bool
l : List α
n : ℕ
x : α
⊢ (match p x with
      | true => x :: takeWhile p l.reverse
      | false => []).reverse =
    if p x = true then (takeWhile p l.reverse).reverse ++ [x] else []
tactic: simp only [rtakeWhile, takeWhile, reverse_append, reverse_singleton, singleton_append]
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
x : α
⊢ (match p x with
      | true => x :: takeWhile p l.reverse
      | false => []).reverse =
    if p x = true then (takeWhile p l.reverse).reverse ++ [x] else []
state_after: no goals
tactic: split_ifs with h <;> simp [h]
Theorem: CategoryTheory.Functor.postcomp_map_heq'
File: Mathlib/CategoryTheory/EqToHom.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
β : Sort u_1
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F G : C ⥤ D
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
H : D ⥤ E
hobj : ∀ (X : C), F.obj X = G.obj X
hmap : ∀ {X Y : C} (f : X ⟶ Y), HEq (F.map f) (G.map f)
⊢ HEq ((F ⋙ H).map f) ((G ⋙ H).map f)
state_after: no goals
tactic: rw [Functor.hext hobj fun _ _ => hmap]
Theorem: Matroid.Dep.dep_restriction
File: Mathlib/Data/Matroid/Restrict.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
R I J X Y : Set α
N : Matroid α
hX : M.Dep X
hNM : N ≤r M
hXE : autoParam (X ⊆ N.E) _auto✝
⊢ N.Dep X
state_after: case intro.intro
α : Type u_1
M : Matroid α
R✝ I J X Y : Set α
hX : M.Dep X
R : Set α
hXE : autoParam (X ⊆ (M ↾ R).E) _auto✝
⊢ (M ↾ R).Dep X
tactic: obtain ⟨R, -, rfl⟩ := hNM
state_before: case intro.intro
α : Type u_1
M : Matroid α
R✝ I J X Y : Set α
hX : M.Dep X
R : Set α
hXE : autoParam (X ⊆ (M ↾ R).E) _auto✝
⊢ (M ↾ R).Dep X
state_after: no goals
tactic: simpa [hX.not_indep]
Theorem: ENNReal.le_of_forall_lt_one_mul_le
File: Mathlib/Topology/Instances/ENNReal.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x✝ y✝ z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
x y : ℝ≥0∞
h : ∀ a < 1, a * x ≤ y
this : Tendsto (fun x_1 => x_1 * x) (𝓝[<] 1) (𝓝 (1 * x))
⊢ x ≤ y
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x✝ y✝ z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
x y : ℝ≥0∞
h : ∀ a < 1, a * x ≤ y
this : Tendsto (fun x_1 => x_1 * x) (𝓝[<] 1) (𝓝 x)
⊢ x ≤ y
tactic: rw [one_mul] at this
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x✝ y✝ z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
x y : ℝ≥0∞
h : ∀ a < 1, a * x ≤ y
this : Tendsto (fun x_1 => x_1 * x) (𝓝[<] 1) (𝓝 x)
⊢ x ≤ y
state_after: no goals
tactic: exact le_of_tendsto this (eventually_nhdsWithin_iff.2 <| eventually_of_forall h)
Theorem: List.getElem_rotate
File: Mathlib/Data/List/Rotate.lean

Proof steps:
state_before: α : Type u
l : List α
n k : ℕ
h : k < (l.rotate n).length
⊢ (l.rotate n)[k] = l[(k + n) % l.length]
state_after: α : Type u
l : List α
n k : ℕ
h : k < (l.rotate n).length
⊢ k < l.length
tactic: rw [← Option.some_inj, ← getElem?_eq_getElem, ← getElem?_eq_getElem, getElem?_rotate]
state_before: α : Type u
l : List α
n k : ℕ
h : k < (l.rotate n).length
⊢ k < l.length
state_after: no goals
tactic: exact h.trans_eq (length_rotate _ _)
Theorem: AlgebraicGeometry.Scheme.Pullback.openCoverOfLeftRight_obj
File: Mathlib/AlgebraicGeometry/Pullbacks.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : X.OpenCover
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (𝒰.map i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰X : X.OpenCover
𝒰Y : Y.OpenCover
f : X ⟶ Z
g : Y ⟶ Z
⊢ (pullback f g).OpenCover
state_after: C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : X.OpenCover
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (𝒰.map i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰X : X.OpenCover
𝒰Y : Y.OpenCover
f : X ⟶ Z
g : Y ⟶ Z
⊢ ∀ (i : 𝒰X.J × 𝒰Y.J),
    pullback.map (𝒰X.map i.1 ≫ f) (𝒰Y.map i.2 ≫ g) f g (𝒰X.map i.1) (𝒰Y.map i.2) (𝟙 Z) ⋯ ⋯ =
      (Iso.refl ((fun ij => pullback (𝒰X.map ij.1 ≫ f) (𝒰Y.map ij.2 ≫ g)) i)).hom ≫
        ((openCoverOfLeft 𝒰X f g).bind fun x => openCoverOfRight 𝒰Y (𝒰X.map x ≫ f) g).map
          ((Equiv.sigmaEquivProd 𝒰X.J 𝒰Y.J).symm i)
tactic: fapply
    ((openCoverOfLeft 𝒰X f g).bind fun x => openCoverOfRight 𝒰Y (𝒰X.map x ≫ f) g).copy
      (𝒰X.J × 𝒰Y.J) (fun ij => pullback (𝒰X.map ij.1 ≫ f) (𝒰Y.map ij.2 ≫ g))
      (fun ij =>
        pullback.map _ _ _ _ (𝒰X.map ij.1) (𝒰Y.map ij.2) (𝟙 _) (Category.comp_id _)
          (Category.comp_id _))
      (Equiv.sigmaEquivProd _ _).symm fun _ => Iso.refl _
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : X.OpenCover
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (𝒰.map i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰X : X.OpenCover
𝒰Y : Y.OpenCover
f : X ⟶ Z
g : Y ⟶ Z
⊢ ∀ (i : 𝒰X.J × 𝒰Y.J),
    pullback.map (𝒰X.map i.1 ≫ f) (𝒰Y.map i.2 ≫ g) f g (𝒰X.map i.1) (𝒰Y.map i.2) (𝟙 Z) ⋯ ⋯ =
      (Iso.refl ((fun ij => pullback (𝒰X.map ij.1 ≫ f) (𝒰Y.map ij.2 ≫ g)) i)).hom ≫
        ((openCoverOfLeft 𝒰X f g).bind fun x => openCoverOfRight 𝒰Y (𝒰X.map x ≫ f) g).map
          ((Equiv.sigmaEquivProd 𝒰X.J 𝒰Y.J).symm i)
state_after: case mk
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : X.OpenCover
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (𝒰.map i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰X : X.OpenCover
𝒰Y : Y.OpenCover
f : X ⟶ Z
g : Y ⟶ Z
i : 𝒰X.J
j : 𝒰Y.J
⊢ pullback.map (𝒰X.map (i, j).1 ≫ f) (𝒰Y.map (i, j).2 ≫ g) f g (𝒰X.map (i, j).1) (𝒰Y.map (i, j).2) (𝟙 Z) ⋯ ⋯ =
    (Iso.refl ((fun ij => pullback (𝒰X.map ij.1 ≫ f) (𝒰Y.map ij.2 ≫ g)) (i, j))).hom ≫
      ((openCoverOfLeft 𝒰X f g).bind fun x => openCoverOfRight 𝒰Y (𝒰X.map x ≫ f) g).map
        ((Equiv.sigmaEquivProd 𝒰X.J 𝒰Y.J).symm (i, j))
tactic: rintro ⟨i, j⟩
state_before: case mk
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : X.OpenCover
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (𝒰.map i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰X : X.OpenCover
𝒰Y : Y.OpenCover
f : X ⟶ Z
g : Y ⟶ Z
i : 𝒰X.J
j : 𝒰Y.J
⊢ pullback.map (𝒰X.map (i, j).1 ≫ f) (𝒰Y.map (i, j).2 ≫ g) f g (𝒰X.map (i, j).1) (𝒰Y.map (i, j).2) (𝟙 Z) ⋯ ⋯ =
    (Iso.refl ((fun ij => pullback (𝒰X.map ij.1 ≫ f) (𝒰Y.map ij.2 ≫ g)) (i, j))).hom ≫
      ((openCoverOfLeft 𝒰X f g).bind fun x => openCoverOfRight 𝒰Y (𝒰X.map x ≫ f) g).map
        ((Equiv.sigmaEquivProd 𝒰X.J 𝒰Y.J).symm (i, j))
state_after: no goals
tactic: apply pullback.hom_ext <;> simp
Theorem: CategoryTheory.Limits.IsZero.iff_isSplitEpi_eq_zero
File: Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : IsSplitEpi f
⊢ IsZero Y ↔ f = 0
state_after: C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : IsSplitEpi f
⊢ 𝟙 Y = 0 ↔ f = 0
tactic: rw [iff_id_eq_zero]
state_before: C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : IsSplitEpi f
⊢ 𝟙 Y = 0 ↔ f = 0
state_after: case mp
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : IsSplitEpi f
⊢ 𝟙 Y = 0 → f = 0

case mpr
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : IsSplitEpi f
⊢ f = 0 → 𝟙 Y = 0
tactic: constructor
Theorem: EuclideanDomain.gcdA_zero_left
File: Mathlib/Algebra/EuclideanDomain/Defs.lean

Proof steps:
state_before: R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
s : R
⊢ gcdA 0 s = 0
state_after: R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
s : R
⊢ (xgcd 0 s).1 = 0
tactic: unfold gcdA
state_before: R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
s : R
⊢ (xgcd 0 s).1 = 0
state_after: no goals
tactic: rw [xgcd, xgcd_zero_left]
Theorem: CategoryTheory.SingleFunctors.isoMk_inv_hom
File: Mathlib/CategoryTheory/Shift/SingleFunctors.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
E : Type u_3
E' : Type u_4
inst✝⁷ : Category.{?u.41001, u_1} C
inst✝⁶ : Category.{?u.41005, u_2} D
inst✝⁵ : Category.{?u.41009, u_3} E
inst✝⁴ : Category.{?u.41013, u_4} E'
A : Type u_5
inst✝³ : AddMonoid A
inst✝² : HasShift D A
inst✝¹ : HasShift E A
inst✝ : HasShift E' A
F G H : SingleFunctors C D A
iso : (a : A) → F.functor a ≅ G.functor a
comm :
  ∀ (n a a' : A) (ha' : n + a = a'),
    (F.shiftIso n a a' ha').hom ≫ (iso a).hom =
      whiskerRight (iso a').hom (shiftFunctor D n) ≫ (G.shiftIso n a a' ha').hom
n a a' : A
ha' : n + a = a'
⊢ (G.shiftIso n a a' ha').hom ≫ (fun a => (iso a).inv) a =
    whiskerRight ((fun a => (iso a).inv) a') (shiftFunctor D n) ≫ (F.shiftIso n a a' ha').hom
state_after: C : Type u_1
D : Type u_2
E : Type u_3
E' : Type u_4
inst✝⁷ : Category.{?u.41001, u_1} C
inst✝⁶ : Category.{?u.41005, u_2} D
inst✝⁵ : Category.{?u.41009, u_3} E
inst✝⁴ : Category.{?u.41013, u_4} E'
A : Type u_5
inst✝³ : AddMonoid A
inst✝² : HasShift D A
inst✝¹ : HasShift E A
inst✝ : HasShift E' A
F G H : SingleFunctors C D A
iso : (a : A) → F.functor a ≅ G.functor a
comm :
  ∀ (n a a' : A) (ha' : n + a = a'),
    (F.shiftIso n a a' ha').hom ≫ (iso a).hom =
      whiskerRight (iso a').hom (shiftFunctor D n) ≫ (G.shiftIso n a a' ha').hom
n a a' : A
ha' : n + a = a'
⊢ (G.shiftIso n a a' ha').hom ≫ (iso a).inv = whiskerRight (iso a').inv (shiftFunctor D n) ≫ (F.shiftIso n a a' ha').hom
tactic: dsimp only
state_before: C : Type u_1
D : Type u_2
E : Type u_3
E' : Type u_4
inst✝⁷ : Category.{?u.41001, u_1} C
inst✝⁶ : Category.{?u.41005, u_2} D
inst✝⁵ : Category.{?u.41009, u_3} E
inst✝⁴ : Category.{?u.41013, u_4} E'
A : Type u_5
inst✝³ : AddMonoid A
inst✝² : HasShift D A
inst✝¹ : HasShift E A
inst✝ : HasShift E' A
F G H : SingleFunctors C D A
iso : (a : A) → F.functor a ≅ G.functor a
comm :
  ∀ (n a a' : A) (ha' : n + a = a'),
    (F.shiftIso n a a' ha').hom ≫ (iso a).hom =
      whiskerRight (iso a').hom (shiftFunctor D n) ≫ (G.shiftIso n a a' ha').hom
n a a' : A
ha' : n + a = a'
⊢ (G.shiftIso n a a' ha').hom ≫ (iso a).inv = whiskerRight (iso a').inv (shiftFunctor D n) ≫ (F.shiftIso n a a' ha').hom
state_after: no goals
tactic: rw [← cancel_mono (iso a).hom, assoc, assoc, Iso.inv_hom_id, comp_id, comm,
          ← whiskerRight_comp_assoc, Iso.inv_hom_id, whiskerRight_id', id_comp]
Theorem: Multiset.lcm_dvd
File: Mathlib/Algebra/GCDMonoid/Multiset.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s : Multiset α
a : α
⊢ lcm 0 ∣ a ↔ ∀ b ∈ 0, b ∣ a
state_after: no goals
tactic: simp
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s : Multiset α
a : α
⊢ ∀ (a_1 : α) (s : Multiset α), (s.lcm ∣ a ↔ ∀ b ∈ s, b ∣ a) → ((a_1 ::ₘ s).lcm ∣ a ↔ ∀ b ∈ a_1 ::ₘ s, b ∣ a)
state_after: no goals
tactic: simp (config := { contextual := true }) [or_imp, forall_and, lcm_dvd_iff]
Theorem: TopologicalSpace.nhds_mkOfNhds_of_hasBasis
File: Mathlib/Topology/Order.lean

Proof steps:
state_before: α : Type u
n : α → Filter α
ι : α → Sort u_1
p : (a : α) → ι a → Prop
s : (a : α) → ι a → Set α
hb : ∀ (a : α), (n a).HasBasis (p a) (s a)
hpure : ∀ (a : α) (i : ι a), p a i → a ∈ s a i
hopen : ∀ (a : α) (i : ι a), p a i → ∀ᶠ (x : α) in n a, s a i ∈ n x
a : α
⊢ 𝓝 a = n a
state_after: α : Type u
n : α → Filter α
ι : α → Sort u_1
p : (a : α) → ι a → Prop
s : (a : α) → ι a → Set α
hb : ∀ (a : α), (n a).HasBasis (p a) (s a)
hpure : ∀ (a : α) (i : ι a), p a i → a ∈ s a i
hopen : ∀ (a : α) (i : ι a), p a i → ∀ᶠ (x : α) in n a, s a i ∈ n x
a : α
t : TopologicalSpace α := TopologicalSpace.mkOfNhds n
⊢ 𝓝 a = n a
tactic: let t : TopologicalSpace α := .mkOfNhds n
state_before: α : Type u
n : α → Filter α
ι : α → Sort u_1
p : (a : α) → ι a → Prop
s : (a : α) → ι a → Set α
hb : ∀ (a : α), (n a).HasBasis (p a) (s a)
hpure : ∀ (a : α) (i : ι a), p a i → a ∈ s a i
hopen : ∀ (a : α) (i : ι a), p a i → ∀ᶠ (x : α) in n a, s a i ∈ n x
a : α
t : TopologicalSpace α := TopologicalSpace.mkOfNhds n
⊢ 𝓝 a = n a
state_after: case a
α : Type u
n : α → Filter α
ι : α → Sort u_1
p : (a : α) → ι a → Prop
s : (a : α) → ι a → Set α
hb : ∀ (a : α), (n a).HasBasis (p a) (s a)
hpure : ∀ (a : α) (i : ι a), p a i → a ∈ s a i
hopen : ∀ (a : α) (i : ι a), p a i → ∀ᶠ (x : α) in n a, s a i ∈ n x
a : α
t : TopologicalSpace α := TopologicalSpace.mkOfNhds n
⊢ 𝓝 a ≤ n a

case a
α : Type u
n : α → Filter α
ι : α → Sort u_1
p : (a : α) → ι a → Prop
s : (a : α) → ι a → Set α
hb : ∀ (a : α), (n a).HasBasis (p a) (s a)
hpure : ∀ (a : α) (i : ι a), p a i → a ∈ s a i
hopen : ∀ (a : α) (i : ι a), p a i → ∀ᶠ (x : α) in n a, s a i ∈ n x
a : α
t : TopologicalSpace α := TopologicalSpace.mkOfNhds n
⊢ n a ≤ 𝓝 a
tactic: apply le_antisymm