ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: SimpContFract.determinant_aux
File: Mathlib/Algebra/ContinuedFractions/Determinant.lean

Proof steps:
state_before: K : Type u_1
inst✝ : Field K
s : SimpContFract K
n : ℕ
hyp : n = 0 ∨ ¬(↑s).TerminatedAt (n - 1)
⊢ ((↑s).contsAux n).a * ((↑s).contsAux (n + 1)).b - ((↑s).contsAux n).b * ((↑s).contsAux (n + 1)).a = (-1) ^ n
state_after: no goals
tactic: induction n with
  | zero => simp [contsAux]
  | succ n IH =>
    -- set up some shorthand notation
    let g := (↑s : GenContFract K)
    let conts := contsAux g (n + 2)
    set pred_conts := contsAux g (n + 1) with pred_conts_eq
    set ppred_conts := contsAux g n with ppred_conts_eq
    let pA := pred_conts.a
    let pB := pred_conts.b
    let ppA := ppred_conts.a
    let ppB := ppred_conts.b
    -- let's change the goal to something more readable
    change pA * conts.b - pB * conts.a = (-1) ^ (n + 1)
    have not_terminated_at_n : ¬TerminatedAt g n := Or.resolve_left hyp n.succ_ne_zero
    obtain ⟨gp, s_nth_eq⟩ : ∃ gp, g.s.get? n = some gp :=
      Option.ne_none_iff_exists'.1 not_terminated_at_n
    -- unfold the recurrence relation for `conts` once and simplify to derive the following
    suffices pA * (ppB + gp.b * pB) - pB * (ppA + gp.b * pA) = (-1) ^ (n + 1) by
      simp only [conts, contsAux_recurrence s_nth_eq ppred_conts_eq pred_conts_eq]
      have gp_a_eq_one : gp.a = 1 := s.property _ _ (partNum_eq_s_a s_nth_eq)
      rw [gp_a_eq_one, this.symm]
      ring
    suffices pA * ppB - pB * ppA = (-1) ^ (n + 1) by calc
      pA * (ppB + gp.b * pB) - pB * (ppA + gp.b * pA) =
          pA * ppB + pA * gp.b * pB - pB * ppA - pB * gp.b * pA := by ring
      _ = pA * ppB - pB * ppA := by ring
      _ = (-1) ^ (n + 1) := by assumption
    suffices ppA * pB - ppB * pA = (-1) ^ n by
      have pow_succ_n : (-1 : K) ^ (n + 1) = -1 * (-1) ^ n := pow_succ' (-1) n
      rw [pow_succ_n, ← this]
      ring
    exact IH <| Or.inr <| mt (terminated_stable <| n.sub_le 1) not_terminated_at_n
Theorem: Filter.HasBasis.prod_self
File: Mathlib/Order/Filter/Bases.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
la : Filter α
pa : ι → Prop
sa : ι → Set α
lb : Filter β
pb : ι' → Prop
sb : ι' → Set β
f : α → β
hl : la.HasBasis pa sa
i j : ι
hi : pa i
hj : pa j
⊢ ∃ k, pa k ∧ sa k ⊆ sa i ∧ sa k ⊆ sa j
state_after: no goals
tactic: simpa only [exists_prop, subset_inter_iff] using
      hl.mem_iff.1 (inter_mem (hl.mem_of_mem hi) (hl.mem_of_mem hj))
Theorem: inf_symmDiff_distrib_right
File: Mathlib/Order/SymmDiff.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedBooleanAlgebra α
a b c d : α
⊢ a ∆ b ⊓ c = (a ⊓ c) ∆ (b ⊓ c)
state_after: no goals
tactic: simp_rw [inf_comm _ c, inf_symmDiff_distrib_left]
Theorem: Set.preimage_image_sigmaMk_of_ne
File: Mathlib/Data/Set/Sigma.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
β : ι → Type u_4
s✝ s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
u : Set ((i : ι) × α i)
x : (i : ι) × α i
i j : ι
a : α i
h : i ≠ j
s : Set (α j)
⊢ Sigma.mk i ⁻¹' (Sigma.mk j '' s) = ∅
state_after: case h
ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
β : ι → Type u_4
s✝ s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
u : Set ((i : ι) × α i)
x✝ : (i : ι) × α i
i j : ι
a : α i
h : i ≠ j
s : Set (α j)
x : α i
⊢ x ∈ Sigma.mk i ⁻¹' (Sigma.mk j '' s) ↔ x ∈ ∅
tactic: ext x
state_before: case h
ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
β : ι → Type u_4
s✝ s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
u : Set ((i : ι) × α i)
x✝ : (i : ι) × α i
i j : ι
a : α i
h : i ≠ j
s : Set (α j)
x : α i
⊢ x ∈ Sigma.mk i ⁻¹' (Sigma.mk j '' s) ↔ x ∈ ∅
state_after: no goals
tactic: simp [h.symm]
Theorem: CategoryTheory.reflects_epi_of_reflectsColimit
File: Mathlib/CategoryTheory/Limits/Constructions/EpiMono.lean

Proof steps:
state_before: C : Type u₁
D : Type u₂
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
F : C ⥤ D
X Y : C
f : X ⟶ Y
inst✝¹ : ReflectsColimit (span f f) F
inst✝ : Epi (F.map f)
⊢ Epi f
state_after: C : Type u₁
D : Type u₂
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
F : C ⥤ D
X Y : C
f : X ⟶ Y
inst✝¹ : ReflectsColimit (span f f) F
inst✝ : Epi (F.map f)
this : IsColimit (PushoutCocone.mk (𝟙 (F.obj Y)) (𝟙 (F.obj Y)) ⋯)
⊢ Epi f
tactic: have := PushoutCocone.isColimitMkIdId (F.map f)
state_before: C : Type u₁
D : Type u₂
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
F : C ⥤ D
X Y : C
f : X ⟶ Y
inst✝¹ : ReflectsColimit (span f f) F
inst✝ : Epi (F.map f)
this : IsColimit (PushoutCocone.mk (𝟙 (F.obj Y)) (𝟙 (F.obj Y)) ⋯)
⊢ Epi f
state_after: C : Type u₁
D : Type u₂
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
F : C ⥤ D
X Y : C
f : X ⟶ Y
inst✝¹ : ReflectsColimit (span f f) F
inst✝ : Epi (F.map f)
this : IsColimit (PushoutCocone.mk (F.map (𝟙 Y)) (F.map (𝟙 Y)) ⋯)
⊢ Epi f
tactic: simp_rw [← F.map_id] at this
state_before: C : Type u₁
D : Type u₂
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
F : C ⥤ D
X Y : C
f : X ⟶ Y
inst✝¹ : ReflectsColimit (span f f) F
inst✝ : Epi (F.map f)
this : IsColimit (PushoutCocone.mk (F.map (𝟙 Y)) (F.map (𝟙 Y)) ⋯)
⊢ Epi f
state_after: no goals
tactic: apply
    PushoutCocone.epi_of_isColimitMkIdId _
      (isColimitOfIsColimitPushoutCoconeMap F _ this)
Theorem: GaussianInt.sq_add_sq_of_nat_prime_of_not_irreducible
File: Mathlib/NumberTheory/Zsqrtd/GaussianInt.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
hpi : ¬Irreducible ↑p
⊢ ¬(norm ↑p).natAbs = 1
state_after: p : ℕ
hp : Fact (Nat.Prime p)
hpi : ¬Irreducible ↑p
⊢ ¬((↑p).natAbs = 1 ∧ (↑p).natAbs = 1)
tactic: rw [norm_natCast, Int.natAbs_mul, mul_eq_one]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
hpi : ¬Irreducible ↑p
⊢ ¬((↑p).natAbs = 1 ∧ (↑p).natAbs = 1)
state_after: no goals
tactic: exact fun h => (ne_of_lt hp.1.one_lt).symm h.1
state_before: p : ℕ
hp : Fact (Nat.Prime p)
hpi : ¬Irreducible ↑p
hpu : ¬IsUnit ↑p
⊢ ∃ a b, ↑p = a * b ∧ ¬IsUnit a ∧ ¬IsUnit b
state_after: no goals
tactic: simpa only [true_and, not_false_iff, exists_prop, irreducible_iff, hpu, not_forall, not_or]
      using hpi
state_before: p : ℕ
hp : Fact (Nat.Prime p)
hpi : ¬Irreducible ↑p
hpu : ¬IsUnit ↑p
hab : ∃ a b, ↑p = a * b ∧ ¬IsUnit a ∧ ¬IsUnit b
a b : ℤ[i]
hpab : ↑p = a * b
hau : ¬IsUnit a
hbu : ¬IsUnit b
⊢ (norm a).natAbs * (norm b).natAbs = p ^ 2
state_after: p : ℕ
hp : Fact (Nat.Prime p)
hpi : ¬Irreducible ↑p
hpu : ¬IsUnit ↑p
hab : ∃ a b, ↑p = a * b ∧ ¬IsUnit a ∧ ¬IsUnit b
a b : ℤ[i]
hpab : ↑p = a * b
hau : ¬IsUnit a
hbu : ¬IsUnit b
⊢ ↑((norm a).natAbs * (norm b).natAbs) = norm (a * b)
tactic: rw [← Int.natCast_inj, Int.natCast_pow, sq, ← @norm_natCast (-1), hpab]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
hpi : ¬Irreducible ↑p
hpu : ¬IsUnit ↑p
hab : ∃ a b, ↑p = a * b ∧ ¬IsUnit a ∧ ¬IsUnit b
a b : ℤ[i]
hpab : ↑p = a * b
hau : ¬IsUnit a
hbu : ¬IsUnit b
⊢ ↑((norm a).natAbs * (norm b).natAbs) = norm (a * b)
state_after: no goals
tactic: simp
state_before: p : ℕ
hp : Fact (Nat.Prime p)
hpi : ¬Irreducible ↑p
hpu : ¬IsUnit ↑p
hab : ∃ a b, ↑p = a * b ∧ ¬IsUnit a ∧ ¬IsUnit b
a b : ℤ[i]
hpab : ↑p = a * b
hau : ¬IsUnit a
hbu : ¬IsUnit b
hnap : (norm a).natAbs = p
⊢ a.re.natAbs ^ 2 + a.im.natAbs ^ 2 = p
state_after: no goals
tactic: simpa [natAbs_norm_eq, sq] using hnap
Theorem: Nat.minFacAux_has_prop
File: Mathlib/Data/Nat/Prime/Defs.lean

Proof steps:
state_before: n✝ n : ℕ
n2 : 2 ≤ n
x✝ : ℕ
k : ℕ := x✝
i : ℕ
e : x✝ = 2 * i + 3
a : ∀ (m : ℕ), 2 ≤ m → m ∣ n → x✝ ≤ m
⊢ Nat.minFacProp n (n.minFacAux x✝)
state_after: n✝ n : ℕ
n2 : 2 ≤ n
x✝ : ℕ
k : ℕ := x✝
i : ℕ
e : x✝ = 2 * i + 3
a : ∀ (m : ℕ), 2 ≤ m → m ∣ n → x✝ ≤ m
⊢ Nat.minFacProp n (if n < x✝ * x✝ then n else if x✝ ∣ n then x✝ else n.minFacAux (x✝ + 2))
tactic: rw [minFacAux]
state_before: n✝ n : ℕ
n2 : 2 ≤ n
x✝ : ℕ
k : ℕ := x✝
i : ℕ
e : x✝ = 2 * i + 3
a : ∀ (m : ℕ), 2 ≤ m → m ∣ n → x✝ ≤ m
⊢ Nat.minFacProp n (if n < x✝ * x✝ then n else if x✝ ∣ n then x✝ else n.minFacAux (x✝ + 2))
state_after: case pos
n✝ n : ℕ
n2 : 2 ≤ n
x✝ : ℕ
k : ℕ := x✝
i : ℕ
e : x✝ = 2 * i + 3
a : ∀ (m : ℕ), 2 ≤ m → m ∣ n → x✝ ≤ m
h : n < k * k
⊢ Nat.minFacProp n (if n < x✝ * x✝ then n else if x✝ ∣ n then x✝ else n.minFacAux (x✝ + 2))

case neg
n✝ n : ℕ
n2 : 2 ≤ n
x✝ : ℕ
k : ℕ := x✝
i : ℕ
e : x✝ = 2 * i + 3
a : ∀ (m : ℕ), 2 ≤ m → m ∣ n → x✝ ≤ m
h : ¬n < k * k
⊢ Nat.minFacProp n (if n < x✝ * x✝ then n else if x✝ ∣ n then x✝ else n.minFacAux (x✝ + 2))
tactic: by_cases h : n < k * k
state_before: case neg
n✝ n : ℕ
n2 : 2 ≤ n
x✝ : ℕ
k : ℕ := x✝
i : ℕ
e : x✝ = 2 * i + 3
a : ∀ (m : ℕ), 2 ≤ m → m ∣ n → x✝ ≤ m
h : ¬n < k * k
⊢ Nat.minFacProp n (if n < x✝ * x✝ then n else if x✝ ∣ n then x✝ else n.minFacAux (x✝ + 2))
state_after: case neg
n✝ n : ℕ
n2 : 2 ≤ n
x✝ : ℕ
k : ℕ := x✝
i : ℕ
e : x✝ = 2 * i + 3
a : ∀ (m : ℕ), 2 ≤ m → m ∣ n → x✝ ≤ m
h : ¬n < k * k
k2 : 2 ≤ k
⊢ Nat.minFacProp n (if n < x✝ * x✝ then n else if x✝ ∣ n then x✝ else n.minFacAux (x✝ + 2))
tactic: have k2 : 2 ≤ k := by
      subst e
      apply Nat.le_add_left
state_before: case neg
n✝ n : ℕ
n2 : 2 ≤ n
x✝ : ℕ
k : ℕ := x✝
i : ℕ
e : x✝ = 2 * i + 3
a : ∀ (m : ℕ), 2 ≤ m → m ∣ n → x✝ ≤ m
h : ¬n < k * k
k2 : 2 ≤ k
⊢ Nat.minFacProp n (if n < x✝ * x✝ then n else if x✝ ∣ n then x✝ else n.minFacAux (x✝ + 2))
state_after: case neg
n✝ n : ℕ
n2 : 2 ≤ n
x✝ : ℕ
k : ℕ := x✝
i : ℕ
e : x✝ = 2 * i + 3
a : ∀ (m : ℕ), 2 ≤ m → m ∣ n → x✝ ≤ m
h : ¬n < k * k
k2 : 2 ≤ k
⊢ Nat.minFacProp n (if x✝ ∣ n then x✝ else n.minFacAux (x✝ + 2))
tactic: simp only [h, ↓reduceIte]
state_before: case neg
n✝ n : ℕ
n2 : 2 ≤ n
x✝ : ℕ
k : ℕ := x✝
i : ℕ
e : x✝ = 2 * i + 3
a : ∀ (m : ℕ), 2 ≤ m → m ∣ n → x✝ ≤ m
h : ¬n < k * k
k2 : 2 ≤ k
⊢ Nat.minFacProp n (if x✝ ∣ n then x✝ else n.minFacAux (x✝ + 2))
state_after: case pos
n✝ n : ℕ
n2 : 2 ≤ n
x✝ : ℕ
k : ℕ := x✝
i : ℕ
e : x✝ = 2 * i + 3
a : ∀ (m : ℕ), 2 ≤ m → m ∣ n → x✝ ≤ m
h : ¬n < k * k
k2 : 2 ≤ k
dk : k ∣ n
⊢ Nat.minFacProp n x✝

case neg
n✝ n : ℕ
n2 : 2 ≤ n
x✝ : ℕ
k : ℕ := x✝
i : ℕ
e : x✝ = 2 * i + 3
a : ∀ (m : ℕ), 2 ≤ m → m ∣ n → x✝ ≤ m
h : ¬n < k * k
k2 : 2 ≤ k
dk : ¬k ∣ n
⊢ Nat.minFacProp n (n.minFacAux (x✝ + 2))
tactic: by_cases dk : k ∣ n <;> simp only [dk, ↓reduceIte]
Theorem: CategoryTheory.Limits.IsLimit.lift_comp_conePointUniqueUpToIso_hom
File: Mathlib/CategoryTheory/Limits/IsLimit.lean

Proof steps:
state_before: J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
r s t : Cone F
P : IsLimit s
Q : IsLimit t
⊢ ∀ (j : J), (P.lift r ≫ (P.conePointUniqueUpToIso Q).hom) ≫ t.π.app j = r.π.app j
state_after: no goals
tactic: simp
Theorem: Fin.succAbove_rev_right
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n m : ℕ
p✝ : Fin (n + 1)
i✝ j : Fin n
p : Fin (n + 1)
i : Fin n
⊢ p.succAbove i.rev = (p.rev.succAbove i).rev
state_after: no goals
tactic: rw [succAbove_rev_left, rev_rev]
Theorem: Ordinal.relIso_enum'
File: Mathlib/SetTheory/Ordinal/Basic.lean

Proof steps:
state_before: α✝ : Type u
β✝ : Type u_1
γ : Type u_2
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
α β : Type u
r : α → α → Prop
s : β → β → Prop
inst✝¹ : IsWellOrder α r
inst✝ : IsWellOrder β s
f : r ≃r s
o : Ordinal.{u}
⊢ ∀ (hr : o < type r) (hs : o < type s), f (enum r o hr) = enum s o hs
state_after: α✝ : Type u
β✝ : Type u_1
γ : Type u_2
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
α β : Type u
r : α → α → Prop
s : β → β → Prop
inst✝¹ : IsWellOrder α r
inst✝ : IsWellOrder β s
f : r ≃r s
o : Ordinal.{u}
⊢ ∀ (α_1 : Type u) (r_1 : α_1 → α_1 → Prop) [inst : IsWellOrder α_1 r_1] (hr : type r_1 < type r)
    (hs : type r_1 < type s), f (enum r (type r_1) hr) = enum s (type r_1) hs
tactic: refine inductionOn o ?_
state_before: α✝ : Type u
β✝ : Type u_1
γ : Type u_2
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
α β : Type u
r : α → α → Prop
s : β → β → Prop
inst✝¹ : IsWellOrder α r
inst✝ : IsWellOrder β s
f : r ≃r s
o : Ordinal.{u}
⊢ ∀ (α_1 : Type u) (r_1 : α_1 → α_1 → Prop) [inst : IsWellOrder α_1 r_1] (hr : type r_1 < type r)
    (hs : type r_1 < type s), f (enum r (type r_1) hr) = enum s (type r_1) hs
state_after: case intro.intro
α✝ : Type u
β✝ : Type u_1
γ✝ : Type u_2
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t✝ : γ✝ → γ✝ → Prop
α β : Type u
r : α → α → Prop
s : β → β → Prop
inst✝¹ : IsWellOrder α r
inst✝ : IsWellOrder β s
f : r ≃r s
o : Ordinal.{u}
γ : Type u
t : γ → γ → Prop
wo : IsWellOrder γ t
g : t ≺i r
h : t ≺i s
⊢ f (enum r (type t) ⋯) = enum s (type t) ⋯
tactic: rintro γ t wo ⟨g⟩ ⟨h⟩
state_before: case intro.intro
α✝ : Type u
β✝ : Type u_1
γ✝ : Type u_2
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t✝ : γ✝ → γ✝ → Prop
α β : Type u
r : α → α → Prop
s : β → β → Prop
inst✝¹ : IsWellOrder α r
inst✝ : IsWellOrder β s
f : r ≃r s
o : Ordinal.{u}
γ : Type u
t : γ → γ → Prop
wo : IsWellOrder γ t
g : t ≺i r
h : t ≺i s
⊢ f (enum r (type t) ⋯) = enum s (type t) ⋯
state_after: case intro.intro
α✝ : Type u
β✝ : Type u_1
γ✝ : Type u_2
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t✝ : γ✝ → γ✝ → Prop
α β : Type u
r : α → α → Prop
s : β → β → Prop
inst✝¹ : IsWellOrder α r
inst✝ : IsWellOrder β s
f : r ≃r s
o : Ordinal.{u}
γ : Type u
t : γ → γ → Prop
wo : IsWellOrder γ t
g : t ≺i r
h : t ≺i s
⊢ f g.top = (g.ltEquiv f).top
tactic: rw [enum_type g, enum_type (PrincipalSeg.ltEquiv g f)]
state_before: case intro.intro
α✝ : Type u
β✝ : Type u_1
γ✝ : Type u_2
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t✝ : γ✝ → γ✝ → Prop
α β : Type u
r : α → α → Prop
s : β → β → Prop
inst✝¹ : IsWellOrder α r
inst✝ : IsWellOrder β s
f : r ≃r s
o : Ordinal.{u}
γ : Type u
t : γ → γ → Prop
wo : IsWellOrder γ t
g : t ≺i r
h : t ≺i s
⊢ f g.top = (g.ltEquiv f).top
state_after: no goals
tactic: rfl
Theorem: HasSum.hasSum_at_zero
File: Mathlib/Analysis/Analytic/IsolatedZeros.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : E
p q : FormalMultilinearSeries 𝕜 𝕜 E
f g : 𝕜 → E
n : ℕ
z z₀ : 𝕜
a✝ a : ℕ → E
⊢ HasSum (fun n => 0 ^ n • a n) (a 0)
state_after: no goals
tactic: convert hasSum_single (α := E) 0 fun b h ↦ _ <;> simp [*]
Theorem: CategoryTheory.Subobject.inf_factors
File: Mathlib/CategoryTheory/Subobject/Lattice.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
X✝ Y✝ Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : HasPullbacks C
A B : C
X Y : Subobject B
f : A ⟶ B
⊢ X.Factors f ∧ Y.Factors f → (X ⊓ Y).Factors f
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : HasPullbacks C
A B : C
f : A ⟶ B
⊢ ∀ {X Y : Subobject B}, X.Factors f ∧ Y.Factors f → (X ⊓ Y).Factors f
tactic: revert X Y
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : HasPullbacks C
A B : C
f : A ⟶ B
⊢ ∀ {X Y : Subobject B}, X.Factors f ∧ Y.Factors f → (X ⊓ Y).Factors f
state_after: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : HasPullbacks C
A B : C
f : A ⟶ B
⊢ ∀ (a₁ a₂ : MonoOver B),
    Factors (Quotient.mk'' a₁) f ∧ Factors (Quotient.mk'' a₂) f → (Quotient.mk'' a₁ ⊓ Quotient.mk'' a₂).Factors f
tactic: apply Quotient.ind₂'
state_before: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : HasPullbacks C
A B : C
f : A ⟶ B
⊢ ∀ (a₁ a₂ : MonoOver B),
    Factors (Quotient.mk'' a₁) f ∧ Factors (Quotient.mk'' a₂) f → (Quotient.mk'' a₁ ⊓ Quotient.mk'' a₂).Factors f
state_after: case h.intro.intro.intro
C : Type u₁
inst✝² : Category.{v₁, u₁} C
X✝ Y✝ Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : HasPullbacks C
A B : C
X Y : MonoOver B
g₁ : A ⟶ X.obj.left
g₂ : A ⟶ Y.obj.left
hg₂ : g₂ ≫ Y.arrow = g₁ ≫ X.arrow
⊢ (Quotient.mk'' X ⊓ Quotient.mk'' Y).Factors (g₁ ≫ X.arrow)
tactic: rintro X Y ⟨⟨g₁, rfl⟩, ⟨g₂, hg₂⟩⟩
state_before: case h.intro.intro.intro
C : Type u₁
inst✝² : Category.{v₁, u₁} C
X✝ Y✝ Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : HasPullbacks C
A B : C
X Y : MonoOver B
g₁ : A ⟶ X.obj.left
g₂ : A ⟶ Y.obj.left
hg₂ : g₂ ≫ Y.arrow = g₁ ≫ X.arrow
⊢ (Quotient.mk'' X ⊓ Quotient.mk'' Y).Factors (g₁ ≫ X.arrow)
state_after: no goals
tactic: exact ⟨_, pullback.lift_snd_assoc _ _ hg₂ _⟩
Theorem: AdicCompletion.induction_on
File: Mathlib/RingTheory/AdicCompletion/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommRing R
I : Ideal R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
N : Type u_3
inst✝¹ : AddCommGroup N
inst✝ : Module R N
p : AdicCompletion I M → Prop
x : AdicCompletion I M
h : ∀ (f : AdicCauchySequence I M), p ((mk I M) f)
⊢ p x
state_after: case intro
R : Type u_1
inst✝⁴ : CommRing R
I : Ideal R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
N : Type u_3
inst✝¹ : AddCommGroup N
inst✝ : Module R N
p : AdicCompletion I M → Prop
h : ∀ (f : AdicCauchySequence I M), p ((mk I M) f)
f : AdicCauchySequence I M
⊢ p ((mk I M) f)
tactic: obtain ⟨f, rfl⟩ := mk_surjective I M x
state_before: case intro
R : Type u_1
inst✝⁴ : CommRing R
I : Ideal R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
N : Type u_3
inst✝¹ : AddCommGroup N
inst✝ : Module R N
p : AdicCompletion I M → Prop
h : ∀ (f : AdicCauchySequence I M), p ((mk I M) f)
f : AdicCauchySequence I M
⊢ p ((mk I M) f)
state_after: no goals
tactic: exact h f
Theorem: iterateFrobenius_mul_apply
File: Mathlib/Algebra/CharP/ExpChar.lean

Proof steps:
state_before: R : Type u
inst✝³ : CommSemiring R
S : Type u_1
inst✝² : CommSemiring S
f : R →* S
g : R →+* S
p m n : ℕ
inst✝¹ : ExpChar R p
inst✝ : ExpChar S p
x y : R
⊢ (iterateFrobenius R p (m * n)) x = (⇑(iterateFrobenius R p m))^[n] x
state_after: no goals
tactic: simp_rw [coe_iterateFrobenius, Function.iterate_mul]
Theorem: Odd.sub_even
File: Mathlib/Algebra/Ring/Parity.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝ : Ring α
a b : α
n : ℕ
ha : Odd a
hb : Even b
⊢ Odd (a - b)
state_after: F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝ : Ring α
a b : α
n : ℕ
ha : Odd a
hb : Even b
⊢ Odd (a + -b)
tactic: rw [sub_eq_add_neg]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝ : Ring α
a b : α
n : ℕ
ha : Odd a
hb : Even b
⊢ Odd (a + -b)
state_after: no goals
tactic: exact ha.add_even hb.neg
Theorem: MulAction.pow_smul_mod_minimalPeriod
File: Mathlib/Dynamics/PeriodicPts.lean

Proof steps:
state_before: α : Type v
G : Type u
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u
inst✝¹ : Monoid M
inst✝ : MulAction M α
a : G
b : α
n : ℕ
⊢ a ^ (n % minimalPeriod (fun x => a • x) b) • b = a ^ n • b
state_after: no goals
tactic: rw [← period_eq_minimalPeriod, pow_mod_period_smul]
Theorem: SimpleGraph.Subgraph.sInf_adj_of_nonempty
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

Proof steps:
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
s : Set G.Subgraph
hs : s.Nonempty
⊢ (∀ G' ∈ s, G'.Adj a b) → G.Adj a b
state_after: case intro
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
s : Set G.Subgraph
G' : G.Subgraph
hG' : G' ∈ s
⊢ (∀ G' ∈ s, G'.Adj a b) → G.Adj a b
tactic: obtain ⟨G', hG'⟩ := hs
state_before: case intro
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
s : Set G.Subgraph
G' : G.Subgraph
hG' : G' ∈ s
⊢ (∀ G' ∈ s, G'.Adj a b) → G.Adj a b
state_after: no goals
tactic: exact fun h => G'.adj_sub (h _ hG')
Theorem: RCLike.ofReal_nonpos
File: Mathlib/Analysis/RCLike/Basic.lean

Proof steps:
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z w : K
x : ℝ
⊢ ↑x ≤ 0 ↔ x ≤ 0
state_after: no goals
tactic: rw [← ofReal_zero, ofReal_le_ofReal]
Theorem: Finset.card_Ico_finset
File: Mathlib/Data/Finset/Interval.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s t : Finset α
h : s ⊆ t
⊢ (Ico s t).card = 2 ^ (t.card - s.card) - 1
state_after: no goals
tactic: rw [card_Ico_eq_card_Icc_sub_one, card_Icc_finset h]
Theorem: List.zipRight_nil_left
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a : α
as : List α
b : β
bs : List β
⊢ [].zipRight bs = map (fun b => (none, b)) bs
state_after: no goals
tactic: cases bs <;> rfl
Theorem: Set.apply_indicator_symmDiff
File: Mathlib/Algebra/Group/Indicator.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
inst✝ : Group G
s✝ t✝ : Set α
f✝ g✝ : α → G
a : α
g : G → β
hg : ∀ (x : G), g x⁻¹ = g x
s t : Set α
f : α → G
x : α
⊢ g ((s ∆ t).mulIndicator f x) = g (s.mulIndicator f x / t.mulIndicator f x)
state_after: no goals
tactic: by_cases hs : x ∈ s <;> by_cases ht : x ∈ t <;> simp [mem_symmDiff, *]
Theorem: IsSelfAdjoint.val_re_map_spectrum
File: Mathlib/Analysis/CstarAlgebra/Spectrum.lean

Proof steps:
state_before: A : Type u_1
inst✝⁵ : NormedRing A
inst✝⁴ : NormedAlgebra ℂ A
inst✝³ : CompleteSpace A
inst✝² : StarRing A
inst✝¹ : CstarRing A
inst✝ : StarModule ℂ A
a : A
ha : IsSelfAdjoint a
z : ℂ
⊢ z ∈ ofReal' ∘ re '' spectrum ℂ a → z ∈ spectrum ℂ a
state_after: case intro.intro
A : Type u_1
inst✝⁵ : NormedRing A
inst✝⁴ : NormedAlgebra ℂ A
inst✝³ : CompleteSpace A
inst✝² : StarRing A
inst✝¹ : CstarRing A
inst✝ : StarModule ℂ A
a : A
ha : IsSelfAdjoint a
z : ℂ
hz : z ∈ spectrum ℂ a
⊢ (ofReal' ∘ re) z ∈ spectrum ℂ a
tactic: rintro ⟨z, hz, rfl⟩
state_before: case intro.intro
A : Type u_1
inst✝⁵ : NormedRing A
inst✝⁴ : NormedAlgebra ℂ A
inst✝³ : CompleteSpace A
inst✝² : StarRing A
inst✝¹ : CstarRing A
inst✝ : StarModule ℂ A
a : A
ha : IsSelfAdjoint a
z : ℂ
hz : z ∈ spectrum ℂ a
⊢ (ofReal' ∘ re) z ∈ spectrum ℂ a
state_after: no goals
tactic: simpa only [(ha.mem_spectrum_eq_re hz).symm, Function.comp_apply] using hz
Theorem: LaurentSeries.eq_coeff_of_valuation_sub_lt
File: Mathlib/RingTheory/LaurentSeries.lean

Proof steps:
state_before: R : Type u_1
K : Type u_2
inst✝ : Field K
d n : ℤ
f g : LaurentSeries K
H : Valued.v (g - f) ≤ ↑(Multiplicative.ofAdd (-d))
⊢ n < d → g.coeff n = f.coeff n
state_after: case pos
R : Type u_1
K : Type u_2
inst✝ : Field K
d n : ℤ
f g : LaurentSeries K
H : Valued.v (g - f) ≤ ↑(Multiplicative.ofAdd (-d))
triv : g = f
⊢ n < d → g.coeff n = f.coeff n

case neg
R : Type u_1
K : Type u_2
inst✝ : Field K
d n : ℤ
f g : LaurentSeries K
H : Valued.v (g - f) ≤ ↑(Multiplicative.ofAdd (-d))
triv : ¬g = f
⊢ n < d → g.coeff n = f.coeff n
tactic: by_cases triv : g = f
Theorem: CategoryTheory.IsCofiltered.cospan
File: Mathlib/CategoryTheory/Filtered/Basic.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : IsCofilteredOrEmpty C
i j j' : C
f : j ⟶ i
f' : j' ⟶ i
K : C
G : K ⟶ j
G' : K ⟶ j'
h✝ : True
k : C
e : k ⟶ K
he : e ≫ G ≫ f = e ≫ G' ≫ f'
⊢ (e ≫ G) ≫ f = (e ≫ G') ≫ f'
state_after: no goals
tactic: simpa only [Category.assoc] using he
Theorem: Matroid.restrict_empty
File: Mathlib/Data/Matroid/Constructions.lean

Proof steps:
state_before: α : Type u_1
M✝ : Matroid α
E B I X R J : Set α
M : Matroid α
⊢ M ↾ ∅ = emptyOn α
state_after: no goals
tactic: simp [← ground_eq_empty_iff]
Theorem: Finset.disjoint_biUnion_right
File: Mathlib/Data/Finset/Union.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : α → Finset β
inst✝ : DecidableEq β
s : Finset β
t : Finset α
f : α → Finset β
⊢ Disjoint s (t.biUnion f) ↔ ∀ i ∈ t, Disjoint s (f i)
state_after: no goals
tactic: simpa only [_root_.disjoint_comm] using disjoint_biUnion_left t f s