ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: EuclideanGeometry.Sphere.secondInter_collinear
File: Mathlib/Geometry/Euclidean/Sphere/SecondInter.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Sphere P
p p' : P
⊢ Collinear ℝ {p, p', s.secondInter p (p' -ᵥ p)}
state_after: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Sphere P
p p' : P
⊢ Collinear ℝ {s.secondInter p (p' -ᵥ p), p, p'}
tactic: rw [Set.pair_comm, Set.insert_comm]
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Sphere P
p p' : P
⊢ Collinear ℝ {s.secondInter p (p' -ᵥ p), p, p'}
state_after: no goals
tactic: exact
    (collinear_insert_iff_of_mem_affineSpan (s.secondInter_vsub_mem_affineSpan _ _)).2
      (collinear_pair ℝ _ _)
Theorem: FractionalIdeal.mul_right_le_iff
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : Algebra A K
inst✝¹ : IsFractionRing A K
inst✝ : IsDedekindDomain A
J : FractionalIdeal A⁰ K
hJ : J ≠ 0
⊢ ∀ {I I' : FractionalIdeal A⁰ K}, I * J ≤ I' * J ↔ I ≤ I'
state_after: R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : Algebra A K
inst✝¹ : IsFractionRing A K
inst✝ : IsDedekindDomain A
J : FractionalIdeal A⁰ K
hJ : J ≠ 0
I I' : FractionalIdeal A⁰ K
⊢ I * J ≤ I' * J ↔ I ≤ I'
tactic: intro I I'
state_before: R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : Algebra A K
inst✝¹ : IsFractionRing A K
inst✝ : IsDedekindDomain A
J : FractionalIdeal A⁰ K
hJ : J ≠ 0
I I' : FractionalIdeal A⁰ K
⊢ I * J ≤ I' * J ↔ I ≤ I'
state_after: case mp
R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : Algebra A K
inst✝¹ : IsFractionRing A K
inst✝ : IsDedekindDomain A
J : FractionalIdeal A⁰ K
hJ : J ≠ 0
I I' : FractionalIdeal A⁰ K
⊢ I * J ≤ I' * J → I ≤ I'

case mpr
R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : Algebra A K
inst✝¹ : IsFractionRing A K
inst✝ : IsDedekindDomain A
J : FractionalIdeal A⁰ K
hJ : J ≠ 0
I I' : FractionalIdeal A⁰ K
⊢ I ≤ I' → I * J ≤ I' * J
tactic: constructor
Theorem: CategoryTheory.Limits.biprod.isoCoprod_inv
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

Proof steps:
state_before: J : Type w
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
D : Type uD
inst✝² : Category.{uD', uD} D
inst✝¹ : HasZeroMorphisms D
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
⊢ (isoCoprod X Y).inv = coprod.desc inl inr
state_after: no goals
tactic: ext <;> simp [biprod.isoCoprod]
Theorem: Int.coe_greatestOfBdd_eq
File: Mathlib/Data/Int/LeastGreatest.lean

Proof steps:
state_before: P : ℤ → Prop
inst✝ : DecidablePred P
b b' : ℤ
Hb : ∀ (z : ℤ), P z → z ≤ b
Hb' : ∀ (z : ℤ), P z → z ≤ b'
Hinh : ∃ z, P z
⊢ ↑(b.greatestOfBdd Hb Hinh) = ↑(b'.greatestOfBdd Hb' Hinh)
state_after: case mk.intro
P : ℤ → Prop
inst✝ : DecidablePred P
b b' : ℤ
Hb : ∀ (z : ℤ), P z → z ≤ b
Hb' : ∀ (z : ℤ), P z → z ≤ b'
Hinh : ∃ z, P z
n : ℤ
hn : P n
h2n : ∀ (z : ℤ), P z → z ≤ n
⊢ ↑⟨n, ⋯⟩ = ↑(b'.greatestOfBdd Hb' Hinh)
tactic: rcases greatestOfBdd b Hb Hinh with ⟨n, hn, h2n⟩
state_before: case mk.intro
P : ℤ → Prop
inst✝ : DecidablePred P
b b' : ℤ
Hb : ∀ (z : ℤ), P z → z ≤ b
Hb' : ∀ (z : ℤ), P z → z ≤ b'
Hinh : ∃ z, P z
n : ℤ
hn : P n
h2n : ∀ (z : ℤ), P z → z ≤ n
⊢ ↑⟨n, ⋯⟩ = ↑(b'.greatestOfBdd Hb' Hinh)
state_after: case mk.intro.mk.intro
P : ℤ → Prop
inst✝ : DecidablePred P
b b' : ℤ
Hb : ∀ (z : ℤ), P z → z ≤ b
Hb' : ∀ (z : ℤ), P z → z ≤ b'
Hinh : ∃ z, P z
n : ℤ
hn : P n
h2n : ∀ (z : ℤ), P z → z ≤ n
n' : ℤ
hn' : P n'
h2n' : ∀ (z : ℤ), P z → z ≤ n'
⊢ ↑⟨n, ⋯⟩ = ↑⟨n', ⋯⟩
tactic: rcases greatestOfBdd b' Hb' Hinh with ⟨n', hn', h2n'⟩
state_before: case mk.intro.mk.intro
P : ℤ → Prop
inst✝ : DecidablePred P
b b' : ℤ
Hb : ∀ (z : ℤ), P z → z ≤ b
Hb' : ∀ (z : ℤ), P z → z ≤ b'
Hinh : ∃ z, P z
n : ℤ
hn : P n
h2n : ∀ (z : ℤ), P z → z ≤ n
n' : ℤ
hn' : P n'
h2n' : ∀ (z : ℤ), P z → z ≤ n'
⊢ ↑⟨n, ⋯⟩ = ↑⟨n', ⋯⟩
state_after: no goals
tactic: exact le_antisymm (h2n' _ hn) (h2n _ hn')
Theorem: RightOrdContinuous.id
File: Mathlib/Order/OrdContinuous.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
g : β → γ
f : α → β
s : Set α
x : α
h : IsGLB s x
⊢ IsGLB (id '' s) (id x)
state_after: no goals
tactic: simpa only [image_id] using h
Theorem: _private.Mathlib.NumberTheory.SiegelsLemma.0.Int.Matrix.card_T_eq
File: Mathlib/NumberTheory/SiegelsLemma.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : Fintype α
inst✝² : Fintype β
A : Matrix α β ℤ
v : β → ℤ
hn : m < n
hm : 0 < m
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
⊢ T.card = (B + 1) ^ n
state_after: α : Type u_1
β : Type u_2
inst✝³ : Fintype α
inst✝² : Fintype β
A : Matrix α β ℤ
v : β → ℤ
hn : m < n
hm : 0 < m
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
⊢ ∏ i : β, (Icc (0 i) ↑B).card = (B + 1) ^ n
tactic: rw [Pi.card_Icc 0 B']
state_before: α : Type u_1
β : Type u_2
inst✝³ : Fintype α
inst✝² : Fintype β
A : Matrix α β ℤ
v : β → ℤ
hn : m < n
hm : 0 < m
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
⊢ ∏ i : β, (Icc (0 i) ↑B).card = (B + 1) ^ n
state_after: no goals
tactic: simp only [Pi.zero_apply, card_Icc, sub_zero, toNat_ofNat_add_one, prod_const, card_univ,
    add_pos_iff, zero_lt_one, or_true]
Theorem: QuotSMulTop.map_surjective
File: Mathlib/RingTheory/QuotSMulTop.lean

Proof steps:
state_before: R : Type u_2
inst✝⁶ : CommRing R
r : R
M : Type u_1
M' : Type u_3
M'' : Type ?u.123295
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : AddCommGroup M''
inst✝ : Module R M''
f : M →ₗ[R] M'
hf : Surjective ⇑f
H₁ : Surjective (⇑(r • ⊤).mkQ ∘ ⇑f)
⊢ Surjective (⇑((map r) f) ∘ ⇑(r • ⊤).mkQ)
state_after: no goals
tactic: rwa [← LinearMap.coe_comp, map_comp_mkQ, LinearMap.coe_comp]
Theorem: Ideal.isRadical_iff_quotient_reduced
File: Mathlib/RingTheory/QuotientNilpotent.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommRing R
I : Ideal R
⊢ I.IsRadical ↔ IsReduced (R ⧸ I)
state_after: R : Type u_1
inst✝ : CommRing R
I : Ideal R
⊢ (RingHom.ker (Quotient.mk I)).IsRadical ↔ IsReduced (R ⧸ I)
tactic: conv_lhs => rw [← @Ideal.mk_ker R _ I]
state_before: R : Type u_1
inst✝ : CommRing R
I : Ideal R
⊢ (RingHom.ker (Quotient.mk I)).IsRadical ↔ IsReduced (R ⧸ I)
state_after: no goals
tactic: exact RingHom.ker_isRadical_iff_reduced_of_surjective (@Ideal.Quotient.mk_surjective R _ I)
Theorem: IntermediateField.iInf_toSubfield
File: Mathlib/FieldTheory/Adjoin.lean

Proof steps:
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
ι : Sort u_3
S : ι → IntermediateField F E
⊢ ↑(iInf S).toSubfield = ↑(⨅ i, (S i).toSubfield)
state_after: no goals
tactic: simp [iInf]
Theorem: lipschitzWith_iff_norm_div_le
File: Mathlib/Analysis/Normed/Group/Uniform.lean

Proof steps:
state_before: 𝓕 : Type u_1
α : Type u_2
E : Type u_3
F : Type u_4
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
inst✝ : FunLike 𝓕 E F
f : E → F
C : ℝ≥0
⊢ LipschitzWith C f ↔ ∀ (x y : E), ‖f x / f y‖ ≤ ↑C * ‖x / y‖
state_after: no goals
tactic: simp only [lipschitzWith_iff_dist_le_mul, dist_eq_norm_div]
Theorem: Ordnode.node3L_size
File: Mathlib/Data/Ordmap/Ordset.lean

Proof steps:
state_before: α : Type u_1
l : Ordnode α
x : α
m : Ordnode α
y : α
r : Ordnode α
⊢ (l.node3L x m y r).size = l.size + m.size + r.size + 2
state_after: α : Type u_1
l : Ordnode α
x : α
m : Ordnode α
y : α
r : Ordnode α
⊢ (((match l with
            | nil => 0
            | node sz l x r => sz) +
            match m with
            | nil => 0
            | node sz l x r => sz) +
          1 +
        match r with
        | nil => 0
        | node sz l x r => sz) +
      1 =
    (((match l with
          | nil => 0
          | node sz l x r => sz) +
          match m with
          | nil => 0
          | node sz l x r => sz) +
        match r with
        | nil => 0
        | node sz l x r => sz) +
      2
tactic: dsimp [node3L, node', size]
state_before: α : Type u_1
l : Ordnode α
x : α
m : Ordnode α
y : α
r : Ordnode α
⊢ (((match l with
            | nil => 0
            | node sz l x r => sz) +
            match m with
            | nil => 0
            | node sz l x r => sz) +
          1 +
        match r with
        | nil => 0
        | node sz l x r => sz) +
      1 =
    (((match l with
          | nil => 0
          | node sz l x r => sz) +
          match m with
          | nil => 0
          | node sz l x r => sz) +
        match r with
        | nil => 0
        | node sz l x r => sz) +
      2
state_after: no goals
tactic: rw [add_right_comm _ 1]
Theorem: isUpperSet_iff_forall_lt
File: Mathlib/Order/UpperLower/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝ : PartialOrder α
s : Set α
a : α
⊢ (∀ ⦃b : α⦄, a ≤ b → a ∈ s → b ∈ s) ↔ ∀ ⦃b : α⦄, a < b → a ∈ s → b ∈ s
state_after: no goals
tactic: simp [le_iff_eq_or_lt, or_imp, forall_and]
Theorem: Dense.inter_of_isOpen_left
File: Mathlib/Topology/Basic.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x✝ : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
hs : Dense s
ht : Dense t
hso : IsOpen s
x : X
⊢ x ∈ closure (s ∩ closure t)
state_after: no goals
tactic: simp [hs.closure_eq, ht.closure_eq]
Theorem: nhdsSet_union
File: Mathlib/Topology/NhdsSet.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f : Filter X
s✝ t✝ s₁ s₂ t₁ t₂ : Set X
x : X
s t : Set X
⊢ 𝓝ˢ (s ∪ t) = 𝓝ˢ s ⊔ 𝓝ˢ t
state_after: no goals
tactic: simp only [nhdsSet, image_union, sSup_union]
Theorem: Matrix.PosSemidef.eq_sqrt_of_sq_eq
File: Mathlib/LinearAlgebra/Matrix/PosDef.lean

Proof steps:
state_before: m : Type u_1
n : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝⁷ : Fintype m
inst✝⁶ : Fintype n
inst✝⁵ : CommRing R
inst✝⁴ : PartialOrder R
inst✝³ : StarRing R
inst✝² : StarOrderedRing R
inst✝¹ : RCLike 𝕜
inst✝ : DecidableEq n
A : Matrix n n 𝕜
hA : A.PosSemidef
B : Matrix n n 𝕜
hB : B.PosSemidef
hAB : A ^ 2 = B
⊢ A = hB.sqrt
state_after: m : Type u_1
n : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝⁷ : Fintype m
inst✝⁶ : Fintype n
inst✝⁵ : CommRing R
inst✝⁴ : PartialOrder R
inst✝³ : StarRing R
inst✝² : StarOrderedRing R
inst✝¹ : RCLike 𝕜
inst✝ : DecidableEq n
A : Matrix n n 𝕜
hA : A.PosSemidef
hB : (A ^ 2).PosSemidef
⊢ A = hB.sqrt
tactic: subst B
state_before: m : Type u_1
n : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝⁷ : Fintype m
inst✝⁶ : Fintype n
inst✝⁵ : CommRing R
inst✝⁴ : PartialOrder R
inst✝³ : StarRing R
inst✝² : StarOrderedRing R
inst✝¹ : RCLike 𝕜
inst✝ : DecidableEq n
A : Matrix n n 𝕜
hA : A.PosSemidef
hB : (A ^ 2).PosSemidef
⊢ A = hB.sqrt
state_after: no goals
tactic: rw [hA.sqrt_sq]
Theorem: StarSubalgebra.coe_isUnit
File: Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Basic.lean

Proof steps:
state_before: A : Type u_1
inst✝⁶ : NormedRing A
inst✝⁵ : NormedAlgebra ℂ A
inst✝⁴ : StarRing A
inst✝³ : CstarRing A
inst✝² : StarModule ℂ A
inst✝¹ : CompleteSpace A
a : A
inst✝ : IsStarNormal a
S✝ S : StarSubalgebra ℂ A
hS : IsClosed ↑S
x : ↥S
⊢ IsUnit ↑x ↔ IsUnit x
state_after: case refine_1
A : Type u_1
inst✝⁶ : NormedRing A
inst✝⁵ : NormedAlgebra ℂ A
inst✝⁴ : StarRing A
inst✝³ : CstarRing A
inst✝² : StarModule ℂ A
inst✝¹ : CompleteSpace A
a : A
inst✝ : IsStarNormal a
S✝ S : StarSubalgebra ℂ A
hS : IsClosed ↑S
x : ↥S
hx : IsUnit ↑x
⊢ x * ⟨↑hx.unit⁻¹, ⋯⟩ = 1

case refine_2
A : Type u_1
inst✝⁶ : NormedRing A
inst✝⁵ : NormedAlgebra ℂ A
inst✝⁴ : StarRing A
inst✝³ : CstarRing A
inst✝² : StarModule ℂ A
inst✝¹ : CompleteSpace A
a : A
inst✝ : IsStarNormal a
S✝ S : StarSubalgebra ℂ A
hS : IsClosed ↑S
x : ↥S
hx : IsUnit ↑x
⊢ ⟨↑hx.unit⁻¹, ⋯⟩ * x = 1
tactic: refine ⟨fun hx =>
           ⟨⟨x, ⟨(↑hx.unit⁻¹ : A), StarSubalgebra.isUnit_coe_inv_mem hS hx x.prop⟩, ?_, ?_⟩, rfl⟩,
          fun hx => hx.map S.subtype⟩
state_before: case refine_1
A : Type u_1
inst✝⁶ : NormedRing A
inst✝⁵ : NormedAlgebra ℂ A
inst✝⁴ : StarRing A
inst✝³ : CstarRing A
inst✝² : StarModule ℂ A
inst✝¹ : CompleteSpace A
a : A
inst✝ : IsStarNormal a
S✝ S : StarSubalgebra ℂ A
hS : IsClosed ↑S
x : ↥S
hx : IsUnit ↑x
⊢ x * ⟨↑hx.unit⁻¹, ⋯⟩ = 1

case refine_2
A : Type u_1
inst✝⁶ : NormedRing A
inst✝⁵ : NormedAlgebra ℂ A
inst✝⁴ : StarRing A
inst✝³ : CstarRing A
inst✝² : StarModule ℂ A
inst✝¹ : CompleteSpace A
a : A
inst✝ : IsStarNormal a
S✝ S : StarSubalgebra ℂ A
hS : IsClosed ↑S
x : ↥S
hx : IsUnit ↑x
⊢ ⟨↑hx.unit⁻¹, ⋯⟩ * x = 1
state_after: no goals
tactic: exacts [Subtype.coe_injective hx.mul_val_inv, Subtype.coe_injective hx.val_inv_mul]
Theorem: sum_four_sq_mul_sum_four_sq
File: Mathlib/Algebra/Ring/Identities.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommRing R
a b x₁ x₂ x₃ x₄ x₅ x₆ x₇ x₈ y₁ y₂ y₃ y₄ y₅ y₆ y₇ y₈ n : R
⊢ (x₁ ^ 2 + x₂ ^ 2 + x₃ ^ 2 + x₄ ^ 2) * (y₁ ^ 2 + y₂ ^ 2 + y₃ ^ 2 + y₄ ^ 2) =
    (x₁ * y₁ - x₂ * y₂ - x₃ * y₃ - x₄ * y₄) ^ 2 + (x₁ * y₂ + x₂ * y₁ + x₃ * y₄ - x₄ * y₃) ^ 2 +
        (x₁ * y₃ - x₂ * y₄ + x₃ * y₁ + x₄ * y₂) ^ 2 +
      (x₁ * y₄ + x₂ * y₃ - x₃ * y₂ + x₄ * y₁) ^ 2
state_after: no goals
tactic: ring
Theorem: RegularExpression.map_pow
File: Mathlib/Computability/RegularExpressions.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a b : α
f : α → β
P : RegularExpression α
⊢ map f (P ^ 0) = map f P ^ 0
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a b : α
f : α → β
P : RegularExpression α
⊢ 1 = map f P ^ 0
tactic: dsimp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a b : α
f : α → β
P : RegularExpression α
⊢ 1 = map f P ^ 0
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.Functor.FullyFaithful.hasShift.map_add_inv_app
File: Mathlib/CategoryTheory/Shift/Basic.lean

Proof steps:
state_before: C : Type u
A : Type u_1
inst✝³ : Category.{v, u} C
D : Type u_2
inst✝² : Category.{u_3, u_2} D
inst✝¹ : AddMonoid A
inst✝ : HasShift D A
F : C ⥤ D
hF : F.FullyFaithful
s : A → C ⥤ C
i : (i : A) → s i ⋙ F ≅ F ⋙ shiftFunctor D i
a b : A
X : C
⊢ F.map ((add hF s i a b).inv.app X) =
    (i b).hom.app ((s a).obj X) ≫
      (shiftFunctor D b).map ((i a).hom.app X) ≫ (shiftFunctorAdd D a b).inv.app (F.obj X) ≫ (i (a + b)).inv.app X
state_after: C : Type u
A : Type u_1
inst✝³ : Category.{v, u} C
D : Type u_2
inst✝² : Category.{u_3, u_2} D
inst✝¹ : AddMonoid A
inst✝ : HasShift D A
F : C ⥤ D
hF : F.FullyFaithful
s : A → C ⥤ C
i : (i : A) → s i ⋙ F ≅ F ⋙ shiftFunctor D i
a b : A
X : C
⊢ F.map
      (hF.preimage
        ((((((𝟙 (F.obj ((s b).obj ((s a).obj X))) ≫ (i b).hom.app ((s a).obj X)) ≫
                  𝟙 ((shiftFunctor D b).obj (F.obj ((s a).obj X)))) ≫
                (shiftFunctor D b).map ((i a).hom.app X)) ≫
              𝟙 ((shiftFunctor D b).obj ((shiftFunctor D a).obj (F.obj X)))) ≫
            (shiftFunctorAdd D a b).inv.app (F.obj X)) ≫
          (i (a + b)).inv.app X)) =
    (i b).hom.app ((s a).obj X) ≫
      (shiftFunctor D b).map ((i a).hom.app X) ≫ (shiftFunctorAdd D a b).inv.app (F.obj X) ≫ (i (a + b)).inv.app X
tactic: dsimp [add]
state_before: C : Type u
A : Type u_1
inst✝³ : Category.{v, u} C
D : Type u_2
inst✝² : Category.{u_3, u_2} D
inst✝¹ : AddMonoid A
inst✝ : HasShift D A
F : C ⥤ D
hF : F.FullyFaithful
s : A → C ⥤ C
i : (i : A) → s i ⋙ F ≅ F ⋙ shiftFunctor D i
a b : A
X : C
⊢ F.map
      (hF.preimage
        ((((((𝟙 (F.obj ((s b).obj ((s a).obj X))) ≫ (i b).hom.app ((s a).obj X)) ≫
                  𝟙 ((shiftFunctor D b).obj (F.obj ((s a).obj X)))) ≫
                (shiftFunctor D b).map ((i a).hom.app X)) ≫
              𝟙 ((shiftFunctor D b).obj ((shiftFunctor D a).obj (F.obj X)))) ≫
            (shiftFunctorAdd D a b).inv.app (F.obj X)) ≫
          (i (a + b)).inv.app X)) =
    (i b).hom.app ((s a).obj X) ≫
      (shiftFunctor D b).map ((i a).hom.app X) ≫ (shiftFunctorAdd D a b).inv.app (F.obj X) ≫ (i (a + b)).inv.app X
state_after: no goals
tactic: simp
Theorem: Nat.bit_le
File: Mathlib/Data/Nat/Bits.lean

Proof steps:
state_before: m n x✝¹ x✝ : ℕ
h : x✝¹ ≤ x✝
⊢ bit true x✝¹ ≤ bit true x✝
state_after: m n x✝¹ x✝ : ℕ
h : x✝¹ ≤ x✝
⊢ 2 * x✝¹ + 1 ≤ 2 * x✝ + 1
tactic: dsimp [bit]
state_before: m n x✝¹ x✝ : ℕ
h : x✝¹ ≤ x✝
⊢ 2 * x✝¹ + 1 ≤ 2 * x✝ + 1
state_after: no goals
tactic: omega
state_before: m n x✝¹ x✝ : ℕ
h : x✝¹ ≤ x✝
⊢ bit false x✝¹ ≤ bit false x✝
state_after: m n x✝¹ x✝ : ℕ
h : x✝¹ ≤ x✝
⊢ 2 * x✝¹ ≤ 2 * x✝
tactic: dsimp [bit]
state_before: m n x✝¹ x✝ : ℕ
h : x✝¹ ≤ x✝
⊢ 2 * x✝¹ ≤ 2 * x✝
state_after: no goals
tactic: omega
Theorem: List.getElem?_getD_singleton_default_eq
File: Mathlib/Data/List/GetD.lean

Proof steps:
state_before: α : Type u
β : Type v
l : List α
x : α
xs : List α
n✝ : ℕ
d : α
n : ℕ
⊢ [d][n]?.getD d = d
state_after: no goals
tactic: cases n <;> simp
Theorem: WithTop.sum_lt_top_iff
File: Mathlib/Algebra/BigOperators/WithTop.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : AddCommMonoid α
inst✝ : LT α
s : Finset ι
f : ι → WithTop α
⊢ ∑ i ∈ s, f i < ⊤ ↔ ∀ i ∈ s, f i < ⊤
state_after: no goals
tactic: simp only [WithTop.lt_top_iff_ne_top, ne_eq, sum_eq_top_iff, not_exists, not_and]
Theorem: Function.Antiperiodic.neg_eq
File: Mathlib/Algebra/Periodic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : AddGroup α
inst✝ : InvolutiveNeg β
h : Antiperiodic f c
⊢ f (-c) = -f 0
state_after: no goals
tactic: simpa only [zero_add] using h.neg 0
Theorem: CategoryTheory.Monad.ForgetCreatesLimits.liftedCone_pt
File: Mathlib/CategoryTheory/Monad/Limits.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
T : Monad C
J : Type u
inst✝ : Category.{v, u} J
D : J ⥤ T.Algebra
c : Cone (D ⋙ T.forget)
t : IsLimit c
X Y : J
f : X ⟶ Y
⊢ ((Functor.const J).obj (conePoint D c t)).map f ≫ (fun j => { f := c.π.app j, h := ⋯ }) Y =
    (fun j => { f := c.π.app j, h := ⋯ }) X ≫ D.map f
state_after: case h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
T : Monad C
J : Type u
inst✝ : Category.{v, u} J
D : J ⥤ T.Algebra
c : Cone (D ⋙ T.forget)
t : IsLimit c
X Y : J
f : X ⟶ Y
⊢ (((Functor.const J).obj (conePoint D c t)).map f ≫ (fun j => { f := c.π.app j, h := ⋯ }) Y).f =
    ((fun j => { f := c.π.app j, h := ⋯ }) X ≫ D.map f).f
tactic: ext1
state_before: case h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
T : Monad C
J : Type u
inst✝ : Category.{v, u} J
D : J ⥤ T.Algebra
c : Cone (D ⋙ T.forget)
t : IsLimit c
X Y : J
f : X ⟶ Y
⊢ (((Functor.const J).obj (conePoint D c t)).map f ≫ (fun j => { f := c.π.app j, h := ⋯ }) Y).f =
    ((fun j => { f := c.π.app j, h := ⋯ }) X ≫ D.map f).f
state_after: case h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
T : Monad C
J : Type u
inst✝ : Category.{v, u} J
D : J ⥤ T.Algebra
c : Cone (D ⋙ T.forget)
t : IsLimit c
X Y : J
f : X ⟶ Y
⊢ 𝟙 c.pt ≫ c.π.app Y = c.π.app X ≫ (D.map f).f
tactic: dsimp
state_before: case h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
T : Monad C
J : Type u
inst✝ : Category.{v, u} J
D : J ⥤ T.Algebra
c : Cone (D ⋙ T.forget)
t : IsLimit c
X Y : J
f : X ⟶ Y
⊢ 𝟙 c.pt ≫ c.π.app Y = c.π.app X ≫ (D.map f).f
state_after: case h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
T : Monad C
J : Type u
inst✝ : Category.{v, u} J
D : J ⥤ T.Algebra
c : Cone (D ⋙ T.forget)
t : IsLimit c
X Y : J
f : X ⟶ Y
⊢ 𝟙 c.pt ≫ c.π.app Y = c.π.app Y
tactic: erw [c.w f]
state_before: case h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
T : Monad C
J : Type u
inst✝ : Category.{v, u} J
D : J ⥤ T.Algebra
c : Cone (D ⋙ T.forget)
t : IsLimit c
X Y : J
f : X ⟶ Y
⊢ 𝟙 c.pt ≫ c.π.app Y = c.π.app Y
state_after: no goals
tactic: simp
Theorem: Set.iUnion_Ico_eq_Iio_self_iff
File: Mathlib/Order/Interval/Set/Disjoint.lean

Proof steps:
state_before: ι : Sort u
α : Type v
β : Type w
inst✝ : LinearOrder α
a₁ a₂ b₁ b₂ : α
f : ι → α
a : α
⊢ ⋃ i, Ico (f i) a = Iio a ↔ ∀ x < a, ∃ i, f i ≤ x
state_after: no goals
tactic: simp [← Ici_inter_Iio, ← iUnion_inter, subset_def]
Theorem: LinearEquiv.rTensor_zpow
File: Mathlib/LinearAlgebra/TensorProduct/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝¹⁶ : CommSemiring R
R' : Type u_2
inst✝¹⁵ : Monoid R'
R'' : Type u_3
inst✝¹⁴ : Semiring R''
M : Type u_4
N : Type u_5
P : Type u_6
Q : Type u_7
S : Type u_8
T : Type u_9
inst✝¹³ : AddCommMonoid M
inst✝¹² : AddCommMonoid N
inst✝¹¹ : AddCommMonoid P
inst✝¹⁰ : AddCommMonoid Q
inst✝⁹ : AddCommMonoid S
inst✝⁸ : AddCommMonoid T
inst✝⁷ : Module R M
inst✝⁶ : Module R N
inst✝⁵ : Module R P
inst✝⁴ : Module R Q
inst✝³ : Module R S
inst✝² : Module R T
inst✝¹ : DistribMulAction R' M
inst✝ : Module R'' M
g : P ≃ₗ[R] Q
f✝ : N ≃ₗ[R] P
m : M
n✝ : N
p : P
x : M ⊗[R] N
y : N ⊗[R] M
f : M ≃ₗ[R] M
n : ℤ
⊢ rTensor N f ^ n = rTensor N (f ^ n)
state_after: no goals
tactic: simpa only [one_zpow] using TensorProduct.congr_zpow f (1 : N ≃ₗ[R] N) n
Theorem: ContinuousMap.tendsto_nhds_compactOpen
File: Mathlib/Topology/CompactOpen.lean

Proof steps:
state_before: α : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
T : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace T
K : Set X
U : Set Y
l : Filter α
f : α → C(Y, Z)
g : C(Y, Z)
⊢ Tendsto f l (𝓝 g) ↔
    ∀ (K : Set Y), IsCompact K → ∀ (U : Set Z), IsOpen U → MapsTo (⇑g) K U → ∀ᶠ (a : α) in l, MapsTo (⇑(f a)) K U
state_after: no goals
tactic: simp [nhds_compactOpen]
Theorem: Ideal.injective_lift_iff
File: Mathlib/RingTheory/Ideal/QuotientOperations.lean

Proof steps:
state_before: R : Type u
S : Type v
F : Type w
inst✝¹ : CommRing R
inst✝ : Semiring S
I : Ideal R
f : R →+* S
H : ∀ a ∈ I, f a = 0
⊢ Injective ⇑(Quotient.lift I f H) ↔ ker f = I
state_after: R : Type u
S : Type v
F : Type w
inst✝¹ : CommRing R
inst✝ : Semiring S
I : Ideal R
f : R →+* S
H : ∀ a ∈ I, f a = 0
⊢ ker f ≤ I ↔ ker f = I
tactic: rw [injective_iff_ker_eq_bot, ker_quotient_lift, map_eq_bot_iff_le_ker, mk_ker]
state_before: R : Type u
S : Type v
F : Type w
inst✝¹ : CommRing R
inst✝ : Semiring S
I : Ideal R
f : R →+* S
H : ∀ a ∈ I, f a = 0
⊢ ker f ≤ I ↔ ker f = I
state_after: case mp
R : Type u
S : Type v
F : Type w
inst✝¹ : CommRing R
inst✝ : Semiring S
I : Ideal R
f : R →+* S
H : ∀ a ∈ I, f a = 0
⊢ ker f ≤ I → ker f = I

case mpr
R : Type u
S : Type v
F : Type w
inst✝¹ : CommRing R
inst✝ : Semiring S
I : Ideal R
f : R →+* S
H : ∀ a ∈ I, f a = 0
⊢ ker f = I → ker f ≤ I
tactic: constructor
Theorem: Polynomial.addHom_ext
File: Mathlib/Algebra/Polynomial/Basic.lean

Proof steps:
state_before: R : Type u
a b : R
m n : ℕ
inst✝¹ : Semiring R
p q : R[X]
M : Type u_1
inst✝ : AddMonoid M
f g : R[X] →+ M
h : ∀ (n : ℕ) (a : R), f ((monomial n) a) = g ((monomial n) a)
⊢ Set.EqOn ⇑f ⇑g {p | ∃ n a, p = (monomial n) a}
state_after: case intro.intro
R : Type u
a✝ b : R
m n✝ : ℕ
inst✝¹ : Semiring R
p q : R[X]
M : Type u_1
inst✝ : AddMonoid M
f g : R[X] →+ M
h : ∀ (n : ℕ) (a : R), f ((monomial n) a) = g ((monomial n) a)
n : ℕ
a : R
⊢ f ((monomial n) a) = g ((monomial n) a)
tactic: rintro p ⟨n, a, rfl⟩
state_before: case intro.intro
R : Type u
a✝ b : R
m n✝ : ℕ
inst✝¹ : Semiring R
p q : R[X]
M : Type u_1
inst✝ : AddMonoid M
f g : R[X] →+ M
h : ∀ (n : ℕ) (a : R), f ((monomial n) a) = g ((monomial n) a)
n : ℕ
a : R
⊢ f ((monomial n) a) = g ((monomial n) a)
state_after: no goals
tactic: exact h n a