tasksource/leandojo huggingface dataset:
Theorem: Ideal.snd_comp_quotientInfEquivQuotientProd
File: Mathlib/RingTheory/Ideal/Quotient.lean

tactic: apply Quotient.ringHom_ext
state_before: R : Type u
inst✝ : CommRing R
I✝ : Ideal R
a b : R
S : Type v
I J : Ideal R
coprime : I ⊔ J = ⊤
⊢ RingHom.comp (RingHom.snd (R ⧸ I) (R ⧸ J)) ↑(quotientInfEquivQuotientProd I J coprime) =
    Quotient.factor (I ⊓ J) J (_ : I ⊓ J ≤ J)

tactic: ext
state_before: case h
R : Type u
inst✝ : CommRing R
I✝ : Ideal R
a b : R
S : Type v
I J : Ideal R
coprime : I ⊔ J = ⊤
⊢ RingHom.comp (RingHom.comp (RingHom.snd (R ⧸ I) (R ⧸ J)) ↑(quotientInfEquivQuotientProd I J coprime))
      (Quotient.mk (I ⊓ J)) =
    RingHom.comp (Quotient.factor (I ⊓ J) J (_ : I ⊓ J ≤ J)) (Quotient.mk (I ⊓ J))

tactic: rfl
state_before: case h.a
R : Type u
inst✝ : CommRing R
I✝ : Ideal R
a b : R
S : Type v
I J : Ideal R
coprime : I ⊔ J = ⊤
x✝ : R
⊢ ↑(RingHom.comp (RingHom.comp (RingHom.snd (R ⧸ I) (R ⧸ J)) ↑(quotientInfEquivQuotientProd I J coprime))
          (Quotient.mk (I ⊓ J)))
      x✝ =
    ↑(RingHom.comp (Quotient.factor (I ⊓ J) J (_ : I ⊓ J ≤ J)) (Quotient.mk (I ⊓ J))) x✝
Theorem: Ordinal.IsNormal.le_set'
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: simpa [H₂] using H.le_set (g '' p) (p0.image g) b
state_before: α : Type u_3
β : Type ?u.112020
γ : Type ?u.112023
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
f : Ordinal → Ordinal
o : Ordinal
H : IsNormal f
p : Set α
p0 : Set.Nonempty p
g : α → Ordinal
b : Ordinal
H₂ : ∀ (o : Ordinal), b ≤ o ↔ ∀ (a : α), a ∈ p → g a ≤ o
⊢ f b ≤ o ↔ ∀ (a : α), a ∈ p → f (g a) ≤ o
Theorem: Even.strictConvexOn_pow
File: Mathlib/Analysis/Convex/SpecificFunctions/Deriv.lean

tactic: apply StrictMono.strictConvexOn_univ_of_deriv (continuous_pow n)
state_before: n : ℕ
hn : Even n
h : n ≠ 0
⊢ StrictConvexOn ℝ univ fun x => x ^ n

tactic: rw [deriv_pow']
state_before: n : ℕ
hn : Even n
h : n ≠ 0
⊢ StrictMono (deriv fun a => a ^ n)

tactic: replace h := Nat.pos_of_ne_zero h
state_before: n : ℕ
hn : Even n
h : n ≠ 0
⊢ StrictMono fun x => ↑n * x ^ (n - 1)

tactic: exact StrictMono.const_mul (Odd.strictMono_pow <| Nat.Even.sub_odd h hn <| Nat.odd_iff.2 rfl)
  (Nat.cast_pos.2 h)
state_before: n : ℕ
hn : Even n
h : 0 < n
⊢ StrictMono fun x => ↑n * x ^ (n - 1)
Theorem: Finset.diag_inter
File: Mathlib/Data/Finset/Prod.lean

tactic: simpa only [mem_diag, mem_inter] using and_and_right
state_before: α : Type u_1
β : Type ?u.121780
γ : Type ?u.121783
inst✝ : DecidableEq α
s t : Finset α
x✝ x : α × α
⊢ x ∈ diag (s ∩ t) ↔ x ∈ diag s ∩ diag t
Theorem: Pi.image_update_segment
File: Mathlib/Analysis/Convex/Segment.lean

tactic: ext z
state_before: 𝕜 : Type u_3
E : Type ?u.385768
F : Type ?u.385771
G : Type ?u.385774
ι : Type u_1
π : ι → Type u_2
inst✝³ : OrderedSemiring 𝕜
inst✝² : (i : ι) → AddCommMonoid (π i)
inst✝¹ : (i : ι) → Module 𝕜 (π i)
s : Set ι
inst✝ : DecidableEq ι
i : ι
x₁ x₂ : π i
y : (i : ι) → π i
⊢ update y i '' [x₁-[𝕜]x₂] = [update y i x₁-[𝕜]update y i x₂]

tactic: simp_rw [Set.mem_image, segment, Set.mem_setOf, ← update_smul, ← update_add, update_eq_iff, ←
  exists_and_right, @exists_comm (π i), exists_eq_left']
state_before: case h
𝕜 : Type u_3
E : Type ?u.385768
F : Type ?u.385771
G : Type ?u.385774
ι : Type u_1
π : ι → Type u_2
inst✝³ : OrderedSemiring 𝕜
inst✝² : (i : ι) → AddCommMonoid (π i)
inst✝¹ : (i : ι) → Module 𝕜 (π i)
s : Set ι
inst✝ : DecidableEq ι
i : ι
x₁ x₂ : π i
y z : (a : ι) → π a
⊢ z ∈ update y i '' [x₁-[𝕜]x₂] ↔ z ∈ [update y i x₁-[𝕜]update y i x₂]

tactic: refine' exists₅_congr fun a b ha hb hab => _
state_before: case h
𝕜 : Type u_3
E : Type ?u.385768
F : Type ?u.385771
G : Type ?u.385774
ι : Type u_1
π : ι → Type u_2
inst✝³ : OrderedSemiring 𝕜
inst✝² : (i : ι) → AddCommMonoid (π i)
inst✝¹ : (i : ι) → Module 𝕜 (π i)
s : Set ι
inst✝ : DecidableEq ι
i : ι
x₁ x₂ : π i
y z : (a : ι) → π a
⊢ (∃ b b_1 h h h, b • x₁ + b_1 • x₂ = z i ∧ ∀ (x : ι), x ≠ i → y x = z x) ↔
    ∃ a b h h h, a • x₁ + b • x₂ = z i ∧ ∀ (x : ι), x ≠ i → (a • y + b • y) x = z x

tactic: rw [Convex.combo_self hab]
state_before: case h
𝕜 : Type u_3
E : Type ?u.385768
F : Type ?u.385771
G : Type ?u.385774
ι : Type u_1
π : ι → Type u_2
inst✝³ : OrderedSemiring 𝕜
inst✝² : (i : ι) → AddCommMonoid (π i)
inst✝¹ : (i : ι) → Module 𝕜 (π i)
s : Set ι
inst✝ : DecidableEq ι
i : ι
x₁ x₂ : π i
y z : (a : ι) → π a
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ (a • x₁ + b • x₂ = z i ∧ ∀ (x : ι), x ≠ i → y x = z x) ↔
    a • x₁ + b • x₂ = z i ∧ ∀ (x : ι), x ≠ i → (a • y + b • y) x = z x
Theorem: List.forall_mem_ofFn_iff
File: Mathlib/Data/List/OfFn.lean

tactic: simp only [mem_ofFn, Set.forall_range_iff]
state_before: α : Type u
n : ℕ
f : Fin n → α
P : α → Prop
⊢ (∀ (i : α), i ∈ ofFn f → P i) ↔ ∀ (j : Fin n), P (f j)
Theorem: Stream'.WSeq.bind_ret
File: Mathlib/Data/Seq/WSeq.lean

tactic: dsimp [bind]
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
s : WSeq α
⊢ bind s (ret ∘ f) ~ʷ map f s

tactic: rw [map_comp]
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
s : WSeq α
⊢ join (map (ret ∘ f) s) ~ʷ map f s

tactic: apply join_map_ret
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
s : WSeq α
⊢ join (map ret (map f s)) ~ʷ map f s
Theorem: Submodule.isTorsion'_powers_iff
File: Mathlib/Algebra/Module/Torsion.lean

tactic: constructor
state_before: R : Type u_2
M : Type u_1
inst✝² : Monoid R
inst✝¹ : AddCommMonoid M
inst✝ : DistribMulAction R M
p : R
⊢ IsTorsion' M { x // x ∈ Submonoid.powers p } ↔ ∀ (x : M), ∃ n, p ^ n • x = 0

tactic: intro h x
state_before: case mp
R : Type u_2
M : Type u_1
inst✝² : Monoid R
inst✝¹ : AddCommMonoid M
inst✝ : DistribMulAction R M
p : R
⊢ IsTorsion' M { x // x ∈ Submonoid.powers p } → ∀ (x : M), ∃ n, p ^ n • x = 0

tactic: let ⟨⟨a, ⟨n, hn⟩⟩, hx⟩ := @h x
state_before: case mp
R : Type u_2
M : Type u_1
inst✝² : Monoid R
inst✝¹ : AddCommMonoid M
inst✝ : DistribMulAction R M
p : R
h : IsTorsion' M { x // x ∈ Submonoid.powers p }
x : M
⊢ ∃ n, p ^ n • x = 0

tactic: dsimp at hn
state_before: case mp
R : Type u_2
M : Type u_1
inst✝² : Monoid R
inst✝¹ : AddCommMonoid M
inst✝ : DistribMulAction R M
p : R
h : IsTorsion' M { x // x ∈ Submonoid.powers p }
x : M
a : R
n : ℕ
hn : (fun x x_1 => x ^ x_1) p n = a
hx : { val := a, property := (_ : ∃ y, (fun x x_1 => x ^ x_1) p y = a) } • x = 0
⊢ ∃ n, p ^ n • x = 0

tactic: use n
state_before: case mp
R : Type u_2
M : Type u_1
inst✝² : Monoid R
inst✝¹ : AddCommMonoid M
inst✝ : DistribMulAction R M
p : R
h : IsTorsion' M { x // x ∈ Submonoid.powers p }
x : M
a : R
n : ℕ
hn : p ^ n = a
hx : { val := a, property := (_ : ∃ y, (fun x x_1 => x ^ x_1) p y = a) } • x = 0
⊢ ∃ n, p ^ n • x = 0

tactic: rw [hn]
state_before: case mp
R : Type u_2
M : Type u_1
inst✝² : Monoid R
inst✝¹ : AddCommMonoid M
inst✝ : DistribMulAction R M
p : R
h : IsTorsion' M { x // x ∈ Submonoid.powers p }
x : M
a : R
n : ℕ
hn : p ^ n = a
hx : { val := a, property := (_ : ∃ y, (fun x x_1 => x ^ x_1) p y = a) } • x = 0
⊢ p ^ n • x = 0

tactic: apply hx
state_before: case mp
R : Type u_2
M : Type u_1
inst✝² : Monoid R
inst✝¹ : AddCommMonoid M
inst✝ : DistribMulAction R M
p : R
h : IsTorsion' M { x // x ∈ Submonoid.powers p }
x : M
a : R
n : ℕ
hn : p ^ n = a
hx : { val := a, property := (_ : ∃ y, (fun x x_1 => x ^ x_1) p y = a) } • x = 0
⊢ a • x = 0

tactic: intro h x
state_before: case mpr
R : Type u_2
M : Type u_1
inst✝² : Monoid R
inst✝¹ : AddCommMonoid M
inst✝ : DistribMulAction R M
p : R
⊢ (∀ (x : M), ∃ n, p ^ n • x = 0) → IsTorsion' M { x // x ∈ Submonoid.powers p }

tactic: let ⟨n, hn⟩ := h x
state_before: case mpr
R : Type u_2
M : Type u_1
inst✝² : Monoid R
inst✝¹ : AddCommMonoid M
inst✝ : DistribMulAction R M
p : R
h : ∀ (x : M), ∃ n, p ^ n • x = 0
x : M
⊢ ∃ a, a • x = 0

tactic: exact ⟨⟨_, ⟨n, rfl⟩⟩, hn⟩
state_before: case mpr
R : Type u_2
M : Type u_1
inst✝² : Monoid R
inst✝¹ : AddCommMonoid M
inst✝ : DistribMulAction R M
p : R
h : ∀ (x : M), ∃ n, p ^ n • x = 0
x : M
n : ℕ
hn : p ^ n • x = 0
⊢ ∃ a, a • x = 0
Theorem: Set.exists_min_image
File: Mathlib/Data/Set/Finite.lean

tactic: simpa only [exists_prop, Finite.mem_toFinset] using
  h1.toFinset.exists_min_image f ⟨x, h1.mem_toFinset.2 hx⟩
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝ : LinearOrder β
s : Set α
f : α → β
h1 : Set.Finite s
x : α
hx : x ∈ s
⊢ ∃ a, a ∈ s ∧ ∀ (b : α), b ∈ s → f a ≤ f b
Theorem: Polynomial.rootSet_C
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: rw [rootSet_def, map_C, roots_C, Multiset.toFinset_zero, Finset.coe_empty]
state_before: R : Type u
S : Type v
T : Type w
a✝ b : R
n : ℕ
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
p q : R[X]
inst✝³ : CommRing T
inst✝² : CommRing S
inst✝¹ : IsDomain S
inst✝ : Algebra T S
a : T
⊢ rootSet (↑C a) S = ∅
Theorem: MonoidAlgebra.exists_finset_adjoin_eq_top
File: Mathlib/RingTheory/FiniteType.lean

tactic: obtain ⟨S, hS⟩ := h
state_before: R : Type u_2
M : Type u_1
inst✝¹ : CommRing R
inst✝ : CommMonoid M
h : FiniteType R (MonoidAlgebra R M)
⊢ ∃ G, adjoin R (↑(of R M) '' ↑G) = ⊤

tactic: letI : DecidableEq M := Classical.decEq M
state_before: case mk.intro
R : Type u_2
M : Type u_1
inst✝¹ : CommRing R
inst✝ : CommMonoid M
S : Finset (MonoidAlgebra R M)
hS : adjoin R ↑S = ⊤
⊢ ∃ G, adjoin R (↑(of R M) '' ↑G) = ⊤

tactic: use Finset.biUnion S fun f => f.support
state_before: case mk.intro
R : Type u_2
M : Type u_1
inst✝¹ : CommRing R
inst✝ : CommMonoid M
S : Finset (MonoidAlgebra R M)
hS : adjoin R ↑S = ⊤
this : DecidableEq M := Classical.decEq M
⊢ ∃ G, adjoin R (↑(of R M) '' ↑G) = ⊤

tactic: have : (Finset.biUnion S fun f => f.support : Set M) = ⋃ f ∈ S, (f.support : Set M) := by
  simp only [Finset.set_biUnion_coe, Finset.coe_biUnion]
state_before: case mk.intro
R : Type u_2
M : Type u_1
inst✝¹ : CommRing R
inst✝ : CommMonoid M
S : Finset (MonoidAlgebra R M)
hS : adjoin R ↑S = ⊤
this : DecidableEq M := Classical.decEq M
⊢ adjoin R (↑(of R M) '' ↑(Finset.biUnion S fun f => f.support)) = ⊤

tactic: rw [this]
state_before: case mk.intro
R : Type u_2
M : Type u_1
inst✝¹ : CommRing R
inst✝ : CommMonoid M
S : Finset (MonoidAlgebra R M)
hS : adjoin R ↑S = ⊤
this✝ : DecidableEq M := Classical.decEq M
this : ↑(Finset.biUnion S fun f => f.support) = ⋃ (f : MonoidAlgebra R M) (_ : f ∈ S), ↑f.support
⊢ adjoin R (↑(of R M) '' ↑(Finset.biUnion S fun f => f.support)) = ⊤

tactic: exact support_gen_of_gen' hS
state_before: case mk.intro
R : Type u_2
M : Type u_1
inst✝¹ : CommRing R
inst✝ : CommMonoid M
S : Finset (MonoidAlgebra R M)
hS : adjoin R ↑S = ⊤
this✝ : DecidableEq M := Classical.decEq M
this : ↑(Finset.biUnion S fun f => f.support) = ⋃ (f : MonoidAlgebra R M) (_ : f ∈ S), ↑f.support
⊢ adjoin R (↑(of R M) '' ⋃ (f : MonoidAlgebra R M) (_ : f ∈ S), ↑f.support) = ⊤

tactic: simp only [Finset.set_biUnion_coe, Finset.coe_biUnion]
state_before: R : Type u_2
M : Type u_1
inst✝¹ : CommRing R
inst✝ : CommMonoid M
S : Finset (MonoidAlgebra R M)
hS : adjoin R ↑S = ⊤
this : DecidableEq M := Classical.decEq M
⊢ ↑(Finset.biUnion S fun f => f.support) = ⋃ (f : MonoidAlgebra R M) (_ : f ∈ S), ↑f.support
Theorem: Finset.sup_eq_bot_iff
File: Mathlib/Data/Finset/Lattice.lean

tactic: classical induction' S using Finset.induction with a S _ hi <;> simp [*]
state_before: F : Type ?u.82158
α : Type u_2
β : Type u_1
γ : Type ?u.82167
ι : Type ?u.82170
κ : Type ?u.82173
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s s₁ s₂ : Finset β
f✝ g : β → α
a : α
f : β → α
S : Finset β
⊢ sup S f = ⊥ ↔ ∀ (s : β), s ∈ S → f s = ⊥

tactic: induction' S using Finset.induction with a S _ hi <;> simp [*]
state_before: F : Type ?u.82158
α : Type u_2
β : Type u_1
γ : Type ?u.82167
ι : Type ?u.82170
κ : Type ?u.82173
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s s₁ s₂ : Finset β
f✝ g : β → α
a : α
f : β → α
S : Finset β
⊢ sup S f = ⊥ ↔ ∀ (s : β), s ∈ S → f s = ⊥
Theorem: finprod_mem_empty
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: simp
state_before: α : Type u_2
β : Type ?u.324567
ι : Type ?u.324570
G : Type ?u.324573
M : Type u_1
N : Type ?u.324579
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g : α → M
a b : α
s t : Set α
⊢ (∏ᶠ (i : α) (_ : i ∈ ∅), f i) = 1
Theorem: CircleDeg1Lift.units_inv_apply_apply
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

tactic: simp only [← mul_apply, f.inv_mul, coe_one, id]
state_before: f✝ g : CircleDeg1Lift
f : CircleDeg1Liftˣ
x : ℝ
⊢ ↑↑f⁻¹ (↑↑f x) = x
Theorem: Lists.equiv_atom
File: Mathlib/SetTheory/Lists.lean

tactic: cases h
state_before: α : Type u_1
a : α
l : Lists α
h : atom a ~ l
⊢ atom a = l

tactic: rfl
state_before: case refl
α : Type u_1
a : α
⊢ atom a = atom a
Theorem: Complex.arg_eq_arg_iff
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: simp only [ext_abs_arg_iff, map_mul, map_div₀, abs_ofReal, abs_abs,
  div_mul_cancel _ (abs.ne_zero hx), eq_self_iff_true, true_and_iff]
state_before: x y : ℂ
hx : x ≠ 0
hy : y ≠ 0
⊢ arg x = arg y ↔ ↑(↑abs y) / ↑(↑abs x) * x = y

tactic: rw [← ofReal_div, arg_real_mul]
state_before: x y : ℂ
hx : x ≠ 0
hy : y ≠ 0
⊢ arg x = arg y ↔ arg (↑(↑abs y) / ↑(↑abs x) * x) = arg y

tactic: exact div_pos (abs.pos hy) (abs.pos hx)
state_before: case hr
x y : ℂ
hx : x ≠ 0
hy : y ≠ 0
⊢ 0 < ↑abs y / ↑abs x
Theorem: CategoryTheory.isCoseparator_def
File: Mathlib/CategoryTheory/Generator.lean

tactic: obtain rfl := Set.mem_singleton_iff.1 hH
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
G : C
hG : IsCoseparator G
X Y : C
f g : X ⟶ Y
hfg : ∀ (h : Y ⟶ G), f ≫ h = g ≫ h
H : C
hH : H ∈ {G}
h : Y ⟶ H
⊢ f ≫ h = g ≫ h

tactic: exact hfg h
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
X Y : C
f g : X ⟶ Y
H : C
h : Y ⟶ H
hG : IsCoseparator H
hfg : ∀ (h : Y ⟶ H), f ≫ h = g ≫ h
hH : H ∈ {H}
⊢ f ≫ h = g ≫ h
Theorem: Real.summable_one_div_int_pow
File: Mathlib/Analysis/PSeries.lean

tactic: refine'
  ⟨fun h => Real.summable_one_div_nat_pow.mp (h.comp_injective Nat.cast_injective), fun h =>
    summable_int_of_summable_nat (Real.summable_one_div_nat_pow.mpr h)
      (((Real.summable_one_div_nat_pow.mpr h).mul_left <| 1 / (-1 : ℝ) ^ p).congr fun n => _)⟩
state_before: p : ℕ
⊢ (Summable fun n => 1 / ↑n ^ ↑p) ↔ 1 < p

tactic: conv_rhs =>
  rw [Int.cast_neg, neg_eq_neg_one_mul, Real.rpow_nat_cast, mul_pow, ← div_div]
state_before: p : ℕ
h : 1 < p
n : ℕ
⊢ 1 / (-1) ^ ↑p * (1 / ↑n ^ ↑p) = 1 / ↑(-↑n) ^ ↑p

tactic: conv_lhs => rw [mul_div, mul_one]
state_before: p : ℕ
h : 1 < p
n : ℕ
⊢ 1 / (-1) ^ ↑p * (1 / ↑n ^ ↑p) = 1 / (-1) ^ p / ↑↑n ^ p

tactic: norm_cast
state_before: p : ℕ
h : 1 < p
n : ℕ
⊢ 1 / (-1) ^ ↑p / ↑n ^ ↑p = 1 / (-1) ^ p / ↑↑n ^ p
Theorem: Finset.shadow_image_compl
File: Mathlib/Combinatorics/SetFamily/Shadow.lean

tactic: ext s
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s t : Finset α
a : α
k r : ℕ
⊢ image compl ((∂ ) 𝒜) = (∂⁺ ) (image compl 𝒜)

tactic: simp only [mem_image, exists_prop, mem_shadow_iff, mem_upShadow_iff]
state_before: case a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s✝ t : Finset α
a : α
k r : ℕ
s : Finset α
⊢ s ∈ image compl ((∂ ) 𝒜) ↔ s ∈ (∂⁺ ) (image compl 𝒜)

tactic: constructor
state_before: case a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s✝ t : Finset α
a : α
k r : ℕ
s : Finset α
⊢ (∃ a, (∃ t, t ∈ 𝒜 ∧ ∃ a_1, a_1 ∈ t ∧ erase t a_1 = a) ∧ aᶜ = s) ↔
    ∃ t, (∃ a, a ∈ 𝒜 ∧ aᶜ = t) ∧ ∃ a, ¬a ∈ t ∧ insert a t = s

tactic: rintro ⟨_, ⟨s, hs, a, ha, rfl⟩, rfl⟩
state_before: case a.mp
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s✝ t : Finset α
a : α
k r : ℕ
s : Finset α
⊢ (∃ a, (∃ t, t ∈ 𝒜 ∧ ∃ a_1, a_1 ∈ t ∧ erase t a_1 = a) ∧ aᶜ = s) →
    ∃ t, (∃ a, a ∈ 𝒜 ∧ aᶜ = t) ∧ ∃ a, ¬a ∈ t ∧ insert a t = s

tactic: exact ⟨sᶜ, ⟨s, hs, rfl⟩, a, not_mem_compl.2 ha, compl_erase.symm⟩
state_before: case a.mp.intro.intro.intro.intro.intro.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s✝ t : Finset α
a✝ : α
k r : ℕ
s : Finset α
hs : s ∈ 𝒜
a : α
ha : a ∈ s
⊢ ∃ t, (∃ a, a ∈ 𝒜 ∧ aᶜ = t) ∧ ∃ a_1, ¬a_1 ∈ t ∧ insert a_1 t = erase s aᶜ

tactic: rintro ⟨_, ⟨s, hs, rfl⟩, a, ha, rfl⟩
state_before: case a.mpr
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s✝ t : Finset α
a : α
k r : ℕ
s : Finset α
⊢ (∃ t, (∃ a, a ∈ 𝒜 ∧ aᶜ = t) ∧ ∃ a, ¬a ∈ t ∧ insert a t = s) →
    ∃ a, (∃ t, t ∈ 𝒜 ∧ ∃ a_1, a_1 ∈ t ∧ erase t a_1 = a) ∧ aᶜ = s

tactic: exact ⟨s.erase a, ⟨s, hs, a, not_mem_compl.1 ha, rfl⟩, compl_erase⟩
state_before: case a.mpr.intro.intro.intro.intro.intro.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s✝ t : Finset α
a✝ : α
k r : ℕ
s : Finset α
hs : s ∈ 𝒜
a : α
ha : ¬a ∈ sᶜ
⊢ ∃ a_1, (∃ t, t ∈ 𝒜 ∧ ∃ a, a ∈ t ∧ erase t a = a_1) ∧ a_1ᶜ = insert a (sᶜ)
Theorem: MvPolynomial.rename_esymm
File: Mathlib/RingTheory/MvPolynomial/Symmetric.lean

tactic: simp_rw [esymm, map_sum, map_prod, rename_X]
state_before: σ : Type u_1
R : Type u_3
τ : Type u_2
S : Type ?u.127979
inst✝³ : CommSemiring R
inst✝² : CommSemiring S
inst✝¹ : Fintype σ
inst✝ : Fintype τ
n : ℕ
e : σ ≃ τ
⊢ ↑(rename ↑e) (esymm σ R n) = ∑ x in powersetLen n univ, ∏ i in x, X (↑e i)

tactic: simp [Finset.powersetLen_map, -Finset.map_univ_equiv]
state_before: σ : Type u_1
R : Type u_3
τ : Type u_2
S : Type ?u.127979
inst✝³ : CommSemiring R
inst✝² : CommSemiring S
inst✝¹ : Fintype σ
inst✝ : Fintype τ
n : ℕ
e : σ ≃ τ
⊢ ∑ x in powersetLen n univ, ∏ i in x, X (↑e i) =
    ∑ t in powersetLen n (Finset.map (Equiv.toEmbedding e) univ), ∏ i in t, X i

tactic: dsimp [mapEmbedding, OrderEmbedding.ofMapLEIff]
state_before: σ : Type u_1
R : Type u_3
τ : Type u_2
S : Type ?u.127979
inst✝³ : CommSemiring R
inst✝² : CommSemiring S
inst✝¹ : Fintype σ
inst✝ : Fintype τ
n : ℕ
e : σ ≃ τ
⊢ ∑ x in powersetLen n univ, ∏ x in x, X (↑e x) =
    ∑ x in powersetLen n univ, ∏ i in ↑(mapEmbedding (Equiv.toEmbedding e)) x, X i

tactic: simp
state_before: σ : Type u_1
R : Type u_3
τ : Type u_2
S : Type ?u.127979
inst✝³ : CommSemiring R
inst✝² : CommSemiring S
inst✝¹ : Fintype σ
inst✝ : Fintype τ
n : ℕ
e : σ ≃ τ
⊢ ∑ x in powersetLen n univ, ∏ x in x, X (↑e x) =
    ∑ x in powersetLen n univ, ∏ i in Finset.map (Equiv.toEmbedding e) x, X i

tactic: rw [Finset.map_univ_equiv]
state_before: σ : Type u_1
R : Type u_3
τ : Type u_2
S : Type ?u.127979
inst✝³ : CommSemiring R
inst✝² : CommSemiring S
inst✝¹ : Fintype σ
inst✝ : Fintype τ
n : ℕ
e : σ ≃ τ
⊢ ∑ t in powersetLen n (Finset.map (Equiv.toEmbedding e) univ), ∏ i in t, X i = ∑ t in powersetLen n univ, ∏ i in t, X i
Theorem: Set.image_update_Ioc_left
File: Mathlib/Data/Set/Intervals/Pi.lean

tactic: simpa using image_update_Ioc f i a (f i)
state_before: ι : Type u_1
α : ι → Type u_2
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → PartialOrder (α i)
f : (i : ι) → α i
i : ι
a : α i
⊢ update f i '' Ioc a (f i) = Ioc (update f i a) f
Theorem: CategoryTheory.Limits.biprod.add_eq_lift_id_desc
File: Mathlib/CategoryTheory/Preadditive/Biproducts.lean

tactic: simp
state_before: C : Type u
inst✝³ : Category C
inst✝² : Preadditive C
J : Type
inst✝¹ : Fintype J
X Y : C
f g : X ⟶ Y
inst✝ : HasBinaryBiproduct X X
⊢ f + g = lift (𝟙 X) (𝟙 X) ≫ desc f g
Theorem: toIcoMod_eq_iff
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: refine'
  ⟨fun h =>
    ⟨h ▸ toIcoMod_mem_Ico hp a b, toIcoDiv hp a b, h ▸ (toIcoMod_add_toIcoDiv_zsmul _ _ _).symm⟩,
    _⟩
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
⊢ toIcoMod hp a b = c ↔ c ∈ Set.Ico a (a + p) ∧ ∃ z, b = c + z • p

tactic: simp_rw [← @sub_eq_iff_eq_add]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
⊢ (c ∈ Set.Ico a (a + p) ∧ ∃ z, b = c + z • p) → toIcoMod hp a b = c

tactic: rintro ⟨hc, n, rfl⟩
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
⊢ (c ∈ Set.Ico a (a + p) ∧ ∃ z, b - z • p = c) → toIcoMod hp a b = c

tactic: rw [← toIcoDiv_eq_of_sub_zsmul_mem_Ico hp hc, toIcoMod]
state_before: case intro.intro
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b : α
n✝ n : ℤ
hc : b - n • p ∈ Set.Ico a (a + p)
⊢ toIcoMod hp a b = b - n • p
Theorem: Lagrange.degree_nodal
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: simp_rw [nodal, degree_prod, degree_X_sub_C, sum_const, Nat.smul_one_eq_coe]
state_before: F : Type u_1
inst✝ : Field F
ι : Type u_2
s : Finset ι
v : ι → F
i : ι
r : ι → F
x : F
⊢ degree (nodal s v) = ↑(card s)
Theorem: LowerSet.coe_iInf₂
File: Mathlib/Order/UpperLower/Basic.lean

tactic: simp_rw [coe_iInf]
state_before: α : Type u_1
β : Type ?u.74343
γ : Type ?u.74346
ι : Sort u_2
κ : ι → Sort u_3
inst✝ : LE α
S : Set (LowerSet α)
s t : LowerSet α
a : α
f : (i : ι) → κ i → LowerSet α
⊢ ↑(⨅ (i : ι) (j : κ i), f i j) = ⋂ (i : ι) (j : κ i), ↑(f i j)
Theorem: isLUB_of_tendsto_atTop
File: Mathlib/Topology/Algebra/Order/MonotoneConvergence.lean

tactic: constructor
state_before: α : Type u_1
β : Type u_2
inst✝⁴ : TopologicalSpace α
inst✝³ : Preorder α
inst✝² : OrderClosedTopology α
inst✝¹ : Nonempty β
inst✝ : SemilatticeSup β
f : β → α
a : α
hf : Monotone f
ha : Tendsto f atTop (𝓝 a)
⊢ IsLUB (range f) a

tactic: rintro _ ⟨b, rfl⟩
state_before: case left
α : Type u_1
β : Type u_2
inst✝⁴ : TopologicalSpace α
inst✝³ : Preorder α
inst✝² : OrderClosedTopology α
inst✝¹ : Nonempty β
inst✝ : SemilatticeSup β
f : β → α
a : α
hf : Monotone f
ha : Tendsto f atTop (𝓝 a)
⊢ a ∈ upperBounds (range f)

tactic: exact hf.ge_of_tendsto ha b
state_before: case left.intro
α : Type u_1
β : Type u_2
inst✝⁴ : TopologicalSpace α
inst✝³ : Preorder α
inst✝² : OrderClosedTopology α
inst✝¹ : Nonempty β
inst✝ : SemilatticeSup β
f : β → α
a : α
hf : Monotone f
ha : Tendsto f atTop (𝓝 a)
b : β
⊢ f b ≤ a

tactic: exact fun _ hb => le_of_tendsto' ha fun x => hb (Set.mem_range_self x)
state_before: case right
α : Type u_1
β : Type u_2
inst✝⁴ : TopologicalSpace α
inst✝³ : Preorder α
inst✝² : OrderClosedTopology α
inst✝¹ : Nonempty β
inst✝ : SemilatticeSup β
f : β → α
a : α
hf : Monotone f
ha : Tendsto f atTop (𝓝 a)
⊢ a ∈ lowerBounds (upperBounds (range f))
Theorem: Multiset.normalize_lcm
File: Mathlib/Algebra/GCDMonoid/Multiset.lean

tactic: simp
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s : Multiset α
⊢ ↑normalize (lcm 0) = lcm 0

tactic: simp
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s✝ : Multiset α
a : α
s : Multiset α
x✝ : ↑normalize (lcm s) = lcm s
⊢ ↑normalize (lcm (a ::ₘ s)) = lcm (a ::ₘ s)
Theorem: LinearIsometryEquiv.norm_iteratedFDeriv_comp_right
File: Mathlib/Analysis/Calculus/ContDiff.lean

tactic: simp only [← iteratedFDerivWithin_univ]
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
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 ?u.549479
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g✝ : F → G
x✝ x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
g : G ≃ₗᵢ[𝕜] E
f : E → F
x : G
i : ℕ
⊢ ‖iteratedFDeriv 𝕜 i (f ∘ ↑g) x‖ = ‖iteratedFDeriv 𝕜 i f (↑g x)‖

tactic: apply g.norm_iteratedFDerivWithin_comp_right f uniqueDiffOn_univ (mem_univ (g x)) i
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
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 ?u.549479
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g✝ : F → G
x✝ x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
g : G ≃ₗᵢ[𝕜] E
f : E → F
x : G
i : ℕ
⊢ ‖iteratedFDerivWithin 𝕜 i (f ∘ ↑g) univ x‖ = ‖iteratedFDerivWithin 𝕜 i f univ (↑g x)‖
Theorem: String.drop_empty
File: Std/Data/String/Lemmas.lean

tactic: rw [drop_eq, List.drop_nil]
state_before: n : Nat
⊢ drop "" n = ""