tasksource/leandojo huggingface dataset:
Theorem: Nat.fib_two_mul_add_two
File: Mathlib/Data/Nat/Fib.lean

tactic: rw [fib_add_two, fib_two_mul, fib_two_mul_add_one]
state_before: n : ℕ
⊢ fib (2 * n + 2) = fib (n + 1) * (2 * fib n + fib (n + 1))

tactic: have : fib n ≤ 2 * fib (n + 1) :=
  le_trans (fib_le_fib_succ) (mul_comm 2 _ ▸ le_mul_of_pos_right two_pos)
state_before: n : ℕ
⊢ fib n * (2 * fib (n + 1) - fib n) + (fib (n + 1) ^ 2 + fib n ^ 2) = fib (n + 1) * (2 * fib n + fib (n + 1))

tactic: zify [this]
state_before: n : ℕ
this : fib n ≤ 2 * fib (n + 1)
⊢ fib n * (2 * fib (n + 1) - fib n) + (fib (n + 1) ^ 2 + fib n ^ 2) = fib (n + 1) * (2 * fib n + fib (n + 1))

tactic: ring
state_before: n : ℕ
this : fib n ≤ 2 * fib (n + 1)
⊢ ↑(fib n) * (2 * ↑(fib (n + 1)) - ↑(fib n)) + (↑(fib (n + 1)) ^ 2 + ↑(fib n) ^ 2) =
    ↑(fib (n + 1)) * (2 * ↑(fib n) + ↑(fib (n + 1)))
Theorem: Real.Angle.sin_eq_zero_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: nth_rw 1 [← sin_zero]
state_before: θ : Angle
⊢ sin θ = 0 ↔ θ = 0 ∨ θ = ↑π

tactic: rw [sin_eq_iff_eq_or_add_eq_pi]
state_before: θ : Angle
⊢ sin θ = sin 0 ↔ θ = 0 ∨ θ = ↑π

tactic: simp
state_before: θ : Angle
⊢ θ = 0 ∨ θ + 0 = ↑π ↔ θ = 0 ∨ θ = ↑π
Theorem: Fin.sum_pow_mul_eq_add_pow
File: Mathlib/Algebra/BigOperators/Fin.lean

tactic: simpa using Fintype.sum_pow_mul_eq_add_pow (Fin n) a b
state_before: α : Type ?u.35983
β : Type ?u.35986
n : ℕ
R : Type u_1
inst✝ : CommSemiring R
a b : R
⊢ ∑ s : Finset (Fin n), a ^ card s * b ^ (n - card s) = (a + b) ^ n
Theorem: Int.mod_add_div
File: Std/Data/Int/DivMod.lean

tactic: show (m % succ n + -↑(succ n) * -↑(m / succ n) : Int) = m
state_before: m n : Nat
⊢ mod (ofNat m) -[n+1] + -[n+1] * div (ofNat m) -[n+1] = ofNat m

tactic: rw [Int.neg_mul_neg]
state_before: m n : Nat
⊢ ↑m % ↑(succ n) + -↑(succ n) * -↑(m / succ n) = ↑m

tactic: exact congrArg ofNat (Nat.mod_add_div ..)
state_before: m n : Nat
⊢ ↑m % ↑(succ n) + ↑(succ n) * ↑(m / succ n) = ↑m

tactic: show -(↑((succ m) % n) : Int) + ↑n * -↑(succ m / n) = -↑(succ m)
state_before: m n : Nat
⊢ mod -[m+1] (ofNat n) + ofNat n * div -[m+1] (ofNat n) = -[m+1]

tactic: rw [Int.mul_neg, ← Int.neg_add]
state_before: m n : Nat
⊢ -↑(succ m % n) + ↑n * -↑(succ m / n) = -↑(succ m)

tactic: show -(↑(succ m % succ n) : Int) + -↑(succ n) * ↑(succ m / succ n) = -↑(succ m)
state_before: m n : Nat
⊢ mod -[m+1] -[n+1] + -[n+1] * div -[m+1] -[n+1] = -[m+1]

tactic: rw [Int.neg_mul, ← Int.neg_add]
state_before: m n : Nat
⊢ -↑(succ m % succ n) + -↑(succ n) * ↑(succ m / succ n) = -↑(succ m)
Theorem: IsAssociatedPrime.annihilator_le
File: Mathlib/RingTheory/Ideal/AssociatedPrime.lean

tactic: obtain ⟨hI, x, rfl⟩ := h
state_before: R : Type u_1
inst✝⁴ : CommRing R
I J : Ideal R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
M' : Type ?u.70734
inst✝¹ : AddCommGroup M'
inst✝ : Module R M'
f : M →ₗ[R] M'
h : IsAssociatedPrime I M
⊢ Submodule.annihilator ⊤ ≤ I

tactic: exact Submodule.annihilator_mono le_top
state_before: case intro.intro
R : Type u_1
inst✝⁴ : CommRing R
J : Ideal R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
M' : Type ?u.70734
inst✝¹ : AddCommGroup M'
inst✝ : Module R M'
f : M →ₗ[R] M'
x : M
hI : Ideal.IsPrime (Submodule.annihilator (Submodule.span R {x}))
⊢ Submodule.annihilator ⊤ ≤ Submodule.annihilator (Submodule.span R {x})
Theorem: multiplicity.multiplicity_sub_of_gt
File: Mathlib/RingTheory/Multiplicity.lean

tactic: rw [sub_eq_add_neg, multiplicity_add_of_gt] <;> rw [multiplicity.neg]
state_before: α : Type u_1
inst✝¹ : Ring α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p a b : α
h : multiplicity p b < multiplicity p a
⊢ multiplicity p (a - b) = multiplicity p b

tactic: assumption
state_before: α : Type u_1
inst✝¹ : Ring α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p a b : α
h : multiplicity p b < multiplicity p a
⊢ multiplicity p b < multiplicity p a
Theorem: WittVector.mapFun.pow
File: Mathlib/RingTheory/WittVector/Basic.lean

tactic: map_fun_tac
state_before: p : ℕ
R : Type u_2
S : Type u_1
T : Type ?u.460757
hp : Fact (Nat.Prime p)
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : CommRing T
α : Type ?u.460772
β : Type ?u.460775
f : R →+* S
x y : 𝕎 R
n : ℕ
⊢ mapFun (↑f) (x ^ n) = mapFun (↑f) x ^ n
Theorem: Fin.castLT_succAbove
File: Mathlib/Data/Fin/Basic.lean

tactic: simp only [succAbove_below _ _ h, castLT_castSucc]
state_before: n m : ℕ
x : Fin n
y : Fin (n + 1)
h : ↑castSucc x < y
h' : optParam (↑(↑(succAbove y) x) < n) (_ : ↑(↑(succAbove y) x) < n)
⊢ castLT (↑(succAbove y) x) h' = x
Theorem: ENNReal.toNNReal_top_mul
File: Mathlib/Data/Real/ENNReal.lean

tactic: simp
state_before: α : Type ?u.818755
β : Type ?u.818758
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ≥0∞
⊢ ENNReal.toNNReal (⊤ * a) = 0
Theorem: Complex.imClm_norm
File: Mathlib/Analysis/Complex/OperatorNorm.lean

tactic: simp
state_before: ⊢ 1 = ‖↑imClm I‖

tactic: simp
state_before: ⊢ ‖I‖ ≤ 1
Theorem: RatFunc.liftOn_div
File: Mathlib/FieldTheory/RatFunc.lean

tactic: rw [← mk_eq_div, liftOn_mk _ _ f f0 @H']
state_before: K : Type u
inst✝¹ : CommRing K
inst✝ : IsDomain K
P : Sort v
p q : K[X]
f : K[X] → K[X] → P
f0 : ∀ (p : K[X]), f p 0 = f 0 1
H' : ∀ {p q p' q' : K[X]}, q ≠ 0 → q' ≠ 0 → q' * p = q * p' → f p q = f p' q'
H :
  optParam (∀ {p q p' q' : K[X]}, q ∈ K[X]⁰ → q' ∈ K[X]⁰ → q' * p = q * p' → f p q = f p' q')
    (_ : ∀ {p q p' q' : K[X]}, q ∈ K[X]⁰ → q' ∈ K[X]⁰ → q' * p = q * p' → f p q = f p' q')
⊢ RatFunc.liftOn (↑(algebraMap K[X] (RatFunc K)) p / ↑(algebraMap K[X] (RatFunc K)) q) f H = f p q
Theorem: convexOn_norm
File: Mathlib/Analysis/Convex/Normed.lean

tactic: rw [norm_smul, norm_smul, Real.norm_of_nonneg ha, Real.norm_of_nonneg hb]
state_before: ι : Type ?u.38
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s t : Set E
hs : Convex ℝ s
x : E
x✝² : x ∈ s
y : E
x✝¹ : y ∈ s
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
x✝ : a + b = 1
⊢ ‖a • x‖ + ‖b • y‖ = a * ‖x‖ + b * ‖y‖
Theorem: exists_sum_eq_one_iff_pairwise_coprime'
File: Mathlib/RingTheory/Coprime/Lemmas.lean

tactic: convert exists_sum_eq_one_iff_pairwise_coprime Finset.univ_nonempty (s := s) using 1
state_before: R : Type u
I : Type v
inst✝³ : CommSemiring R
x y z : R
s : I → R
t : Finset I
inst✝² : Fintype I
inst✝¹ : Nonempty I
inst✝ : DecidableEq I
⊢ (∃ μ, ∑ i : I, μ i * ∏ j in {i}ᶜ, s j = 1) ↔ Pairwise (IsCoprime on s)

tactic: simp only [Function.onFun, pairwise_subtype_iff_pairwise_finset', coe_univ, Set.pairwise_univ]
state_before: case h.e'_2.a
R : Type u
I : Type v
inst✝³ : CommSemiring R
x y z : R
s : I → R
t : Finset I
inst✝² : Fintype I
inst✝¹ : Nonempty I
inst✝ : DecidableEq I
⊢ Pairwise (IsCoprime on s) ↔ Pairwise (IsCoprime on fun i => s ↑i)
Theorem: CategoryTheory.Limits.biprod.braid_natural
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

tactic: aesop_cat
state_before: J : Type w
C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
P Q : C
inst✝ : HasBinaryBiproducts C
W X Y Z : C
f : X ⟶ Y
g : Z ⟶ W
⊢ map f g ≫ (braiding Y W).hom = (braiding X Z).hom ≫ map g f
Theorem: inv_eq_of_mul
File: Mathlib/Algebra/GroupWithZero/Basic.lean

tactic: rw [← inv_mul_cancel_left₀ (left_ne_zero_of_mul_eq_one h) b, h, mul_one]
state_before: α : Type ?u.20829
M₀ : Type ?u.20832
G₀ : Type u_1
M₀' : Type ?u.20838
G₀' : Type ?u.20841
F : Type ?u.20844
F' : Type ?u.20847
inst✝ : GroupWithZero G₀
a b c g h✝ x : G₀
h : a * b = 1
⊢ a⁻¹ = b
Theorem: CategoryTheory.Limits.pullbackSymmetry_inv_comp_fst
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: simp [Iso.inv_comp_eq]
state_before: C : Type u
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : HasPullback f g
⊢ (pullbackSymmetry f g).inv ≫ pullback.fst = pullback.snd
Theorem: WithSeminorms.tendsto_nhds_atTop
File: Mathlib/Analysis/LocallyConvex/WithSeminorms.lean

tactic: rw [hp.tendsto_nhds u y₀]
state_before: 𝕜 : Type u_1
𝕜₂ : Type ?u.427366
𝕝 : Type ?u.427369
𝕝₂ : Type ?u.427372
E : Type u_2
F : Type u_4
G : Type ?u.427381
ι : Type u_3
ι' : Type ?u.427387
inst✝⁶ : NormedField 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : Nonempty ι
inst✝² : TopologicalSpace E
p : SeminormFamily 𝕜 E ι
inst✝¹ : SemilatticeSup F
inst✝ : Nonempty F
hp : WithSeminorms p
u : F → E
y₀ : E
⊢ Filter.Tendsto u Filter.atTop (𝓝 y₀) ↔ ∀ (i : ι) (ε : ℝ), 0 < ε → ∃ x₀, ∀ (x : F), x₀ ≤ x → ↑(p i) (u x - y₀) < ε

tactic: exact forall₃_congr fun _ _ _ => Filter.eventually_atTop
state_before: 𝕜 : Type u_1
𝕜₂ : Type ?u.427366
𝕝 : Type ?u.427369
𝕝₂ : Type ?u.427372
E : Type u_2
F : Type u_4
G : Type ?u.427381
ι : Type u_3
ι' : Type ?u.427387
inst✝⁶ : NormedField 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : Nonempty ι
inst✝² : TopologicalSpace E
p : SeminormFamily 𝕜 E ι
inst✝¹ : SemilatticeSup F
inst✝ : Nonempty F
hp : WithSeminorms p
u : F → E
y₀ : E
⊢ (∀ (i : ι) (ε : ℝ), 0 < ε → ∀ᶠ (x : F) in Filter.atTop, ↑(p i) (u x - y₀) < ε) ↔
    ∀ (i : ι) (ε : ℝ), 0 < ε → ∃ x₀, ∀ (x : F), x₀ ≤ x → ↑(p i) (u x - y₀) < ε
Theorem: Set.Icc_union_Ici
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: cases' le_or_lt a b with hab hab <;> simp [hab] at h
state_before: α : Type u_1
β : Type ?u.92706
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h : c ≤ max a b
⊢ Icc a b ∪ Ici c = Ici (min a c)

tactic: exact Icc_union_Ici' h
state_before: case inl
α : Type u_1
β : Type ?u.92706
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : a ≤ b
h : c ≤ b
⊢ Icc a b ∪ Ici c = Ici (min a c)

tactic: cases' h with h h
state_before: case inr
α : Type u_1
β : Type ?u.92706
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : b < a
h : c ≤ a ∨ c ≤ b
⊢ Icc a b ∪ Ici c = Ici (min a c)

tactic: simp [*]
state_before: case inr.inl
α : Type u_1
β : Type ?u.92706
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : b < a
h : c ≤ a
⊢ Icc a b ∪ Ici c = Ici (min a c)

tactic: have hca : c ≤ a := h.trans hab.le
state_before: case inr.inr
α : Type u_1
β : Type ?u.92706
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : b < a
h : c ≤ b
⊢ Icc a b ∪ Ici c = Ici (min a c)

tactic: simp [*]
state_before: case inr.inr
α : Type u_1
β : Type ?u.92706
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : b < a
h : c ≤ b
hca : c ≤ a
⊢ Icc a b ∪ Ici c = Ici (min a c)
Theorem: Polynomial.X_pow_comp
File: Mathlib/Data/Polynomial/Eval.lean

tactic: induction' k with k ih
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝ : Semiring R
p q r : R[X]
k : ℕ
⊢ comp (X ^ k) p = p ^ k

tactic: simp
state_before: case zero
R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝ : Semiring R
p q r : R[X]
⊢ comp (X ^ Nat.zero) p = p ^ Nat.zero

tactic: simp [pow_succ', mul_X_comp, ih]
state_before: case succ
R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝ : Semiring R
p q r : R[X]
k : ℕ
ih : comp (X ^ k) p = p ^ k
⊢ comp (X ^ Nat.succ k) p = p ^ Nat.succ k
Theorem: Submodule.torsionBySet_isInternal
File: Mathlib/Algebra/Module/Torsion.lean

tactic: apply (iSup_subtype'' ↑S fun i => torsionBySet R M <| p i).trans
state_before: R : Type u_1
M : Type u_3
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
ι : Type u_2
inst✝ : DecidableEq ι
S : Finset ι
p : ι → Ideal R
hp : Set.Pairwise ↑S fun i j => p i ⊔ p j = ⊤
hM : Module.IsTorsionBySet R M ↑(⨅ (i : ι) (_ : i ∈ S), p i)
⊢ (⨆ (i : { x // x ∈ S }), torsionBySet R M ↑(p ↑i)) = ⊤

tactic: apply (iSup_torsionBySet_ideal_eq_torsionBySet_iInf hp).trans <|
  (Module.isTorsionBySet_iff_torsionBySet_eq_top _).mp hM
state_before: R : Type u_1
M : Type u_3
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
ι : Type u_2
inst✝ : DecidableEq ι
S : Finset ι
p : ι → Ideal R
hp : Set.Pairwise ↑S fun i j => p i ⊔ p j = ⊤
hM : Module.IsTorsionBySet R M ↑(⨅ (i : ι) (_ : i ∈ S), p i)
⊢ (⨆ (t : ι) (_ : t ∈ ↑S), torsionBySet R M ↑(p t)) = ⊤
Theorem: LieSubmodule.lowerCentralSeries_eq_lcs_comap
File: Mathlib/Algebra/Lie/Nilpotent.lean

tactic: induction' k with k ih
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k : ℕ
N : LieSubmodule R L M
⊢ lowerCentralSeries R L { x // x ∈ ↑N } k = comap (incl N) (lcs k N)

tactic: simp
state_before: case zero
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k : ℕ
N : LieSubmodule R L M
⊢ lowerCentralSeries R L { x // x ∈ ↑N } Nat.zero = comap (incl N) (lcs Nat.zero N)

tactic: simp only [lcs_succ, lowerCentralSeries_succ] at ih ⊢
state_before: case succ
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k✝ : ℕ
N : LieSubmodule R L M
k : ℕ
ih : lowerCentralSeries R L { x // x ∈ ↑N } k = comap (incl N) (lcs k N)
⊢ lowerCentralSeries R L { x // x ∈ ↑N } (Nat.succ k) = comap (incl N) (lcs (Nat.succ k) N)

tactic: have : N.lcs k ≤ N.incl.range := by
  rw [N.range_incl]
  apply lcs_le_self
state_before: case succ
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k✝ : ℕ
N : LieSubmodule R L M
k : ℕ
ih : lowerCentralSeries R L { x // x ∈ ↑N } k = comap (incl N) (lcs k N)
⊢ ⁅⊤, lowerCentralSeries R L { x // x ∈ ↑N } k⁆ = comap (incl N) ⁅⊤, lcs k N⁆

tactic: rw [ih, LieSubmodule.comap_bracket_eq _ _ N.incl N.ker_incl this]
state_before: case succ
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k✝ : ℕ
N : LieSubmodule R L M
k : ℕ
ih : lowerCentralSeries R L { x // x ∈ ↑N } k = comap (incl N) (lcs k N)
this : lcs k N ≤ LieModuleHom.range (incl N)
⊢ ⁅⊤, lowerCentralSeries R L { x // x ∈ ↑N } k⁆ = comap (incl N) ⁅⊤, lcs k N⁆

tactic: rw [N.range_incl]
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k✝ : ℕ
N : LieSubmodule R L M
k : ℕ
ih : lowerCentralSeries R L { x // x ∈ ↑N } k = comap (incl N) (lcs k N)
⊢ lcs k N ≤ LieModuleHom.range (incl N)

tactic: apply lcs_le_self
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k✝ : ℕ
N : LieSubmodule R L M
k : ℕ
ih : lowerCentralSeries R L { x // x ∈ ↑N } k = comap (incl N) (lcs k N)
⊢ lcs k N ≤ N
Theorem: IsPathConnected.preimage_coe
File: Mathlib/Topology/PathConnected.lean

tactic: rcases hW with ⟨x, x_in, hx⟩
state_before: X : Type u_1
Y : Type ?u.648239
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type ?u.648254
F U W : Set X
hW : IsPathConnected W
hWU : W ⊆ U
⊢ IsPathConnected (Subtype.val ⁻¹' W)

tactic: use ⟨x, hWU x_in⟩, by simp [x_in]
state_before: case intro.intro
X : Type u_1
Y : Type ?u.648239
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x✝ y z : X
ι : Type ?u.648254
F U W : Set X
hWU : W ⊆ U
x : X
x_in : x ∈ W
hx : ∀ {y : X}, y ∈ W → JoinedIn W x y
⊢ IsPathConnected (Subtype.val ⁻¹' W)

tactic: rintro ⟨y, hyU⟩ hyW
state_before: case intro.intro
X : Type u_1
Y : Type ?u.648239
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x✝ y z : X
ι : Type ?u.648254
F U W : Set X
hWU : W ⊆ U
x : X
x_in : x ∈ W
hx : ∀ {y : X}, y ∈ W → JoinedIn W x y
⊢ ∀ {y : { x // x ∈ U }}, y ∈ Subtype.val ⁻¹' W → JoinedIn (Subtype.val ⁻¹' W) { val := x, property := (_ : x ∈ U) } y

tactic: exact ⟨(hx hyW).joined_subtype.somePath.map (continuous_inclusion hWU), by simp⟩
state_before: case intro.intro.mk
X : Type u_1
Y : Type ?u.648239
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x✝ y✝ z : X
ι : Type ?u.648254
F U W : Set X
hWU : W ⊆ U
x : X
x_in : x ∈ W
hx : ∀ {y : X}, y ∈ W → JoinedIn W x y
y : X
hyU : y ∈ U
hyW : { val := y, property := hyU } ∈ Subtype.val ⁻¹' W
⊢ JoinedIn (Subtype.val ⁻¹' W) { val := x, property := (_ : x ∈ U) } { val := y, property := hyU }

tactic: simp [x_in]
state_before: X : Type u_1
Y : Type ?u.648239
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x✝ y z : X
ι : Type ?u.648254
F U W : Set X
hWU : W ⊆ U
x : X
x_in : x ∈ W
hx : ∀ {y : X}, y ∈ W → JoinedIn W x y
⊢ { val := x, property := (_ : x ∈ U) } ∈ Subtype.val ⁻¹' W

tactic: simp
state_before: X : Type u_1
Y : Type ?u.648239
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x✝ y✝ z : X
ι : Type ?u.648254
F U W : Set X
hWU : W ⊆ U
x : X
x_in : x ∈ W
hx : ∀ {y : X}, y ∈ W → JoinedIn W x y
y : X
hyU : y ∈ U
hyW : { val := y, property := hyU } ∈ Subtype.val ⁻¹' W
⊢ ∀ (t : ↑I),
    ↑(Path.map
            (Joined.somePath
              (_ :
                Joined { val := x, property := (_ : x ∈ W) }
                  { val := ↑{ val := y, property := hyU }, property := (_ : ↑{ val := y, property := hyU } ∈ W) }))
            (_ : Continuous (inclusion hWU)))
        t ∈
      Subtype.val ⁻¹' W
Theorem: Ideal.le_toIdeal_homogeneousHull
File: Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean

tactic: intro r hr
state_before: ι : Type u_2
σ : Type u_3
R : Type ?u.208850
A : Type u_1
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
⊢ I ≤ toIdeal (homogeneousHull 𝒜 I)

tactic: classical
rw [← DirectSum.sum_support_decompose 𝒜 r]
refine' Ideal.sum_mem _ _
intro j _
apply Ideal.subset_span
use j
use ⟨r, hr⟩
state_before: ι : Type u_2
σ : Type u_3
R : Type ?u.208850
A : Type u_1
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
r : A
hr : r ∈ I
⊢ r ∈ toIdeal (homogeneousHull 𝒜 I)

tactic: rw [← DirectSum.sum_support_decompose 𝒜 r]
state_before: ι : Type u_2
σ : Type u_3
R : Type ?u.208850
A : Type u_1
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
r : A
hr : r ∈ I
⊢ r ∈ toIdeal (homogeneousHull 𝒜 I)

tactic: refine' Ideal.sum_mem _ _
state_before: ι : Type u_2
σ : Type u_3
R : Type ?u.208850
A : Type u_1
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
r : A
hr : r ∈ I
⊢ ∑ i in Dfinsupp.support (↑(decompose 𝒜) r), ↑(↑(↑(decompose 𝒜) r) i) ∈ toIdeal (homogeneousHull 𝒜 I)

tactic: intro j _
state_before: ι : Type u_2
σ : Type u_3
R : Type ?u.208850
A : Type u_1
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
r : A
hr : r ∈ I
⊢ ∀ (c : ι), c ∈ Dfinsupp.support (↑(decompose 𝒜) r) → ↑(↑(↑(decompose 𝒜) r) c) ∈ toIdeal (homogeneousHull 𝒜 I)

tactic: apply Ideal.subset_span
state_before: ι : Type u_2
σ : Type u_3
R : Type ?u.208850
A : Type u_1
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
r : A
hr : r ∈ I
j : ι
a✝ : j ∈ Dfinsupp.support (↑(decompose 𝒜) r)
⊢ ↑(↑(↑(decompose 𝒜) r) j) ∈ toIdeal (homogeneousHull 𝒜 I)

tactic: use j
state_before: case a
ι : Type u_2
σ : Type u_3
R : Type ?u.208850
A : Type u_1
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
r : A
hr : r ∈ I
j : ι
a✝ : j ∈ Dfinsupp.support (↑(decompose 𝒜) r)
⊢ ↑(↑(↑(decompose 𝒜) r) j) ∈ {r | ∃ i x, ↑(↑(↑(decompose 𝒜) ↑x) i) = r}

tactic: use ⟨r, hr⟩
state_before: case a
ι : Type u_2
σ : Type u_3
R : Type ?u.208850
A : Type u_1
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
r : A
hr : r ∈ I
j : ι
a✝ : j ∈ Dfinsupp.support (↑(decompose 𝒜) r)
⊢ ∃ x, ↑(↑(↑(decompose 𝒜) ↑x) j) = ↑(↑(↑(decompose 𝒜) r) j)
Theorem: Finset.product_eq_biUnion_right
File: Mathlib/Data/Finset/Prod.lean

tactic: simp only [mem_product, mem_biUnion, mem_image, exists_prop, Prod.mk.inj_iff, and_left_comm,
  exists_and_left, exists_eq_right, exists_eq_left]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.20058
s✝ s' : Finset α
t✝ t' : Finset β
a : α
b : β
inst✝ : DecidableEq (α × β)
s : Finset α
t : Finset β
x✝ : α × β
x : α
y : β
⊢ (x, y) ∈ s ×ˢ t ↔ (x, y) ∈ Finset.biUnion t fun b => image (fun a => (a, b)) s
Theorem: PGame.moveRight_neg_symm'
File: Mathlib/SetTheory/Game/PGame.lean

tactic: simp
state_before: x : PGame
i : RightMoves x
⊢ moveRight x i = -moveLeft (-x) (↑toLeftMovesNeg i)
Theorem: MonoidAlgebra.prod_single
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

tactic: rw [prod_cons has, ih, single_mul_single, prod_cons has, prod_cons has]
state_before: k : Type u₁
G : Type u₂
R : Type ?u.1506427
ι : Type ui
inst✝¹ : CommSemiring k
inst✝ : CommMonoid G
s✝ : Finset ι
a✝ : ι → G
b : ι → k
a : ι
s : Finset ι
has : ¬a ∈ s
ih : ∏ i in s, single (a✝ i) (b i) = single (∏ i in s, a✝ i) (∏ i in s, b i)
⊢ ∏ i in cons a s has, single (a✝ i) (b i) = single (∏ i in cons a s has, a✝ i) (∏ i in cons a s has, b i)
Theorem: Ideal.span_singleton_mul_left_unit
File: Mathlib/RingTheory/Ideal/Basic.lean

tactic: apply le_antisymm <;> rw [span_singleton_le_iff_mem, mem_span_singleton']
state_before: α : Type u
β : Type v
inst✝ : Semiring α
I : Ideal α
a✝ b a : α
h2 : IsUnit a
x : α
⊢ span {a * x} = span {x}

tactic: exacts [⟨a, rfl⟩, ⟨_, h2.unit.inv_mul_cancel_left x⟩]
state_before: case a
α : Type u
β : Type v
inst✝ : Semiring α
I : Ideal α
a✝ b a : α
h2 : IsUnit a
x : α
⊢ ∃ a_1, a_1 * x = a * x

case a
α : Type u
β : Type v
inst✝ : Semiring α
I : Ideal α
a✝ b a : α
h2 : IsUnit a
x : α
⊢ ∃ a_1, a_1 * (a * x) = x
Theorem: Finset.supIndep_singleton
File: Mathlib/Order/SupIndep.lean

tactic: rw [eq_empty_of_ssubset_singleton ⟨hs, fun h => hj (h hji)⟩, sup_empty]
state_before: α : Type u_1
β : Type ?u.4779
ι : Type u_2
ι' : Type ?u.4785
inst✝¹ : Lattice α
inst✝ : OrderBot α
s✝ t : Finset ι
f✝ : ι → α
i✝ i : ι
f : ι → α
s : Finset ι
hs : s ⊆ {i}
j : ι
hji : j ∈ {i}
hj : ¬j ∈ s
⊢ Disjoint (f j) (sup s f)

tactic: exact disjoint_bot_right
state_before: α : Type u_1
β : Type ?u.4779
ι : Type u_2
ι' : Type ?u.4785
inst✝¹ : Lattice α
inst✝ : OrderBot α
s✝ t : Finset ι
f✝ : ι → α
i✝ i : ι
f : ι → α
s : Finset ι
hs : s ⊆ {i}
j : ι
hji : j ∈ {i}
hj : ¬j ∈ s
⊢ Disjoint (f j) ⊥