1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Matroid.Indep.exists_insert_of_not_basis
File: Mathlib/Data/Matroid/Restrict.lean

tactic: rw [← base_restrict_iff] at hI'
state_before: α : Type u_1
M : Matroid α
R I J✝ X Y B J : Set α
e : α
hI : M.Indep I
hIX : I ⊆ X
hI' : ¬M.Basis I X
hJ : M.Basis J X
⊢ ∃ e ∈ J \ I, M.Indep (insert e I)
state_after: α : Type u_1
M : Matroid α
R I J✝ X Y B J : Set α
e : α
hI : M.Indep I
hIX : I ⊆ X
hI' : ¬(M ↾ X).Base I
hJ : M.Basis J X
⊢ ∃ e ∈ J \ I, M.Indep (insert e I)

tactic: rw [← base_restrict_iff] at hJ
state_before: α : Type u_1
M : Matroid α
R I J✝ X Y B J : Set α
e : α
hI : M.Indep I
hIX : I ⊆ X
hI' : ¬(M ↾ X).Base I
hJ : M.Basis J X
⊢ ∃ e ∈ J \ I, M.Indep (insert e I)
state_after: α : Type u_1
M : Matroid α
R I J✝ X Y B J : Set α
e : α
hI : M.Indep I
hIX : I ⊆ X
hI' : ¬(M ↾ X).Base I
hJ : (M ↾ X).Base J
⊢ ∃ e ∈ J \ I, M.Indep (insert e I)

tactic: obtain ⟨e, he, hi⟩ := (hI.indep_restrict_of_subset hIX).exists_insert_of_not_base hI' hJ
state_before: α : Type u_1
M : Matroid α
R I J✝ X Y B J : Set α
e : α
hI : M.Indep I
hIX : I ⊆ X
hI' : ¬(M ↾ X).Base I
hJ : (M ↾ X).Base J
⊢ ∃ e ∈ J \ I, M.Indep (insert e I)
state_after: case intro.intro
α : Type u_1
M : Matroid α
R I J✝ X Y B J : Set α
e✝ : α
hI : M.Indep I
hIX : I ⊆ X
hI' : ¬(M ↾ X).Base I
hJ : (M ↾ X).Base J
e : α
he : e ∈ J \ I
hi : (M ↾ X).Indep (insert e I)
⊢ ∃ e ∈ J \ I, M.Indep (insert e I)

tactic: exact ⟨e, he, (restrict_indep_iff.mp hi).1⟩
state_before: case intro.intro
α : Type u_1
M : Matroid α
R I J✝ X Y B J : Set α
e✝ : α
hI : M.Indep I
hIX : I ⊆ X
hI' : ¬(M ↾ X).Base I
hJ : (M ↾ X).Base J
e : α
he : e ∈ J \ I
hi : (M ↾ X).Indep (insert e I)
⊢ ∃ e ∈ J \ I, M.Indep (insert e I)
state_after: no goals
Theorem: MeasureTheory.Measure.mkMetric_top
File: Mathlib/MeasureTheory/Measure/Hausdorff.lean

tactic: apply toOuterMeasure_injective
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝³ : EMetricSpace X
inst✝² : EMetricSpace Y
inst✝¹ : MeasurableSpace X
inst✝ : BorelSpace X
⊢ (mkMetric fun x => ⊤) = ⊤
state_after: case a
ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝³ : EMetricSpace X
inst✝² : EMetricSpace Y
inst✝¹ : MeasurableSpace X
inst✝ : BorelSpace X
⊢ (mkMetric fun x => ⊤).toOuterMeasure = ⊤.toOuterMeasure

tactic: rw [mkMetric_toOuterMeasure, OuterMeasure.mkMetric_top, toOuterMeasure_top]
state_before: case a
ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝³ : EMetricSpace X
inst✝² : EMetricSpace Y
inst✝¹ : MeasurableSpace X
inst✝ : BorelSpace X
⊢ (mkMetric fun x => ⊤).toOuterMeasure = ⊤.toOuterMeasure
state_after: no goals
Theorem: CategoryTheory.Presheaf.isLocallySurjective_of_isLocallySurjective
File: Mathlib/CategoryTheory/Sites/LocallySurjective.lean

tactic: refine J.superset_covering ?_ (imageSieve_mem J (f₁ ≫ f₂) x)
state_before: C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
A : Type u'
inst✝² : Category.{v', u'} A
inst✝¹ : ConcreteCategory A
F₁ F₂ F₃ : Cᵒᵖ ⥤ A
f₁ : F₁ ⟶ F₂
f₂ : F₂ ⟶ F₃
inst✝ : IsLocallySurjective J (f₁ ≫ f₂)
X : C
x : (forget A).obj (F₃.obj { unop := X })
⊢ imageSieve f₂ x ∈ J.sieves X
state_after: C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
A : Type u'
inst✝² : Category.{v', u'} A
inst✝¹ : ConcreteCategory A
F₁ F₂ F₃ : Cᵒᵖ ⥤ A
f₁ : F₁ ⟶ F₂
f₂ : F₂ ⟶ F₃
inst✝ : IsLocallySurjective J (f₁ ≫ f₂)
X : C
x : (forget A).obj (F₃.obj { unop := X })
⊢ imageSieve (f₁ ≫ f₂) x ≤ imageSieve f₂ x

tactic: intro Y g hg
state_before: C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
A : Type u'
inst✝² : Category.{v', u'} A
inst✝¹ : ConcreteCategory A
F₁ F₂ F₃ : Cᵒᵖ ⥤ A
f₁ : F₁ ⟶ F₂
f₂ : F₂ ⟶ F₃
inst✝ : IsLocallySurjective J (f₁ ≫ f₂)
X : C
x : (forget A).obj (F₃.obj { unop := X })
⊢ imageSieve (f₁ ≫ f₂) x ≤ imageSieve f₂ x
state_after: C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
A : Type u'
inst✝² : Category.{v', u'} A
inst✝¹ : ConcreteCategory A
F₁ F₂ F₃ : Cᵒᵖ ⥤ A
f₁ : F₁ ⟶ F₂
f₂ : F₂ ⟶ F₃
inst✝ : IsLocallySurjective J (f₁ ≫ f₂)
X : C
x : (forget A).obj (F₃.obj { unop := X })
Y : C
g : Y ⟶ X
hg : (imageSieve (f₁ ≫ f₂) x).arrows g
⊢ (imageSieve f₂ x).arrows g

tactic: exact ⟨f₁.app _ (localPreimage (f₁ ≫ f₂) x g hg),
  by simpa using app_localPreimage (f₁ ≫ f₂) x g hg⟩
state_before: C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
A : Type u'
inst✝² : Category.{v', u'} A
inst✝¹ : ConcreteCategory A
F₁ F₂ F₃ : Cᵒᵖ ⥤ A
f₁ : F₁ ⟶ F₂
f₂ : F₂ ⟶ F₃
inst✝ : IsLocallySurjective J (f₁ ≫ f₂)
X : C
x : (forget A).obj (F₃.obj { unop := X })
Y : C
g : Y ⟶ X
hg : (imageSieve (f₁ ≫ f₂) x).arrows g
⊢ (imageSieve f₂ x).arrows g
state_after: no goals

tactic: simpa using app_localPreimage (f₁ ≫ f₂) x g hg
state_before: C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
A : Type u'
inst✝² : Category.{v', u'} A
inst✝¹ : ConcreteCategory A
F₁ F₂ F₃ : Cᵒᵖ ⥤ A
f₁ : F₁ ⟶ F₂
f₂ : F₂ ⟶ F₃
inst✝ : IsLocallySurjective J (f₁ ≫ f₂)
X : C
x : (forget A).obj (F₃.obj { unop := X })
Y : C
g : Y ⟶ X
hg : (imageSieve (f₁ ≫ f₂) x).arrows g
⊢ (f₂.app { unop := Y }) ((f₁.app { unop := Y }) (localPreimage (f₁ ≫ f₂) x g hg)) = (F₃.map g.op) x
state_after: no goals
Theorem: Mathlib.Tactic.Qify.intCast_ne
File: Mathlib/Tactic/Qify.lean

tactic: simp only [ne_eq, Int.cast_inj]
state_before: a b : ℤ
⊢ a ≠ b ↔ ↑a ≠ ↑b
state_after: no goals
Theorem: Batteries.PairingHeapImp.Heap.size_combine
File: .lake/packages/batteries/Batteries/Data/PairingHeap.lean

tactic: unfold combine
state_before: α : Type u_1
le : α → α → Bool
s : Heap α
⊢ (combine le s).size = s.size
state_after: α : Type u_1
le : α → α → Bool
s : Heap α
⊢ (match s with
      | h₁@h_1:(node a child h₂@h:(node a_1 child_1 s)) => merge le (merge le h₁ h₂) (combine le s)
      | h => h).size =
    s.size

tactic: split
state_before: α : Type u_1
le : α → α → Bool
s : Heap α
⊢ (match s with
      | h₁@h_1:(node a child h₂@h:(node a_1 child_1 s)) => merge le (merge le h₁ h₂) (combine le s)
      | h => h).size =
    s.size
state_after: case h_1
α : Type u_1
le : α → α → Bool
x✝ : Heap α
a✝¹ : α
child✝¹ : Heap α
a✝ : α
child✝ s✝ : Heap α
⊢ (merge le (merge le (node a✝¹ child✝¹ (node a✝ child✝ s✝)) (node a✝ child✝ s✝)) (combine le s✝)).size =
    (node a✝¹ child✝¹ (node a✝ child✝ s✝)).size

case h_2
α : Type u_1
le : α → α → Bool
s x✝¹ : Heap α
x✝ : ∀ (a : α) (child : Heap α) (a_1 : α) (child_1 s_1 : Heap α), s = node a child (node a_1 child_1 s_1) → False
⊢ s.size = s.size

tactic: rename_i a₁ c₁ a₂ c₂ s
state_before: case h_1
α : Type u_1
le : α → α → Bool
x✝ : Heap α
a✝¹ : α
child✝¹ : Heap α
a✝ : α
child✝ s✝ : Heap α
⊢ (merge le (merge le (node a✝¹ child✝¹ (node a✝ child✝ s✝)) (node a✝ child✝ s✝)) (combine le s✝)).size =
    (node a✝¹ child✝¹ (node a✝ child✝ s✝)).size
state_after: case h_1
α : Type u_1
le : α → α → Bool
x✝ : Heap α
a₁ : α
c₁ : Heap α
a₂ : α
c₂ s : Heap α
⊢ (merge le (merge le (node a₁ c₁ (node a₂ c₂ s)) (node a₂ c₂ s)) (combine le s)).size =
    (node a₁ c₁ (node a₂ c₂ s)).size

tactic: rw [size_merge le (noSibling_merge _ _ _) (noSibling_combine _ _),
  size_merge_node, size_combine le s]
state_before: case h_1
α : Type u_1
le : α → α → Bool
x✝ : Heap α
a₁ : α
c₁ : Heap α
a₂ : α
c₂ s : Heap α
⊢ (merge le (merge le (node a₁ c₁ (node a₂ c₂ s)) (node a₂ c₂ s)) (combine le s)).size =
    (node a₁ c₁ (node a₂ c₂ s)).size
state_after: case h_1
α : Type u_1
le : α → α → Bool
x✝ : Heap α
a₁ : α
c₁ : Heap α
a₂ : α
c₂ s : Heap α
⊢ c₁.size + c₂.size + 2 + s.size = (node a₁ c₁ (node a₂ c₂ s)).size

tactic: simp_arith [size]
state_before: case h_1
α : Type u_1
le : α → α → Bool
x✝ : Heap α
a₁ : α
c₁ : Heap α
a₂ : α
c₂ s : Heap α
⊢ c₁.size + c₂.size + 2 + s.size = (node a₁ c₁ (node a₂ c₂ s)).size
state_after: no goals

tactic: rfl
state_before: case h_2
α : Type u_1
le : α → α → Bool
s x✝¹ : Heap α
x✝ : ∀ (a : α) (child : Heap α) (a_1 : α) (child_1 s_1 : Heap α), s = node a child (node a_1 child_1 s_1) → False
⊢ s.size = s.size
state_after: no goals
Theorem: Monoid.Coprod.range_lift
File: Mathlib/GroupTheory/Coprod/Basic.lean

tactic: simp [range_eq]
state_before: G : Type u_1
H : Type u_2
inst✝² : Group G
inst✝¹ : Group H
K : Type u_3
inst✝ : Group K
f : G →* K
g : H →* K
⊢ (lift f g).range = f.range ⊔ g.range
state_after: no goals
Theorem: CategoryTheory.Center.associator_inv_f
File: Mathlib/CategoryTheory/Monoidal/Center.lean

tactic: apply Iso.inv_ext'
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X Y Z : Center C
⊢ (α_ X Y Z).inv.f = (α_ X.fst Y.fst Z.fst).inv
state_after: case hom_inv_id
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X Y Z : Center C
⊢ (α_ X.fst Y.fst Z.fst).hom ≫ (α_ X Y Z).inv.f = 𝟙 ((X ⊗ Y) ⊗ Z).fst

tactic: rw [← associator_hom_f, ← comp_f, Iso.hom_inv_id]
state_before: case hom_inv_id
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X Y Z : Center C
⊢ (α_ X.fst Y.fst Z.fst).hom ≫ (α_ X Y Z).inv.f = 𝟙 ((X ⊗ Y) ⊗ Z).fst
state_after: case hom_inv_id
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X Y Z : Center C
⊢ (𝟙 ((X ⊗ Y) ⊗ Z)).f = 𝟙 ((X ⊗ Y) ⊗ Z).fst

tactic: rfl
state_before: case hom_inv_id
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X Y Z : Center C
⊢ (𝟙 ((X ⊗ Y) ⊗ Z)).f = 𝟙 ((X ⊗ Y) ⊗ Z).fst
state_after: no goals
Theorem: List.pairwise_reverse
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: induction l <;> simp [*, pairwise_append, and_comm]
state_before: α : Type u_1
R : α → α → Prop
l : List α
⊢ Pairwise R l.reverse ↔ Pairwise (fun a b => R b a) l
state_after: no goals
Theorem: Con.list_prod
File: Mathlib/GroupTheory/Congruence/BigOperators.lean

tactic: induction l with
| nil =>
  simpa only [List.map_nil, List.prod_nil] using c.refl 1
| cons x xs ih =>
  rw [List.map_cons, List.map_cons, List.prod_cons, List.prod_cons]
  exact c.mul (h _ <| .head _) <| ih fun k hk ↦ h _ (.tail _ hk)
state_before: ι : Type u_1
M : Type u_2
inst✝ : Monoid M
c : Con M
l : List ι
f g : ι → M
h : ∀ x ∈ l, c (f x) (g x)
⊢ c (List.map f l).prod (List.map g l).prod
state_after: no goals

tactic: simpa only [List.map_nil, List.prod_nil] using c.refl 1
state_before: case nil
ι : Type u_1
M : Type u_2
inst✝ : Monoid M
c : Con M
f g : ι → M
h : ∀ x ∈ [], c (f x) (g x)
⊢ c (List.map f []).prod (List.map g []).prod
state_after: no goals

tactic: rw [List.map_cons, List.map_cons, List.prod_cons, List.prod_cons]
state_before: case cons
ι : Type u_1
M : Type u_2
inst✝ : Monoid M
c : Con M
f g : ι → M
x : ι
xs : List ι
ih : (∀ x ∈ xs, c (f x) (g x)) → c (List.map f xs).prod (List.map g xs).prod
h : ∀ x_1 ∈ x :: xs, c (f x_1) (g x_1)
⊢ c (List.map f (x :: xs)).prod (List.map g (x :: xs)).prod
state_after: case cons
ι : Type u_1
M : Type u_2
inst✝ : Monoid M
c : Con M
f g : ι → M
x : ι
xs : List ι
ih : (∀ x ∈ xs, c (f x) (g x)) → c (List.map f xs).prod (List.map g xs).prod
h : ∀ x_1 ∈ x :: xs, c (f x_1) (g x_1)
⊢ c (f x * (List.map f xs).prod) (g x * (List.map g xs).prod)

tactic: exact c.mul (h _ <| .head _) <| ih fun k hk ↦ h _ (.tail _ hk)
state_before: case cons
ι : Type u_1
M : Type u_2
inst✝ : Monoid M
c : Con M
f g : ι → M
x : ι
xs : List ι
ih : (∀ x ∈ xs, c (f x) (g x)) → c (List.map f xs).prod (List.map g xs).prod
h : ∀ x_1 ∈ x :: xs, c (f x_1) (g x_1)
⊢ c (f x * (List.map f xs).prod) (g x * (List.map g xs).prod)
state_after: no goals
Theorem: CofiniteTopology.nhds_eq
File: Mathlib/Topology/Constructions.lean

tactic: ext U
state_before: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
x : CofiniteTopology X
⊢ 𝓝 x = pure x ⊔ cofinite
state_after: case a
X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
x : CofiniteTopology X
U : Set (CofiniteTopology X)
⊢ U ∈ 𝓝 x ↔ U ∈ pure x ⊔ cofinite

tactic: rw [mem_nhds_iff]
state_before: case a
X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
x : CofiniteTopology X
U : Set (CofiniteTopology X)
⊢ U ∈ 𝓝 x ↔ U ∈ pure x ⊔ cofinite
state_after: case a
X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
x : CofiniteTopology X
U : Set (CofiniteTopology X)
⊢ (∃ t ⊆ U, IsOpen t ∧ x ∈ t) ↔ U ∈ pure x ⊔ cofinite

tactic: constructor
state_before: case a
X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
x : CofiniteTopology X
U : Set (CofiniteTopology X)
⊢ (∃ t ⊆ U, IsOpen t ∧ x ∈ t) ↔ U ∈ pure x ⊔ cofinite
state_after: case a.mp
X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
x : CofiniteTopology X
U : Set (CofiniteTopology X)
⊢ (∃ t ⊆ U, IsOpen t ∧ x ∈ t) → U ∈ pure x ⊔ cofinite

case a.mpr
X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
x : CofiniteTopology X
U : Set (CofiniteTopology X)
⊢ U ∈ pure x ⊔ cofinite → ∃ t ⊆ U, IsOpen t ∧ x ∈ t

tactic: rintro ⟨V, hVU, V_op, haV⟩
state_before: case a.mp
X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
x : CofiniteTopology X
U : Set (CofiniteTopology X)
⊢ (∃ t ⊆ U, IsOpen t ∧ x ∈ t) → U ∈ pure x ⊔ cofinite
state_after: case a.mp.intro.intro.intro
X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
x : CofiniteTopology X
U V : Set (CofiniteTopology X)
hVU : V ⊆ U
V_op : IsOpen V
haV : x ∈ V
⊢ U ∈ pure x ⊔ cofinite

tactic: exact mem_sup.mpr ⟨hVU haV, mem_of_superset (V_op ⟨_, haV⟩) hVU⟩
state_before: case a.mp.intro.intro.intro
X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
x : CofiniteTopology X
U V : Set (CofiniteTopology X)
hVU : V ⊆ U
V_op : IsOpen V
haV : x ∈ V
⊢ U ∈ pure x ⊔ cofinite
state_after: no goals

tactic: rintro ⟨hU : x ∈ U, hU' : Uᶜ.Finite⟩
state_before: case a.mpr
X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
x : CofiniteTopology X
U : Set (CofiniteTopology X)
⊢ U ∈ pure x ⊔ cofinite → ∃ t ⊆ U, IsOpen t ∧ x ∈ t
state_after: case a.mpr.intro
X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
x : CofiniteTopology X
U : Set (CofiniteTopology X)
hU : x ∈ U
hU' : Uᶜ.Finite
⊢ ∃ t ⊆ U, IsOpen t ∧ x ∈ t

tactic: exact ⟨U, Subset.rfl, fun _ => hU', hU⟩
state_before: case a.mpr.intro
X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
x : CofiniteTopology X
U : Set (CofiniteTopology X)
hU : x ∈ U
hU' : Uᶜ.Finite
⊢ ∃ t ⊆ U, IsOpen t ∧ x ∈ t
state_after: no goals
Theorem: ENNReal.ofReal_tsum_of_nonneg
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: simp_rw [ENNReal.ofReal, ENNReal.tsum_coe_eq (NNReal.hasSum_real_toNNReal_of_nonneg hf_nonneg hf)]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : α → ℝ
hf_nonneg : ∀ (n : α), 0 ≤ f n
hf : Summable f
⊢ ENNReal.ofReal (∑' (n : α), f n) = ∑' (n : α), ENNReal.ofReal (f n)
state_after: no goals
Theorem: LinearMap.lTensor_comp_map
File: Mathlib/LinearAlgebra/TensorProduct/Basic.lean

tactic: simp only [lTensor, rTensor, ← map_comp, id_comp, comp_id]
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
g' : Q →ₗ[R] S
f : M →ₗ[R] P
g : N →ₗ[R] Q
⊢ lTensor P g' ∘ₗ map f g = map f (g' ∘ₗ g)
state_after: no goals
Theorem: CauSeq.const_lt
File: Mathlib/Algebra/Order/CauSeq/Basic.lean

tactic: rw [← const_sub, const_pos, sub_pos]
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrderedField α
x y : α
⊢ (const y - const x).Pos ↔ x < y
state_after: no goals
Theorem: one_lt_div
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [lt_div_iff hb, one_mul]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
hb : 0 < b
⊢ 1 < a / b ↔ b < a
state_after: no goals
Theorem: AdicCompletion.map_comp_apply
File: Mathlib/RingTheory/AdicCompletion/Functoriality.lean

tactic: show (map I g ∘ₗ map I f) x = map I (g ∘ₗ f) x
state_before: R : Type u_1
inst✝⁸ : CommRing R
I : Ideal R
M : Type u_2
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
N : Type u_3
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
P : Type u_4
inst✝³ : AddCommGroup P
inst✝² : Module R P
T : Type u_5
inst✝¹ : AddCommGroup T
inst✝ : Module (AdicCompletion I R) T
f : M →ₗ[R] N
g : N →ₗ[R] P
x : AdicCompletion I M
⊢ (map I g) ((map I f) x) = (map I (g ∘ₗ f)) x
state_after: R : Type u_1
inst✝⁸ : CommRing R
I : Ideal R
M : Type u_2
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
N : Type u_3
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
P : Type u_4
inst✝³ : AddCommGroup P
inst✝² : Module R P
T : Type u_5
inst✝¹ : AddCommGroup T
inst✝ : Module (AdicCompletion I R) T
f : M →ₗ[R] N
g : N →ₗ[R] P
x : AdicCompletion I M
⊢ (map I g ∘ₗ map I f) x = (map I (g ∘ₗ f)) x

tactic: rw [map_comp]
state_before: R : Type u_1
inst✝⁸ : CommRing R
I : Ideal R
M : Type u_2
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
N : Type u_3
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
P : Type u_4
inst✝³ : AddCommGroup P
inst✝² : Module R P
T : Type u_5
inst✝¹ : AddCommGroup T
inst✝ : Module (AdicCompletion I R) T
f : M →ₗ[R] N
g : N →ₗ[R] P
x : AdicCompletion I M
⊢ (map I g ∘ₗ map I f) x = (map I (g ∘ₗ f)) x
state_after: no goals
Theorem: idealFactorsFunOfQuotHom_id
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

tactic: simp only [idealFactorsFunOfQuotHom, map_id, OrderHom.coe_mk, OrderHom.id_coe, id,
  comap_map_of_surjective (Ideal.Quotient.mk J) Quotient.mk_surjective, ←
  RingHom.ker_eq_comap_bot (Ideal.Quotient.mk J), mk_ker,
  sup_eq_left.mpr (dvd_iff_le.mp X.prop), Subtype.coe_eta]
state_before: R : Type u_1
A : Type u_2
K : Type u_3
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Field K
inst✝ : IsDedekindDomain A
I : Ideal R
J : Ideal A
X : { p // p ∣ J }
⊢ (idealFactorsFunOfQuotHom ⋯) X = OrderHom.id X
state_after: no goals
Theorem: Subsemigroup.closure_induction'
File: Mathlib/Algebra/Group/Subsemigroup/Basic.lean

tactic: refine Exists.elim ?_ fun (hx : x ∈ closure s) (hc : p x hx) => hc
state_before: M : Type u_1
N : Type u_2
A : Type u_3
inst✝¹ : Mul M
s✝ : Set M
inst✝ : Add A
t : Set A
S : Subsemigroup M
s : Set M
p : (x : M) → x ∈ closure s → Prop
mem : ∀ (x : M) (h : x ∈ s), p x ⋯
mul : ∀ (x : M) (hx : x ∈ closure s) (y : M) (hy : y ∈ closure s), p x hx → p y hy → p (x * y) ⋯
x : M
hx : x ∈ closure s
⊢ p x hx
state_after: M : Type u_1
N : Type u_2
A : Type u_3
inst✝¹ : Mul M
s✝ : Set M
inst✝ : Add A
t : Set A
S : Subsemigroup M
s : Set M
p : (x : M) → x ∈ closure s → Prop
mem : ∀ (x : M) (h : x ∈ s), p x ⋯
mul : ∀ (x : M) (hx : x ∈ closure s) (y : M) (hy : y ∈ closure s), p x hx → p y hy → p (x * y) ⋯
x : M
hx : x ∈ closure s
⊢ ∃ (x_1 : x ∈ closure s), p x x_1

tactic: exact
  closure_induction hx (fun x hx => ⟨_, mem x hx⟩) fun x y ⟨hx', hx⟩ ⟨hy', hy⟩ =>
    ⟨_, mul _ _ _ _ hx hy⟩
state_before: M : Type u_1
N : Type u_2
A : Type u_3
inst✝¹ : Mul M
s✝ : Set M
inst✝ : Add A
t : Set A
S : Subsemigroup M
s : Set M
p : (x : M) → x ∈ closure s → Prop
mem : ∀ (x : M) (h : x ∈ s), p x ⋯
mul : ∀ (x : M) (hx : x ∈ closure s) (y : M) (hy : y ∈ closure s), p x hx → p y hy → p (x * y) ⋯
x : M
hx : x ∈ closure s
⊢ ∃ (x_1 : x ∈ closure s), p x x_1
state_after: no goals
Theorem: CategoryTheory.Abelian.epi_fst_of_factor_thru_epi_mono_factorization
File: Mathlib/CategoryTheory/Abelian/Basic.lean

tactic: apply epi_fst_of_isLimit _ _ (PullbackCone.isLimitOfFactors f g g₂ f' g₁ hf hg t ht)
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : Abelian C
inst✝² : HasPullbacks C
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
g₁ : Y ⟶ W
inst✝¹ : Epi g₁
g₂ : W ⟶ Z
inst✝ : Mono g₂
hg : g₁ ≫ g₂ = g
f' : X ⟶ W
hf : f' ≫ g₂ = f
t : PullbackCone f g
ht : IsLimit t
⊢ Epi t.fst
state_after: no goals
Theorem: Nat.bitwise_zero
File: Mathlib/Data/Nat/Bitwise.lean

tactic: simp only [bitwise_zero_right, ite_self]
state_before: f : Bool → Bool → Bool
⊢ bitwise f 0 0 = 0
state_after: no goals
Theorem: CochainComplex.of_d
File: Mathlib/Algebra/Homology/HomologicalComplex.lean

tactic: dsimp [of]
state_before: ι : Type u_1
V : Type u
inst✝⁴ : Category.{v, u} V
inst✝³ : HasZeroMorphisms V
α : Type u_2
inst✝² : AddRightCancelSemigroup α
inst✝¹ : One α
inst✝ : DecidableEq α
X : α → V
d : (n : α) → X n ⟶ X (n + 1)
sq : ∀ (n : α), d n ≫ d (n + 1) = 0
j : α
⊢ (of X d sq).d j (j + 1) = d j
state_after: ι : Type u_1
V : Type u
inst✝⁴ : Category.{v, u} V
inst✝³ : HasZeroMorphisms V
α : Type u_2
inst✝² : AddRightCancelSemigroup α
inst✝¹ : One α
inst✝ : DecidableEq α
X : α → V
d : (n : α) → X n ⟶ X (n + 1)
sq : ∀ (n : α), d n ≫ d (n + 1) = 0
j : α
⊢ (if j + 1 = j + 1 then d j ≫ 𝟙 (X (j + 1)) else 0) = d j

tactic: rw [if_pos rfl, Category.comp_id]
state_before: ι : Type u_1
V : Type u
inst✝⁴ : Category.{v, u} V
inst✝³ : HasZeroMorphisms V
α : Type u_2
inst✝² : AddRightCancelSemigroup α
inst✝¹ : One α
inst✝ : DecidableEq α
X : α → V
d : (n : α) → X n ⟶ X (n + 1)
sq : ∀ (n : α), d n ≫ d (n + 1) = 0
j : α
⊢ (if j + 1 = j + 1 then d j ≫ 𝟙 (X (j + 1)) else 0) = d j
state_after: no goals
Theorem: QuadraticForm.polar_neg_left
File: Mathlib/LinearAlgebra/QuadraticForm/Basic.lean

tactic: rw [← neg_one_smul R x, polar_smul_left, neg_one_mul]
state_before: S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
x y : M
⊢ polar (⇑Q) (-x) y = -polar (⇑Q) x y
state_after: no goals
Theorem: pi_dvd_iff
File: Mathlib/Algebra/Divisibility/Prod.lean

tactic: simp_rw [dvd_def, Function.funext_iff, Classical.skolem]
state_before: ι : Type u_1
G₁ : Type u_2
G₂ : Type u_3
G : ι → Type u_4
inst✝² : Semigroup G₁
inst✝¹ : Semigroup G₂
inst✝ : (i : ι) → Semigroup (G i)
x y : (i : ι) → G i
⊢ x ∣ y ↔ ∀ (i : ι), x i ∣ y i
state_after: ι : Type u_1
G₁ : Type u_2
G₂ : Type u_3
G : ι → Type u_4
inst✝² : Semigroup G₁
inst✝¹ : Semigroup G₂
inst✝ : (i : ι) → Semigroup (G i)
x y : (i : ι) → G i
⊢ (∃ c, ∀ (a : ι), y a = (x * c) a) ↔ ∃ f, ∀ (x_1 : ι), y x_1 = x x_1 * f x_1

tactic: rfl
state_before: ι : Type u_1
G₁ : Type u_2
G₂ : Type u_3
G : ι → Type u_4
inst✝² : Semigroup G₁
inst✝¹ : Semigroup G₂
inst✝ : (i : ι) → Semigroup (G i)
x y : (i : ι) → G i
⊢ (∃ c, ∀ (a : ι), y a = (x * c) a) ↔ ∃ f, ∀ (x_1 : ι), y x_1 = x x_1 * f x_1
state_after: no goals
Theorem: Submodule.mapQ_mkQ
File: Mathlib/LinearAlgebra/Quotient.lean

tactic: ext x
state_before: R : Type u_1
M : Type u_2
r : R
x y : M
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
p p' : Submodule R M
R₂ : Type u_3
M₂ : Type u_4
inst✝² : Ring R₂
inst✝¹ : AddCommGroup M₂
inst✝ : Module R₂ M₂
τ₁₂ : R →+* R₂
q : Submodule R₂ M₂
f : M →ₛₗ[τ₁₂] M₂
h : p ≤ comap f q
⊢ (p.mapQ q f h).comp p.mkQ = q.mkQ.comp f
state_after: case h
R : Type u_1
M : Type u_2
r : R
x✝ y : M
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
p p' : Submodule R M
R₂ : Type u_3
M₂ : Type u_4
inst✝² : Ring R₂
inst✝¹ : AddCommGroup M₂
inst✝ : Module R₂ M₂
τ₁₂ : R →+* R₂
q : Submodule R₂ M₂
f : M →ₛₗ[τ₁₂] M₂
h : p ≤ comap f q
x : M
⊢ ((p.mapQ q f h).comp p.mkQ) x = (q.mkQ.comp f) x

tactic: rfl
state_before: case h
R : Type u_1
M : Type u_2
r : R
x✝ y : M
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
p p' : Submodule R M
R₂ : Type u_3
M₂ : Type u_4
inst✝² : Ring R₂
inst✝¹ : AddCommGroup M₂
inst✝ : Module R₂ M₂
τ₁₂ : R →+* R₂
q : Submodule R₂ M₂
f : M →ₛₗ[τ₁₂] M₂
h : p ≤ comap f q
x : M
⊢ ((p.mapQ q f h).comp p.mkQ) x = (q.mkQ.comp f) x
state_after: no goals
Theorem: IsGreatest.union
File: Mathlib/Order/Bounds/Basic.lean

tactic: rcases le_total a b with h | h <;> simp [h, ha.1, hb.1]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
s✝ t✝ : Set α
a✝ b✝ : α
inst✝ : LinearOrder γ
a b : γ
s t : Set γ
ha : IsGreatest s a
hb : IsGreatest t b
⊢ max a b ∈ s ∪ t
state_after: no goals