ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Cardinal.principal_add_ord
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

Proof steps:
state_before: c : Cardinal.{u_1}
hc : ℵ₀ ≤ c
a b : Ordinal.{u_1}
ha : a < c.ord
hb : b < c.ord
⊢ (fun x x_1 => x + x_1) a b < c.ord
state_after: c : Cardinal.{u_1}
hc : ℵ₀ ≤ c
a b : Ordinal.{u_1}
ha : a.card < c
hb : b.card < c
⊢ a.card + b.card < c
tactic: rw [lt_ord, Ordinal.card_add] at *
state_before: c : Cardinal.{u_1}
hc : ℵ₀ ≤ c
a b : Ordinal.{u_1}
ha : a.card < c
hb : b.card < c
⊢ a.card + b.card < c
state_after: no goals
tactic: exact add_lt_of_lt hc ha hb
Theorem: Nat.Primrec.mul
File: Mathlib/Computability/Primrec.lean

Proof steps:
state_before: p : ℕ
⊢ unpaired
      (fun z n =>
        Nat.rec 0
          (fun y IH =>
            unpaired (fun x x_1 => x + x_1)
              (Nat.pair (unpair (Nat.pair z (Nat.pair y IH))).1 (unpair (unpair (Nat.pair z (Nat.pair y IH))).2).2))
          n)
      p =
    unpaired (fun x x_1 => x * x_1) p
state_after: p : ℕ
⊢ Nat.rec 0 (fun y IH => (unpair p).1 + IH) (unpair p).2 = (unpair p).1 * (unpair p).2
tactic: simp
state_before: p : ℕ
⊢ Nat.rec 0 (fun y IH => (unpair p).1 + IH) (unpair p).2 = (unpair p).1 * (unpair p).2
state_after: no goals
tactic: induction p.unpair.2 <;> simp [*, mul_succ, add_comm _ (unpair p).fst]
Theorem: summable_norm_iff
File: Mathlib/Analysis/Normed/Module/FiniteDimension.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
f : α → E
⊢ (Summable fun x => ‖f x‖) ↔ Summable f
state_after: α : Type u_1
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
f : α → E
hf : Summable f
⊢ Summable fun x => ‖f x‖
tactic: refine ⟨Summable.of_norm, fun hf ↦ ?_⟩
state_before: α : Type u_1
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
f : α → E
hf : Summable f
⊢ Summable fun x => ‖f x‖
state_after: α : Type u_1
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
f : α → E
hf : Summable f
⊢ ∀ {N : ℕ} {g : α → Fin N → ℝ}, Summable g → Summable fun x => ‖g x‖
tactic: suffices ∀ {N : ℕ} {g : α → Fin N → ℝ}, Summable g → Summable fun x => ‖g x‖ by
    obtain v := finBasis ℝ E
    set e := v.equivFunL
    have H : Summable fun x => ‖e (f x)‖ := this (e.summable.2 hf)
    refine .of_norm_bounded _ (H.mul_left ↑‖(e.symm : (Fin (finrank ℝ E) → ℝ) →L[ℝ] E)‖₊) fun i ↦ ?_
    simpa using (e.symm : (Fin (finrank ℝ E) → ℝ) →L[ℝ] E).le_opNorm (e <| f i)
state_before: α : Type u_1
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
f : α → E
hf : Summable f
⊢ ∀ {N : ℕ} {g : α → Fin N → ℝ}, Summable g → Summable fun x => ‖g x‖
state_after: α : Type u_1
⊢ ∀ {N : ℕ} {g : α → Fin N → ℝ}, Summable g → Summable fun x => ‖g x‖
tactic: clear! E
state_before: α : Type u_1
⊢ ∀ {N : ℕ} {g : α → Fin N → ℝ}, Summable g → Summable fun x => ‖g x‖
state_after: α : Type u_1
N : ℕ
g : α → Fin N → ℝ
hg : Summable g
⊢ Summable fun x => ‖g x‖
tactic: intro N g hg
state_before: α : Type u_1
N : ℕ
g : α → Fin N → ℝ
hg : Summable g
⊢ Summable fun x => ‖g x‖
state_after: α : Type u_1
N : ℕ
g : α → Fin N → ℝ
hg : Summable g
this : ∀ (i : Fin N), Summable fun x => ‖g x i‖
⊢ Summable fun x => ‖g x‖
tactic: have : ∀ i, Summable fun x => ‖g x i‖ := fun i => (Pi.summable.1 hg i).abs
state_before: α : Type u_1
N : ℕ
g : α → Fin N → ℝ
hg : Summable g
this : ∀ (i : Fin N), Summable fun x => ‖g x i‖
⊢ Summable fun x => ‖g x‖
state_after: α : Type u_1
N : ℕ
g : α → Fin N → ℝ
hg : Summable g
this : ∀ (i : Fin N), Summable fun x => ‖g x i‖
x : α
⊢ ‖‖g x‖‖ ≤ ∑ i : Fin N, ‖g x i‖
tactic: refine .of_norm_bounded _ (summable_sum fun i (_ : i ∈ Finset.univ) => this i) fun x => ?_
state_before: α : Type u_1
N : ℕ
g : α → Fin N → ℝ
hg : Summable g
this : ∀ (i : Fin N), Summable fun x => ‖g x i‖
x : α
⊢ ‖‖g x‖‖ ≤ ∑ i : Fin N, ‖g x i‖
state_after: α : Type u_1
N : ℕ
g : α → Fin N → ℝ
hg : Summable g
this : ∀ (i : Fin N), Summable fun x => ‖g x i‖
x : α
⊢ ∀ (i : Fin N), ‖g x i‖ ≤ ∑ i : Fin N, ‖g x i‖

α : Type u_1
N : ℕ
g : α → Fin N → ℝ
hg : Summable g
this : ∀ (i : Fin N), Summable fun x => ‖g x i‖
x : α
⊢ 0 ≤ ∑ i : Fin N, ‖g x i‖
tactic: rw [norm_norm, pi_norm_le_iff_of_nonneg]
Theorem: Bool.forall_bool'
File: Mathlib/Data/Bool/Basic.lean

Proof steps:
state_before: p : Bool → Prop
b : Bool
x✝ : p b ∧ p !b
x : Bool
h₁ : p b
h₂ : p !b
⊢ p x
state_after: no goals
tactic: cases b <;> cases x <;> assumption
Theorem: Left.one_lt_inv_iff
File: Mathlib/Algebra/Order/Group/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LT α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c : α
⊢ 1 < a⁻¹ ↔ a < 1
state_after: no goals
tactic: rw [← mul_lt_mul_iff_left a, mul_inv_self, mul_one]
Theorem: Complex.Gammaℝ_one_sub_mul_Gammaℝ_one_add
File: Mathlib/Analysis/SpecialFunctions/Gamma/Deligne.lean

Proof steps:
state_before: s : ℂ
⊢ (1 - s).Gammaℝ * (1 + s).Gammaℝ =
    ↑π ^ ((s - 1) / 2) * ↑π ^ ((-1 - s) / 2) * (Gamma ((1 - s) / 2) * Gamma (1 - (1 - s) / 2))
state_after: s : ℂ
⊢ ↑π ^ (-(1 - s) / 2) * Gamma ((1 - s) / 2) * (↑π ^ (-(1 + s) / 2) * Gamma ((1 + s) / 2)) =
    ↑π ^ ((s - 1) / 2) * ↑π ^ ((-1 - s) / 2) * (Gamma ((1 - s) / 2) * Gamma (1 - (1 - s) / 2))
tactic: simp only [Gammaℝ_def]
state_before: s : ℂ
⊢ ↑π ^ (-(1 - s) / 2) * Gamma ((1 - s) / 2) * (↑π ^ (-(1 + s) / 2) * Gamma ((1 + s) / 2)) =
    ↑π ^ ((s - 1) / 2) * ↑π ^ ((-1 - s) / 2) * (Gamma ((1 - s) / 2) * Gamma (1 - (1 - s) / 2))
state_after: no goals
tactic: ring_nf
state_before: s : ℂ
⊢ ↑π ^ ((s - 1) / 2) * ↑π ^ ((-1 - s) / 2) * (Gamma ((1 - s) / 2) * Gamma (1 - (1 - s) / 2)) =
    ↑π ^ ((s - 1) / 2) * ↑π ^ ((-1 - s) / 2) * ↑π ^ 1 / sin (↑π / 2 - ↑π * s / 2)
state_after: s : ℂ
⊢ ↑π ^ ((s - 1) / 2) * ↑π ^ ((-1 - s) / 2) * (↑π / sin (↑π * ((1 - s) / 2))) =
    ↑π ^ ((s - 1) / 2) * ↑π ^ ((-1 - s) / 2) * ↑π / sin (↑π / 2 - ↑π * s / 2)
tactic: rw [Complex.Gamma_mul_Gamma_one_sub, cpow_one]
state_before: s : ℂ
⊢ ↑π ^ ((s - 1) / 2) * ↑π ^ ((-1 - s) / 2) * (↑π / sin (↑π * ((1 - s) / 2))) =
    ↑π ^ ((s - 1) / 2) * ↑π ^ ((-1 - s) / 2) * ↑π / sin (↑π / 2 - ↑π * s / 2)
state_after: no goals
tactic: ring_nf
state_before: s : ℂ
⊢ ↑π ^ ((s - 1) / 2) * ↑π ^ ((-1 - s) / 2) * ↑π ^ 1 / sin (↑π / 2 - ↑π * s / 2) = (cos (↑π * s / 2))⁻¹
state_after: s : ℂ
⊢ ↑π ^ ((s - 1) / 2 + (-1 - s) / 2 + 1) / cos (↑π * s / 2) = (cos (↑π * s / 2))⁻¹
tactic: simp_rw [← cpow_add _ _ (ofReal_ne_zero.mpr pi_ne_zero),
      Complex.sin_pi_div_two_sub]
state_before: s : ℂ
⊢ ↑π ^ ((s - 1) / 2 + (-1 - s) / 2 + 1) / cos (↑π * s / 2) = (cos (↑π * s / 2))⁻¹
state_after: s : ℂ
⊢ ↑π ^ 0 * (cos (s * ↑π * (1 / 2)))⁻¹ = (cos (s * ↑π * (1 / 2)))⁻¹
tactic: ring_nf
state_before: s : ℂ
⊢ ↑π ^ 0 * (cos (s * ↑π * (1 / 2)))⁻¹ = (cos (s * ↑π * (1 / 2)))⁻¹
state_after: no goals
tactic: rw [cpow_zero, one_mul]
Theorem: eventually_mem_of_tendsto_nhdsWithin
File: Mathlib/Topology/ContinuousOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝ : (i : ι) → TopologicalSpace (π i)
f : β → α
a : α
s : Set α
l : Filter β
h : Tendsto f l (𝓝[s] a)
⊢ ∀ᶠ (i : β) in l, f i ∈ s
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝ : (i : ι) → TopologicalSpace (π i)
f : β → α
a : α
s : Set α
l : Filter β
h : ∀ (i : Set α), a ∈ i ∧ IsOpen i → (∀ᶠ (x : β) in l, f x ∈ i) ∧ ∀ᶠ (x : β) in l, f x ∈ s
⊢ ∀ᶠ (i : β) in l, f i ∈ s
tactic: simp_rw [nhdsWithin_eq, tendsto_iInf, mem_setOf_eq, tendsto_principal, mem_inter_iff,
    eventually_and] at h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝ : (i : ι) → TopologicalSpace (π i)
f : β → α
a : α
s : Set α
l : Filter β
h : ∀ (i : Set α), a ∈ i ∧ IsOpen i → (∀ᶠ (x : β) in l, f x ∈ i) ∧ ∀ᶠ (x : β) in l, f x ∈ s
⊢ ∀ᶠ (i : β) in l, f i ∈ s
state_after: no goals
tactic: exact (h univ ⟨mem_univ a, isOpen_univ⟩).2
Theorem: Ordinal.opow_mul
File: Mathlib/SetTheory/Ordinal/Exponential.lean

Proof steps:
state_before: a b c : Ordinal.{u_1}
⊢ a ^ (b * c) = (a ^ b) ^ c
state_after: case pos
a b c : Ordinal.{u_1}
b0 : b = 0
⊢ a ^ (b * c) = (a ^ b) ^ c

case neg
a b c : Ordinal.{u_1}
b0 : ¬b = 0
⊢ a ^ (b * c) = (a ^ b) ^ c
tactic: by_cases b0 : b = 0
state_before: case neg
a b c : Ordinal.{u_1}
b0 : ¬b = 0
⊢ a ^ (b * c) = (a ^ b) ^ c
state_after: case pos
a b c : Ordinal.{u_1}
b0 : ¬b = 0
a0 : a = 0
⊢ a ^ (b * c) = (a ^ b) ^ c

case neg
a b c : Ordinal.{u_1}
b0 : ¬b = 0
a0 : ¬a = 0
⊢ a ^ (b * c) = (a ^ b) ^ c
tactic: by_cases a0 : a = 0
state_before: case neg
a b c : Ordinal.{u_1}
b0 : ¬b = 0
a0 : ¬a = 0
⊢ a ^ (b * c) = (a ^ b) ^ c
state_after: case neg.inl
a b c : Ordinal.{u_1}
b0 : ¬b = 0
a0 : ¬a = 0
a1 : 1 = a
⊢ a ^ (b * c) = (a ^ b) ^ c

case neg.inr
a b c : Ordinal.{u_1}
b0 : ¬b = 0
a0 : ¬a = 0
a1 : 1 < a
⊢ a ^ (b * c) = (a ^ b) ^ c
tactic: cases' eq_or_lt_of_le (one_le_iff_ne_zero.2 a0) with a1 a1
state_before: case neg.inr
a b c : Ordinal.{u_1}
b0 : ¬b = 0
a0 : ¬a = 0
a1 : 1 < a
⊢ a ^ (b * c) = (a ^ b) ^ c
state_after: no goals
tactic: induction c using limitRecOn with
  | H₁ => simp only [mul_zero, opow_zero]
  | H₂ c IH =>
    rw [mul_succ, opow_add, IH, opow_succ]
  | H₃ c l IH =>
    refine
      eq_of_forall_ge_iff fun d =>
        (((opow_isNormal a1).trans (mul_isNormal (Ordinal.pos_iff_ne_zero.2 b0))).limit_le
              l).trans
          ?_
    dsimp only [Function.comp_def]
    simp (config := { contextual := true }) only [IH]
    exact (opow_le_of_limit (opow_ne_zero _ a0) l).symm
Theorem: Num.ofZNum'_toNat
File: Mathlib/Data/Num/Lemmas.lean

Proof steps:
state_before: α : Type u_1
p : PosNum
⊢ castNum <$> ofZNum' (ZNum.pos p) = (↑p).toNat'
state_after: α : Type u_1
p : PosNum
⊢ castNum <$> ofZNum' (ZNum.pos p) = (↑↑p).toNat'
tactic: rw [← PosNum.to_nat_to_int p]
state_before: α : Type u_1
p : PosNum
⊢ castNum <$> ofZNum' (ZNum.pos p) = (↑↑p).toNat'
state_after: no goals
tactic: rfl
state_before: α : Type u_1
p : PosNum
⊢ ↑(↑p.pred' + 1) = ↑p
state_after: α : Type u_1
p : PosNum
⊢ ↑↑p.pred'.succ' = ↑p
tactic: rw [← succ'_to_nat]
state_before: α : Type u_1
p : PosNum
⊢ ↑↑p.pred'.succ' = ↑p
state_after: no goals
tactic: simp
Theorem: Equiv.Perm.sameCycle_inv
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
p : α → Prop
x y z : α
⊢ (∃ b, (f⁻¹ ^ (Equiv.symm (Equiv.neg ℤ)) b) x = y) ↔ f.SameCycle x y
state_after: no goals
tactic: simp [SameCycle]
Theorem: Set.tsub_encard_le_encard_diff
File: Mathlib/Data/Set/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s✝ t✝ s t : Set α
⊢ s.encard - t.encard ≤ (s \ t).encard
state_after: α : Type u_1
β : Type u_2
s✝ t✝ s t : Set α
⊢ s.encard ≤ (s \ t).encard + t.encard
tactic: rw [tsub_le_iff_left, add_comm]
state_before: α : Type u_1
β : Type u_2
s✝ t✝ s t : Set α
⊢ s.encard ≤ (s \ t).encard + t.encard
state_after: no goals
tactic: apply encard_le_encard_diff_add_encard
Theorem: IsConnected.union
File: Mathlib/Topology/Connected/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝ : TopologicalSpace α
s✝ t✝ u v s t : Set α
H : (s ∩ t).Nonempty
Hs : IsConnected s
Ht : IsConnected t
⊢ IsConnected (s ∪ t)
state_after: case intro
α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝ : TopologicalSpace α
s✝ t✝ u v s t : Set α
Hs : IsConnected s
Ht : IsConnected t
x : α
hx : x ∈ s ∩ t
⊢ IsConnected (s ∪ t)
tactic: rcases H with ⟨x, hx⟩
state_before: case intro
α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝ : TopologicalSpace α
s✝ t✝ u v s t : Set α
Hs : IsConnected s
Ht : IsConnected t
x : α
hx : x ∈ s ∩ t
⊢ IsConnected (s ∪ t)
state_after: case intro
α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝ : TopologicalSpace α
s✝ t✝ u v s t : Set α
Hs : IsConnected s
Ht : IsConnected t
x : α
hx : x ∈ s ∩ t
⊢ IsPreconnected (s ∪ t)
tactic: refine ⟨⟨x, mem_union_left t (mem_of_mem_inter_left hx)⟩, ?_⟩
state_before: case intro
α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝ : TopologicalSpace α
s✝ t✝ u v s t : Set α
Hs : IsConnected s
Ht : IsConnected t
x : α
hx : x ∈ s ∩ t
⊢ IsPreconnected (s ∪ t)
state_after: no goals
tactic: exact Hs.isPreconnected.union x (mem_of_mem_inter_left hx) (mem_of_mem_inter_right hx)
    Ht.isPreconnected
Theorem: OrthogonalFamily.independent
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
ι : Type u_4
G : ι → Type u_5
inst✝¹ : (i : ι) → NormedAddCommGroup (G i)
inst✝ : (i : ι) → InnerProductSpace 𝕜 (G i)
V✝ : (i : ι) → G i →ₗᵢ[𝕜] E
hV✝ : OrthogonalFamily 𝕜 G V✝
dec_V : (i : ι) → (x : G i) → Decidable (x ≠ 0)
V : ι → Submodule 𝕜 E
hV : OrthogonalFamily 𝕜 (fun i => ↥(V i)) fun i => (V i).subtypeₗᵢ
⊢ CompleteLattice.Independent V
state_after: no goals
tactic: classical
  apply CompleteLattice.independent_of_dfinsupp_lsum_injective
  refine LinearMap.ker_eq_bot.mp ?_
  rw [Submodule.eq_bot_iff]
  intro v hv
  rw [LinearMap.mem_ker] at hv
  ext i
  suffices ⟪(v i : E), v i⟫ = 0 by simpa only [inner_self_eq_zero] using this
  calc
    ⟪(v i : E), v i⟫ = ⟪(v i : E), DFinsupp.lsum ℕ (fun i => (V i).subtype) v⟫ := by
      simpa only [DFinsupp.sumAddHom_apply, DFinsupp.lsum_apply_apply] using
        (hV.inner_right_dfinsupp v i (v i)).symm
    _ = 0 := by simp only [hv, inner_zero_right]
Theorem: CategoryTheory.Limits.ImageMap.factor_map
File: Mathlib/CategoryTheory/Limits/Shapes/Images.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
f g : Arrow C
inst✝¹ : HasImage f.hom
inst✝ : HasImage g.hom
sq : f ⟶ g
m : ImageMap sq
⊢ (factorThruImage f.hom ≫ m.map) ≫ image.ι g.hom = (sq.left ≫ factorThruImage g.hom) ≫ image.ι g.hom
state_after: no goals
tactic: simp
Theorem: jacobiSym.ne_zero
File: Mathlib/NumberTheory/LegendreSymbol/JacobiSymbol.lean

Proof steps:
state_before: a : ℤ
b : ℕ
h : a.gcd ↑b = 1
⊢ J(a | b) ≠ 0
state_after: case inl
a : ℤ
b : ℕ
h : a.gcd ↑b = 1
hb : b = 0
⊢ J(a | b) ≠ 0

case inr
a : ℤ
b : ℕ
h : a.gcd ↑b = 1
h✝ : NeZero b
⊢ J(a | b) ≠ 0
tactic: cases' eq_zero_or_neZero b with hb
Theorem: Associates.factors_prod
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a : Associates α
⊢ a.factors.prod = a
state_after: case intro
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a : α
⊢ (Associates.mk a).factors.prod = Associates.mk a
tactic: rcases Associates.mk_surjective a with ⟨a, rfl⟩
state_before: case intro
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a : α
⊢ (Associates.mk a).factors.prod = Associates.mk a
state_after: case intro.inl
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
⊢ (Associates.mk 0).factors.prod = Associates.mk 0

case intro.inr
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a : α
ha : a ≠ 0
⊢ (Associates.mk a).factors.prod = Associates.mk a
tactic: rcases eq_or_ne a 0 with rfl | ha
Theorem: CategoryTheory.iterated_mateEquiv_conjugateEquiv_symm
File: Mathlib/CategoryTheory/Adjunction/Mates.lean

Proof steps:
state_before: A : Type u₁
B : Type u₂
C : Type u₃
D : Type u₄
inst✝³ : Category.{v₁, u₁} A
inst✝² : Category.{v₂, u₂} B
inst✝¹ : Category.{v₃, u₃} C
inst✝ : Category.{v₄, u₄} D
F₁ : A ⥤ C
U₁ : C ⥤ A
F₂ : B ⥤ D
U₂ : D ⥤ B
L₁ : A ⥤ B
R₁ : B ⥤ A
L₂ : C ⥤ D
R₂ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : F₁ ⊣ U₁
adj₄ : F₂ ⊣ U₂
α : U₂ ⋙ R₁ ⟶ R₂ ⋙ U₁
⊢ (mateEquiv adj₁ adj₂).symm ((mateEquiv adj₄ adj₃).symm α) = (conjugateEquiv (adj₁.comp adj₄) (adj₃.comp adj₂)).symm α
state_after: A : Type u₁
B : Type u₂
C : Type u₃
D : Type u₄
inst✝³ : Category.{v₁, u₁} A
inst✝² : Category.{v₂, u₂} B
inst✝¹ : Category.{v₃, u₃} C
inst✝ : Category.{v₄, u₄} D
F₁ : A ⥤ C
U₁ : C ⥤ A
F₂ : B ⥤ D
U₂ : D ⥤ B
L₁ : A ⥤ B
R₁ : B ⥤ A
L₂ : C ⥤ D
R₂ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : F₁ ⊣ U₁
adj₄ : F₂ ⊣ U₂
α : U₂ ⋙ R₁ ⟶ R₂ ⋙ U₁
⊢ (mateEquiv adj₄ adj₃) ((mateEquiv adj₁ adj₂) ((mateEquiv adj₁ adj₂).symm ((mateEquiv adj₄ adj₃).symm α))) = α
tactic: rw [Equiv.eq_symm_apply, ← iterated_mateEquiv_conjugateEquiv]
state_before: A : Type u₁
B : Type u₂
C : Type u₃
D : Type u₄
inst✝³ : Category.{v₁, u₁} A
inst✝² : Category.{v₂, u₂} B
inst✝¹ : Category.{v₃, u₃} C
inst✝ : Category.{v₄, u₄} D
F₁ : A ⥤ C
U₁ : C ⥤ A
F₂ : B ⥤ D
U₂ : D ⥤ B
L₁ : A ⥤ B
R₁ : B ⥤ A
L₂ : C ⥤ D
R₂ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : F₁ ⊣ U₁
adj₄ : F₂ ⊣ U₂
α : U₂ ⋙ R₁ ⟶ R₂ ⋙ U₁
⊢ (mateEquiv adj₄ adj₃) ((mateEquiv adj₁ adj₂) ((mateEquiv adj₁ adj₂).symm ((mateEquiv adj₄ adj₃).symm α))) = α
state_after: no goals
tactic: simp only [Equiv.apply_symm_apply]
Theorem: unitInterval.one_minus_nonneg
File: Mathlib/Topology/UnitInterval.lean

Proof steps:
state_before: x : ↑I
⊢ 0 ≤ 1 - ↑x
state_after: no goals
tactic: simpa using x.2.2
Theorem: Multiset.map_comp_coe
File: Mathlib/Data/Multiset/Functor.lean

Proof steps:
state_before: F : Type u → Type u
inst✝¹ : Applicative F
inst✝ : CommApplicative F
α' β' : Type u
f : α' → F β'
α β : Type u_1
h : α → β
⊢ Functor.map h ∘ Coe.coe = Coe.coe ∘ Functor.map h
state_after: case h
F : Type u → Type u
inst✝¹ : Applicative F
inst✝ : CommApplicative F
α' β' : Type u
f : α' → F β'
α β : Type u_1
h : α → β
x✝ : List α
⊢ (Functor.map h ∘ Coe.coe) x✝ = (Coe.coe ∘ Functor.map h) x✝
tactic: funext
state_before: case h
F : Type u → Type u
inst✝¹ : Applicative F
inst✝ : CommApplicative F
α' β' : Type u
f : α' → F β'
α β : Type u_1
h : α → β
x✝ : List α
⊢ (Functor.map h ∘ Coe.coe) x✝ = (Coe.coe ∘ Functor.map h) x✝
state_after: no goals
tactic: simp only [Function.comp_apply, Coe.coe, fmap_def, map_coe, List.map_eq_map]
Theorem: AddMonoid.Coprod.snd_toSum
File: Mathlib/GroupTheory/Coprod/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
inst✝¹ : Monoid M
inst✝ : Monoid N
x : M ∗ N
⊢ (toProd x).2 = snd x
state_after: M : Type u_1
N : Type u_2
inst✝¹ : Monoid M
inst✝ : Monoid N
x : M ∗ N
⊢ (toProd x).2 = ((MonoidHom.snd M N).comp toProd) x
tactic: rw [← snd_comp_toProd]
state_before: M : Type u_1
N : Type u_2
inst✝¹ : Monoid M
inst✝ : Monoid N
x : M ∗ N
⊢ (toProd x).2 = ((MonoidHom.snd M N).comp toProd) x
state_after: no goals
tactic: rfl
Theorem: tsub_tsub_tsub_cancel_right
File: Mathlib/Algebra/Order/Sub/Canonical.lean

Proof steps:
state_before: α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
h : c ≤ b
⊢ a - c - (b - c) = a - b
state_after: no goals
tactic: rw [tsub_tsub, add_tsub_cancel_of_le h]
Theorem: Set.Finite.eq_of_subset_of_encard_le
File: Mathlib/Data/Set/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s t : Set α
ht : t.Finite
hst : s ⊆ t
hts : t.encard ≤ s.encard
⊢ s = t
state_after: α : Type u_1
β : Type u_2
s t : Set α
ht : t.Finite
hst : s ⊆ t
hts : (t \ s).encard + s.encard ≤ 0 + s.encard
⊢ s = t
tactic: rw [← zero_add (a := encard s), ← encard_diff_add_encard_of_subset hst] at hts
state_before: α : Type u_1
β : Type u_2
s t : Set α
ht : t.Finite
hst : s ⊆ t
hts : (t \ s).encard + s.encard ≤ 0 + s.encard
⊢ s = t
state_after: α : Type u_1
β : Type u_2
s t : Set α
ht : t.Finite
hst : s ⊆ t
hts : (t \ s).encard + s.encard ≤ 0 + s.encard
hdiff : (t \ s).encard ≤ 0
⊢ s = t
tactic: have hdiff := WithTop.le_of_add_le_add_right (ht.subset hst).encard_lt_top.ne hts
state_before: α : Type u_1
β : Type u_2
s t : Set α
ht : t.Finite
hst : s ⊆ t
hts : (t \ s).encard + s.encard ≤ 0 + s.encard
hdiff : (t \ s).encard ≤ 0
⊢ s = t
state_after: α : Type u_1
β : Type u_2
s t : Set α
ht : t.Finite
hst : s ⊆ t
hts : (t \ s).encard + s.encard ≤ 0 + s.encard
hdiff : t ⊆ s
⊢ s = t
tactic: rw [nonpos_iff_eq_zero, encard_eq_zero, diff_eq_empty] at hdiff
state_before: α : Type u_1
β : Type u_2
s t : Set α
ht : t.Finite
hst : s ⊆ t
hts : (t \ s).encard + s.encard ≤ 0 + s.encard
hdiff : t ⊆ s
⊢ s = t
state_after: no goals
tactic: exact hst.antisymm hdiff
Theorem: Equiv.Perm.sign_prodCongrLeft
File: Mathlib/GroupTheory/Perm/Sign.lean

Proof steps:
state_before: α : Type u
inst✝³ : DecidableEq α
β : Type v
inst✝² : Fintype α
inst✝¹ : DecidableEq β
inst✝ : Fintype β
σ : α → Perm β
⊢ sign (prodCongrLeft σ) = ∏ k : α, sign (σ k)
state_after: α : Type u
inst✝³ : DecidableEq α
β : Type v
inst✝² : Fintype α
inst✝¹ : DecidableEq β
inst✝ : Fintype β
σ : α → Perm β
⊢ ∀ (x : β × α), (prodComm β α) ((prodCongrLeft σ) x) = (prodCongrRight σ) ((prodComm β α) x)
tactic: refine (sign_eq_sign_of_equiv _ _ (prodComm β α) ?_).trans (sign_prodCongrRight σ)
state_before: α : Type u
inst✝³ : DecidableEq α
β : Type v
inst✝² : Fintype α
inst✝¹ : DecidableEq β
inst✝ : Fintype β
σ : α → Perm β
⊢ ∀ (x : β × α), (prodComm β α) ((prodCongrLeft σ) x) = (prodCongrRight σ) ((prodComm β α) x)
state_after: case mk
α✝ : Type u
inst✝³ : DecidableEq α✝
β : Type v
inst✝² : Fintype α✝
inst✝¹ : DecidableEq β
inst✝ : Fintype β
σ : α✝ → Perm β
b : β
α : α✝
⊢ (prodComm β α✝) ((prodCongrLeft σ) (b, α)) = (prodCongrRight σ) ((prodComm β α✝) (b, α))
tactic: rintro ⟨b, α⟩
state_before: case mk
α✝ : Type u
inst✝³ : DecidableEq α✝
β : Type v
inst✝² : Fintype α✝
inst✝¹ : DecidableEq β
inst✝ : Fintype β
σ : α✝ → Perm β
b : β
α : α✝
⊢ (prodComm β α✝) ((prodCongrLeft σ) (b, α)) = (prodCongrRight σ) ((prodComm β α✝) (b, α))
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.NatTrans.exchange
File: Mathlib/CategoryTheory/Functor/Category.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F G H I✝ : C ⥤ D
I J K : D ⥤ E
α : F ⟶ G
β : G ⟶ H
γ : I ⟶ J
δ : J ⟶ K
⊢ (α ≫ β) ◫ (γ ≫ δ) = (α ◫ γ) ≫ β ◫ δ
state_after: no goals
tactic: aesop_cat
Theorem: Order.not_isSuccLimit_iff_exists_covBy
File: Mathlib/Order/SuccPred/Limit.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LT α
a : α
⊢ ¬IsSuccLimit a ↔ ∃ b, b ⋖ a
state_after: no goals
tactic: simp [IsSuccLimit]
Theorem: RatFunc.algebraMap_eq_zero_iff
File: Mathlib/FieldTheory/RatFunc/Basic.lean

Proof steps:
state_before: K : Type u
inst✝¹ : CommRing K
inst✝ : IsDomain K
x : K[X]
hx : x = 0
⊢ (algebraMap K[X] (RatFunc K)) x = 0
state_after: no goals
tactic: rw [hx, RingHom.map_zero]