1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: imageToKernel_unop
File: Mathlib/Algebra/Homology/Opposite.lean

tactic: rw [← unop_comp, w, unop_zero]
state_before: V : Type u_1
inst✝¹ : Category.{?u.8360, u_1} V
inst✝ : Abelian V
X Y Z : Vᵒᵖ
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ g.unop ≫ f.unop = 0
state_after: no goals

tactic: rw [← cancel_mono (image.ι g), Category.assoc, image.fac, w, zero_comp]
state_before: V : Type u_1
inst✝¹ : Category.{?u.8360, u_1} V
inst✝ : Abelian V
X Y Z : Vᵒᵖ
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ f ≫ factorThruImage g = 0
state_after: no goals

tactic: ext
state_before: V : Type u_1
inst✝¹ : Category.{u_2, u_1} V
inst✝ : Abelian V
X Y Z : Vᵒᵖ
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ imageToKernel g.unop f.unop ⋯ =
    (imageSubobjectIso g.unop ≪≫ (imageUnopUnop g).symm).hom ≫
      (cokernel.desc f (factorThruImage g) ⋯).unop ≫ (kernelSubobjectIso f.unop ≪≫ kernelUnopUnop f).inv
state_after: case h
V : Type u_1
inst✝¹ : Category.{u_2, u_1} V
inst✝ : Abelian V
X Y Z : Vᵒᵖ
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ imageToKernel g.unop f.unop ⋯ ≫ (kernelSubobject f.unop).arrow =
    ((imageSubobjectIso g.unop ≪≫ (imageUnopUnop g).symm).hom ≫
        (cokernel.desc f (factorThruImage g) ⋯).unop ≫ (kernelSubobjectIso f.unop ≪≫ kernelUnopUnop f).inv) ≫
      (kernelSubobject f.unop).arrow

tactic: dsimp only [imageUnopUnop]
state_before: case h
V : Type u_1
inst✝¹ : Category.{u_2, u_1} V
inst✝ : Abelian V
X Y Z : Vᵒᵖ
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ imageToKernel g.unop f.unop ⋯ ≫ (kernelSubobject f.unop).arrow =
    ((imageSubobjectIso g.unop ≪≫ (imageUnopUnop g).symm).hom ≫
        (cokernel.desc f (factorThruImage g) ⋯).unop ≫ (kernelSubobjectIso f.unop ≪≫ kernelUnopUnop f).inv) ≫
      (kernelSubobject f.unop).arrow
state_after: case h
V : Type u_1
inst✝¹ : Category.{u_2, u_1} V
inst✝ : Abelian V
X Y Z : Vᵒᵖ
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ imageToKernel g.unop f.unop ⋯ ≫ (kernelSubobject f.unop).arrow =
    ((imageSubobjectIso g.unop ≪≫ (imageUnopOp g).unop.symm).hom ≫
        (cokernel.desc f (factorThruImage g) ⋯).unop ≫ (kernelSubobjectIso f.unop ≪≫ kernelUnopUnop f).inv) ≫
      (kernelSubobject f.unop).arrow

tactic: simp only [Iso.trans_hom, Iso.symm_hom, Iso.trans_inv, kernelUnopUnop_inv, Category.assoc,
  imageToKernel_arrow, kernelSubobject_arrow', kernel.lift_ι, cokernel.π_desc, Iso.unop_inv,
  ← unop_comp, factorThruImage_comp_imageUnopOp_inv, Quiver.Hom.unop_op, imageSubobject_arrow]
state_before: case h
V : Type u_1
inst✝¹ : Category.{u_2, u_1} V
inst✝ : Abelian V
X Y Z : Vᵒᵖ
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ imageToKernel g.unop f.unop ⋯ ≫ (kernelSubobject f.unop).arrow =
    ((imageSubobjectIso g.unop ≪≫ (imageUnopOp g).unop.symm).hom ≫
        (cokernel.desc f (factorThruImage g) ⋯).unop ≫ (kernelSubobjectIso f.unop ≪≫ kernelUnopUnop f).inv) ≫
      (kernelSubobject f.unop).arrow
state_after: no goals
Theorem: Finset.univ_div_univ
File: Mathlib/Data/Finset/Pointwise.lean

tactic: simp [div_eq_mul_inv]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : DecidableEq α
inst✝² : DecidableEq β
inst✝¹ : DivisionMonoid α
s t : Finset α
inst✝ : Fintype α
⊢ univ / univ = univ
state_after: no goals
Theorem: Finset.prod_fin_eq_prod_range
File: Mathlib/Data/Fintype/BigOperators.lean

tactic: rw [← Fin.prod_univ_eq_prod_range, Finset.prod_congr rfl]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : CommMonoid β
n : ℕ
c : Fin n → β
⊢ ∏ i : Fin n, c i = ∏ i ∈ range n, if h : i < n then c ⟨i, h⟩ else 1
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : CommMonoid β
n : ℕ
c : Fin n → β
⊢ ∀ x ∈ univ, c x = if h : ↑x < n then c ⟨↑x, h⟩ else 1

tactic: rintro ⟨i, hi⟩ _
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : CommMonoid β
n : ℕ
c : Fin n → β
⊢ ∀ x ∈ univ, c x = if h : ↑x < n then c ⟨↑x, h⟩ else 1
state_after: case mk
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : CommMonoid β
n : ℕ
c : Fin n → β
i : ℕ
hi : i < n
a✝ : ⟨i, hi⟩ ∈ univ
⊢ c ⟨i, hi⟩ = if h : ↑⟨i, hi⟩ < n then c ⟨↑⟨i, hi⟩, h⟩ else 1

tactic: simp only [hi, dif_pos]
state_before: case mk
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : CommMonoid β
n : ℕ
c : Fin n → β
i : ℕ
hi : i < n
a✝ : ⟨i, hi⟩ ∈ univ
⊢ c ⟨i, hi⟩ = if h : ↑⟨i, hi⟩ < n then c ⟨↑⟨i, hi⟩, h⟩ else 1
state_after: no goals
Theorem: Submonoid.dense_induction
File: Mathlib/Algebra/Group/Submonoid/Basic.lean

tactic: have : ∀ x ∈ closure s, p x := fun x hx => closure_induction hx mem one mul
state_before: M : Type u_1
N : Type u_2
A : Type u_3
inst✝¹ : MulOneClass M
s✝ : Set M
inst✝ : AddZeroClass A
t : Set A
S : Submonoid M
p : M → Prop
x : M
s : Set M
hs : closure s = ⊤
mem : ∀ x ∈ s, p x
one : p 1
mul : ∀ (x y : M), p x → p y → p (x * y)
⊢ p x
state_after: M : Type u_1
N : Type u_2
A : Type u_3
inst✝¹ : MulOneClass M
s✝ : Set M
inst✝ : AddZeroClass A
t : Set A
S : Submonoid M
p : M → Prop
x : M
s : Set M
hs : closure s = ⊤
mem : ∀ x ∈ s, p x
one : p 1
mul : ∀ (x y : M), p x → p y → p (x * y)
this : ∀ x ∈ closure s, p x
⊢ p x

tactic: simpa [hs] using this x
state_before: M : Type u_1
N : Type u_2
A : Type u_3
inst✝¹ : MulOneClass M
s✝ : Set M
inst✝ : AddZeroClass A
t : Set A
S : Submonoid M
p : M → Prop
x : M
s : Set M
hs : closure s = ⊤
mem : ∀ x ∈ s, p x
one : p 1
mul : ∀ (x y : M), p x → p y → p (x * y)
this : ∀ x ∈ closure s, p x
⊢ p x
state_after: no goals
Theorem: List.mem_inits
File: Mathlib/Data/List/Infix.lean

tactic: simpa only [inits, mem_singleton]
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a b : α
m n : ℕ
s : List α
this : s = [] ↔ s <+: []
⊢ s ∈ [].inits ↔ s <+: []
state_after: no goals

tactic: simpa
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a✝ b : α
m n : ℕ
s : List α
a : α
t : List α
this : (s = [] ∨ ∃ l, l ∈ t.inits ∧ a :: l = s) ↔ s <+: a :: t
⊢ s ∈ (a :: t).inits ↔ s <+: a :: t
state_after: no goals

tactic: let ⟨s, ht⟩ := (mem_inits _ _).1 hr
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a✝ b : α
m n : ℕ
s✝ : List α
a : α
t : List α
o : s✝ = [] ∨ ∃ l, l ∈ t.inits ∧ a :: l = s✝
s r : List α
hr : r ∈ t.inits
hs : a :: r = s
⊢ s <+: a :: t
state_after: α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a✝ b : α
m n : ℕ
s✝¹ : List α
a : α
t : List α
o : s✝¹ = [] ∨ ∃ l, l ∈ t.inits ∧ a :: l = s✝¹
s✝ r : List α
hr : r ∈ t.inits
hs : a :: r = s✝
s : List α
ht : r ++ s = t
⊢ s✝ <+: a :: t

tactic: rw [← hs, ← ht]
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a✝ b : α
m n : ℕ
s✝¹ : List α
a : α
t : List α
o : s✝¹ = [] ∨ ∃ l, l ∈ t.inits ∧ a :: l = s✝¹
s✝ r : List α
hr : r ∈ t.inits
hs : a :: r = s✝
s : List α
ht : r ++ s = t
⊢ s✝ <+: a :: t
state_after: α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a✝ b : α
m n : ℕ
s✝¹ : List α
a : α
t : List α
o : s✝¹ = [] ∨ ∃ l, l ∈ t.inits ∧ a :: l = s✝¹
s✝ r : List α
hr : r ∈ t.inits
hs : a :: r = s✝
s : List α
ht : r ++ s = t
⊢ a :: r <+: a :: (r ++ s)

tactic: exact ⟨s, rfl⟩
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a✝ b : α
m n : ℕ
s✝¹ : List α
a : α
t : List α
o : s✝¹ = [] ∨ ∃ l, l ∈ t.inits ∧ a :: l = s✝¹
s✝ r : List α
hr : r ∈ t.inits
hs : a :: r = s✝
s : List α
ht : r ++ s = t
⊢ a :: r <+: a :: (r ++ s)
state_after: no goals

tactic: rw [ba]
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a✝ b✝ : α
m n : ℕ
s✝ : List α
a : α
t : List α
mi : s✝ <+: a :: t
b : α
s r : List α
hr : b :: s ++ r = a :: t
ba : b = a
st : s ++ r = t
⊢ ∃ l, l ∈ t.inits ∧ a :: l = b :: s
state_after: α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a✝ b✝ : α
m n : ℕ
s✝ : List α
a : α
t : List α
mi : s✝ <+: a :: t
b : α
s r : List α
hr : b :: s ++ r = a :: t
ba : b = a
st : s ++ r = t
⊢ ∃ l, l ∈ t.inits ∧ a :: l = a :: s

tactic: exact ⟨_, (mem_inits _ _).2 ⟨_, st⟩, rfl⟩
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a✝ b✝ : α
m n : ℕ
s✝ : List α
a : α
t : List α
mi : s✝ <+: a :: t
b : α
s r : List α
hr : b :: s ++ r = a :: t
ba : b = a
st : s ++ r = t
⊢ ∃ l, l ∈ t.inits ∧ a :: l = a :: s
state_after: no goals
Theorem: Projectivization.Subspace.span_sup
File: Mathlib/LinearAlgebra/Projectivization/Subspace.lean

tactic: rw [span_union, span_coe]
state_before: K : Type u_1
V : Type u_2
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
S : Set (ℙ K V)
W : Subspace K V
⊢ span S ⊔ W = span (S ∪ ↑W)
state_after: no goals
Theorem: WithZeroTopology.nhds_zero
File: Mathlib/Topology/Algebra/WithZeroTopology.lean

tactic: rw [nhds_eq_update, update_same]
state_before: α : Type u_1
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
γ γ₁ γ₂ : Γ₀
l : Filter α
f : α → Γ₀
⊢ 𝓝 0 = ⨅ γ, ⨅ (_ : γ ≠ 0), 𝓟 (Iio γ)
state_after: no goals
Theorem: MeasureTheory.ConvolutionExistsAt.distrib_add
File: Mathlib/Analysis/Convolution.lean

tactic: simp only [convolution_def, (L _).map_add, Pi.add_apply, integral_add hfg hfg']
state_before: 𝕜 : Type u𝕜
G : Type uG
E : Type uE
E' : Type uE'
E'' : Type uE''
F : Type uF
F' : Type uF'
F'' : Type uF''
P : Type uP
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedAddCommGroup E'
inst✝⁹ : NormedAddCommGroup E''
inst✝⁸ : NormedAddCommGroup F
f f' : G → E
g g' : G → E'
x✝ x' : G
y y' : E
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedSpace 𝕜 E'
inst✝⁴ : NormedSpace 𝕜 E''
inst✝³ : NormedSpace 𝕜 F
L : E →L[𝕜] E' →L[𝕜] F
inst✝² : MeasurableSpace G
μ ν : Measure G
inst✝¹ : NormedSpace ℝ F
inst✝ : AddGroup G
x : G
hfg : ConvolutionExistsAt f g x L μ
hfg' : ConvolutionExistsAt f g' x L μ
⊢ (f ⋆[L, μ] (g + g')) x = (f ⋆[L, μ] g) x + (f ⋆[L, μ] g') x
state_after: no goals
Theorem: DirichletCharacter.toUnitHom_eq_iff
File: Mathlib/NumberTheory/DirichletCharacter/Basic.lean

tactic: simp
state_before: R : Type u_1
inst✝ : CommMonoidWithZero R
n : ℕ
χ ψ : DirichletCharacter R n
⊢ toUnitHom χ = toUnitHom ψ ↔ χ = ψ
state_after: no goals
Theorem: CategoryTheory.Localization.liftNatTrans_id
File: Mathlib/CategoryTheory/Localization/Predicate.lean

tactic: simp only [liftNatTrans_app, NatTrans.id_app, id_comp, Iso.hom_inv_id_app]
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_4, u_1} C
inst✝² : Category.{u_6, u_2} D
L : C ⥤ D
W : MorphismProperty C
E : Type u_3
inst✝¹ : Category.{u_5, u_3} E
inst✝ : L.IsLocalization W
F : C ⥤ E
F' : D ⥤ E
h : Lifting L W F F'
X : C
⊢ (liftNatTrans L W F F F' F' (𝟙 F)).app (L.obj X) = (𝟙 F').app (L.obj X)
state_after: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_4, u_1} C
inst✝² : Category.{u_6, u_2} D
L : C ⥤ D
W : MorphismProperty C
E : Type u_3
inst✝¹ : Category.{u_5, u_3} E
inst✝ : L.IsLocalization W
F : C ⥤ E
F' : D ⥤ E
h : Lifting L W F F'
X : C
⊢ 𝟙 ((L ⋙ F').obj X) = 𝟙 (F'.obj (L.obj X))

tactic: rfl
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_4, u_1} C
inst✝² : Category.{u_6, u_2} D
L : C ⥤ D
W : MorphismProperty C
E : Type u_3
inst✝¹ : Category.{u_5, u_3} E
inst✝ : L.IsLocalization W
F : C ⥤ E
F' : D ⥤ E
h : Lifting L W F F'
X : C
⊢ 𝟙 ((L ⋙ F').obj X) = 𝟙 (F'.obj (L.obj X))
state_after: no goals
Theorem: inv_neg_one
File: Mathlib/Algebra/Field/Basic.lean

tactic: rw [← neg_inv, inv_one]
state_before: α : Type u_1
β : Type u_2
K : Type u_3
inst✝¹ : DivisionMonoid K
inst✝ : HasDistribNeg K
a b : K
⊢ (-1)⁻¹ = -1
state_after: no goals
Theorem: FreeRing.coe_surjective
File: Mathlib/RingTheory/FreeCommRing.lean

tactic: induction x with
| hn1 =>
  use -1
  rfl
| hb b =>
  exact ⟨FreeRing.of b, rfl⟩
| ha _ _ hx hy =>
  rcases hx with ⟨x, rfl⟩; rcases hy with ⟨y, rfl⟩
  exact ⟨x + y, (FreeRing.lift _).map_add _ _⟩
| hm _ _ hx hy =>
  rcases hx with ⟨x, rfl⟩; rcases hy with ⟨y, rfl⟩
  exact ⟨x * y, (FreeRing.lift _).map_mul _ _⟩
state_before: α : Type u
x : FreeCommRing α
⊢ ∃ a, ↑a = x
state_after: no goals

tactic: use -1
state_before: case hn1
α : Type u
⊢ ∃ a, ↑a = -1
state_after: case h
α : Type u
⊢ ↑(-1) = -1

tactic: rfl
state_before: case h
α : Type u
⊢ ↑(-1) = -1
state_after: no goals

tactic: exact ⟨FreeRing.of b, rfl⟩
state_before: case hb
α : Type u
b : α
⊢ ∃ a, ↑a = FreeCommRing.of b
state_after: no goals

tactic: rcases hx with ⟨x, rfl⟩
state_before: case ha
α : Type u
x✝ y✝ : FreeCommRing α
hx : ∃ a, ↑a = x✝
hy : ∃ a, ↑a = y✝
⊢ ∃ a, ↑a = x✝ + y✝
state_after: case ha.intro
α : Type u
y✝ : FreeCommRing α
hy : ∃ a, ↑a = y✝
x : FreeRing α
⊢ ∃ a, ↑a = ↑x + y✝

tactic: rcases hy with ⟨y, rfl⟩
state_before: case ha.intro
α : Type u
y✝ : FreeCommRing α
hy : ∃ a, ↑a = y✝
x : FreeRing α
⊢ ∃ a, ↑a = ↑x + y✝
state_after: case ha.intro.intro
α : Type u
x y : FreeRing α
⊢ ∃ a, ↑a = ↑x + ↑y

tactic: exact ⟨x + y, (FreeRing.lift _).map_add _ _⟩
state_before: case ha.intro.intro
α : Type u
x y : FreeRing α
⊢ ∃ a, ↑a = ↑x + ↑y
state_after: no goals

tactic: rcases hx with ⟨x, rfl⟩
state_before: case hm
α : Type u
x✝ y✝ : FreeCommRing α
hx : ∃ a, ↑a = x✝
hy : ∃ a, ↑a = y✝
⊢ ∃ a, ↑a = x✝ * y✝
state_after: case hm.intro
α : Type u
y✝ : FreeCommRing α
hy : ∃ a, ↑a = y✝
x : FreeRing α
⊢ ∃ a, ↑a = ↑x * y✝

tactic: rcases hy with ⟨y, rfl⟩
state_before: case hm.intro
α : Type u
y✝ : FreeCommRing α
hy : ∃ a, ↑a = y✝
x : FreeRing α
⊢ ∃ a, ↑a = ↑x * y✝
state_after: case hm.intro.intro
α : Type u
x y : FreeRing α
⊢ ∃ a, ↑a = ↑x * ↑y

tactic: exact ⟨x * y, (FreeRing.lift _).map_mul _ _⟩
state_before: case hm.intro.intro
α : Type u
x y : FreeRing α
⊢ ∃ a, ↑a = ↑x * ↑y
state_after: no goals
Theorem: MeasurableEmbedding.restrict_comap
File: Mathlib/MeasureTheory/Measure/Restrict.lean

tactic: rw [comap_restrict hf, preimage_image_eq _ hf.injective]
state_before: R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
m1 : MeasurableSpace β
f : α → β
hf : MeasurableEmbedding f
μ : Measure β
s : Set α
⊢ (Measure.comap f μ).restrict s = Measure.comap f (μ.restrict (f '' s))
state_after: no goals
Theorem: Submodule.dense_iff_topologicalClosure_eq_top
File: Mathlib/Topology/Algebra/Module/Basic.lean

tactic: rw [← SetLike.coe_set_eq, dense_iff_closure_eq]
state_before: R R' : Type u
M M' : Type v
inst✝¹⁰ : Semiring R
inst✝⁹ : Ring R'
inst✝⁸ : TopologicalSpace M
inst✝⁷ : AddCommMonoid M
inst✝⁶ : TopologicalSpace M'
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M
inst✝³ : ContinuousConstSMul R M
inst✝² : Module R' M'
inst✝¹ : ContinuousConstSMul R' M'
inst✝ : ContinuousAdd M
s : Submodule R M
⊢ Dense ↑s ↔ s.topologicalClosure = ⊤
state_after: R R' : Type u
M M' : Type v
inst✝¹⁰ : Semiring R
inst✝⁹ : Ring R'
inst✝⁸ : TopologicalSpace M
inst✝⁷ : AddCommMonoid M
inst✝⁶ : TopologicalSpace M'
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M
inst✝³ : ContinuousConstSMul R M
inst✝² : Module R' M'
inst✝¹ : ContinuousConstSMul R' M'
inst✝ : ContinuousAdd M
s : Submodule R M
⊢ closure ↑s = Set.univ ↔ ↑s.topologicalClosure = ↑⊤

tactic: simp
state_before: R R' : Type u
M M' : Type v
inst✝¹⁰ : Semiring R
inst✝⁹ : Ring R'
inst✝⁸ : TopologicalSpace M
inst✝⁷ : AddCommMonoid M
inst✝⁶ : TopologicalSpace M'
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M
inst✝³ : ContinuousConstSMul R M
inst✝² : Module R' M'
inst✝¹ : ContinuousConstSMul R' M'
inst✝ : ContinuousAdd M
s : Submodule R M
⊢ closure ↑s = Set.univ ↔ ↑s.topologicalClosure = ↑⊤
state_after: no goals
Theorem: Real.logb_nonneg_of_base_lt_one
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: rw [logb_nonneg_iff_of_base_lt_one b_pos b_lt_one hx]
state_before: b x y : ℝ
b_pos : 0 < b
b_lt_one : b < 1
hx : 0 < x
hx' : x ≤ 1
⊢ 0 ≤ logb b x
state_after: b x y : ℝ
b_pos : 0 < b
b_lt_one : b < 1
hx : 0 < x
hx' : x ≤ 1
⊢ x ≤ 1

tactic: exact hx'
state_before: b x y : ℝ
b_pos : 0 < b
b_lt_one : b < 1
hx : 0 < x
hx' : x ≤ 1
⊢ x ≤ 1
state_after: no goals
Theorem: Set.Iic_sInf
File: Mathlib/Data/Set/Lattice.lean

tactic: rw [sInf_eq_iInf, Iic_iInf₂]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
inst✝ : CompleteLattice α
s : Set α
⊢ Iic (sInf s) = ⋂ a ∈ s, Iic a
state_after: no goals
Theorem: upperBounds_supClosure
File: Mathlib/Order/SupClosed.lean

tactic: rintro a ha _ ⟨t, ht, hts, rfl⟩
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : SemilatticeSup α
inst✝ : SemilatticeSup β
s✝ t : Set α
a b : α
s : Set α
⊢ upperBounds s ⊆ upperBounds (supClosure s)
state_after: case intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : SemilatticeSup α
inst✝ : SemilatticeSup β
s✝ t✝ : Set α
a✝ b : α
s : Set α
a : α
ha : a ∈ upperBounds s
t : Finset α
ht : t.Nonempty
hts : ↑t ⊆ s
⊢ t.sup' ht id ≤ a

tactic: exact sup'_le _ _ fun b hb ↦ ha <| hts hb
state_before: case intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : SemilatticeSup α
inst✝ : SemilatticeSup β
s✝ t✝ : Set α
a✝ b : α
s : Set α
a : α
ha : a ∈ upperBounds s
t : Finset α
ht : t.Nonempty
hts : ↑t ⊆ s
⊢ t.sup' ht id ≤ a
state_after: no goals
Theorem: Int.pred_iterate
File: Mathlib/Data/Int/SuccPred.lean

tactic: rw [Function.iterate_succ', Int.ofNat_succ, ← sub_sub]
state_before: a : ℤ
n : ℕ
⊢ pred^[n + 1] a = a - ↑(n + 1)
state_after: a : ℤ
n : ℕ
⊢ (pred ∘ pred^[n]) a = a - ↑n - 1

tactic: exact congr_arg _ (pred_iterate a n)
state_before: a : ℤ
n : ℕ
⊢ (pred ∘ pred^[n]) a = a - ↑n - 1
state_after: no goals
Theorem: MeasurableSpace.generateFrom_induction
File: Mathlib/MeasureTheory/MeasurableSpace/Defs.lean

tactic: induction hs
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort u_6
s✝ t u : Set α
p : Set α → Prop
C : Set (Set α)
hC : ∀ t ∈ C, p t
h_empty : p ∅
h_compl : ∀ (t : Set α), p t → p tᶜ
h_Union : ∀ (f : ℕ → Set α), (∀ (n : ℕ), p (f n)) → p (⋃ i, f i)
s : Set α
hs : MeasurableSet s
⊢ p s
state_after: case basic
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort u_6
s✝ t u : Set α
p : Set α → Prop
C : Set (Set α)
hC : ∀ t ∈ C, p t
h_empty : p ∅
h_compl : ∀ (t : Set α), p t → p tᶜ
h_Union : ∀ (f : ℕ → Set α), (∀ (n : ℕ), p (f n)) → p (⋃ i, f i)
s u✝ : Set α
a✝ : u✝ ∈ C
⊢ p u✝

case empty
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort u_6
s✝ t u : Set α
p : Set α → Prop
C : Set (Set α)
hC : ∀ t ∈ C, p t
h_empty : p ∅
h_compl : ∀ (t : Set α), p t → p tᶜ
h_Union : ∀ (f : ℕ → Set α), (∀ (n : ℕ), p (f n)) → p (⋃ i, f i)
s : Set α
⊢ p ∅

case compl
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort u_6
s✝ t u : Set α
p : Set α → Prop
C : Set (Set α)
hC : ∀ t ∈ C, p t
h_empty : p ∅
h_compl : ∀ (t : Set α), p t → p tᶜ
h_Union : ∀ (f : ℕ → Set α), (∀ (n : ℕ), p (f n)) → p (⋃ i, f i)
s t✝ : Set α
a✝ : GenerateMeasurable C t✝
a_ih✝ : p t✝
⊢ p t✝ᶜ

case iUnion
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort u_6
s✝ t u : Set α
p : Set α → Prop
C : Set (Set α)
hC : ∀ t ∈ C, p t
h_empty : p ∅
h_compl : ∀ (t : Set α), p t → p tᶜ
h_Union : ∀ (f : ℕ → Set α), (∀ (n : ℕ), p (f n)) → p (⋃ i, f i)
s : Set α
f✝ : ℕ → Set α
a✝ : ∀ (n : ℕ), GenerateMeasurable C (f✝ n)
a_ih✝ : ∀ (n : ℕ), p (f✝ n)
⊢ p (⋃ i, f✝ i)

tactic: exacts [hC _ ‹_›, h_empty, h_compl _ ‹_›, h_Union ‹_› ‹_›]
state_before: case basic
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort u_6
s✝ t u : Set α
p : Set α → Prop
C : Set (Set α)
hC : ∀ t ∈ C, p t
h_empty : p ∅
h_compl : ∀ (t : Set α), p t → p tᶜ
h_Union : ∀ (f : ℕ → Set α), (∀ (n : ℕ), p (f n)) → p (⋃ i, f i)
s u✝ : Set α
a✝ : u✝ ∈ C
⊢ p u✝

case empty
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort u_6
s✝ t u : Set α
p : Set α → Prop
C : Set (Set α)
hC : ∀ t ∈ C, p t
h_empty : p ∅
h_compl : ∀ (t : Set α), p t → p tᶜ
h_Union : ∀ (f : ℕ → Set α), (∀ (n : ℕ), p (f n)) → p (⋃ i, f i)
s : Set α
⊢ p ∅

case compl
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort u_6
s✝ t u : Set α
p : Set α → Prop
C : Set (Set α)
hC : ∀ t ∈ C, p t
h_empty : p ∅
h_compl : ∀ (t : Set α), p t → p tᶜ
h_Union : ∀ (f : ℕ → Set α), (∀ (n : ℕ), p (f n)) → p (⋃ i, f i)
s t✝ : Set α
a✝ : GenerateMeasurable C t✝
a_ih✝ : p t✝
⊢ p t✝ᶜ

case iUnion
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort u_6
s✝ t u : Set α
p : Set α → Prop
C : Set (Set α)
hC : ∀ t ∈ C, p t
h_empty : p ∅
h_compl : ∀ (t : Set α), p t → p tᶜ
h_Union : ∀ (f : ℕ → Set α), (∀ (n : ℕ), p (f n)) → p (⋃ i, f i)
s : Set α
f✝ : ℕ → Set α
a✝ : ∀ (n : ℕ), GenerateMeasurable C (f✝ n)
a_ih✝ : ∀ (n : ℕ), p (f✝ n)
⊢ p (⋃ i, f✝ i)
state_after: no goals
Theorem: List.forall₂_nil_left_iff
File: Mathlib/Data/List/Forall2.lean

tactic: cases H
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
l : List β
H : Forall₂ R [] l
⊢ l = []
state_after: case nil
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
⊢ [] = []

tactic: rfl
state_before: case nil
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
⊢ [] = []
state_after: no goals

tactic: rintro rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
l : List β
⊢ l = [] → Forall₂ R [] l
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
⊢ Forall₂ R [] []

tactic: exact Forall₂.nil
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
⊢ Forall₂ R [] []
state_after: no goals
Theorem: CategoryTheory.IsSubterminal.isIso_diag
File: Mathlib/CategoryTheory/Subterminal.lean

tactic: simp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
A : C
hA : IsSubterminal A
inst✝ : HasBinaryProduct A A
⊢ diag A ≫ prod.fst = 𝟙 A
state_after: no goals

tactic: rw [IsSubterminal.def] at hA
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
A : C
hA : IsSubterminal A
inst✝ : HasBinaryProduct A A
⊢ prod.fst ≫ diag A = 𝟙 (A ⨯ A)
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
A : C
hA : ∀ ⦃Z : C⦄ (f g : Z ⟶ A), f = g
inst✝ : HasBinaryProduct A A
⊢ prod.fst ≫ diag A = 𝟙 (A ⨯ A)

tactic: aesop_cat
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
A : C
hA : ∀ ⦃Z : C⦄ (f g : Z ⟶ A), f = g
inst✝ : HasBinaryProduct A A
⊢ prod.fst ≫ diag A = 𝟙 (A ⨯ A)
state_after: no goals
Theorem: Nat.eq_prime_pow_of_dvd_least_prime_pow
File: Mathlib/Data/Nat/Prime.lean

tactic: obtain ⟨l, ⟨h, rfl⟩⟩ := (dvd_prime_pow pp).1 h₂
state_before: n a p k : ℕ
pp : Prime p
h₁ : ¬a ∣ p ^ k
h₂ : a ∣ p ^ (k + 1)
⊢ a = p ^ (k + 1)
state_after: case intro.intro
n p k : ℕ
pp : Prime p
l : ℕ
h : l ≤ k + 1
h₁ : ¬p ^ l ∣ p ^ k
h₂ : p ^ l ∣ p ^ (k + 1)
⊢ p ^ l = p ^ (k + 1)

tactic: congr
state_before: case intro.intro
n p k : ℕ
pp : Prime p
l : ℕ
h : l ≤ k + 1
h₁ : ¬p ^ l ∣ p ^ k
h₂ : p ^ l ∣ p ^ (k + 1)
⊢ p ^ l = p ^ (k + 1)
state_after: case intro.intro.e_a
n p k : ℕ
pp : Prime p
l : ℕ
h : l ≤ k + 1
h₁ : ¬p ^ l ∣ p ^ k
h₂ : p ^ l ∣ p ^ (k + 1)
⊢ l = k + 1

tactic: exact le_antisymm h (not_le.1 ((not_congr (pow_dvd_pow_iff_le_right (Prime.one_lt pp))).1 h₁))
state_before: case intro.intro.e_a
n p k : ℕ
pp : Prime p
l : ℕ
h : l ≤ k + 1
h₁ : ¬p ^ l ∣ p ^ k
h₂ : p ^ l ∣ p ^ (k + 1)
⊢ l = k + 1
state_after: no goals
Theorem: MvPolynomial.support_mul_X
File: Mathlib/Algebra/MvPolynomial/Basic.lean

tactic: simp
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s✝ : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p✝ q : MvPolynomial σ R
s : σ
p : MvPolynomial σ R
⊢ ∀ (y : R), y * 1 = 0 ↔ y = 0
state_after: no goals