1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: CategoryTheory.Functor.Iteration.restrictionLT_map
File: Mathlib/CategoryTheory/SmallObject/Iteration.lean

tactic: simpa using leOfHom φ
state_before: C : Type u_1
inst✝³ : Category.{?u.7640, u_1} C
Φ : C ⥤ C
ε : 𝟭 C ⟶ Φ
J : Type u
inst✝² : LinearOrder J
inst✝¹ : IsWellOrder J fun x x_1 => x < x_1
inst✝ : OrderBot J
j : J
F : { i // i ≤ j } ⥤ C
i : J
hi : i ≤ j
k₁ k₂ : { k // k < i }
φ : k₁ ⟶ k₂
⊢ ⋯.functor.obj k₁ ≤ ⋯.functor.obj k₂
state_after: no goals
Theorem: Class.mem_wf
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: refine fun A => ⟨A, ?_⟩
state_before: H : ∀ (x : ZFSet), Acc (fun x x_1 => x ∈ x_1) ↑x
⊢ ∀ (a : Class), Acc (fun x x_1 => x ∈ x_1) a
state_after: H : ∀ (x : ZFSet), Acc (fun x x_1 => x ∈ x_1) ↑x
A : Class
⊢ ∀ y ∈ A, Acc (fun x x_1 => x ∈ x_1) y

tactic: rintro B ⟨x, rfl, _⟩
state_before: H : ∀ (x : ZFSet), Acc (fun x x_1 => x ∈ x_1) ↑x
A : Class
⊢ ∀ y ∈ A, Acc (fun x x_1 => x ∈ x_1) y
state_after: case intro.intro
H : ∀ (x : ZFSet), Acc (fun x x_1 => x ∈ x_1) ↑x
A : Class
x : ZFSet
right✝ : A x
⊢ Acc (fun x x_1 => x ∈ x_1) ↑x

tactic: exact H x
state_before: case intro.intro
H : ∀ (x : ZFSet), Acc (fun x x_1 => x ∈ x_1) ↑x
A : Class
x : ZFSet
right✝ : A x
⊢ Acc (fun x x_1 => x ∈ x_1) ↑x
state_after: no goals

tactic: refine fun a => ZFSet.inductionOn a fun x IH => ⟨_, ?_⟩
state_before: ⊢ ∀ (x : ZFSet), Acc (fun x x_1 => x ∈ x_1) ↑x
state_after: a x : ZFSet
IH : ∀ y ∈ x, Acc (fun x x_1 => x ∈ x_1) ↑y
⊢ ∀ y ∈ ↑x, Acc (fun x x_1 => x ∈ x_1) y

tactic: rintro A ⟨z, rfl, hz⟩
state_before: a x : ZFSet
IH : ∀ y ∈ x, Acc (fun x x_1 => x ∈ x_1) ↑y
⊢ ∀ y ∈ ↑x, Acc (fun x x_1 => x ∈ x_1) y
state_after: case intro.intro
a x : ZFSet
IH : ∀ y ∈ x, Acc (fun x x_1 => x ∈ x_1) ↑y
z : ZFSet
hz : ↑x z
⊢ Acc (fun x x_1 => x ∈ x_1) ↑z

tactic: exact IH z hz
state_before: case intro.intro
a x : ZFSet
IH : ∀ y ∈ x, Acc (fun x x_1 => x ∈ x_1) ↑y
z : ZFSet
hz : ↑x z
⊢ Acc (fun x x_1 => x ∈ x_1) ↑z
state_after: no goals
Theorem: Orientation.rotation_pi_apply
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Rotation.lean

tactic: simp
state_before: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x : V
⊢ (o.rotation ↑π) x = -x
state_after: no goals
Theorem: Equiv.prodCongr_refl_right
File: Mathlib/Logic/Equiv/Basic.lean

tactic: ext ⟨a, b⟩ : 1
state_before: α₁ : Type u_3
β₁ : Type u_1
β₂ : Type u_2
e✝ : α₁ → β₁ ≃ β₂
e : β₁ ≃ β₂
⊢ e.prodCongr (Equiv.refl α₁) = prodCongrLeft fun x => e
state_after: case H.mk
α₁ : Type u_3
β₁ : Type u_1
β₂ : Type u_2
e✝ : α₁ → β₁ ≃ β₂
e : β₁ ≃ β₂
a : β₁
b : α₁
⊢ (e.prodCongr (Equiv.refl α₁)) (a, b) = (prodCongrLeft fun x => e) (a, b)

tactic: simp
state_before: case H.mk
α₁ : Type u_3
β₁ : Type u_1
β₂ : Type u_2
e✝ : α₁ → β₁ ≃ β₂
e : β₁ ≃ β₂
a : β₁
b : α₁
⊢ (e.prodCongr (Equiv.refl α₁)) (a, b) = (prodCongrLeft fun x => e) (a, b)
state_after: no goals
Theorem: IsometryEquiv.preimage_closedBall
File: Mathlib/Topology/MetricSpace/Isometry.lean

tactic: rw [← h.isometry.preimage_closedBall (h.symm x) r, h.apply_symm_apply]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
h✝ h : α ≃ᵢ β
x : β
r : ℝ
⊢ ⇑h ⁻¹' Metric.closedBall x r = Metric.closedBall (h.symm x) r
state_after: no goals
Theorem: Polynomial.eval₂_sum
File: Mathlib/Algebra/Polynomial/Eval.lean

tactic: let T : R[X] →+ S :=
  { toFun := eval₂ f x
    map_zero' := eval₂_zero _ _
    map_add' := fun p q => eval₂_add _ _ }
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝² : Semiring R
p✝ q r : R[X]
inst✝¹ : Semiring S
f : R →+* S
x✝ : S
inst✝ : Semiring T
p : T[X]
g : ℕ → T → R[X]
x : S
⊢ eval₂ f x (p.sum g) = p.sum fun n a => eval₂ f x (g n a)
state_after: R : Type u
S : Type v
T✝ : Type w
ι : Type y
a b : R
m n : ℕ
inst✝² : Semiring R
p✝ q r : R[X]
inst✝¹ : Semiring S
f : R →+* S
x✝ : S
inst✝ : Semiring T✝
p : T✝[X]
g : ℕ → T✝ → R[X]
x : S
T : R[X] →+ S := { toFun := eval₂ f x, map_zero' := ⋯, map_add' := ⋯ }
⊢ eval₂ f x (p.sum g) = p.sum fun n a => eval₂ f x (g n a)

tactic: have A : ∀ y, eval₂ f x y = T y := fun y => rfl
state_before: R : Type u
S : Type v
T✝ : Type w
ι : Type y
a b : R
m n : ℕ
inst✝² : Semiring R
p✝ q r : R[X]
inst✝¹ : Semiring S
f : R →+* S
x✝ : S
inst✝ : Semiring T✝
p : T✝[X]
g : ℕ → T✝ → R[X]
x : S
T : R[X] →+ S := { toFun := eval₂ f x, map_zero' := ⋯, map_add' := ⋯ }
⊢ eval₂ f x (p.sum g) = p.sum fun n a => eval₂ f x (g n a)
state_after: R : Type u
S : Type v
T✝ : Type w
ι : Type y
a b : R
m n : ℕ
inst✝² : Semiring R
p✝ q r : R[X]
inst✝¹ : Semiring S
f : R →+* S
x✝ : S
inst✝ : Semiring T✝
p : T✝[X]
g : ℕ → T✝ → R[X]
x : S
T : R[X] →+ S := { toFun := eval₂ f x, map_zero' := ⋯, map_add' := ⋯ }
A : ∀ (y : R[X]), eval₂ f x y = T y
⊢ eval₂ f x (p.sum g) = p.sum fun n a => eval₂ f x (g n a)

tactic: simp only [A]
state_before: R : Type u
S : Type v
T✝ : Type w
ι : Type y
a b : R
m n : ℕ
inst✝² : Semiring R
p✝ q r : R[X]
inst✝¹ : Semiring S
f : R →+* S
x✝ : S
inst✝ : Semiring T✝
p : T✝[X]
g : ℕ → T✝ → R[X]
x : S
T : R[X] →+ S := { toFun := eval₂ f x, map_zero' := ⋯, map_add' := ⋯ }
A : ∀ (y : R[X]), eval₂ f x y = T y
⊢ eval₂ f x (p.sum g) = p.sum fun n a => eval₂ f x (g n a)
state_after: R : Type u
S : Type v
T✝ : Type w
ι : Type y
a b : R
m n : ℕ
inst✝² : Semiring R
p✝ q r : R[X]
inst✝¹ : Semiring S
f : R →+* S
x✝ : S
inst✝ : Semiring T✝
p : T✝[X]
g : ℕ → T✝ → R[X]
x : S
T : R[X] →+ S := { toFun := eval₂ f x, map_zero' := ⋯, map_add' := ⋯ }
A : ∀ (y : R[X]), eval₂ f x y = T y
⊢ T (p.sum g) = p.sum fun n a => T (g n a)

tactic: rw [sum, map_sum, sum]
state_before: R : Type u
S : Type v
T✝ : Type w
ι : Type y
a b : R
m n : ℕ
inst✝² : Semiring R
p✝ q r : R[X]
inst✝¹ : Semiring S
f : R →+* S
x✝ : S
inst✝ : Semiring T✝
p : T✝[X]
g : ℕ → T✝ → R[X]
x : S
T : R[X] →+ S := { toFun := eval₂ f x, map_zero' := ⋯, map_add' := ⋯ }
A : ∀ (y : R[X]), eval₂ f x y = T y
⊢ T (p.sum g) = p.sum fun n a => T (g n a)
state_after: no goals
Theorem: Polynomial.IsPrimitive.primPart_eq
File: Mathlib/RingTheory/Polynomial/Content.lean

tactic: rw [← one_mul p.primPart, ← C_1, ← hp.content_eq_one, ← p.eq_C_content_mul_primPart]
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
hp : p.IsPrimitive
⊢ p.primPart = p
state_after: no goals
Theorem: ContinuousMap.toNNReal_add_add_neg_add_neg_eq
File: Mathlib/Topology/ContinuousFunction/UniqueCFC.lean

tactic: ext x
state_before: X : Type u_1
inst✝ : TopologicalSpace X
f g : C(X, ℝ)
⊢ (f + g).toNNReal + (-f).toNNReal + (-g).toNNReal = (-(f + g)).toNNReal + f.toNNReal + g.toNNReal
state_after: case h.a
X : Type u_1
inst✝ : TopologicalSpace X
f g : C(X, ℝ)
x : X
⊢ ↑(((f + g).toNNReal + (-f).toNNReal + (-g).toNNReal) x) = ↑(((-(f + g)).toNNReal + f.toNNReal + g.toNNReal) x)

tactic: simp [max_neg_zero, -neg_add_rev]
state_before: case h.a
X : Type u_1
inst✝ : TopologicalSpace X
f g : C(X, ℝ)
x : X
⊢ ↑(((f + g).toNNReal + (-f).toNNReal + (-g).toNNReal) x) = ↑(((-(f + g)).toNNReal + f.toNNReal + g.toNNReal) x)
state_after: case h.a
X : Type u_1
inst✝ : TopologicalSpace X
f g : C(X, ℝ)
x : X
⊢ max (f x + g x) 0 + (-f x + max (f x) 0) + (-g x + max (g x) 0) =
    -(f x + g x) + max (f x + g x) 0 + max (f x) 0 + max (g x) 0

tactic: abel
state_before: case h.a
X : Type u_1
inst✝ : TopologicalSpace X
f g : C(X, ℝ)
x : X
⊢ max (f x + g x) 0 + (-f x + max (f x) 0) + (-g x + max (g x) 0) =
    -(f x + g x) + max (f x + g x) 0 + max (f x) 0 + max (g x) 0
state_after: no goals
Theorem: ContinuousMap.specializes_coe
File: Mathlib/Topology/CompactOpen.lean

tactic: refine ⟨fun h ↦ ?_, fun h ↦ h.map continuous_coe⟩
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
f g : C(X, Y)
⊢ ⇑f ⤳ ⇑g ↔ f ⤳ g
state_after: α : 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
f g : C(X, Y)
h : ⇑f ⤳ ⇑g
⊢ f ⤳ g

tactic: suffices ∀ K, IsCompact K → ∀ U, IsOpen U → MapsTo g K U → MapsTo f K U by
  simpa [specializes_iff_pure, nhds_compactOpen]
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
f g : C(X, Y)
h : ⇑f ⤳ ⇑g
⊢ f ⤳ g
state_after: α : 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
f g : C(X, Y)
h : ⇑f ⤳ ⇑g
⊢ ∀ (K : Set X), IsCompact K → ∀ (U : Set Y), IsOpen U → MapsTo (⇑g) K U → MapsTo (⇑f) K U

tactic: exact fun K _ U hU hg x hx ↦ (h.map (continuous_apply x)).mem_open hU (hg hx)
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
f g : C(X, Y)
h : ⇑f ⤳ ⇑g
⊢ ∀ (K : Set X), IsCompact K → ∀ (U : Set Y), IsOpen U → MapsTo (⇑g) K U → MapsTo (⇑f) K U
state_after: no goals

tactic: simpa [specializes_iff_pure, nhds_compactOpen]
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
f g : C(X, Y)
h : ⇑f ⤳ ⇑g
this : ∀ (K : Set X), IsCompact K → ∀ (U : Set Y), IsOpen U → MapsTo (⇑g) K U → MapsTo (⇑f) K U
⊢ f ⤳ g
state_after: no goals
Theorem: Real.contDiffAt_rpow_of_ne
File: Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean

tactic: cases' hp.lt_or_lt with hneg hpos
state_before: x y z : ℝ
p : ℝ × ℝ
hp : p.1 ≠ 0
n : ℕ∞
⊢ ContDiffAt ℝ n (fun p => p.1 ^ p.2) p
state_after: case inl
x y z : ℝ
p : ℝ × ℝ
hp : p.1 ≠ 0
n : ℕ∞
hneg : p.1 < 0
⊢ ContDiffAt ℝ n (fun p => p.1 ^ p.2) p

case inr
x y z : ℝ
p : ℝ × ℝ
hp : p.1 ≠ 0
n : ℕ∞
hpos : 0 < p.1
⊢ ContDiffAt ℝ n (fun p => p.1 ^ p.2) p

tactic: exacts
  [(((contDiffAt_fst.log hneg.ne).mul contDiffAt_snd).exp.mul
        (contDiffAt_snd.mul contDiffAt_const).cos).congr_of_eventuallyEq
    ((continuousAt_fst.eventually (gt_mem_nhds hneg)).mono fun p hp => rpow_def_of_neg hp _),
  ((contDiffAt_fst.log hpos.ne').mul contDiffAt_snd).exp.congr_of_eventuallyEq
    ((continuousAt_fst.eventually (lt_mem_nhds hpos)).mono fun p hp => rpow_def_of_pos hp _)]
state_before: case inl
x y z : ℝ
p : ℝ × ℝ
hp : p.1 ≠ 0
n : ℕ∞
hneg : p.1 < 0
⊢ ContDiffAt ℝ n (fun p => p.1 ^ p.2) p

case inr
x y z : ℝ
p : ℝ × ℝ
hp : p.1 ≠ 0
n : ℕ∞
hpos : 0 < p.1
⊢ ContDiffAt ℝ n (fun p => p.1 ^ p.2) p
state_after: no goals
Theorem: Polynomial.natTrailingDegree_intCast
File: Mathlib/Algebra/Polynomial/Degree/TrailingDegree.lean

tactic: simp only [← C_eq_intCast, natTrailingDegree_C]
state_before: R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Ring R
n : ℤ
⊢ (↑n).natTrailingDegree = 0
state_after: no goals
Theorem: Pi.uniformSpace_comap_restrict_sUnion
File: Mathlib/Topology/UniformSpace/Pi.lean

tactic: simp_rw [Pi.uniformSpace_comap_restrict α, iInf_sUnion]
state_before: ι : Type u_1
ι' : Type u_2
β : Type u_3
α : ι → Type u
U : (i : ι) → UniformSpace (α i)
inst✝ : UniformSpace β
𝔖 : Set (Set ι)
⊢ UniformSpace.comap (⋃₀ 𝔖).restrict (uniformSpace fun i => α ↑i) =
    ⨅ S ∈ 𝔖, UniformSpace.comap S.restrict (uniformSpace fun i => α ↑i)
state_after: no goals
Theorem: PNat.XgcdType.reduce_b
File: Mathlib/Data/PNat/Xgcd.lean

tactic: rw [reduce]
state_before: u✝ u : XgcdType
h : u.r ≠ 0
⊢ u.reduce = u.step.reduce.flip
state_after: u✝ u : XgcdType
h : u.r ≠ 0
⊢ (if x : u.r = 0 then u.finish else u.step.reduce.flip) = u.step.reduce.flip

tactic: exact if_neg h
state_before: u✝ u : XgcdType
h : u.r ≠ 0
⊢ (if x : u.r = 0 then u.finish else u.step.reduce.flip) = u.step.reduce.flip
state_after: no goals
Theorem: CategoryTheory.Limits.Types.descSet_empty
File: Mathlib/CategoryTheory/Limits/Preserves/Ulift.lean

tactic: simp [descSet_spec]
state_before: J : Type u_1
inst✝ : Category.{u_2, u_1} J
K : J ⥤ Type u
c : Cocone K
hc : IsColimit c
lc : Cocone (K ⋙ uliftFunctor.{v, u})
⊢ descSet hc ∅ = ∅
state_after: no goals
Theorem: IsChain.directed
File: Mathlib/Order/Chain.lean

tactic: simp only [hab, exists_prop, and_self_iff, Subtype.exists]
state_before: α : Type u_1
β : Type u_2
r : α → α → Prop
c✝ c₁ c₂ c₃ s t : Set α
a✝ b✝ x y : α
inst✝ : IsRefl α r
f : β → α
c : Set β
h : IsChain (f ⁻¹'o r) c
x✝¹ x✝ : { a // a ∈ c }
a : β
ha : a ∈ c
b : β
hb : b ∈ c
hab : a = b
⊢ ∃ z, r ((fun x => f ↑x) ⟨a, ha⟩) ((fun x => f ↑x) z) ∧ r ((fun x => f ↑x) ⟨b, hb⟩) ((fun x => f ↑x) z)
state_after: α : Type u_1
β : Type u_2
r : α → α → Prop
c✝ c₁ c₂ c₃ s t : Set α
a✝ b✝ x y : α
inst✝ : IsRefl α r
f : β → α
c : Set β
h : IsChain (f ⁻¹'o r) c
x✝¹ x✝ : { a // a ∈ c }
a : β
ha : a ∈ c
b : β
hb : b ∈ c
hab : a = b
⊢ ∃ a ∈ c, r (f b) (f a)

tactic: exact ⟨b, hb, refl _⟩
state_before: α : Type u_1
β : Type u_2
r : α → α → Prop
c✝ c₁ c₂ c₃ s t : Set α
a✝ b✝ x y : α
inst✝ : IsRefl α r
f : β → α
c : Set β
h : IsChain (f ⁻¹'o r) c
x✝¹ x✝ : { a // a ∈ c }
a : β
ha : a ∈ c
b : β
hb : b ∈ c
hab : a = b
⊢ ∃ a ∈ c, r (f b) (f a)
state_after: no goals
Theorem: CategoryTheory.Limits.IsImage.e_isoExt_inv
File: Mathlib/CategoryTheory/Limits/Shapes/Images.lean

tactic: simp
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
F F' : MonoFactorisation f
hF : IsImage F
hF' : IsImage F'
⊢ F'.e ≫ (hF.isoExt hF').inv = F.e
state_after: no goals
Theorem: Commute.orderOf_mul_eq_mul_orderOf_of_coprime
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: rw [orderOf, ← comp_mul_left]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n m : ℕ
h : Commute x y
hco : (orderOf x).Coprime (orderOf y)
⊢ orderOf (x * y) = orderOf x * orderOf y
state_after: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n m : ℕ
h : Commute x y
hco : (orderOf x).Coprime (orderOf y)
⊢ minimalPeriod ((fun x_1 => x * x_1) ∘ fun x => y * x) 1 = orderOf x * orderOf y

tactic: exact h.function_commute_mul_left.minimalPeriod_of_comp_eq_mul_of_coprime hco
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n m : ℕ
h : Commute x y
hco : (orderOf x).Coprime (orderOf y)
⊢ minimalPeriod ((fun x_1 => x * x_1) ∘ fun x => y * x) 1 = orderOf x * orderOf y
state_after: no goals
Theorem: Real.Angle.cos_coe_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [cos_coe, Real.cos_pi]
state_before: ⊢ (↑π).cos = -1
state_after: no goals
Theorem: Finset.not_mem_uIcc_of_lt
File: Mathlib/Order/Interval/Finset/Basic.lean

tactic: rw [mem_uIcc]
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ c < a → c < b → c ∉ [[a, b]]
state_after: ι : Type u_1
α : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ c < a → c < b → ¬(a ⊓ b ≤ c ∧ c ≤ a ⊔ b)

tactic: exact Set.not_mem_uIcc_of_lt
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ c < a → c < b → ¬(a ⊓ b ≤ c ∧ c ≤ a ⊔ b)
state_after: no goals
Theorem: CategoryTheory.ExponentialIdeal.mk_of_iso
File: Mathlib/CategoryTheory/Closed/Ideal.lean

tactic: apply ExponentialIdeal.mk'
state_before: C : Type u₁
D : Type u₂
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : Category.{v₁, u₂} D
i : D ⥤ C
inst✝² : HasFiniteProducts C
inst✝¹ : CartesianClosed C
inst✝ : Reflective i
h : (A : C) → i ⋙ exp A ⋙ reflector i ⋙ i ≅ i ⋙ exp A
⊢ ExponentialIdeal i
state_after: case h
C : Type u₁
D : Type u₂
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : Category.{v₁, u₂} D
i : D ⥤ C
inst✝² : HasFiniteProducts C
inst✝¹ : CartesianClosed C
inst✝ : Reflective i
h : (A : C) → i ⋙ exp A ⋙ reflector i ⋙ i ≅ i ⋙ exp A
⊢ ∀ (B : D) (A : C), (A ⟹ i.obj B) ∈ i.essImage

tactic: intro B A
state_before: case h
C : Type u₁
D : Type u₂
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : Category.{v₁, u₂} D
i : D ⥤ C
inst✝² : HasFiniteProducts C
inst✝¹ : CartesianClosed C
inst✝ : Reflective i
h : (A : C) → i ⋙ exp A ⋙ reflector i ⋙ i ≅ i ⋙ exp A
⊢ ∀ (B : D) (A : C), (A ⟹ i.obj B) ∈ i.essImage
state_after: case h
C : Type u₁
D : Type u₂
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : Category.{v₁, u₂} D
i : D ⥤ C
inst✝² : HasFiniteProducts C
inst✝¹ : CartesianClosed C
inst✝ : Reflective i
h : (A : C) → i ⋙ exp A ⋙ reflector i ⋙ i ≅ i ⋙ exp A
B : D
A : C
⊢ (A ⟹ i.obj B) ∈ i.essImage

tactic: exact ⟨_, ⟨(h A).app B⟩⟩
state_before: case h
C : Type u₁
D : Type u₂
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : Category.{v₁, u₂} D
i : D ⥤ C
inst✝² : HasFiniteProducts C
inst✝¹ : CartesianClosed C
inst✝ : Reflective i
h : (A : C) → i ⋙ exp A ⋙ reflector i ⋙ i ≅ i ⋙ exp A
B : D
A : C
⊢ (A ⟹ i.obj B) ∈ i.essImage
state_after: no goals
Theorem: RingCon.coe_sInf
File: Mathlib/RingTheory/Congruence/Basic.lean

tactic: ext
state_before: α : Type u_1
R : Type u_2
inst✝¹ : Add R
inst✝ : Mul R
S : Set (RingCon R)
⊢ ⇑(sInf S) = sInf (DFunLike.coe '' S)
state_after: case h.h.a
α : Type u_1
R : Type u_2
inst✝¹ : Add R
inst✝ : Mul R
S : Set (RingCon R)
x✝¹ x✝ : R
⊢ (sInf S) x✝¹ x✝ ↔ sInf (DFunLike.coe '' S) x✝¹ x✝

tactic: simp only [sInf_image, iInf_apply, iInf_Prop_eq]
state_before: case h.h.a
α : Type u_1
R : Type u_2
inst✝¹ : Add R
inst✝ : Mul R
S : Set (RingCon R)
x✝¹ x✝ : R
⊢ (sInf S) x✝¹ x✝ ↔ sInf (DFunLike.coe '' S) x✝¹ x✝
state_after: case h.h.a
α : Type u_1
R : Type u_2
inst✝¹ : Add R
inst✝ : Mul R
S : Set (RingCon R)
x✝¹ x✝ : R
⊢ (sInf S) x✝¹ x✝ ↔ ∀ i ∈ S, i x✝¹ x✝

tactic: rfl
state_before: case h.h.a
α : Type u_1
R : Type u_2
inst✝¹ : Add R
inst✝ : Mul R
S : Set (RingCon R)
x✝¹ x✝ : R
⊢ (sInf S) x✝¹ x✝ ↔ ∀ i ∈ S, i x✝¹ x✝
state_after: no goals
Theorem: Complex.volume_ball
File: Mathlib/MeasureTheory/Measure/Lebesgue/VolumeOfBalls.lean

tactic: rw [InnerProductSpace.volume_ball a r, finrank_real_complex, Nat.cast_ofNat, div_self two_ne_zero,
  one_add_one_eq_two, Real.Gamma_two, div_one, Real.sq_sqrt (by positivity),
  ← NNReal.coe_real_pi, ofReal_coe_nnreal]
state_before: a : ℂ
r : ℝ
⊢ volume (Metric.ball a r) = ENNReal.ofReal r ^ 2 * ↑NNReal.pi
state_after: no goals

tactic: positivity
state_before: a : ℂ
r : ℝ
⊢ 0 ≤ Real.pi
state_after: no goals
Theorem: Set.encard_eq_top_iff
File: Mathlib/Data/Set/Card.lean

tactic: rw [← not_iff_not, ← Ne, ← lt_top_iff_ne_top, encard_lt_top_iff, not_infinite]
state_before: α : Type u_1
β : Type u_2
s t : Set α
⊢ s.encard = ⊤ ↔ s.Infinite
state_after: no goals
Theorem: HahnSeries.mk_eq_zero
File: Mathlib/RingTheory/HahnSeries/Basic.lean

tactic: rw [HahnSeries.ext_iff]
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : Zero R
f : Γ → R
h : (Function.support f).IsPWO
⊢ { coeff := f, isPWO_support' := h } = 0 ↔ f = 0
state_after: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : Zero R
f : Γ → R
h : (Function.support f).IsPWO
⊢ { coeff := f, isPWO_support' := h }.coeff = coeff 0 ↔ f = 0

tactic: rfl
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : Zero R
f : Γ → R
h : (Function.support f).IsPWO
⊢ { coeff := f, isPWO_support' := h }.coeff = coeff 0 ↔ f = 0
state_after: no goals
Theorem: QuotientGroup.leftRel_apply
File: Mathlib/GroupTheory/Coset.lean

tactic: simp only [inv_mul_eq_iff_eq_mul, Subgroup.coe_inv, eq_mul_inv_iff_mul_eq]
state_before: α : Type u_1
inst✝ : Group α
s : Subgroup α
x y : α
⊢ (∃ a, y * ↑a = x) ↔ ∃ a, x⁻¹ * y = ↑a⁻¹
state_after: no goals

tactic: simp [exists_inv_mem_iff_exists_mem]
state_before: α : Type u_1
inst✝ : Group α
s : Subgroup α
x y : α
⊢ (∃ a, x⁻¹ * y = ↑a⁻¹) ↔ x⁻¹ * y ∈ s
state_after: no goals
Theorem: Real.sin_eq_zero_iff_of_lt_of_lt
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: contrapose! h
state_before: x : ℝ
hx₁ : -π < x
hx₂ : x < π
h : sin x = 0
⊢ x = 0
state_after: x : ℝ
hx₁ : -π < x
hx₂ : x < π
h : x ≠ 0
⊢ sin x ≠ 0

tactic: cases h.lt_or_lt with
| inl h0 => exact (sin_neg_of_neg_of_neg_pi_lt h0 hx₁).ne
| inr h0 => exact (sin_pos_of_pos_of_lt_pi h0 hx₂).ne'
state_before: x : ℝ
hx₁ : -π < x
hx₂ : x < π
h : x ≠ 0
⊢ sin x ≠ 0
state_after: no goals

tactic: exact (sin_neg_of_neg_of_neg_pi_lt h0 hx₁).ne
state_before: case inl
x : ℝ
hx₁ : -π < x
hx₂ : x < π
h : x ≠ 0
h0 : x < 0
⊢ sin x ≠ 0
state_after: no goals

tactic: exact (sin_pos_of_pos_of_lt_pi h0 hx₂).ne'
state_before: case inr
x : ℝ
hx₁ : -π < x
hx₂ : x < π
h : x ≠ 0
h0 : 0 < x
⊢ sin x ≠ 0
state_after: no goals

tactic: simp [h]
state_before: x : ℝ
hx₁ : -π < x
hx₂ : x < π
h : x = 0
⊢ sin x = 0
state_after: no goals
Theorem: Bornology.isBounded_iUnion
File: Mathlib/Topology/Bornology/Basic.lean

tactic: rw [← sUnion_range, isBounded_sUnion (finite_range s), forall_mem_range]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
s✝ : Set α
inst✝¹ : Bornology α
inst✝ : Finite ι
s : ι → Set α
⊢ IsBounded (⋃ i, s i) ↔ ∀ (i : ι), IsBounded (s i)
state_after: no goals
Theorem: List.filter_append_perm
File: .lake/packages/batteries/Batteries/Data/List/Perm.lean

tactic: rfl
state_before: case nil
α : Type u_1
p : α → Bool
⊢ filter p [] ++ filter (fun x => !p x) [] ~ []
state_after: no goals

tactic: by_cases h : p x <;> simp [h]
state_before: case cons
α : Type u_1
p : α → Bool
x : α
l : List α
ih : filter p l ++ filter (fun x => !p x) l ~ l
⊢ filter p (x :: l) ++ filter (fun x => !p x) (x :: l) ~ x :: l
state_after: case pos
α : Type u_1
p : α → Bool
x : α
l : List α
ih : filter p l ++ filter (fun x => !p x) l ~ l
h : p x = true
⊢ x :: (filter p l ++ filter (fun x => !p x) l) ~ x :: l

case neg
α : Type u_1
p : α → Bool
x : α
l : List α
ih : filter p l ++ filter (fun x => !p x) l ~ l
h : ¬p x = true
⊢ filter p l ++ x :: filter (fun x => !p x) l ~ x :: l

tactic: exact ih.cons x
state_before: case pos
α : Type u_1
p : α → Bool
x : α
l : List α
ih : filter p l ++ filter (fun x => !p x) l ~ l
h : p x = true
⊢ x :: (filter p l ++ filter (fun x => !p x) l) ~ x :: l
state_after: no goals

tactic: exact Perm.trans (perm_append_comm.trans (perm_append_comm.cons _)) (ih.cons x)
state_before: case neg
α : Type u_1
p : α → Bool
x : α
l : List α
ih : filter p l ++ filter (fun x => !p x) l ~ l
h : ¬p x = true
⊢ filter p l ++ x :: filter (fun x => !p x) l ~ x :: l
state_after: no goals
Theorem: SetTheory.PGame.Numeric.moveRight
File: Mathlib/SetTheory/Surreal/Basic.lean

tactic: cases x
state_before: x : PGame
o : x.Numeric
j : x.RightMoves
⊢ (x.moveRight j).Numeric
state_after: case mk
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
o : (PGame.mk α✝ β✝ a✝¹ a✝).Numeric
j : (PGame.mk α✝ β✝ a✝¹ a✝).RightMoves
⊢ ((PGame.mk α✝ β✝ a✝¹ a✝).moveRight j).Numeric

tactic: exact o.2.2 j
state_before: case mk
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
o : (PGame.mk α✝ β✝ a✝¹ a✝).Numeric
j : (PGame.mk α✝ β✝ a✝¹ a✝).RightMoves
⊢ ((PGame.mk α✝ β✝ a✝¹ a✝).moveRight j).Numeric
state_after: no goals