ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Cardinal.derivFamily_lt_ord
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

Proof steps:
state_before: α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{u} → Ordinal.{u}
c : Cardinal.{u}
hc : c.IsRegular
hι : #ι < c
hc' : c ≠ ℵ₀
hf : ∀ (i : ι), ∀ b < c.ord, f i b < c.ord
a : Ordinal.{u}
⊢ lift.{u, u} #ι < c
state_after: no goals
tactic: rwa [lift_id]
Theorem: MeasureTheory.IsFundamentalDomain.measure_eq
File: Mathlib/MeasureTheory/Group/FundamentalDomain.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
E : Type u_5
inst✝¹⁰ : Group G
inst✝⁹ : Group H
inst✝⁸ : MulAction G α
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MulAction H β
inst✝⁵ : MeasurableSpace β
inst✝⁴ : NormedAddCommGroup E
s t : Set α
μ : Measure α
inst✝³ : MeasurableSpace G
inst✝² : MeasurableSMul G α
inst✝¹ : SMulInvariantMeasure G α μ
inst✝ : Countable G
ν : Measure α
hs : IsFundamentalDomain G s μ
ht : IsFundamentalDomain G t μ
⊢ μ s = μ t
state_after: no goals
tactic: simpa only [setLIntegral_one] using hs.setLIntegral_eq ht (fun _ => 1) fun _ _ => rfl
Theorem: existsUnique_isIdempotentElem_eq_of_ker_isNilpotent
File: Mathlib/RingTheory/Idempotents.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : Ring S
f : R →+* S
h : ∀ x ∈ RingHom.ker f, IsNilpotent x
e : S
he : e ∈ f.range
he' : IsIdempotentElem e
⊢ ∃! e', IsIdempotentElem e' ∧ f e' = e
state_after: case intro.intro
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : Ring S
f : R →+* S
h : ∀ x ∈ RingHom.ker f, IsNilpotent x
e' : R
he₂ : IsIdempotentElem e'
he : f e' ∈ f.range
he' : IsIdempotentElem (f e')
⊢ ∃! e'_1, IsIdempotentElem e'_1 ∧ f e'_1 = f e'
tactic: obtain ⟨e', he₂, rfl⟩ := exists_isIdempotentElem_eq_of_ker_isNilpotent f h e he he'
state_before: case intro.intro
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : Ring S
f : R →+* S
h : ∀ x ∈ RingHom.ker f, IsNilpotent x
e' : R
he₂ : IsIdempotentElem e'
he : f e' ∈ f.range
he' : IsIdempotentElem (f e')
⊢ ∃! e'_1, IsIdempotentElem e'_1 ∧ f e'_1 = f e'
state_after: no goals
tactic: exact ⟨e', ⟨he₂, rfl⟩, fun x ⟨hx, hx'⟩ ↦
    eq_of_isNilpotent_sub_of_isIdempotentElem hx he₂
      (h _ (by rw [RingHom.mem_ker, map_sub, hx', sub_self]))⟩
Theorem: IsCompact.mem_closure_iff_exists_inseparable
File: Mathlib/Topology/Separation.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : FirstCountableTopology X
inst✝ : R1Space X
x y : X
K : Set X
hK : IsCompact K
⊢ y ∈ closure K ↔ ∃ x ∈ K, Inseparable x y
state_after: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : FirstCountableTopology X
inst✝ : R1Space X
x y : X
K : Set X
hK : IsCompact K
hy : y ∈ closure K
⊢ ∃ x ∈ K, Inseparable x y
tactic: refine ⟨fun hy ↦ ?_, fun ⟨x, hxK, hxy⟩ ↦
    (hxy.mem_closed_iff isClosed_closure).1 <| subset_closure hxK⟩
state_before: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : FirstCountableTopology X
inst✝ : R1Space X
x y : X
K : Set X
hK : IsCompact K
hy : y ∈ closure K
⊢ ∃ x ∈ K, Inseparable x y
state_after: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : FirstCountableTopology X
inst✝ : R1Space X
x y : X
K : Set X
hK : IsCompact K
hy : ∀ x ∈ K, ¬Inseparable x y
⊢ y ∉ closure K
tactic: contrapose! hy
state_before: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : FirstCountableTopology X
inst✝ : R1Space X
x y : X
K : Set X
hK : IsCompact K
hy : ∀ x ∈ K, ¬Inseparable x y
⊢ y ∉ closure K
state_after: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : FirstCountableTopology X
inst✝ : R1Space X
x y : X
K : Set X
hK : IsCompact K
hy : ∀ x ∈ K, ¬Inseparable x y
this : Disjoint (𝓝 y) (𝓝ˢ K)
⊢ y ∉ closure K
tactic: have : Disjoint (𝓝 y) (𝓝ˢ K) := hK.disjoint_nhdsSet_right.2 fun x hx ↦
    (disjoint_nhds_nhds_iff_not_inseparable.2 (hy x hx)).symm
state_before: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : FirstCountableTopology X
inst✝ : R1Space X
x y : X
K : Set X
hK : IsCompact K
hy : ∀ x ∈ K, ¬Inseparable x y
this : Disjoint (𝓝 y) (𝓝ˢ K)
⊢ y ∉ closure K
state_after: no goals
tactic: simpa only [disjoint_iff, not_mem_closure_iff_nhdsWithin_eq_bot]
    using this.mono_right principal_le_nhdsSet
Theorem: FormalMultilinearSeries.nnnorm_changeOriginSeriesTerm
File: Mathlib/Analysis/Analytic/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
p : FormalMultilinearSeries 𝕜 E F
x y : E
r R : ℝ≥0
k l : ℕ
s : Finset (Fin (k + l))
hs : s.card = l
⊢ ‖p.changeOriginSeriesTerm k l s hs‖₊ = ‖p (k + l)‖₊
state_after: no goals
tactic: simp only [changeOriginSeriesTerm, LinearIsometryEquiv.nnnorm_map]
Theorem: Seminorm.ball_sup
File: Mathlib/Analysis/Seminorm.lean

Proof steps:
state_before: R : Type u_1
R' : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type u_5
𝕝 : Type u_6
E : Type u_7
E₂ : Type u_8
E₃ : Type u_9
F : Type u_10
G : Type u_11
ι : Type u_12
inst✝² : SeminormedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : SMul 𝕜 E
p✝ : Seminorm 𝕜 E
x y : E
r✝ : ℝ
p q : Seminorm 𝕜 E
e : E
r : ℝ
⊢ (p ⊔ q).ball e r = p.ball e r ∩ q.ball e r
state_after: no goals
tactic: simp_rw [ball, ← Set.setOf_and, coe_sup, Pi.sup_apply, sup_lt_iff]
Theorem: OrderMonoidHom.cancel_left
File: Mathlib/Algebra/Order/Hom/Monoid.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝⁷ : Preorder α
inst✝⁶ : Preorder β
inst✝⁵ : Preorder γ
inst✝⁴ : Preorder δ
inst✝³ : MulOneClass α
inst✝² : MulOneClass β
inst✝¹ : MulOneClass γ
inst✝ : MulOneClass δ
f g✝ : α →*o β
g : β →*o γ
f₁ f₂ : α →*o β
hg : Injective ⇑g
h : g.comp f₁ = g.comp f₂
a : α
⊢ g (f₁ a) = g (f₂ a)
state_after: no goals
tactic: rw [← comp_apply, h, comp_apply]
Theorem: Finset.prod_erase_attach
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid α
inst✝ : DecidableEq ι
s : Finset ι
f : ι → α
i : { x // x ∈ s }
⊢ ∏ j ∈ s.attach.erase i, f ↑j = ∏ j ∈ s.erase ↑i, f j
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid α
inst✝ : DecidableEq ι
s : Finset ι
f : ι → α
i : { x // x ∈ s }
⊢ ∏ x ∈ map (Embedding.subtype fun x => x ∈ s) (s.attach.erase i), f x =
    ∏ j ∈ s.erase ((Embedding.subtype fun x => x ∈ s) i), f j
tactic: rw [← Function.Embedding.coe_subtype, ← prod_map]
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid α
inst✝ : DecidableEq ι
s : Finset ι
f : ι → α
i : { x // x ∈ s }
⊢ ∏ x ∈ map (Embedding.subtype fun x => x ∈ s) (s.attach.erase i), f x =
    ∏ j ∈ s.erase ((Embedding.subtype fun x => x ∈ s) i), f j
state_after: no goals
tactic: simp [attach_map_val]
Theorem: Nat.count_eq_card_fintype
File: Mathlib/Data/Nat/Count.lean

Proof steps:
state_before: p : ℕ → Prop
inst✝ : DecidablePred p
n : ℕ
⊢ count p n = Fintype.card { k // k < n ∧ p k }
state_after: p : ℕ → Prop
inst✝ : DecidablePred p
n : ℕ
⊢ (Fintype.card ↑fun x => x < n ∧ p x) = Fintype.card { k // k < n ∧ p k }
tactic: rw [count_eq_card_filter_range, ← Fintype.card_ofFinset, ← CountSet.fintype]
state_before: p : ℕ → Prop
inst✝ : DecidablePred p
n : ℕ
⊢ (Fintype.card ↑fun x => x < n ∧ p x) = Fintype.card { k // k < n ∧ p k }
state_after: no goals
tactic: rfl
Theorem: Cardinal.mk_insert
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α✝ β : Type u
c : Cardinal.{?u.214930}
α : Type u
s : Set α
a : α
h : a ∉ s
⊢ #↑(insert a s) = #↑s + 1
state_after: α✝ β : Type u
c : Cardinal.{?u.214930}
α : Type u
s : Set α
a : α
h : a ∉ s
⊢ Disjoint s {a}
tactic: rw [← union_singleton, mk_union_of_disjoint, mk_singleton]
state_before: α✝ β : Type u
c : Cardinal.{?u.214930}
α : Type u
s : Set α
a : α
h : a ∉ s
⊢ Disjoint s {a}
state_after: no goals
tactic: simpa
Theorem: Comon_.comul_assoc_flip
File: Mathlib/CategoryTheory/Monoidal/Comon_.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M : Comon_ C
⊢ M.comul ≫ M.comul ▷ M.X = M.comul ≫ M.X ◁ M.comul ≫ (α_ M.X M.X M.X).inv
state_after: no goals
tactic: simp [← comul_assoc]
Theorem: CategoryTheory.Limits.kernelSubobject_arrow_comp
File: Mathlib/CategoryTheory/Subobject/Limits.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
X Y Z : C
inst✝¹ : HasZeroMorphisms C
f : X ⟶ Y
inst✝ : HasKernel f
⊢ (kernelSubobject f).arrow ≫ f = 0
state_after: C : Type u
inst✝² : Category.{v, u} C
X Y Z : C
inst✝¹ : HasZeroMorphisms C
f : X ⟶ Y
inst✝ : HasKernel f
⊢ ((kernelSubobjectIso f).hom ≫ kernel.ι f) ≫ f = 0
tactic: rw [← kernelSubobject_arrow]
state_before: C : Type u
inst✝² : Category.{v, u} C
X Y Z : C
inst✝¹ : HasZeroMorphisms C
f : X ⟶ Y
inst✝ : HasKernel f
⊢ ((kernelSubobjectIso f).hom ≫ kernel.ι f) ≫ f = 0
state_after: no goals
tactic: simp only [Category.assoc, kernel.condition, comp_zero]
Theorem: Irreducible.squarefree
File: Mathlib/Algebra/Squarefree/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommMonoid R
x : R
h : Irreducible x
⊢ Squarefree x
state_after: case intro
R : Type u_1
inst✝ : CommMonoid R
x : R
h : Irreducible x
y z : R
hz : x = y * y * z
⊢ IsUnit y
tactic: rintro y ⟨z, hz⟩
state_before: case intro
R : Type u_1
inst✝ : CommMonoid R
x : R
h : Irreducible x
y z : R
hz : x = y * y * z
⊢ IsUnit y
state_after: case intro
R : Type u_1
inst✝ : CommMonoid R
x : R
h : Irreducible x
y z : R
hz : x = y * (y * z)
⊢ IsUnit y
tactic: rw [mul_assoc] at hz
state_before: case intro
R : Type u_1
inst✝ : CommMonoid R
x : R
h : Irreducible x
y z : R
hz : x = y * (y * z)
⊢ IsUnit y
state_after: case intro.inl
R : Type u_1
inst✝ : CommMonoid R
x : R
h : Irreducible x
y z : R
hz : x = y * (y * z)
hu : IsUnit y
⊢ IsUnit y

case intro.inr
R : Type u_1
inst✝ : CommMonoid R
x : R
h : Irreducible x
y z : R
hz : x = y * (y * z)
hu : IsUnit (y * z)
⊢ IsUnit y
tactic: rcases h.isUnit_or_isUnit hz with (hu | hu)
Theorem: DirichletCharacter.changeLevel_trans
File: Mathlib/NumberTheory/DirichletCharacter/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommMonoidWithZero R
n : ℕ
χ : DirichletCharacter R n
m d : ℕ
hm : n ∣ m
hd : m ∣ d
⊢ (changeLevel ⋯) χ = (changeLevel hd) ((changeLevel hm) χ)
state_after: no goals
tactic: simp [changeLevel_def, MonoidHom.comp_assoc, ZMod.unitsMap_comp]
Theorem: List.formPerm_apply_getElem_zero
File: Mathlib/GroupTheory/Perm/List.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : l.Nodup
hl : 1 < l.length
⊢ l.formPerm l[0] = l[1]
state_after: case nil
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l : List α
x : α
h : [].Nodup
hl : 1 < [].length
⊢ [].formPerm [][0] = [][1]

case cons.nil
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l : List α
x✝ x : α
h : [x].Nodup
hl : 1 < [x].length
⊢ [x].formPerm [x][0] = [x][1]

case cons.cons
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l : List α
x✝ x y : α
tl : List α
h : (x :: y :: tl).Nodup
hl : 1 < (x :: y :: tl).length
⊢ (x :: y :: tl).formPerm (x :: y :: tl)[0] = (x :: y :: tl)[1]
tactic: rcases l with (_ | ⟨x, _ | ⟨y, tl⟩⟩)
Theorem: Finpartition.exists_equipartition_card_eq
File: Mathlib/Combinatorics/SimpleGraph/Regularity/Equitabilise.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
m n a b : ℕ
P : Finpartition s
h : a * m + b * (m + 1) = s.card
hn : n ≠ 0
hs : n ≤ s.card
⊢ ∃ P, P.IsEquipartition ∧ P.parts.card = n
state_after: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
m n a b : ℕ
P : Finpartition s
h : a * m + b * (m + 1) = s.card
hn : 0 < n
hs : n ≤ s.card
⊢ ∃ P, P.IsEquipartition ∧ P.parts.card = n
tactic: rw [← pos_iff_ne_zero] at hn
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
m n a b : ℕ
P : Finpartition s
h : a * m + b * (m + 1) = s.card
hn : 0 < n
hs : n ≤ s.card
⊢ ∃ P, P.IsEquipartition ∧ P.parts.card = n
state_after: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
m n a b : ℕ
P : Finpartition s
h : a * m + b * (m + 1) = s.card
hn : 0 < n
hs : n ≤ s.card
this : (n - s.card % n) * (s.card / n) + s.card % n * (s.card / n + 1) = s.card
⊢ ∃ P, P.IsEquipartition ∧ P.parts.card = n
tactic: have : (n - s.card % n) * (s.card / n) + s.card % n * (s.card / n + 1) = s.card := by
    rw [tsub_mul, mul_add, ← add_assoc,
      tsub_add_cancel_of_le (Nat.mul_le_mul_right _ (mod_lt _ hn).le), mul_one, add_comm,
      mod_add_div]
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
m n a b : ℕ
P : Finpartition s
h : a * m + b * (m + 1) = s.card
hn : 0 < n
hs : n ≤ s.card
this : (n - s.card % n) * (s.card / n) + s.card % n * (s.card / n + 1) = s.card
⊢ ∃ P, P.IsEquipartition ∧ P.parts.card = n
state_after: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
m n a b : ℕ
P : Finpartition s
h : a * m + b * (m + 1) = s.card
hn : 0 < n
hs : n ≤ s.card
this : (n - s.card % n) * (s.card / n) + s.card % n * (s.card / n + 1) = s.card
⊢ (equitabilise this).parts.card = n
tactic: refine
    ⟨(indiscrete (card_pos.1 <| hn.trans_le hs).ne_empty).equitabilise this,
      equitabilise_isEquipartition, ?_⟩
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
m n a b : ℕ
P : Finpartition s
h : a * m + b * (m + 1) = s.card
hn : 0 < n
hs : n ≤ s.card
this : (n - s.card % n) * (s.card / n) + s.card % n * (s.card / n + 1) = s.card
⊢ (equitabilise this).parts.card = n
state_after: no goals
tactic: rw [card_parts_equitabilise _ _ (Nat.div_pos hs hn).ne', tsub_add_cancel_of_le (mod_lt _ hn).le]
Theorem: Function.Injective.dite
File: Mathlib/Logic/Function/Basic.lean

Proof steps:
state_before: α : Sort u_1
β : Sort u_2
γ : Sort u_3
f✝ : α → β
p : α → Prop
inst✝ : DecidablePred p
f : { a // p a } → β
f' : { a // ¬p a } → β
hf : Injective f
hf' : Injective f'
im_disj : ∀ {x x' : α} {hx : p x} {hx' : ¬p x'}, f ⟨x, hx⟩ ≠ f' ⟨x', hx'⟩
x₁ x₂ : α
h : (fun x => if h : p x then f ⟨x, h⟩ else f' ⟨x, h⟩) x₁ = (fun x => if h : p x then f ⟨x, h⟩ else f' ⟨x, h⟩) x₂
⊢ x₁ = x₂
state_after: α : Sort u_1
β : Sort u_2
γ : Sort u_3
f✝ : α → β
p : α → Prop
inst✝ : DecidablePred p
f : { a // p a } → β
f' : { a // ¬p a } → β
hf : Injective f
hf' : Injective f'
im_disj : ∀ {x x' : α} {hx : p x} {hx' : ¬p x'}, f ⟨x, hx⟩ ≠ f' ⟨x', hx'⟩
x₁ x₂ : α
h : (if h : p x₁ then f ⟨x₁, h⟩ else f' ⟨x₁, h⟩) = if h : p x₂ then f ⟨x₂, h⟩ else f' ⟨x₂, h⟩
⊢ x₁ = x₂
tactic: dsimp only at h
state_before: α : Sort u_1
β : Sort u_2
γ : Sort u_3
f✝ : α → β
p : α → Prop
inst✝ : DecidablePred p
f : { a // p a } → β
f' : { a // ¬p a } → β
hf : Injective f
hf' : Injective f'
im_disj : ∀ {x x' : α} {hx : p x} {hx' : ¬p x'}, f ⟨x, hx⟩ ≠ f' ⟨x', hx'⟩
x₁ x₂ : α
h : (if h : p x₁ then f ⟨x₁, h⟩ else f' ⟨x₁, h⟩) = if h : p x₂ then f ⟨x₂, h⟩ else f' ⟨x₂, h⟩
⊢ x₁ = x₂
state_after: case pos
α : Sort u_1
β : Sort u_2
γ : Sort u_3
f✝ : α → β
p : α → Prop
inst✝ : DecidablePred p
f : { a // p a } → β
f' : { a // ¬p a } → β
hf : Injective f
hf' : Injective f'
im_disj : ∀ {x x' : α} {hx : p x} {hx' : ¬p x'}, f ⟨x, hx⟩ ≠ f' ⟨x', hx'⟩
x₁ x₂ : α
h : (if h : p x₁ then f ⟨x₁, h⟩ else f' ⟨x₁, h⟩) = if h : p x₂ then f ⟨x₂, h⟩ else f' ⟨x₂, h⟩
h₁ : p x₁
h₂ : p x₂
⊢ x₁ = x₂

case neg
α : Sort u_1
β : Sort u_2
γ : Sort u_3
f✝ : α → β
p : α → Prop
inst✝ : DecidablePred p
f : { a // p a } → β
f' : { a // ¬p a } → β
hf : Injective f
hf' : Injective f'
im_disj : ∀ {x x' : α} {hx : p x} {hx' : ¬p x'}, f ⟨x, hx⟩ ≠ f' ⟨x', hx'⟩
x₁ x₂ : α
h : (if h : p x₁ then f ⟨x₁, h⟩ else f' ⟨x₁, h⟩) = if h : p x₂ then f ⟨x₂, h⟩ else f' ⟨x₂, h⟩
h₁ : p x₁
h₂ : ¬p x₂
⊢ x₁ = x₂

case pos
α : Sort u_1
β : Sort u_2
γ : Sort u_3
f✝ : α → β
p : α → Prop
inst✝ : DecidablePred p
f : { a // p a } → β
f' : { a // ¬p a } → β
hf : Injective f
hf' : Injective f'
im_disj : ∀ {x x' : α} {hx : p x} {hx' : ¬p x'}, f ⟨x, hx⟩ ≠ f' ⟨x', hx'⟩
x₁ x₂ : α
h : (if h : p x₁ then f ⟨x₁, h⟩ else f' ⟨x₁, h⟩) = if h : p x₂ then f ⟨x₂, h⟩ else f' ⟨x₂, h⟩
h₁ : ¬p x₁
h₂ : p x₂
⊢ x₁ = x₂

case neg
α : Sort u_1
β : Sort u_2
γ : Sort u_3
f✝ : α → β
p : α → Prop
inst✝ : DecidablePred p
f : { a // p a } → β
f' : { a // ¬p a } → β
hf : Injective f
hf' : Injective f'
im_disj : ∀ {x x' : α} {hx : p x} {hx' : ¬p x'}, f ⟨x, hx⟩ ≠ f' ⟨x', hx'⟩
x₁ x₂ : α
h : (if h : p x₁ then f ⟨x₁, h⟩ else f' ⟨x₁, h⟩) = if h : p x₂ then f ⟨x₂, h⟩ else f' ⟨x₂, h⟩
h₁ : ¬p x₁
h₂ : ¬p x₂
⊢ x₁ = x₂
tactic: by_cases h₁ : p x₁ <;> by_cases h₂ : p x₂
Theorem: Set.Ioo_subset_Ioo_iff
File: Mathlib/Order/Interval/Set/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
inst✝ : DenselyOrdered α
h₁ : a₁ < b₁
h : Ioo a₁ b₁ ⊆ Ioo a₂ b₂
⊢ a₂ ≤ a₁ ∧ b₁ ≤ b₂
state_after: case intro.intro
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
inst✝ : DenselyOrdered α
h₁ : a₁ < b₁
h : Ioo a₁ b₁ ⊆ Ioo a₂ b₂
x : α
xa : a₁ < x
xb : x < b₁
⊢ a₂ ≤ a₁ ∧ b₁ ≤ b₂
tactic: rcases exists_between h₁ with ⟨x, xa, xb⟩
state_before: case intro.intro
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
inst✝ : DenselyOrdered α
h₁ : a₁ < b₁
h : Ioo a₁ b₁ ⊆ Ioo a₂ b₂
x : α
xa : a₁ < x
xb : x < b₁
⊢ a₂ ≤ a₁ ∧ b₁ ≤ b₂
state_after: case intro.intro.left
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
inst✝ : DenselyOrdered α
h₁ : a₁ < b₁
h : Ioo a₁ b₁ ⊆ Ioo a₂ b₂
x : α
xa : a₁ < x
xb : x < b₁
h' : a₁ < a₂
⊢ False

case intro.intro.right
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
inst✝ : DenselyOrdered α
h₁ : a₁ < b₁
h : Ioo a₁ b₁ ⊆ Ioo a₂ b₂
x : α
xa : a₁ < x
xb : x < b₁
h' : b₂ < b₁
⊢ False
tactic: constructor <;> refine le_of_not_lt fun h' => ?_
Theorem: Nat.coprime_list_prod_left_iff
File: Mathlib/Data/Nat/GCD/BigOperators.lean

Proof steps:
state_before: ι : Type u_1
l : List ℕ
k : ℕ
⊢ l.prod.Coprime k ↔ ∀ n ∈ l, n.Coprime k
state_after: no goals
tactic: induction l <;> simp [Nat.coprime_mul_iff_left, *]
Theorem: Set.inter_indicator_mul
File: Mathlib/Algebra/GroupWithZero/Indicator.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
G₀ : Type u_3
M₀ : Type u_4
R : Type u_5
inst✝ : MulZeroClass M₀
s t : Set ι
f✝ g✝ : ι → M₀
i✝ : ι
f g : ι → M₀
i : ι
⊢ (s ∩ t).indicator (fun j => f j * g j) i = s.indicator f i * t.indicator g i
state_after: ι : Type u_1
κ : Type u_2
G₀ : Type u_3
M₀ : Type u_4
R : Type u_5
inst✝ : MulZeroClass M₀
s t : Set ι
f✝ g✝ : ι → M₀
i✝ : ι
f g : ι → M₀
i : ι
⊢ s.indicator (t.indicator fun j => f j * g j) i = s.indicator f i * t.indicator g i
tactic: rw [← Set.indicator_indicator]
state_before: ι : Type u_1
κ : Type u_2
G₀ : Type u_3
M₀ : Type u_4
R : Type u_5
inst✝ : MulZeroClass M₀
s t : Set ι
f✝ g✝ : ι → M₀
i✝ : ι
f g : ι → M₀
i : ι
⊢ s.indicator (t.indicator fun j => f j * g j) i = s.indicator f i * t.indicator g i
state_after: ι : Type u_1
κ : Type u_2
G₀ : Type u_3
M₀ : Type u_4
R : Type u_5
inst✝ : MulZeroClass M₀
s t : Set ι
f✝ g✝ : ι → M₀
i✝ : ι
f g : ι → M₀
i : ι
⊢ (if i ∈ s then if i ∈ t then f i * g i else 0 else 0) = (if i ∈ s then f i else 0) * if i ∈ t then g i else 0
tactic: simp_rw [indicator]
state_before: ι : Type u_1
κ : Type u_2
G₀ : Type u_3
M₀ : Type u_4
R : Type u_5
inst✝ : MulZeroClass M₀
s t : Set ι
f✝ g✝ : ι → M₀
i✝ : ι
f g : ι → M₀
i : ι
⊢ (if i ∈ s then if i ∈ t then f i * g i else 0 else 0) = (if i ∈ s then f i else 0) * if i ∈ t then g i else 0
state_after: no goals
tactic: split_ifs <;> simp
Theorem: FirstOrder.Language.Substructure.CG.sup
File: Mathlib/ModelTheory/FinitelyGenerated.lean

Proof steps:
state_before: L : Language
M : Type u_1
inst✝ : L.Structure M
N₁ N₂ : L.Substructure M
hN₁ : N₁.CG
hN₂ : N₂.CG
t₁ : Set M
ht₁ : t₁.Countable ∧ (closure L).toFun t₁ = N₁
t₂ : Set M
ht₂ : t₂.Countable ∧ (closure L).toFun t₂ = N₂
⊢ (closure L).toFun (t₁ ∪ t₂) = N₁ ⊔ N₂
state_after: no goals
tactic: rw [closure_union, ht₁.2, ht₂.2]
Theorem: MeasureTheory.Measure.measure_toMeasurable_add_inter_right
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ s t : Set α
hs : MeasurableSet s
ht : (μ + ν) t ≠ ⊤
⊢ ν (toMeasurable (μ + ν) t ∩ s) = ν (t ∩ s)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ s t : Set α
hs : MeasurableSet s
ht : (ν + μ) t ≠ ⊤
⊢ ν (toMeasurable (ν + μ) t ∩ s) = ν (t ∩ s)
tactic: rw [add_comm] at ht ⊢
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ s t : Set α
hs : MeasurableSet s
ht : (ν + μ) t ≠ ⊤
⊢ ν (toMeasurable (ν + μ) t ∩ s) = ν (t ∩ s)
state_after: no goals
tactic: exact measure_toMeasurable_add_inter_left hs ht
Theorem: CategoryTheory.Limits.WidePullbackShape.wideCospan_obj
File: Mathlib/CategoryTheory/Limits/Shapes/WidePullbacks.lean

Proof steps:
state_before: J : Type w
C : Type u
inst✝ : Category.{v, u} C
B : C
objs : J → C
arrows : (j : J) → objs j ⟶ B
X✝ Y✝ : WidePullbackShape J
f : X✝ ⟶ Y✝
⊢ (fun j => Option.casesOn j B objs) X✝ ⟶ (fun j => Option.casesOn j B objs) Y✝
state_after: case id
J : Type w
C : Type u
inst✝ : Category.{v, u} C
B : C
objs : J → C
arrows : (j : J) → objs j ⟶ B
X✝ : WidePullbackShape J
⊢ (fun j => Option.casesOn j B objs) X✝ ⟶ (fun j => Option.casesOn j B objs) X✝

case term
J : Type w
C : Type u
inst✝ : Category.{v, u} C
B : C
objs : J → C
arrows : (j : J) → objs j ⟶ B
j : J
⊢ (fun j => Option.casesOn j B objs) (some j) ⟶ (fun j => Option.casesOn j B objs) none
tactic: cases' f with _ j
Theorem: Nat.gcd_mul_right_add_right
File: Mathlib/Data/Nat/GCD/Basic.lean

Proof steps:
state_before: m n k : ℕ
⊢ m.gcd (k * m + n) = m.gcd n
state_after: no goals
tactic: simp [add_comm _ n]
Theorem: ContractingWith.eq_or_edist_eq_top_of_fixedPoints
File: Mathlib/Topology/MetricSpace/Contracting.lean

Proof steps:
state_before: α : Type u_1
inst✝ : EMetricSpace α
cs : CompleteSpace α
K : ℝ≥0
f : α → α
hf : ContractingWith K f
x y : α
hx : IsFixedPt f x
hy : IsFixedPt f y
⊢ x = y ∨ edist x y = ⊤
state_after: α : Type u_1
inst✝ : EMetricSpace α
cs : CompleteSpace α
K : ℝ≥0
f : α → α
hf : ContractingWith K f
x y : α
hx : IsFixedPt f x
hy : IsFixedPt f y
h : ¬edist x y = ⊤
⊢ edist x y ≤ 0
tactic: refine or_iff_not_imp_right.2 fun h ↦ edist_le_zero.1 ?_
state_before: α : Type u_1
inst✝ : EMetricSpace α
cs : CompleteSpace α
K : ℝ≥0
f : α → α
hf : ContractingWith K f
x y : α
hx : IsFixedPt f x
hy : IsFixedPt f y
h : ¬edist x y = ⊤
⊢ edist x y ≤ 0
state_after: no goals
tactic: simpa only [hx.eq, edist_self, add_zero, ENNReal.zero_div] using hf.edist_le_of_fixedPoint h hy