1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Polynomial.coeff_mul_C
File: Mathlib/Algebra/Polynomial/Coeff.lean

tactic: rcases p with ⟨p⟩
state_before: R : Type u
S : Type v
a✝ b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n : ℕ
a : R
⊢ (p * C a).coeff n = p.coeff n * a
state_after: case ofFinsupp
R : Type u
S : Type v
a✝ b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r : R[X]
n : ℕ
a : R
p : R[ℕ]
⊢ ({ toFinsupp := p } * C a).coeff n = { toFinsupp := p }.coeff n * a

tactic: simp_rw [← monomial_zero_left, ← ofFinsupp_single, ← ofFinsupp_mul, coeff]
state_before: case ofFinsupp
R : Type u
S : Type v
a✝ b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r : R[X]
n : ℕ
a : R
p : R[ℕ]
⊢ ({ toFinsupp := p } * C a).coeff n = { toFinsupp := p }.coeff n * a
state_after: case ofFinsupp
R : Type u
S : Type v
a✝ b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r : R[X]
n : ℕ
a : R
p : R[ℕ]
⊢ (p * Finsupp.single 0 a) n = p n * a

tactic: exact AddMonoidAlgebra.mul_single_zero_apply p a n
state_before: case ofFinsupp
R : Type u
S : Type v
a✝ b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r : R[X]
n : ℕ
a : R
p : R[ℕ]
⊢ (p * Finsupp.single 0 a) n = p n * a
state_after: no goals
Theorem: ClosedEmbedding.normalSpace
File: Mathlib/Topology/Separation.lean

tactic: have H : SeparatedNhds (f '' s) (f '' t) :=
  NormalSpace.normal (f '' s) (f '' t) (hf.isClosedMap s hs) (hf.isClosedMap t ht)
    (disjoint_image_of_injective hf.inj hst)
state_before: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : NormalSpace Y
f : X → Y
hf : ClosedEmbedding f
s t : Set X
hs : IsClosed s
ht : IsClosed t
hst : Disjoint s t
⊢ SeparatedNhds s t
state_after: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : NormalSpace Y
f : X → Y
hf : ClosedEmbedding f
s t : Set X
hs : IsClosed s
ht : IsClosed t
hst : Disjoint s t
H : SeparatedNhds (f '' s) (f '' t)
⊢ SeparatedNhds s t

tactic: exact (H.preimage hf.continuous).mono (subset_preimage_image _ _) (subset_preimage_image _ _)
state_before: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : NormalSpace Y
f : X → Y
hf : ClosedEmbedding f
s t : Set X
hs : IsClosed s
ht : IsClosed t
hst : Disjoint s t
H : SeparatedNhds (f '' s) (f '' t)
⊢ SeparatedNhds s t
state_after: no goals
Theorem: Complex.frontier_setOf_le_re_and_im_le
File: Mathlib/Analysis/Complex/ReImTopology.lean

tactic: simpa only [closure_Ici, closure_Iic, frontier_Ici, frontier_Iic] using
  frontier_reProdIm (Ici a) (Iic b)
state_before: a b : ℝ
⊢ frontier {z | a ≤ z.re ∧ z.im ≤ b} = {z | a ≤ z.re ∧ z.im = b ∨ z.re = a ∧ z.im ≤ b}
state_after: no goals
Theorem: List.sublistsLenAux_zero
File: Mathlib/Data/List/Sublists.lean

tactic: cases l <;> rfl
state_before: α : Type u
β : Type v
γ : Type w
l : List α
f : List α → β
r : List β
⊢ sublistsLenAux 0 l f r = f [] :: r
state_after: no goals
Theorem: nat_log_eq_padicValNat_iff
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: rw [Nat.log_eq_iff (Or.inr ⟨(Nat.Prime.one_lt' p).out, by omega⟩), and_iff_right_iff_imp]
state_before: p n : ℕ
hp : Fact (Nat.Prime p)
hn : 0 < n
⊢ log p n = padicValNat p n ↔ n < p ^ (padicValNat p n + 1)
state_after: p n : ℕ
hp : Fact (Nat.Prime p)
hn : 0 < n
⊢ n < p ^ (padicValNat p n + 1) → p ^ padicValNat p n ≤ n

tactic: exact fun _ => Nat.le_of_dvd hn pow_padicValNat_dvd
state_before: p n : ℕ
hp : Fact (Nat.Prime p)
hn : 0 < n
⊢ n < p ^ (padicValNat p n + 1) → p ^ padicValNat p n ≤ n
state_after: no goals

tactic: omega
state_before: p n : ℕ
hp : Fact (Nat.Prime p)
hn : 0 < n
⊢ n ≠ 0
state_after: no goals
Theorem: WittVector.teichmuller_mul_aux₂
File: Mathlib/RingTheory/WittVector/Teichmuller.lean

tactic: refine map_injective (MvPolynomial.map (Int.castRingHom ℚ))
  (MvPolynomial.map_injective _ Int.cast_injective) ?_
state_before: p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
x y : MvPolynomial R ℤ
⊢ teichmullerFun p (x * y) = teichmullerFun p x * teichmullerFun p y
state_after: p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
x y : MvPolynomial R ℤ
⊢ (map (MvPolynomial.map (Int.castRingHom ℚ))) (teichmullerFun p (x * y)) =
    (map (MvPolynomial.map (Int.castRingHom ℚ))) (teichmullerFun p x * teichmullerFun p y)

tactic: simp only [teichmuller_mul_aux₁, map_teichmullerFun, RingHom.map_mul]
state_before: p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
x y : MvPolynomial R ℤ
⊢ (map (MvPolynomial.map (Int.castRingHom ℚ))) (teichmullerFun p (x * y)) =
    (map (MvPolynomial.map (Int.castRingHom ℚ))) (teichmullerFun p x * teichmullerFun p y)
state_after: no goals
Theorem: CompleteLattice.sSup_continuous'
File: Mathlib/Order/OmegaCompletePartialOrder.lean

tactic: lift s to Set (α →o β) using fun f hf => (hc f hf).to_monotone
state_before: α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
s : Set (α → β)
hc : ∀ f ∈ s, Continuous' f
⊢ Continuous' (sSup s)
state_after: case intro
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
s : Set (α →o β)
hc : ∀ f ∈ DFunLike.coe '' s, Continuous' f
⊢ Continuous' (sSup (DFunLike.coe '' s))

tactic: simp only [Set.forall_mem_image, continuous'_coe] at hc
state_before: case intro
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
s : Set (α →o β)
hc : ∀ f ∈ DFunLike.coe '' s, Continuous' f
⊢ Continuous' (sSup (DFunLike.coe '' s))
state_after: case intro
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
s : Set (α →o β)
hc : ∀ ⦃x : α →o β⦄, x ∈ s → Continuous x
⊢ Continuous' (sSup (DFunLike.coe '' s))

tactic: rw [sSup_image]
state_before: case intro
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
s : Set (α →o β)
hc : ∀ ⦃x : α →o β⦄, x ∈ s → Continuous x
⊢ Continuous' (sSup (DFunLike.coe '' s))
state_after: case intro
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
s : Set (α →o β)
hc : ∀ ⦃x : α →o β⦄, x ∈ s → Continuous x
⊢ Continuous' (⨆ a ∈ s, ⇑a)

tactic: norm_cast
state_before: case intro
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
s : Set (α →o β)
hc : ∀ ⦃x : α →o β⦄, x ∈ s → Continuous x
⊢ Continuous' (⨆ a ∈ s, ⇑a)
state_after: case intro
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
s : Set (α →o β)
hc : ∀ ⦃x : α →o β⦄, x ∈ s → Continuous x
⊢ Continuous (⨆ i ∈ s, i)

tactic: exact iSup_continuous fun f ↦ iSup_continuous fun hf ↦ hc hf
state_before: case intro
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
s : Set (α →o β)
hc : ∀ ⦃x : α →o β⦄, x ∈ s → Continuous x
⊢ Continuous (⨆ i ∈ s, i)
state_after: no goals
Theorem: fourier_coe_apply
File: Mathlib/Analysis/Fourier/AddCircle.lean

tactic: rw [fourier_apply, ← QuotientAddGroup.mk_zsmul, toCircle, Function.Periodic.lift_coe,
  expMapCircle_apply, Complex.ofReal_mul, Complex.ofReal_div, Complex.ofReal_mul, zsmul_eq_mul,
  Complex.ofReal_mul, Complex.ofReal_intCast]
state_before: T : ℝ
n : ℤ
x : ℝ
⊢ (fourier n) ↑x = Complex.exp (2 * ↑π * Complex.I * ↑n * ↑x / ↑T)
state_after: T : ℝ
n : ℤ
x : ℝ
⊢ Complex.exp (↑2 * ↑π / ↑T * (↑n * ↑x) * Complex.I) = Complex.exp (2 * ↑π * Complex.I * ↑n * ↑x / ↑T)

tactic: norm_num
state_before: T : ℝ
n : ℤ
x : ℝ
⊢ Complex.exp (↑2 * ↑π / ↑T * (↑n * ↑x) * Complex.I) = Complex.exp (2 * ↑π * Complex.I * ↑n * ↑x / ↑T)
state_after: T : ℝ
n : ℤ
x : ℝ
⊢ Complex.exp (2 * ↑π / ↑T * (↑n * ↑x) * Complex.I) = Complex.exp (2 * ↑π * Complex.I * ↑n * ↑x / ↑T)

tactic: congr 1
state_before: T : ℝ
n : ℤ
x : ℝ
⊢ Complex.exp (2 * ↑π / ↑T * (↑n * ↑x) * Complex.I) = Complex.exp (2 * ↑π * Complex.I * ↑n * ↑x / ↑T)
state_after: case e_z
T : ℝ
n : ℤ
x : ℝ
⊢ 2 * ↑π / ↑T * (↑n * ↑x) * Complex.I = 2 * ↑π * Complex.I * ↑n * ↑x / ↑T

tactic: ring
state_before: case e_z
T : ℝ
n : ℤ
x : ℝ
⊢ 2 * ↑π / ↑T * (↑n * ↑x) * Complex.I = 2 * ↑π * Complex.I * ↑n * ↑x / ↑T
state_after: no goals
Theorem: Finset.disjSups_union_left
File: Mathlib/Data/Finset/Sups.lean

tactic: simp [disjSups, filter_union, image_union]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝⁴ : DecidableEq α
inst✝³ : DecidableEq β
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
inst✝ : DecidableRel Disjoint
s s₁ s₂ t t₁ t₂ u : Finset α
a b c : α
⊢ (s₁ ∪ s₂) ○ t = s₁ ○ t ∪ s₂ ○ t
state_after: no goals
Theorem: multiplicity.lt_top_iff_finite
File: Mathlib/RingTheory/Multiplicity.lean

tactic: rw [lt_top_iff_ne_top, ne_top_iff_finite]
state_before: α : Type u_1
β : Type u_2
inst✝³ : Monoid α
inst✝² : Monoid β
inst✝¹ : DecidableRel fun x x_1 => x ∣ x_1
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
⊢ multiplicity a b < ⊤ ↔ Finite a b
state_after: no goals
Theorem: Finset.map_subtype_embedding_Ici
File: Mathlib/Order/Interval/Finset/Defs.lean

tactic: rw [subtype_Ici_eq]
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrderTop α
a : Subtype p
hp : ∀ ⦃a x : α⦄, a ≤ x → p a → p x
⊢ map (Embedding.subtype p) (Ici a) = Ici ↑a
state_after: α : Type u_1
β : Type u_2
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrderTop α
a : Subtype p
hp : ∀ ⦃a x : α⦄, a ≤ x → p a → p x
⊢ map (Embedding.subtype p) (Finset.subtype p (Ici ↑a)) = Ici ↑a

tactic: exact Finset.subtype_map_of_mem fun x hx => hp (mem_Ici.1 hx) a.prop
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrderTop α
a : Subtype p
hp : ∀ ⦃a x : α⦄, a ≤ x → p a → p x
⊢ map (Embedding.subtype p) (Finset.subtype p (Ici ↑a)) = Ici ↑a
state_after: no goals
Theorem: List.bagInter_nil
File: Mathlib/Data/List/Lattice.lean

tactic: cases l <;> rfl
state_before: α : Type u_1
l✝ l₁ l₂ : List α
p : α → Prop
a : α
inst✝ : DecidableEq α
l : List α
⊢ l.bagInter [] = []
state_after: no goals
Theorem: SimpleGraph.Iso.card_eq
File: Mathlib/Combinatorics/SimpleGraph/Maps.lean

tactic: rw [← Fintype.ofEquiv_card f.toEquiv]
state_before: V : Type u_1
W : Type u_2
X : Type u_3
G : SimpleGraph V
G' : SimpleGraph W
u v : V
f : G ≃g G'
inst✝¹ : Fintype V
inst✝ : Fintype W
⊢ Fintype.card V = Fintype.card W
state_after: V : Type u_1
W : Type u_2
X : Type u_3
G : SimpleGraph V
G' : SimpleGraph W
u v : V
f : G ≃g G'
inst✝¹ : Fintype V
inst✝ : Fintype W
⊢ Fintype.card W = Fintype.card W

tactic: convert rfl
state_before: V : Type u_1
W : Type u_2
X : Type u_3
G : SimpleGraph V
G' : SimpleGraph W
u v : V
f : G ≃g G'
inst✝¹ : Fintype V
inst✝ : Fintype W
⊢ Fintype.card W = Fintype.card W
state_after: no goals
Theorem: contDiff_succ_iff_fderiv
File: Mathlib/Analysis/Calculus/ContDiff/Defs.lean

tactic: simp only [← contDiffOn_univ, ← differentiableOn_univ, ← fderivWithin_univ,
  contDiffOn_succ_iff_fderivWithin uniqueDiffOn_univ]
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
n : ℕ
⊢ ContDiff 𝕜 (↑(n + 1)) f ↔ Differentiable 𝕜 f ∧ ContDiff 𝕜 ↑n fun y => fderiv 𝕜 f y
state_after: no goals
Theorem: MeasureTheory.weightedSMul_zero_measure
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: ext1
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m✝ : MeasurableSpace α
μ : Measure α
m : MeasurableSpace α
⊢ weightedSMul 0 = 0
state_after: case h
α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m✝ : MeasurableSpace α
μ : Measure α
m : MeasurableSpace α
x✝ : Set α
⊢ weightedSMul 0 x✝ = 0 x✝

tactic: simp [weightedSMul]
state_before: case h
α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m✝ : MeasurableSpace α
μ : Measure α
m : MeasurableSpace α
x✝ : Set α
⊢ weightedSMul 0 x✝ = 0 x✝
state_after: no goals
Theorem: SimpleGraph.deleteEdges_empty
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: simp [deleteEdges]
state_before: ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v w : V
e : Sym2 V
H : SimpleGraph V
s s₁ s₂ : Set (Sym2 V)
⊢ G.deleteEdges ∅ = G
state_after: no goals
Theorem: CategoryTheory.Abelian.has_projective_separator
File: Mathlib/CategoryTheory/Abelian/Generator.lean

tactic: obtain ⟨T, hT₁, hT₂⟩ := has_injective_coseparator (op G) ((isSeparator_op_iff _).2 hG)
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Abelian C
inst✝¹ : HasColimits C
inst✝ : EnoughProjectives C
G : C
hG : IsCoseparator G
⊢ ∃ G, Projective G ∧ IsSeparator G
state_after: case intro.intro
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Abelian C
inst✝¹ : HasColimits C
inst✝ : EnoughProjectives C
G : C
hG : IsCoseparator G
T : Cᵒᵖ
hT₁ : Injective T
hT₂ : IsCoseparator T
⊢ ∃ G, Projective G ∧ IsSeparator G

tactic: exact ⟨unop T, inferInstance, (isSeparator_unop_iff _).2 hT₂⟩
state_before: case intro.intro
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Abelian C
inst✝¹ : HasColimits C
inst✝ : EnoughProjectives C
G : C
hG : IsCoseparator G
T : Cᵒᵖ
hT₁ : Injective T
hT₂ : IsCoseparator T
⊢ ∃ G, Projective G ∧ IsSeparator G
state_after: no goals
Theorem: CartanMatrix.Relations.adE_of_eq_eq_zero
File: Mathlib/Algebra/Lie/CartanMatrix.lean

tactic: have h' : (-2 : ℤ).toNat = 0 := rfl
state_before: R : Type u
B : Type v
inst✝² : CommRing R
inst✝¹ : DecidableEq B
inst✝ : Fintype B
A : Matrix B B ℤ
i : B
h : A i i = 2
⊢ adE R A (i, i) = 0
state_after: R : Type u
B : Type v
inst✝² : CommRing R
inst✝¹ : DecidableEq B
inst✝ : Fintype B
A : Matrix B B ℤ
i : B
h : A i i = 2
h' : (-2).toNat = 0
⊢ adE R A (i, i) = 0

tactic: simp [adE, h, h']
state_before: R : Type u
B : Type v
inst✝² : CommRing R
inst✝¹ : DecidableEq B
inst✝ : Fintype B
A : Matrix B B ℤ
i : B
h : A i i = 2
h' : (-2).toNat = 0
⊢ adE R A (i, i) = 0
state_after: no goals
Theorem: ZMod.neg_val'
File: Mathlib/Data/ZMod/Basic.lean

tactic: rw [Nat.mod_eq_of_lt (-a).val_lt]
state_before: n : ℕ
inst✝ : NeZero n
a : ZMod n
⊢ (-a).val = (-a).val % n
state_after: no goals

tactic: rw [Nat.ModEq, ← val_add, add_left_neg, tsub_add_cancel_of_le a.val_le, Nat.mod_self,
  val_zero]
state_before: n : ℕ
inst✝ : NeZero n
a : ZMod n
⊢ (-a).val + ?m.123344 ≡ n - a.val + ?m.123344 [MOD n]
state_after: no goals
Theorem: tsub_left_inj
File: Mathlib/Algebra/Order/Sub/Canonical.lean

tactic: simp_rw [le_antisymm_iff, tsub_le_tsub_iff_right h1, tsub_le_tsub_iff_right h2]
state_before: α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
h1 : c ≤ a
h2 : c ≤ b
⊢ a - c = b - c ↔ a = b
state_after: no goals
Theorem: CategoryTheory.rightDualIso_id
File: Mathlib/CategoryTheory/Monoidal/Rigid/Basic.lean

tactic: ext
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X Y : C
p : ExactPairing X Y
⊢ rightDualIso p p = Iso.refl Y
state_after: case w
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X Y : C
p : ExactPairing X Y
⊢ (rightDualIso p p).hom = (Iso.refl Y).hom

tactic: simp only [rightDualIso, Iso.refl_hom, @rightAdjointMate_id _ _ _ _ ⟨Y⟩]
state_before: case w
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X Y : C
p : ExactPairing X Y
⊢ (rightDualIso p p).hom = (Iso.refl Y).hom
state_after: no goals
Theorem: uniformSpace_comap_id
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: ext : 2
state_before: α✝ : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
α : Type u_2
⊢ UniformSpace.comap id = id
state_after: case h.h
α✝ : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
α : Type u_2
x✝ : UniformSpace α
⊢ 𝓤 α = 𝓤 α

tactic: rw [uniformity_comap, Prod.map_id, comap_id]
state_before: case h.h
α✝ : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
α : Type u_2
x✝ : UniformSpace α
⊢ 𝓤 α = 𝓤 α
state_after: no goals
Theorem: exists_one_lt_mul_of_lt'
File: Mathlib/Algebra/Order/Monoid/Canonical/Defs.lean

tactic: obtain ⟨c, rfl⟩ := exists_mul_of_le h.le
state_before: α : Type u
inst✝³ : MulOneClass α
inst✝² : Preorder α
inst✝¹ : ContravariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : ExistsMulOfLE α
a b : α
h : a < b
⊢ ∃ c, 1 < c ∧ a * c = b
state_after: case intro
α : Type u
inst✝³ : MulOneClass α
inst✝² : Preorder α
inst✝¹ : ContravariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : ExistsMulOfLE α
a c : α
h : a < a * c
⊢ ∃ c_1, 1 < c_1 ∧ a * c_1 = a * c

tactic: exact ⟨c, one_lt_of_lt_mul_right h, rfl⟩
state_before: case intro
α : Type u
inst✝³ : MulOneClass α
inst✝² : Preorder α
inst✝¹ : ContravariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : ExistsMulOfLE α
a c : α
h : a < a * c
⊢ ∃ c_1, 1 < c_1 ∧ a * c_1 = a * c
state_after: no goals
Theorem: DFinsupp.support_erase
File: Mathlib/Data/DFinsupp/Basic.lean

tactic: ext j
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
i : ι
f : Π₀ (i : ι), β i
⊢ (erase i f).support = f.support.erase i
state_after: case a
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
i : ι
f : Π₀ (i : ι), β i
j : ι
⊢ j ∈ (erase i f).support ↔ j ∈ f.support.erase i

tactic: by_cases h1 : j = i
state_before: case a
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
i : ι
f : Π₀ (i : ι), β i
j : ι
⊢ j ∈ (erase i f).support ↔ j ∈ f.support.erase i
state_after: case pos
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
i : ι
f : Π₀ (i : ι), β i
j : ι
h1 : j = i
⊢ j ∈ (erase i f).support ↔ j ∈ f.support.erase i

case neg
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
i : ι
f : Π₀ (i : ι), β i
j : ι
h1 : ¬j = i
⊢ j ∈ (erase i f).support ↔ j ∈ f.support.erase i

tactic: by_cases h2 : f j ≠ 0 <;> simp at h2 <;> simp [h1, h2]
state_before: case neg
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
i : ι
f : Π₀ (i : ι), β i
j : ι
h1 : ¬j = i
⊢ j ∈ (erase i f).support ↔ j ∈ f.support.erase i
state_after: no goals

tactic: simp only [h1, mem_support_toFun, erase_apply, ite_true, ne_eq, not_true, not_not,
  Finset.mem_erase, false_and]
state_before: case pos
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
i : ι
f : Π₀ (i : ι), β i
j : ι
h1 : j = i
⊢ j ∈ (erase i f).support ↔ j ∈ f.support.erase i
state_after: no goals
Theorem: List.chain'_append
File: Mathlib/Data/List/Chain.lean

tactic: simp
state_before: α : Type u
β : Type v
R r : α → α → Prop
l✝ l₁ l₂ : List α
a b : α
l : List α
⊢ Chain' R ([] ++ l) ↔ Chain' R [] ∧ Chain' R l ∧ ∀ (x : α), x ∈ [].getLast? → ∀ (y : α), y ∈ l.head? → R x y
state_after: no goals

tactic: simp [chain'_cons', and_comm]
state_before: α : Type u
β : Type v
R r : α → α → Prop
l✝ l₁ l₂ : List α
a✝ b a : α
l : List α
⊢ Chain' R ([a] ++ l) ↔ Chain' R [a] ∧ Chain' R l ∧ ∀ (x : α), x ∈ [a].getLast? → ∀ (y : α), y ∈ l.head? → R x y
state_after: no goals

tactic: rw [cons_append, cons_append, chain'_cons, chain'_cons, ← cons_append, chain'_append,
  and_assoc]
state_before: α : Type u
β : Type v
R r : α → α → Prop
l l₁✝ l₂✝ : List α
a✝ b✝ a b : α
l₁ l₂ : List α
⊢ Chain' R (a :: b :: l₁ ++ l₂) ↔
    Chain' R (a :: b :: l₁) ∧ Chain' R l₂ ∧ ∀ (x : α), x ∈ (a :: b :: l₁).getLast? → ∀ (y : α), y ∈ l₂.head? → R x y
state_after: α : Type u
β : Type v
R r : α → α → Prop
l l₁✝ l₂✝ : List α
a✝ b✝ a b : α
l₁ l₂ : List α
⊢ (R a b ∧ Chain' R (b :: l₁) ∧ Chain' R l₂ ∧ ∀ (x : α), x ∈ (b :: l₁).getLast? → ∀ (y : α), y ∈ l₂.head? → R x y) ↔
    R a b ∧ Chain' R (b :: l₁) ∧ Chain' R l₂ ∧ ∀ (x : α), x ∈ (a :: b :: l₁).getLast? → ∀ (y : α), y ∈ l₂.head? → R x y

tactic: simp
state_before: α : Type u
β : Type v
R r : α → α → Prop
l l₁✝ l₂✝ : List α
a✝ b✝ a b : α
l₁ l₂ : List α
⊢ (R a b ∧ Chain' R (b :: l₁) ∧ Chain' R l₂ ∧ ∀ (x : α), x ∈ (b :: l₁).getLast? → ∀ (y : α), y ∈ l₂.head? → R x y) ↔
    R a b ∧ Chain' R (b :: l₁) ∧ Chain' R l₂ ∧ ∀ (x : α), x ∈ (a :: b :: l₁).getLast? → ∀ (y : α), y ∈ l₂.head? → R x y
state_after: no goals
Theorem: Mon_.whiskerLeft_hom
File: Mathlib/CategoryTheory/Monoidal/Mon_.lean

tactic: rw [← tensorHom_id]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X Y : Mon_ C
f : X ⟶ Y
Z : Mon_ C
⊢ (f ▷ Z).hom = f.hom ▷ Z.X
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X Y : Mon_ C
f : X ⟶ Y
Z : Mon_ C
⊢ (f ▷ Z).hom = f.hom ⊗ 𝟙 Z.X

tactic: rfl
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X Y : Mon_ C
f : X ⟶ Y
Z : Mon_ C
⊢ (f ▷ Z).hom = f.hom ⊗ 𝟙 Z.X
state_after: no goals
Theorem: Finset.map_erase
File: Mathlib/Data/Finset/Image.lean

tactic: simp_rw [map_eq_image]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : DecidableEq β
f✝ g : α → β
s✝ : Finset α
t : Finset β
a✝ : α
b c : β
inst✝ : DecidableEq α
f : α ↪ β
s : Finset α
a : α
⊢ map f (s.erase a) = (map f s).erase (f a)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : DecidableEq β
f✝ g : α → β
s✝ : Finset α
t : Finset β
a✝ : α
b c : β
inst✝ : DecidableEq α
f : α ↪ β
s : Finset α
a : α
⊢ image (⇑f) (s.erase a) = (image (⇑f) s).erase (f a)

tactic: exact s.image_erase f.2 a
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : DecidableEq β
f✝ g : α → β
s✝ : Finset α
t : Finset β
a✝ : α
b c : β
inst✝ : DecidableEq α
f : α ↪ β
s : Finset α
a : α
⊢ image (⇑f) (s.erase a) = (image (⇑f) s).erase (f a)
state_after: no goals
Theorem: IsSeparable.sepDegree_eq
File: Mathlib/FieldTheory/SeparableClosure.lean

tactic: rw [sepDegree, (separableClosure.eq_top_iff F E).2 ‹_›, IntermediateField.rank_top']
state_before: F : Type u
E : Type v
inst✝⁵ : Field F
inst✝⁴ : Field E
inst✝³ : Algebra F E
K : Type w
inst✝² : Field K
inst✝¹ : Algebra F K
inst✝ : IsSeparable F E
⊢ sepDegree F E = Module.rank F E
state_after: no goals