1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: CategoryTheory.Limits.limit_obj_ext
File: Mathlib/CategoryTheory/Limits/FunctorCategory.lean

tactic: apply (cancel_mono (limitObjIsoLimitCompEvaluation H k).hom).1
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
H : J ⥤ K ⥤ C
inst✝ : HasLimitsOfShape J C
k : K
W : C
f g : W ⟶ (limit H).obj k
w : ∀ (j : J), f ≫ (limit.π H j).app k = g ≫ (limit.π H j).app k
⊢ f = g
state_after: C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
H : J ⥤ K ⥤ C
inst✝ : HasLimitsOfShape J C
k : K
W : C
f g : W ⟶ (limit H).obj k
w : ∀ (j : J), f ≫ (limit.π H j).app k = g ≫ (limit.π H j).app k
⊢ f ≫ (limitObjIsoLimitCompEvaluation H k).hom = g ≫ (limitObjIsoLimitCompEvaluation H k).hom

tactic: ext j
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
H : J ⥤ K ⥤ C
inst✝ : HasLimitsOfShape J C
k : K
W : C
f g : W ⟶ (limit H).obj k
w : ∀ (j : J), f ≫ (limit.π H j).app k = g ≫ (limit.π H j).app k
⊢ f ≫ (limitObjIsoLimitCompEvaluation H k).hom = g ≫ (limitObjIsoLimitCompEvaluation H k).hom
state_after: case w
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
H : J ⥤ K ⥤ C
inst✝ : HasLimitsOfShape J C
k : K
W : C
f g : W ⟶ (limit H).obj k
w : ∀ (j : J), f ≫ (limit.π H j).app k = g ≫ (limit.π H j).app k
j : J
⊢ (f ≫ (limitObjIsoLimitCompEvaluation H k).hom) ≫ limit.π (H ⋙ (evaluation K C).obj k) j =
    (g ≫ (limitObjIsoLimitCompEvaluation H k).hom) ≫ limit.π (H ⋙ (evaluation K C).obj k) j

tactic: simpa using w j
state_before: case w
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
H : J ⥤ K ⥤ C
inst✝ : HasLimitsOfShape J C
k : K
W : C
f g : W ⟶ (limit H).obj k
w : ∀ (j : J), f ≫ (limit.π H j).app k = g ≫ (limit.π H j).app k
j : J
⊢ (f ≫ (limitObjIsoLimitCompEvaluation H k).hom) ≫ limit.π (H ⋙ (evaluation K C).obj k) j =
    (g ≫ (limitObjIsoLimitCompEvaluation H k).hom) ≫ limit.π (H ⋙ (evaluation K C).obj k) j
state_after: no goals
Theorem: Zspan.fundamentalDomain_subset_parallelepiped
File: Mathlib/Algebra/Module/Zlattice/Basic.lean

tactic: rw [fundamentalDomain, parallelepiped_basis_eq, Set.setOf_subset_setOf]
state_before: E : Type u_1
ι : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
b : Basis ι ℝ E
inst✝ : Fintype ι
⊢ fundamentalDomain b ⊆ parallelepiped ⇑b
state_after: E : Type u_1
ι : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
b : Basis ι ℝ E
inst✝ : Fintype ι
⊢ ∀ (a : E), (∀ (i : ι), (b.repr a) i ∈ Set.Ico 0 1) → ∀ (i : ι), (b.repr a) i ∈ Set.Icc 0 1

tactic: exact fun _ h i ↦ Set.Ico_subset_Icc_self (h i)
state_before: E : Type u_1
ι : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
b : Basis ι ℝ E
inst✝ : Fintype ι
⊢ ∀ (a : E), (∀ (i : ι), (b.repr a) i ∈ Set.Ico 0 1) → ∀ (i : ι), (b.repr a) i ∈ Set.Icc 0 1
state_after: no goals
Theorem: Set.right_mem_Iic
File: Mathlib/Order/Interval/Set/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
inst✝ : Preorder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ a ∈ Iic a
state_after: no goals
Theorem: ofBoolAlg_symmDiff
File: Mathlib/Algebra/Ring/BooleanRing.lean

tactic: rw [symmDiff_eq_sup_sdiff_inf]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : BooleanRing α
inst✝¹ : BooleanRing β
inst✝ : BooleanRing γ
a b : AsBoolAlg α
⊢ ofBoolAlg (a ∆ b) = ofBoolAlg a + ofBoolAlg b
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : BooleanRing α
inst✝¹ : BooleanRing β
inst✝ : BooleanRing γ
a b : AsBoolAlg α
⊢ ofBoolAlg ((a ⊔ b) \ (a ⊓ b)) = ofBoolAlg a + ofBoolAlg b

tactic: exact of_boolalg_symmDiff_aux _ _
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : BooleanRing α
inst✝¹ : BooleanRing β
inst✝ : BooleanRing γ
a b : AsBoolAlg α
⊢ ofBoolAlg ((a ⊔ b) \ (a ⊓ b)) = ofBoolAlg a + ofBoolAlg b
state_after: no goals
Theorem: IsChain.succ
File: Mathlib/Order/Chain.lean

tactic: rw [exists_and_left] at h
state_before: α : Type u_1
β : Type u_2
r : α → α → Prop
c c₁ c₂ c₃ s t : Set α
a b x y : α
hs : IsChain r s
h : ¬∃ t, IsChain r s ∧ SuperChain r s t
⊢ IsChain r (SuccChain r s)
state_after: α : Type u_1
β : Type u_2
r : α → α → Prop
c c₁ c₂ c₃ s t : Set α
a b x y : α
hs : IsChain r s
h : ¬(IsChain r s ∧ ∃ x, SuperChain r s x)
⊢ IsChain r (SuccChain r s)

tactic: simpa [SuccChain, dif_neg, h] using hs
state_before: α : Type u_1
β : Type u_2
r : α → α → Prop
c c₁ c₂ c₃ s t : Set α
a b x y : α
hs : IsChain r s
h : ¬(IsChain r s ∧ ∃ x, SuperChain r s x)
⊢ IsChain r (SuccChain r s)
state_after: no goals
Theorem: inseparable_prod
File: Mathlib/Topology/Inseparable.lean

tactic: simp only [Inseparable, nhds_prod_eq, prod_inj]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x y z : X
s : Set X
f g : X → Y
x₁ x₂ : X
y₁ y₂ : Y
⊢ ((x₁, y₁) ~ᵢ (x₂, y₂)) ↔ (x₁ ~ᵢ x₂) ∧ (y₁ ~ᵢ y₂)
state_after: no goals
Theorem: EReal.nhds_top_basis
File: Mathlib/Topology/Instances/EReal.lean

tactic: refine nhds_top_basis.to_hasBasis (fun x hx => ?_) fun _ _ ↦ ⟨_, coe_lt_top _, Subset.rfl⟩
state_before: α : Type u_1
inst✝ : TopologicalSpace α
⊢ (𝓝 ⊤).HasBasis (fun x => True) fun x => Ioi ↑x
state_after: α : Type u_1
inst✝ : TopologicalSpace α
x : EReal
hx : x < ⊤
⊢ ∃ i', True ∧ Ioi ↑i' ⊆ Ioi x

tactic: rcases exists_rat_btwn_of_lt hx with ⟨y, hxy, -⟩
state_before: α : Type u_1
inst✝ : TopologicalSpace α
x : EReal
hx : x < ⊤
⊢ ∃ i', True ∧ Ioi ↑i' ⊆ Ioi x
state_after: case intro.intro
α : Type u_1
inst✝ : TopologicalSpace α
x : EReal
hx : x < ⊤
y : ℚ
hxy : x < ↑↑y
⊢ ∃ i', True ∧ Ioi ↑i' ⊆ Ioi x

tactic: exact ⟨_, trivial, Ioi_subset_Ioi hxy.le⟩
state_before: case intro.intro
α : Type u_1
inst✝ : TopologicalSpace α
x : EReal
hx : x < ⊤
y : ℚ
hxy : x < ↑↑y
⊢ ∃ i', True ∧ Ioi ↑i' ⊆ Ioi x
state_after: no goals
Theorem: PadicInt.ext_of_toZModPow
File: Mathlib/NumberTheory/Padics/RingHoms.lean

tactic: constructor
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
x y : ℤ_[p]
⊢ (∀ (n : ℕ), (toZModPow n) x = (toZModPow n) y) ↔ x = y
state_after: case mp
p : ℕ
hp_prime : Fact (Nat.Prime p)
x y : ℤ_[p]
⊢ (∀ (n : ℕ), (toZModPow n) x = (toZModPow n) y) → x = y

case mpr
p : ℕ
hp_prime : Fact (Nat.Prime p)
x y : ℤ_[p]
⊢ x = y → ∀ (n : ℕ), (toZModPow n) x = (toZModPow n) y

tactic: intro h
state_before: case mp
p : ℕ
hp_prime : Fact (Nat.Prime p)
x y : ℤ_[p]
⊢ (∀ (n : ℕ), (toZModPow n) x = (toZModPow n) y) → x = y
state_after: case mp
p : ℕ
hp_prime : Fact (Nat.Prime p)
x y : ℤ_[p]
h : ∀ (n : ℕ), (toZModPow n) x = (toZModPow n) y
⊢ x = y

tactic: rw [← lift_self x, ← lift_self y]
state_before: case mp
p : ℕ
hp_prime : Fact (Nat.Prime p)
x y : ℤ_[p]
h : ∀ (n : ℕ), (toZModPow n) x = (toZModPow n) y
⊢ x = y
state_after: case mp
p : ℕ
hp_prime : Fact (Nat.Prime p)
x y : ℤ_[p]
h : ∀ (n : ℕ), (toZModPow n) x = (toZModPow n) y
⊢ (lift ⋯) x = (lift ⋯) y

tactic: simp (config := { unfoldPartialApp := true }) [lift, limNthHom, nthHom, h]
state_before: case mp
p : ℕ
hp_prime : Fact (Nat.Prime p)
x y : ℤ_[p]
h : ∀ (n : ℕ), (toZModPow n) x = (toZModPow n) y
⊢ (lift ⋯) x = (lift ⋯) y
state_after: no goals

tactic: rintro rfl _
state_before: case mpr
p : ℕ
hp_prime : Fact (Nat.Prime p)
x y : ℤ_[p]
⊢ x = y → ∀ (n : ℕ), (toZModPow n) x = (toZModPow n) y
state_after: case mpr
p : ℕ
hp_prime : Fact (Nat.Prime p)
x : ℤ_[p]
n✝ : ℕ
⊢ (toZModPow n✝) x = (toZModPow n✝) x

tactic: rfl
state_before: case mpr
p : ℕ
hp_prime : Fact (Nat.Prime p)
x : ℤ_[p]
n✝ : ℕ
⊢ (toZModPow n✝) x = (toZModPow n✝) x
state_after: no goals
Theorem: Filter.mem_lift_sets
File: Mathlib/Order/Filter/Lift.lean

tactic: simp only [id, exists_mem_subset_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
f f₁ f₂ : Filter α
g g₁ g₂ : Set α → Filter β
hg : Monotone g
s : Set β
⊢ (∃ i ∈ f, ∃ x ∈ g i, id x ⊆ s) ↔ ∃ t ∈ f, s ∈ g t
state_after: no goals
Theorem: Polynomial.coeff_scaleRoots
File: Mathlib/RingTheory/Polynomial/ScaleRoots.lean

tactic: simp (config := { contextual := true }) [scaleRoots, coeff_monomial]
state_before: R : Type u_1
S : Type u_2
A : Type u_3
K : Type u_4
inst✝¹ : Semiring R
inst✝ : Semiring S
p : R[X]
s : R
i : ℕ
⊢ (p.scaleRoots s).coeff i = p.coeff i * s ^ (p.natDegree - i)
state_after: no goals
Theorem: HahnSeries.order_neg
File: Mathlib/RingTheory/HahnSeries/Addition.lean

tactic: by_cases hf : f = 0
state_before: Γ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ
inst✝¹ : AddGroup R
inst✝ : Zero Γ
f : HahnSeries Γ R
⊢ (-f).order = f.order
state_after: case pos
Γ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ
inst✝¹ : AddGroup R
inst✝ : Zero Γ
f : HahnSeries Γ R
hf : f = 0
⊢ (-f).order = f.order

case neg
Γ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ
inst✝¹ : AddGroup R
inst✝ : Zero Γ
f : HahnSeries Γ R
hf : ¬f = 0
⊢ (-f).order = f.order

tactic: simp only [order, support_neg, neg_eq_zero]
state_before: case neg
Γ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ
inst✝¹ : AddGroup R
inst✝ : Zero Γ
f : HahnSeries Γ R
hf : ¬f = 0
⊢ (-f).order = f.order
state_after: no goals

tactic: simp only [hf, neg_zero]
state_before: case pos
Γ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ
inst✝¹ : AddGroup R
inst✝ : Zero Γ
f : HahnSeries Γ R
hf : f = 0
⊢ (-f).order = f.order
state_after: no goals
Theorem: Asymptotics.SuperpolynomialDecay.param_zpow_mul
File: Mathlib/Analysis/Asymptotics/SuperpolynomialDecay.lean

tactic: rw [superpolynomialDecay_iff_zpow_tendsto_zero _ hk] at hf ⊢
state_before: α : Type u_1
β : Type u_2
l : Filter α
k f g g' : α → β
inst✝² : TopologicalSpace β
inst✝¹ : LinearOrderedField β
inst✝ : OrderTopology β
hk : Tendsto k l atTop
hf : SuperpolynomialDecay l k f
z : ℤ
⊢ SuperpolynomialDecay l k fun a => k a ^ z * f a
state_after: α : Type u_1
β : Type u_2
l : Filter α
k f g g' : α → β
inst✝² : TopologicalSpace β
inst✝¹ : LinearOrderedField β
inst✝ : OrderTopology β
hk : Tendsto k l atTop
hf : ∀ (z : ℤ), Tendsto (fun a => k a ^ z * f a) l (𝓝 0)
z : ℤ
⊢ ∀ (z_1 : ℤ), Tendsto (fun a => k a ^ z_1 * (k a ^ z * f a)) l (𝓝 0)

tactic: refine fun z' => (hf <| z' + z).congr' ((hk.eventually_ne_atTop 0).mono fun x hx => ?_)
state_before: α : Type u_1
β : Type u_2
l : Filter α
k f g g' : α → β
inst✝² : TopologicalSpace β
inst✝¹ : LinearOrderedField β
inst✝ : OrderTopology β
hk : Tendsto k l atTop
hf : ∀ (z : ℤ), Tendsto (fun a => k a ^ z * f a) l (𝓝 0)
z : ℤ
⊢ ∀ (z_1 : ℤ), Tendsto (fun a => k a ^ z_1 * (k a ^ z * f a)) l (𝓝 0)
state_after: α : Type u_1
β : Type u_2
l : Filter α
k f g g' : α → β
inst✝² : TopologicalSpace β
inst✝¹ : LinearOrderedField β
inst✝ : OrderTopology β
hk : Tendsto k l atTop
hf : ∀ (z : ℤ), Tendsto (fun a => k a ^ z * f a) l (𝓝 0)
z z' : ℤ
x : α
hx : k x ≠ 0
⊢ k x ^ (z' + z) * f x = (fun a => k a ^ z' * (k a ^ z * f a)) x

tactic: simp [zpow_add₀ hx, mul_assoc, Pi.mul_apply]
state_before: α : Type u_1
β : Type u_2
l : Filter α
k f g g' : α → β
inst✝² : TopologicalSpace β
inst✝¹ : LinearOrderedField β
inst✝ : OrderTopology β
hk : Tendsto k l atTop
hf : ∀ (z : ℤ), Tendsto (fun a => k a ^ z * f a) l (𝓝 0)
z z' : ℤ
x : α
hx : k x ≠ 0
⊢ k x ^ (z' + z) * f x = (fun a => k a ^ z' * (k a ^ z * f a)) x
state_after: no goals
Theorem: Module.finite_of_rank_eq_zero
File: Mathlib/LinearAlgebra/Dimension/Finite.lean

tactic: nontriviality R
state_before: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁷ : Ring R
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : AddCommGroup M₁
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M₁
inst✝ : NoZeroSMulDivisors R M
h : Module.rank R M = 0
⊢ Finite R M
state_after: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁷ : Ring R
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : AddCommGroup M₁
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M₁
inst✝ : NoZeroSMulDivisors R M
h : Module.rank R M = 0
a✝ : Nontrivial R
⊢ Finite R M

tactic: rw [rank_zero_iff] at h
state_before: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁷ : Ring R
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : AddCommGroup M₁
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M₁
inst✝ : NoZeroSMulDivisors R M
h : Module.rank R M = 0
a✝ : Nontrivial R
⊢ Finite R M
state_after: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁷ : Ring R
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : AddCommGroup M₁
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M₁
inst✝ : NoZeroSMulDivisors R M
h : Subsingleton M
a✝ : Nontrivial R
⊢ Finite R M

tactic: infer_instance
state_before: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁷ : Ring R
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : AddCommGroup M₁
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M₁
inst✝ : NoZeroSMulDivisors R M
h : Subsingleton M
a✝ : Nontrivial R
⊢ Finite R M
state_after: no goals
Theorem: Nat.even_xor_odd
File: Mathlib/Algebra/Ring/Parity.lean

tactic: simp [Xor', odd_iff_not_even, Decidable.em (Even n)]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
m n✝ n : ℕ
⊢ Xor' (Even n) (Odd n)
state_after: no goals
Theorem: Ideal.Polynomial.Subring.mem_closure_image_of
File: Mathlib/RingTheory/Jacobson.lean

tactic: rw [Subring.mem_closure] at hx ⊢
state_before: S : Type u_1
T : Type u_2
inst✝¹ : CommRing S
inst✝ : CommRing T
g : S →+* T
u : Set S
x : S
hx : x ∈ Subring.closure u
⊢ g x ∈ Subring.closure (⇑g '' u)
state_after: S : Type u_1
T : Type u_2
inst✝¹ : CommRing S
inst✝ : CommRing T
g : S →+* T
u : Set S
x : S
hx : ∀ (S_1 : Subring S), u ⊆ ↑S_1 → x ∈ S_1
⊢ ∀ (S_1 : Subring T), ⇑g '' u ⊆ ↑S_1 → g x ∈ S_1

tactic: intro T₁ h₁
state_before: S : Type u_1
T : Type u_2
inst✝¹ : CommRing S
inst✝ : CommRing T
g : S →+* T
u : Set S
x : S
hx : ∀ (S_1 : Subring S), u ⊆ ↑S_1 → x ∈ S_1
⊢ ∀ (S_1 : Subring T), ⇑g '' u ⊆ ↑S_1 → g x ∈ S_1
state_after: S : Type u_1
T : Type u_2
inst✝¹ : CommRing S
inst✝ : CommRing T
g : S →+* T
u : Set S
x : S
hx : ∀ (S_1 : Subring S), u ⊆ ↑S_1 → x ∈ S_1
T₁ : Subring T
h₁ : ⇑g '' u ⊆ ↑T₁
⊢ g x ∈ T₁

tactic: rw [← Subring.mem_comap]
state_before: S : Type u_1
T : Type u_2
inst✝¹ : CommRing S
inst✝ : CommRing T
g : S →+* T
u : Set S
x : S
hx : ∀ (S_1 : Subring S), u ⊆ ↑S_1 → x ∈ S_1
T₁ : Subring T
h₁ : ⇑g '' u ⊆ ↑T₁
⊢ g x ∈ T₁
state_after: S : Type u_1
T : Type u_2
inst✝¹ : CommRing S
inst✝ : CommRing T
g : S →+* T
u : Set S
x : S
hx : ∀ (S_1 : Subring S), u ⊆ ↑S_1 → x ∈ S_1
T₁ : Subring T
h₁ : ⇑g '' u ⊆ ↑T₁
⊢ x ∈ Subring.comap g T₁

tactic: apply hx
state_before: S : Type u_1
T : Type u_2
inst✝¹ : CommRing S
inst✝ : CommRing T
g : S →+* T
u : Set S
x : S
hx : ∀ (S_1 : Subring S), u ⊆ ↑S_1 → x ∈ S_1
T₁ : Subring T
h₁ : ⇑g '' u ⊆ ↑T₁
⊢ x ∈ Subring.comap g T₁
state_after: case a
S : Type u_1
T : Type u_2
inst✝¹ : CommRing S
inst✝ : CommRing T
g : S →+* T
u : Set S
x : S
hx : ∀ (S_1 : Subring S), u ⊆ ↑S_1 → x ∈ S_1
T₁ : Subring T
h₁ : ⇑g '' u ⊆ ↑T₁
⊢ u ⊆ ↑(Subring.comap g T₁)

tactic: simp only [Subring.coe_comap, ← Set.image_subset_iff, SetLike.mem_coe]
state_before: case a
S : Type u_1
T : Type u_2
inst✝¹ : CommRing S
inst✝ : CommRing T
g : S →+* T
u : Set S
x : S
hx : ∀ (S_1 : Subring S), u ⊆ ↑S_1 → x ∈ S_1
T₁ : Subring T
h₁ : ⇑g '' u ⊆ ↑T₁
⊢ u ⊆ ↑(Subring.comap g T₁)
state_after: case a
S : Type u_1
T : Type u_2
inst✝¹ : CommRing S
inst✝ : CommRing T
g : S →+* T
u : Set S
x : S
hx : ∀ (S_1 : Subring S), u ⊆ ↑S_1 → x ∈ S_1
T₁ : Subring T
h₁ : ⇑g '' u ⊆ ↑T₁
⊢ ⇑g '' u ⊆ ↑T₁

tactic: exact h₁
state_before: case a
S : Type u_1
T : Type u_2
inst✝¹ : CommRing S
inst✝ : CommRing T
g : S →+* T
u : Set S
x : S
hx : ∀ (S_1 : Subring S), u ⊆ ↑S_1 → x ∈ S_1
T₁ : Subring T
h₁ : ⇑g '' u ⊆ ↑T₁
⊢ ⇑g '' u ⊆ ↑T₁
state_after: no goals
Theorem: CategoryTheory.GradedObject.mapBifunctorRightUnitor_naturality
File: Mathlib/CategoryTheory/GradedObject/Unitor.lean

tactic: rw [← cancel_mono (mapBifunctorRightUnitor F Y e p hp X').inv, assoc, assoc, Iso.hom_inv_id,
  comp_id, mapBifunctorRightUnitor_inv_naturality, Iso.hom_inv_id_assoc]
state_before: C : Type u_1
D : Type u_2
I : Type u_3
J : Type u_4
inst✝⁷ : Category.{u_6, u_1} C
inst✝⁶ : Category.{u_5, u_2} D
inst✝⁵ : Zero I
inst✝⁴ : DecidableEq I
inst✝³ : HasInitial C
F : D ⥤ C ⥤ D
Y : C
e : F.flip.obj Y ≅ 𝟭 D
inst✝² : (X : D) → PreservesColimit (Functor.empty C) (F.obj X)
p : J × I → J
hp : ∀ (j : J), p (j, 0) = j
X X' : GradedObject J D
φ : X ⟶ X'
inst✝¹ : (((mapBifunctor F J I).obj X).obj ((single₀ I).obj Y)).HasMap p
inst✝ : (((mapBifunctor F J I).obj X').obj ((single₀ I).obj Y)).HasMap p
Y' : ?m.145288
⊢ mapBifunctorMapMap F p φ (𝟙 ((single₀ I).obj Y)) ≫ (mapBifunctorRightUnitor F Y e p hp X').hom =
    (mapBifunctorRightUnitor F Y e p hp X).hom ≫ φ
state_after: no goals
Theorem: Multiset.toList_eq_singleton_iff
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [← perm_singleton, ← coe_eq_coe, coe_toList, coe_singleton]
state_before: α : Type u_1
β : Type v
γ : Type u_2
a : α
m : Multiset α
⊢ m.toList = [a] ↔ m = {a}
state_after: no goals
Theorem: Nat.bit1_div_bit0
File: Mathlib/Algebra/Ring/Parity.lean

tactic: rw [bit0_eq_two_mul, ← Nat.div_div_eq_div_mul, bit1_div_two]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
m n : ℕ
⊢ bit1 n / bit0 m = n / m
state_after: no goals
Theorem: Turing.TM0.step_supports
File: Mathlib/Computability/TuringMachine.lean

tactic: intro ⟨q, T⟩ c' h₁ h₂
state_before: Γ : Type u_1
inst✝¹ : Inhabited Γ
Λ : Type u_2
inst✝ : Inhabited Λ
M : Machine₀
S : Set Λ
ss : Supports M S
⊢ ∀ {c c' : Cfg₀}, c' ∈ step M c → c.q ∈ S → c'.q ∈ S
state_after: Γ : Type u_1
inst✝¹ : Inhabited Γ
Λ : Type u_2
inst✝ : Inhabited Λ
M : Machine₀
S : Set Λ
ss : Supports M S
q : Λ
T : Tape Γ
c' : Cfg₀
h₁ : c' ∈ step M { q := q, Tape := T }
h₂ : { q := q, Tape := T }.q ∈ S
⊢ c'.q ∈ S

tactic: rcases Option.map_eq_some'.1 h₁ with ⟨⟨q', a⟩, h, rfl⟩
state_before: Γ : Type u_1
inst✝¹ : Inhabited Γ
Λ : Type u_2
inst✝ : Inhabited Λ
M : Machine₀
S : Set Λ
ss : Supports M S
q : Λ
T : Tape Γ
c' : Cfg₀
h₁ : c' ∈ step M { q := q, Tape := T }
h₂ : { q := q, Tape := T }.q ∈ S
⊢ c'.q ∈ S
state_after: case intro.mk.intro
Γ : Type u_1
inst✝¹ : Inhabited Γ
Λ : Type u_2
inst✝ : Inhabited Λ
M : Machine₀
S : Set Λ
ss : Supports M S
q : Λ
T : Tape Γ
h₂ : { q := q, Tape := T }.q ∈ S
q' : Λ
a : Stmt₀
h : M q T.head = some (q', a)
h₁ :
  (match (q', a) with
    | (q', a) =>
      { q := q',
        Tape :=
          match a with
          | Stmt.move d => Tape.move d T
          | Stmt.write a => Tape.write a T }) ∈
    step M { q := q, Tape := T }
⊢ (match (q', a) with
      | (q', a) =>
        { q := q',
          Tape :=
            match a with
            | Stmt.move d => Tape.move d T
            | Stmt.write a => Tape.write a T }).q ∈
    S

tactic: exact ss.2 h h₂
state_before: case intro.mk.intro
Γ : Type u_1
inst✝¹ : Inhabited Γ
Λ : Type u_2
inst✝ : Inhabited Λ
M : Machine₀
S : Set Λ
ss : Supports M S
q : Λ
T : Tape Γ
h₂ : { q := q, Tape := T }.q ∈ S
q' : Λ
a : Stmt₀
h : M q T.head = some (q', a)
h₁ :
  (match (q', a) with
    | (q', a) =>
      { q := q',
        Tape :=
          match a with
          | Stmt.move d => Tape.move d T
          | Stmt.write a => Tape.write a T }) ∈
    step M { q := q, Tape := T }
⊢ (match (q', a) with
      | (q', a) =>
        { q := q',
          Tape :=
            match a with
            | Stmt.move d => Tape.move d T
            | Stmt.write a => Tape.write a T }).q ∈
    S
state_after: no goals
Theorem: CategoryTheory.GrothendieckTopology.pullback_close
File: Mathlib/CategoryTheory/Sites/Closed.lean

tactic: apply le_antisymm
state_before: C : Type u
inst✝ : Category.{v, u} C
J₁ J₂ : GrothendieckTopology C
X Y : C
f : Y ⟶ X
S : Sieve X
⊢ J₁.close (Sieve.pullback f S) = Sieve.pullback f (J₁.close S)
state_after: case a
C : Type u
inst✝ : Category.{v, u} C
J₁ J₂ : GrothendieckTopology C
X Y : C
f : Y ⟶ X
S : Sieve X
⊢ J₁.close (Sieve.pullback f S) ≤ Sieve.pullback f (J₁.close S)

case a
C : Type u
inst✝ : Category.{v, u} C
J₁ J₂ : GrothendieckTopology C
X Y : C
f : Y ⟶ X
S : Sieve X
⊢ Sieve.pullback f (J₁.close S) ≤ J₁.close (Sieve.pullback f S)

tactic: refine J₁.le_close_of_isClosed (Sieve.pullback_monotone _ (J₁.le_close S)) ?_
state_before: case a
C : Type u
inst✝ : Category.{v, u} C
J₁ J₂ : GrothendieckTopology C
X Y : C
f : Y ⟶ X
S : Sieve X
⊢ J₁.close (Sieve.pullback f S) ≤ Sieve.pullback f (J₁.close S)
state_after: case a
C : Type u
inst✝ : Category.{v, u} C
J₁ J₂ : GrothendieckTopology C
X Y : C
f : Y ⟶ X
S : Sieve X
⊢ J₁.IsClosed (Sieve.pullback f (J₁.close S))

tactic: apply J₁.isClosed_pullback _ _ (J₁.close_isClosed _)
state_before: case a
C : Type u
inst✝ : Category.{v, u} C
J₁ J₂ : GrothendieckTopology C
X Y : C
f : Y ⟶ X
S : Sieve X
⊢ J₁.IsClosed (Sieve.pullback f (J₁.close S))
state_after: no goals

tactic: intro Z g hg
state_before: case a
C : Type u
inst✝ : Category.{v, u} C
J₁ J₂ : GrothendieckTopology C
X Y : C
f : Y ⟶ X
S : Sieve X
⊢ Sieve.pullback f (J₁.close S) ≤ J₁.close (Sieve.pullback f S)
state_after: case a
C : Type u
inst✝ : Category.{v, u} C
J₁ J₂ : GrothendieckTopology C
X Y : C
f : Y ⟶ X
S : Sieve X
Z : C
g : Z ⟶ Y
hg : (Sieve.pullback f (J₁.close S)).arrows g
⊢ (J₁.close (Sieve.pullback f S)).arrows g

tactic: change _ ∈ J₁ _
state_before: case a
C : Type u
inst✝ : Category.{v, u} C
J₁ J₂ : GrothendieckTopology C
X Y : C
f : Y ⟶ X
S : Sieve X
Z : C
g : Z ⟶ Y
hg : (Sieve.pullback f (J₁.close S)).arrows g
⊢ (J₁.close (Sieve.pullback f S)).arrows g
state_after: case a
C : Type u
inst✝ : Category.{v, u} C
J₁ J₂ : GrothendieckTopology C
X Y : C
f : Y ⟶ X
S : Sieve X
Z : C
g : Z ⟶ Y
hg : (Sieve.pullback f (J₁.close S)).arrows g
⊢ Sieve.pullback g (Sieve.pullback f S) ∈ J₁.sieves Z

tactic: rw [← Sieve.pullback_comp]
state_before: case a
C : Type u
inst✝ : Category.{v, u} C
J₁ J₂ : GrothendieckTopology C
X Y : C
f : Y ⟶ X
S : Sieve X
Z : C
g : Z ⟶ Y
hg : (Sieve.pullback f (J₁.close S)).arrows g
⊢ Sieve.pullback g (Sieve.pullback f S) ∈ J₁.sieves Z
state_after: case a
C : Type u
inst✝ : Category.{v, u} C
J₁ J₂ : GrothendieckTopology C
X Y : C
f : Y ⟶ X
S : Sieve X
Z : C
g : Z ⟶ Y
hg : (Sieve.pullback f (J₁.close S)).arrows g
⊢ Sieve.pullback (g ≫ f) S ∈ J₁.sieves Z

tactic: apply hg
state_before: case a
C : Type u
inst✝ : Category.{v, u} C
J₁ J₂ : GrothendieckTopology C
X Y : C
f : Y ⟶ X
S : Sieve X
Z : C
g : Z ⟶ Y
hg : (Sieve.pullback f (J₁.close S)).arrows g
⊢ Sieve.pullback (g ≫ f) S ∈ J₁.sieves Z
state_after: no goals
Theorem: Set.ncard_singleton
File: Mathlib/Data/Set/Card.lean

tactic: simpa [ncard, encard_singleton] using ENat.toNat_coe 1
state_before: α : Type u_1
β : Type u_2
s t : Set α
a : α
⊢ {a}.ncard = 1
state_after: no goals
Theorem: Equiv.Perm.signAux_inv
File: Mathlib/GroupTheory/Perm/Sign.lean

tactic: simp_all [signBijAux, dif_pos h, if_neg h.not_le, apply_inv_self, apply_inv_self,
  if_neg (mem_finPairsLT.1 hab).not_le]
state_before: α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a b : Fin n
hab : ⟨a, b⟩ ∈ finPairsLT n
h : f⁻¹ b < f⁻¹ a
⊢ (if f⁻¹ ⟨a, b⟩.fst ≤ f⁻¹ ⟨a, b⟩.snd then -1 else 1) =
    if f (f⁻¹.signBijAux ⟨a, b⟩).fst ≤ f (f⁻¹.signBijAux ⟨a, b⟩).snd then -1 else 1
state_after: no goals

tactic: simp_all [signBijAux, if_pos (le_of_not_gt h), dif_neg h, apply_inv_self, apply_inv_self,
  if_pos (mem_finPairsLT.1 hab).le]
state_before: α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a b : Fin n
hab : ⟨a, b⟩ ∈ finPairsLT n
h : ¬f⁻¹ b < f⁻¹ a
⊢ (if f⁻¹ ⟨a, b⟩.fst ≤ f⁻¹ ⟨a, b⟩.snd then -1 else 1) =
    if f (f⁻¹.signBijAux ⟨a, b⟩).fst ≤ f (f⁻¹.signBijAux ⟨a, b⟩).snd then -1 else 1
state_after: no goals