ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: SSet.horn.primitiveTriangle_coe
File: Mathlib/AlgebraicTopology/SimplicialSet.lean

Proof steps:
state_before: n : ℕ
i : Fin (n + 4)
h₀ : 0 < i
hₙ : i < Fin.last (n + 3)
k : ℕ
h : k < n + 2
⊢ Λ[n + 3, i] _[2]
state_after: case refine_1
n : ℕ
i : Fin (n + 4)
h₀ : 0 < i
hₙ : i < Fin.last (n + 3)
k : ℕ
h : k < n + 2
⊢ ⟨k, ⋯⟩ ≤ ⟨k + 1, ⋯⟩

case refine_2
n : ℕ
i : Fin (n + 4)
h₀ : 0 < i
hₙ : i < Fin.last (n + 3)
k : ℕ
h : k < n + 2
⊢ ⟨k + 1, ⋯⟩ ≤ ⟨k + 2, ⋯⟩

case refine_3
n : ℕ
i : Fin (n + 4)
h₀ : 0 < i
hₙ : i < Fin.last (n + 3)
k : ℕ
h : k < n + 2
⊢ Set.range ⇑(asOrderHom (standardSimplex.triangle ⟨k, ⋯⟩ ⟨k + 1, ⋯⟩ ⟨k + 2, ⋯⟩ ?refine_1 ?refine_2)) ∪ {i} ≠ Set.univ
tactic: refine ⟨standardSimplex.triangle
    (n := n+3) ⟨k, by omega⟩ ⟨k+1, by omega⟩ ⟨k+2, by omega⟩ ?_ ?_, ?_⟩
state_before: case refine_3
n : ℕ
i : Fin (n + 4)
h₀ : 0 < i
hₙ : i < Fin.last (n + 3)
k : ℕ
h : k < n + 2
⊢ Set.range ⇑(asOrderHom (standardSimplex.triangle ⟨k, ⋯⟩ ⟨k + 1, ⋯⟩ ⟨k + 2, ⋯⟩ ⋯ ⋯)) ∪ {i} ≠ Set.univ
state_after: case refine_3
n : ℕ
i : Fin (n + 4)
h₀ : 0 < i
hₙ : i < Fin.last (n + 3)
k : ℕ
h : k < n + 2
⊢ ∃ x,
    ¬i = x ∧
      ∀ (x_1 : Fin (2 + 1)),
        ¬(Hom.toOrderHom
                ({ toFun := ULift.down, invFun := ULift.up, left_inv := ⋯, right_inv := ⋯ }.symm
                    (Hom.mk { toFun := ![⟨k, ⋯⟩, ⟨k + 1, ⋯⟩, ⟨k + 2, ⋯⟩], monotone' := ⋯ })).down)
              x_1 =
            x
tactic: simp only [unop_op, SimplexCategory.len_mk, asOrderHom, SimplexCategory.Hom.toOrderHom_mk,
    OrderHom.const_coe_coe, Set.union_singleton, ne_eq, ← Set.univ_subset_iff, Set.subset_def,
    Set.mem_univ, Set.mem_insert_iff, Set.mem_range, Function.const_apply, exists_const,
    forall_true_left, not_forall, not_or, unop_op, not_exists,
    standardSimplex.triangle, OrderHom.coe_mk, @eq_comm _ _ i,
    standardSimplex.objMk, standardSimplex.objEquiv, Equiv.ulift]
state_before: case refine_3
n : ℕ
i : Fin (n + 4)
h₀ : 0 < i
hₙ : i < Fin.last (n + 3)
k : ℕ
h : k < n + 2
⊢ ∃ x,
    ¬i = x ∧
      ∀ (x_1 : Fin (2 + 1)),
        ¬(Hom.toOrderHom
                ({ toFun := ULift.down, invFun := ULift.up, left_inv := ⋯, right_inv := ⋯ }.symm
                    (Hom.mk { toFun := ![⟨k, ⋯⟩, ⟨k + 1, ⋯⟩, ⟨k + 2, ⋯⟩], monotone' := ⋯ })).down)
              x_1 =
            x
state_after: case refine_3
n : ℕ
i : Fin (n + 4)
h₀ : 0 < i
hₙ : i < Fin.last (n + 3)
k : ℕ
h : k < n + 2
⊢ ∃ x, ¬i = x ∧ ∀ (x_1 : Fin 3), ¬![⟨k, ⋯⟩, ⟨k + 1, ⋯⟩, ⟨k + 2, ⋯⟩] x_1 = x
tactic: dsimp
state_before: case refine_3
n : ℕ
i : Fin (n + 4)
h₀ : 0 < i
hₙ : i < Fin.last (n + 3)
k : ℕ
h : k < n + 2
⊢ ∃ x, ¬i = x ∧ ∀ (x_1 : Fin 3), ¬![⟨k, ⋯⟩, ⟨k + 1, ⋯⟩, ⟨k + 2, ⋯⟩] x_1 = x
state_after: case pos
n : ℕ
i : Fin (n + 4)
h₀ : 0 < i
hₙ : i < Fin.last (n + 3)
k : ℕ
h : k < n + 2
hk0 : k = 0
⊢ ∃ x, ¬i = x ∧ ∀ (x_1 : Fin 3), ¬![⟨k, ⋯⟩, ⟨k + 1, ⋯⟩, ⟨k + 2, ⋯⟩] x_1 = x

case neg
n : ℕ
i : Fin (n + 4)
h₀ : 0 < i
hₙ : i < Fin.last (n + 3)
k : ℕ
h : k < n + 2
hk0 : ¬k = 0
⊢ ∃ x, ¬i = x ∧ ∀ (x_1 : Fin 3), ¬![⟨k, ⋯⟩, ⟨k + 1, ⋯⟩, ⟨k + 2, ⋯⟩] x_1 = x
tactic: by_cases hk0 : k = 0
Theorem: Polynomial.not_isUnit_of_degree_pos
File: Mathlib/Algebra/Polynomial/RingDivision.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p✝ q p : R[X]
hpl : 0 < p.degree
⊢ ¬IsUnit p
state_after: case inl
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p✝ q p : R[X]
hpl : 0 < p.degree
h✝ : Subsingleton R
⊢ ¬IsUnit p

case inr
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p✝ q p : R[X]
hpl : 0 < p.degree
h✝ : Nontrivial R
⊢ ¬IsUnit p
tactic: cases subsingleton_or_nontrivial R
state_before: case inr
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p✝ q p : R[X]
hpl : 0 < p.degree
h✝ : Nontrivial R
⊢ ¬IsUnit p
state_after: case inr
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p✝ q p : R[X]
hpl : 0 < p.degree
h✝ : Nontrivial R
h : IsUnit p
⊢ False
tactic: intro h
state_before: case inr
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p✝ q p : R[X]
hpl : 0 < p.degree
h✝ : Nontrivial R
h : IsUnit p
⊢ False
state_after: no goals
tactic: simp [degree_eq_zero_of_isUnit h] at hpl
Theorem: Nat.bitwise_zero
File: Mathlib/Data/Nat/Bitwise.lean

Proof steps:
state_before: f : Bool → Bool → Bool
⊢ bitwise f 0 0 = 0
state_after: no goals
tactic: simp only [bitwise_zero_right, ite_self]
Theorem: RootPairing.reflection_dualMap_eq_coreflection
File: Mathlib/LinearAlgebra/RootSystem/Defs.lean

Proof steps:
state_before: ι : Type u_1
R : Type u_2
M : Type u_3
N : Type u_4
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
P : RootPairing ι R M N
i j : ι
⊢ ↑(P.reflection i).dualMap ∘ₗ P.toLin.flip = P.toLin.flip ∘ₗ ↑(P.coreflection i)
state_after: case h.h
ι : Type u_1
R : Type u_2
M : Type u_3
N : Type u_4
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
P : RootPairing ι R M N
i j : ι
n : N
m : M
⊢ ((↑(P.reflection i).dualMap ∘ₗ P.toLin.flip) n) m = ((P.toLin.flip ∘ₗ ↑(P.coreflection i)) n) m
tactic: ext n m
state_before: case h.h
ι : Type u_1
R : Type u_2
M : Type u_3
N : Type u_4
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
P : RootPairing ι R M N
i j : ι
n : N
m : M
⊢ ((↑(P.reflection i).dualMap ∘ₗ P.toLin.flip) n) m = ((P.toLin.flip ∘ₗ ↑(P.coreflection i)) n) m
state_after: no goals
tactic: simp [coreflection_apply, reflection_apply, mul_comm (P.toLin m (P.coroot i))]
Theorem: Set.image_eq_empty
File: Mathlib/Data/Set/Image.lean

Proof steps:
state_before: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α✝ → β✝
s✝ t : Set α✝
α : Type u_6
β : Type u_7
f : α → β
s : Set α
⊢ f '' s = ∅ ↔ s = ∅
state_after: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α✝ → β✝
s✝ t : Set α✝
α : Type u_6
β : Type u_7
f : α → β
s : Set α
⊢ (∀ (x : β), x ∉ f '' s) ↔ ∀ (x : α), x ∉ s
tactic: simp only [eq_empty_iff_forall_not_mem]
state_before: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α✝ → β✝
s✝ t : Set α✝
α : Type u_6
β : Type u_7
f : α → β
s : Set α
⊢ (∀ (x : β), x ∉ f '' s) ↔ ∀ (x : α), x ∉ s
state_after: no goals
tactic: exact ⟨fun H a ha => H _ ⟨_, ha, rfl⟩, fun H b ⟨_, ha, _⟩ => H _ ha⟩
Theorem: real_inner_smul_self_left
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x : F
r : ℝ
⊢ ⟪r • x, x⟫_ℝ = r * (‖x‖ * ‖x‖)
state_after: no goals
tactic: rw [real_inner_smul_left, ← real_inner_self_eq_norm_mul_norm]
Theorem: List.join_append
File: Mathlib/Data/List/Join.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
L₁ L₂ : List (List α)
⊢ (L₁ ++ L₂).join = L₁.join ++ L₂.join
state_after: case nil
α : Type u_1
β : Type u_2
L₂ : List (List α)
⊢ ([] ++ L₂).join = [].join ++ L₂.join

case cons
α : Type u_1
β : Type u_2
L₂ : List (List α)
head✝ : List α
tail✝ : List (List α)
tail_ih✝ : (tail✝ ++ L₂).join = tail✝.join ++ L₂.join
⊢ (head✝ :: tail✝ ++ L₂).join = (head✝ :: tail✝).join ++ L₂.join
tactic: induction L₁
Theorem: Set.one_lt_ncard_iff
File: Mathlib/Data/Set/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s t : Set α
f : α → β
hs : autoParam s.Finite _auto✝
⊢ 1 < s.ncard ↔ ∃ a b, a ∈ s ∧ b ∈ s ∧ a ≠ b
state_after: α : Type u_1
β : Type u_2
s t : Set α
f : α → β
hs : autoParam s.Finite _auto✝
⊢ (∃ a ∈ s, ∃ b ∈ s, a ≠ b) ↔ ∃ a b, a ∈ s ∧ b ∈ s ∧ a ≠ b
tactic: rw [one_lt_ncard hs]
state_before: α : Type u_1
β : Type u_2
s t : Set α
f : α → β
hs : autoParam s.Finite _auto✝
⊢ (∃ a ∈ s, ∃ b ∈ s, a ≠ b) ↔ ∃ a b, a ∈ s ∧ b ∈ s ∧ a ≠ b
state_after: no goals
tactic: simp only [exists_prop, exists_and_left]
Theorem: MeasureTheory.Measure.fst_apply
File: Mathlib/MeasureTheory/Constructions/Prod/Basic.lean

Proof steps:
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝⁶ : MeasurableSpace α
inst✝⁵ : MeasurableSpace α'
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace β'
inst✝² : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝¹ : NormedAddCommGroup E
inst✝ : SFinite ν
ρ : Measure (α × β)
s : Set α
hs : MeasurableSet s
⊢ ρ.fst s = ρ (Prod.fst ⁻¹' s)
state_after: no goals
tactic: rw [fst, Measure.map_apply measurable_fst hs]
Theorem: Matroid.Indep.insert_basis_iff_mem_closure
File: Mathlib/Data/Matroid/Closure.lean

Proof steps:
state_before: ι✝ : Type u_1
α : Type u_2
M : Matroid α
F X Y : Set α
e : α
ι : Sort u_3
I J B : Set α
f x y : α
hI : M.Indep I
⊢ M.Basis I (insert e I) ↔ e ∈ M.closure I
state_after: no goals
tactic: rw [hI.closure_eq_setOf_basis_insert, mem_setOf]
Theorem: ContinuousMap.prod_apply
File: Mathlib/Topology/ContinuousFunction/Algebra.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : CommMonoid β
inst✝ : ContinuousMul β
ι : Type u_3
s : Finset ι
f : ι → C(α, β)
a : α
⊢ (∏ i ∈ s, f i) a = ∏ i ∈ s, (f i) a
state_after: no goals
tactic: simp
Theorem: Filter.map₂_pure_left
File: Mathlib/Order/Filter/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
m : α → β → γ
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
h h₁ h₂ : Filter γ
s s₁ s₂ : Set α
t t₁ t₂ : Set β
u : Set γ
v : Set δ
a : α
b : β
c : γ
⊢ map₂ m (pure a) g = map (m a) g
state_after: α : 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
m : α → β → γ
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
h h₁ h₂ : Filter γ
s s₁ s₂ : Set α
t t₁ t₂ : Set β
u : Set γ
v : Set δ
a : α
b : β
c : γ
⊢ map ((fun p => m p.1 p.2) ∘ Prod.mk a) g = map (m a) g
tactic: rw [← map_prod_eq_map₂, pure_prod, map_map]
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
m : α → β → γ
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
h h₁ h₂ : Filter γ
s s₁ s₂ : Set α
t t₁ t₂ : Set β
u : Set γ
v : Set δ
a : α
b : β
c : γ
⊢ map ((fun p => m p.1 p.2) ∘ Prod.mk a) g = map (m a) g
state_after: no goals
tactic: rfl
Theorem: MeasureTheory.lintegral_inter_add_diff
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
B : Set α
f : α → ℝ≥0∞
A : Set α
hB : MeasurableSet B
⊢ ∫⁻ (x : α) in A ∩ B, f x ∂μ + ∫⁻ (x : α) in A \ B, f x ∂μ = ∫⁻ (x : α) in A, f x ∂μ
state_after: no goals
tactic: rw [← lintegral_add_measure, restrict_inter_add_diff _ hB]
Theorem: Nat.Partrec'.bind
File: Mathlib/Computability/Halting.lean

Proof steps:
state_before: n : ℕ
f : Vector ℕ n →. ℕ
g : Vector ℕ (n + 1) →. ℕ
hf : Partrec' f
hg : Partrec' g
i : Fin (n + 1)
⊢ Partrec' ((fun i => Fin.cases f (fun i v => ↑(some (v.get i))) i) i)
state_after: case refine_2
n : ℕ
f : Vector ℕ n →. ℕ
g : Vector ℕ (n + 1) →. ℕ
hf : Partrec' f
hg : Partrec' g
i✝ : Fin (n + 1)
i : Fin n
⊢ Partrec' fun v => Part.some (v.get i)
tactic: refine Fin.cases ?_ (fun i => ?_) i <;> simp [*]
state_before: case refine_2
n : ℕ
f : Vector ℕ n →. ℕ
g : Vector ℕ (n + 1) →. ℕ
hf : Partrec' f
hg : Partrec' g
i✝ : Fin (n + 1)
i : Fin n
⊢ Partrec' fun v => Part.some (v.get i)
state_after: no goals
tactic: exact prim (Nat.Primrec'.get _)
state_before: n : ℕ
f : Vector ℕ n →. ℕ
g : Vector ℕ (n + 1) →. ℕ
hf : Partrec' f
hg : Partrec' g
v : Vector ℕ n
⊢ (mOfFn fun i => Fin.cases f (fun i v => ↑(some (v.get i))) i v) >>= g = (f v).bind fun a => g (a ::ᵥ v)
state_after: no goals
tactic: simp [mOfFn, Part.bind_assoc, pure]
Theorem: exists_pos_bound_of_bound
File: Mathlib/Analysis/Normed/Group/Hom.lean

Proof steps:
state_before: V : Type u_1
W : Type u_2
inst✝¹ : SeminormedAddCommGroup V
inst✝ : SeminormedAddCommGroup W
f : V → W
M : ℝ
h : ∀ (x : V), ‖f x‖ ≤ M * ‖x‖
x : V
⊢ M * ‖x‖ ≤ max M 1 * ‖x‖
state_after: case h
V : Type u_1
W : Type u_2
inst✝¹ : SeminormedAddCommGroup V
inst✝ : SeminormedAddCommGroup W
f : V → W
M : ℝ
h : ∀ (x : V), ‖f x‖ ≤ M * ‖x‖
x : V
⊢ M ≤ max M 1
tactic: gcongr
state_before: case h
V : Type u_1
W : Type u_2
inst✝¹ : SeminormedAddCommGroup V
inst✝ : SeminormedAddCommGroup W
f : V → W
M : ℝ
h : ∀ (x : V), ‖f x‖ ≤ M * ‖x‖
x : V
⊢ M ≤ max M 1
state_after: no goals
tactic: apply le_max_left
Theorem: Nat.zero_descFactorial_succ
File: Mathlib/Data/Nat/Factorial/Basic.lean

Proof steps:
state_before: k : ℕ
⊢ descFactorial 0 (k + 1) = 0
state_after: no goals
tactic: rw [descFactorial_succ, Nat.zero_sub, Nat.zero_mul]
Theorem: Inducing.isClosedMap
File: Mathlib/Topology/Maps/Basic.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
hf : Inducing f
h : IsClosed (range f)
⊢ IsClosedMap f
state_after: X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
hf : Inducing f
h : IsClosed (range f)
s : Set X
hs : IsClosed s
⊢ IsClosed (f '' s)
tactic: intro s hs
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
hf : Inducing f
h : IsClosed (range f)
s : Set X
hs : IsClosed s
⊢ IsClosed (f '' s)
state_after: case intro.intro
X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
hf : Inducing f
h : IsClosed (range f)
t : Set Y
ht : IsClosed t
hs : IsClosed (f ⁻¹' t)
⊢ IsClosed (f '' (f ⁻¹' t))
tactic: rcases hf.isClosed_iff.1 hs with ⟨t, ht, rfl⟩
state_before: case intro.intro
X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
hf : Inducing f
h : IsClosed (range f)
t : Set Y
ht : IsClosed t
hs : IsClosed (f ⁻¹' t)
⊢ IsClosed (f '' (f ⁻¹' t))
state_after: case intro.intro
X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
hf : Inducing f
h : IsClosed (range f)
t : Set Y
ht : IsClosed t
hs : IsClosed (f ⁻¹' t)
⊢ IsClosed (t ∩ range f)
tactic: rw [image_preimage_eq_inter_range]
state_before: case intro.intro
X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
hf : Inducing f
h : IsClosed (range f)
t : Set Y
ht : IsClosed t
hs : IsClosed (f ⁻¹' t)
⊢ IsClosed (t ∩ range f)
state_after: no goals
tactic: exact ht.inter h
Theorem: Rat.abs_def
File: Mathlib/Algebra/Order/Ring/Rat.lean

Proof steps:
state_before: a b c p q✝ q : ℚ
⊢ |q| = ↑q.num.natAbs /. ↑q.den
state_after: case inl
a b c p q✝ q : ℚ
hq : q ≤ 0
⊢ |q| = ↑q.num.natAbs /. ↑q.den

case inr
a b c p q✝ q : ℚ
hq : 0 ≤ q
⊢ |q| = ↑q.num.natAbs /. ↑q.den
tactic: rcases le_total q 0 with hq | hq
Theorem: AlgHom.fst_prod
File: Mathlib/Algebra/Algebra/Prod.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
B : Type u_3
C : Type u_4
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : Semiring C
inst✝ : Algebra R C
f : A →ₐ[R] B
g : A →ₐ[R] C
⊢ (fst R B C).comp (f.prod g) = f
state_after: case H
R : Type u_1
A : Type u_2
B : Type u_3
C : Type u_4
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : Semiring C
inst✝ : Algebra R C
f : A →ₐ[R] B
g : A →ₐ[R] C
x✝ : A
⊢ ((fst R B C).comp (f.prod g)) x✝ = f x✝
tactic: ext
state_before: case H
R : Type u_1
A : Type u_2
B : Type u_3
C : Type u_4
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : Semiring C
inst✝ : Algebra R C
f : A →ₐ[R] B
g : A →ₐ[R] C
x✝ : A
⊢ ((fst R B C).comp (f.prod g)) x✝ = f x✝
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.ComposableArrows.Mk₁.map_comp
File: Mathlib/CategoryTheory/ComposableArrows.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F G : ComposableArrows C n
X₀ X₁ : C
f : X₀ ⟶ X₁
i j k : Fin 2
hjk : 0 ≤ k
hij : 0 ≤ 0
⊢ map f 0 k ⋯ = map f 0 0 hij ≫ map f 0 k hjk
state_after: no goals
tactic: rw [map_id, id_comp]
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F G : ComposableArrows C n
X₀ X₁ : C
f : X₀ ⟶ X₁
i j k : Fin 2
hjk : 1 ≤ k
hij : 0 ≤ 1
⊢ map f 0 k ⋯ = map f 0 1 hij ≫ map f 1 k hjk
state_after: C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F G : ComposableArrows C n
X₀ X₁ : C
f : X₀ ⟶ X₁
i j : Fin 2
hij : 0 ≤ 1
hjk : 1 ≤ 1
⊢ map f 0 1 ⋯ = map f 0 1 hij ≫ map f 1 1 hjk
tactic: obtain rfl : k = 1 := k.eq_one_of_neq_zero (by rintro rfl; simp at hjk)
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F G : ComposableArrows C n
X₀ X₁ : C
f : X₀ ⟶ X₁
i j : Fin 2
hij : 0 ≤ 1
hjk : 1 ≤ 1
⊢ map f 0 1 ⋯ = map f 0 1 hij ≫ map f 1 1 hjk
state_after: no goals
tactic: rw [map_id, comp_id]
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F G : ComposableArrows C n
X₀ X₁ : C
f : X₀ ⟶ X₁
i j k : Fin 2
hjk : j ≤ k
hij : 1 ≤ j
⊢ map f 1 k ⋯ = map f 1 j hij ≫ map f j k hjk
state_after: C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F G : ComposableArrows C n
X₀ X₁ : C
f : X₀ ⟶ X₁
i k : Fin 2
hjk : 1 ≤ k
hij : 1 ≤ 1
⊢ map f 1 k ⋯ = map f 1 1 hij ≫ map f 1 k hjk
tactic: obtain rfl := j.eq_one_of_neq_zero (by rintro rfl; simp at hij)
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F G : ComposableArrows C n
X₀ X₁ : C
f : X₀ ⟶ X₁
i k : Fin 2
hjk : 1 ≤ k
hij : 1 ≤ 1
⊢ map f 1 k ⋯ = map f 1 1 hij ≫ map f 1 k hjk
state_after: C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F G : ComposableArrows C n
X₀ X₁ : C
f : X₀ ⟶ X₁
i : Fin 2
hij hjk : 1 ≤ 1
⊢ map f 1 1 ⋯ = map f 1 1 hij ≫ map f 1 1 hjk
tactic: obtain rfl := k.eq_one_of_neq_zero (by rintro rfl; simp at hjk)
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F G : ComposableArrows C n
X₀ X₁ : C
f : X₀ ⟶ X₁
i : Fin 2
hij hjk : 1 ≤ 1
⊢ map f 1 1 ⋯ = map f 1 1 hij ≫ map f 1 1 hjk
state_after: no goals
tactic: rw [map_id, id_comp]
Theorem: CategoryTheory.GradedObject.Monoidal.ι_tensorObjDesc
File: Mathlib/CategoryTheory/GradedObject/Monoidal.lean

Proof steps:
state_before: I : Type u
inst✝³ : AddMonoid I
C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : MonoidalCategory C
X₁ X₂ : GradedObject I C
inst✝ : X₁.HasTensor X₂
A : C
k : I
f : (i₁ i₂ : I) → i₁ + i₂ = k → (X₁ i₁ ⊗ X₂ i₂ ⟶ A)
i₁ i₂ : I
hi : i₁ + i₂ = k
⊢ ιTensorObj X₁ X₂ i₁ i₂ k hi ≫ tensorObjDesc f = f i₁ i₂ hi
state_after: no goals
tactic: apply ι_mapBifunctorMapObjDesc
Theorem: CategoryTheory.Pretriangulated.isoTriangleOfIso₁₂_hom_hom₂
File: Mathlib/CategoryTheory/Triangulated/Pretriangulated.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : Preadditive C
inst✝ : ∀ (n : ℤ), (shiftFunctor C n).Additive
hC : Pretriangulated C
T₁ T₂ : Triangle C
hT₁ : T₁ ∈ distinguishedTriangles
hT₂ : T₂ ∈ distinguishedTriangles
e₁ : T₁.obj₁ ≅ T₂.obj₁
e₂ : T₁.obj₂ ≅ T₂.obj₂
comm : T₁.mor₁ ≫ e₂.hom = e₁.hom ≫ T₂.mor₁
⊢ T₁ ≅ T₂
state_after: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : Preadditive C
inst✝ : ∀ (n : ℤ), (shiftFunctor C n).Additive
hC : Pretriangulated C
T₁ T₂ : Triangle C
hT₁ : T₁ ∈ distinguishedTriangles
hT₂ : T₂ ∈ distinguishedTriangles
e₁ : T₁.obj₁ ≅ T₂.obj₁
e₂ : T₁.obj₂ ≅ T₂.obj₂
comm : T₁.mor₁ ≫ e₂.hom = e₁.hom ≫ T₂.mor₁
h : ∃ e', e'.hom.hom₁ = (Arrow.isoMk e₁ e₂ ⋯).hom.left ∧ e'.hom.hom₂ = (Arrow.isoMk e₁ e₂ ⋯).hom.right
⊢ T₁ ≅ T₂
tactic: have h := exists_iso_of_arrow_iso T₁ T₂ hT₁ hT₂ (Arrow.isoMk e₁ e₂ comm.symm)
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : Preadditive C
inst✝ : ∀ (n : ℤ), (shiftFunctor C n).Additive
hC : Pretriangulated C
T₁ T₂ : Triangle C
hT₁ : T₁ ∈ distinguishedTriangles
hT₂ : T₂ ∈ distinguishedTriangles
e₁ : T₁.obj₁ ≅ T₂.obj₁
e₂ : T₁.obj₂ ≅ T₂.obj₂
comm : T₁.mor₁ ≫ e₂.hom = e₁.hom ≫ T₂.mor₁
h : ∃ e', e'.hom.hom₁ = (Arrow.isoMk e₁ e₂ ⋯).hom.left ∧ e'.hom.hom₂ = (Arrow.isoMk e₁ e₂ ⋯).hom.right
⊢ T₁ ≅ T₂
state_after: no goals
tactic: exact Triangle.isoMk _ _ e₁ e₂ (Triangle.π₃.mapIso h.choose) comm (by
    have eq := h.choose_spec.2
    dsimp at eq ⊢
    conv_rhs => rw [← eq, ← TriangleMorphism.comm₂]) (by
    have eq := h.choose_spec.1
    dsimp at eq ⊢
    conv_lhs => rw [← eq, TriangleMorphism.comm₃])
Theorem: addOrderOf_le_of_nsmul_eq_zero
File: Mathlib/GroupTheory/OrderOfElement.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n m : ℕ
hn : 0 < n
h : x ^ n = 1
⊢ IsPeriodicPt (fun x_1 => x * x_1) n 1
state_after: no goals
tactic: rwa [isPeriodicPt_mul_iff_pow_eq_one]
Theorem: ZFSet.mem_of_mem_sInter
File: Mathlib/SetTheory/ZFC/Basic.lean

Proof steps:
state_before: x y z : ZFSet
hy : y ∈ ⋂₀ x
hz : z ∈ x
⊢ y ∈ z
state_after: case inl
y z : ZFSet
hy : y ∈ ⋂₀ ∅
hz : z ∈ ∅
⊢ y ∈ z

case inr
x y z : ZFSet
hy : y ∈ ⋂₀ x
hz : z ∈ x
hx : x.Nonempty
⊢ y ∈ z
tactic: rcases eq_empty_or_nonempty x with (rfl | hx)
Theorem: Set.Countable.sUnion_iff
File: Mathlib/Data/Set/Countable.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
s : Set (Set α)
hs : s.Countable
⊢ (⋃₀ s).Countable ↔ ∀ a ∈ s, a.Countable
state_after: no goals
tactic: rw [sUnion_eq_biUnion, hs.biUnion_iff]
Theorem: Finset.empty_nsmul
File: Mathlib/Data/Finset/Pointwise.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : Monoid α
s t : Finset α
a : α
m n : ℕ
hn : n ≠ 0
⊢ ∅ ^ n = ∅
state_after: no goals
tactic: rw [← tsub_add_cancel_of_le (Nat.succ_le_of_lt <| Nat.pos_of_ne_zero hn), pow_succ', empty_mul]