1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Set.image_eq_empty
File: Mathlib/Data/Set/Image.lean

tactic: simp only [eq_empty_iff_forall_not_mem]
state_before: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α✝ → β✝
s✝ t : Set α✝
α : Type u_6
β : Type u_7
f : α → β
s : Set α
⊢ f '' s = ∅ ↔ s = ∅
state_after: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α✝ → β✝
s✝ t : Set α✝
α : Type u_6
β : Type u_7
f : α → β
s : Set α
⊢ (∀ (x : β), x ∉ f '' s) ↔ ∀ (x : α), x ∉ s

tactic: exact ⟨fun H a ha => H _ ⟨_, ha, rfl⟩, fun H b ⟨_, ha, _⟩ => H _ ha⟩
state_before: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α✝ → β✝
s✝ t : Set α✝
α : Type u_6
β : Type u_7
f : α → β
s : Set α
⊢ (∀ (x : β), x ∉ f '' s) ↔ ∀ (x : α), x ∉ s
state_after: no goals
Theorem: Submodule.mem_iSup_iff_exists_dfinsupp'
File: Mathlib/LinearAlgebra/DFinsupp.lean

tactic: rw [mem_iSup_iff_exists_dfinsupp]
state_before: ι : Type u_1
R : Type u_2
S : Type u_3
M : ι → Type u_4
N : Type u_5
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : DecidableEq ι
p : ι → Submodule R N
inst✝ : (i : ι) → (x : ↥(p i)) → Decidable (x ≠ 0)
x : N
⊢ x ∈ iSup p ↔ ∃ f, (f.sum fun i xi => ↑xi) = x
state_after: ι : Type u_1
R : Type u_2
S : Type u_3
M : ι → Type u_4
N : Type u_5
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : DecidableEq ι
p : ι → Submodule R N
inst✝ : (i : ι) → (x : ↥(p i)) → Decidable (x ≠ 0)
x : N
⊢ (∃ f, ((lsum ℕ) fun i => (p i).subtype) f = x) ↔ ∃ f, (f.sum fun i xi => ↑xi) = x

tactic: simp_rw [DFinsupp.lsum_apply_apply, DFinsupp.sumAddHom_apply,
  LinearMap.toAddMonoidHom_coe, coeSubtype]
state_before: ι : Type u_1
R : Type u_2
S : Type u_3
M : ι → Type u_4
N : Type u_5
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : DecidableEq ι
p : ι → Submodule R N
inst✝ : (i : ι) → (x : ↥(p i)) → Decidable (x ≠ 0)
x : N
⊢ (∃ f, ((lsum ℕ) fun i => (p i).subtype) f = x) ↔ ∃ f, (f.sum fun i xi => ↑xi) = x
state_after: no goals
Theorem: Polynomial.coeff_map
File: Mathlib/Algebra/Polynomial/Eval.lean

tactic: rw [map, eval₂_def, coeff_sum, sum]
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]
inst✝ : Semiring S
f : R →+* S
n : ℕ
⊢ (map f p).coeff n = f (p.coeff n)
state_after: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n✝ : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : Semiring S
f : R →+* S
n : ℕ
⊢ ∑ n_1 ∈ p.support, ((C.comp f) (p.coeff n_1) * X ^ n_1).coeff n = f (p.coeff n)

tactic: conv_rhs => rw [← sum_C_mul_X_pow_eq p, coeff_sum, sum, map_sum]
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]
inst✝ : Semiring S
f : R →+* S
n : ℕ
⊢ ∑ n_1 ∈ p.support, ((C.comp f) (p.coeff n_1) * X ^ n_1).coeff n = f (p.coeff n)
state_after: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n✝ : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : Semiring S
f : R →+* S
n : ℕ
⊢ ∑ n_1 ∈ p.support, ((C.comp f) (p.coeff n_1) * X ^ n_1).coeff n = ∑ x ∈ p.support, f ((C (p.coeff x) * X ^ x).coeff n)

tactic: refine Finset.sum_congr rfl fun x _hx => ?_
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]
inst✝ : Semiring S
f : R →+* S
n : ℕ
⊢ ∑ n_1 ∈ p.support, ((C.comp f) (p.coeff n_1) * X ^ n_1).coeff n = ∑ x ∈ p.support, f ((C (p.coeff x) * X ^ x).coeff n)
state_after: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n✝ : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : Semiring S
f : R →+* S
n x : ℕ
_hx : x ∈ p.support
⊢ ((C.comp f) (p.coeff x) * X ^ x).coeff n = f ((C (p.coeff x) * X ^ x).coeff n)

tactic: simp only [RingHom.coe_comp, Function.comp, coeff_C_mul_X_pow]
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]
inst✝ : Semiring S
f : R →+* S
n x : ℕ
_hx : x ∈ p.support
⊢ ((C.comp f) (p.coeff x) * X ^ x).coeff n = f ((C (p.coeff x) * X ^ x).coeff n)
state_after: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n✝ : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : Semiring S
f : R →+* S
n x : ℕ
_hx : x ∈ p.support
⊢ (if n = x then f (p.coeff x) else 0) = f (if n = x then p.coeff x else 0)

tactic: split_ifs <;> simp [f.map_zero]
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]
inst✝ : Semiring S
f : R →+* S
n x : ℕ
_hx : x ∈ p.support
⊢ (if n = x then f (p.coeff x) else 0) = f (if n = x then p.coeff x else 0)
state_after: no goals
Theorem: Nat.Partrec'.of_part
File: Mathlib/Computability/Halting.lean

tactic: let g := fun n₁ =>
  (Part.ofOption (decode (α := Vector ℕ n) n₁)).bind (fun a => Part.map encode (f a))
state_before: this : ∀ (f : ℕ →. ℕ), Partrec f → Partrec' fun v => f v.head
n : ℕ
f : Vector ℕ n →. ℕ
hf : _root_.Partrec f
⊢ Partrec' f
state_after: this : ∀ (f : ℕ →. ℕ), Partrec f → Partrec' fun v => f v.head
n : ℕ
f : Vector ℕ n →. ℕ
hf : _root_.Partrec f
g : ℕ → Part ℕ := fun n₁ => (↑(decode n₁)).bind fun a => Part.map encode (f a)
⊢ Partrec' f

tactic: exact
  (comp₁ g (this g hf) (prim Nat.Primrec'.encode)).of_eq fun i => by
    dsimp only [g]; simp [encodek, Part.map_id']
state_before: this : ∀ (f : ℕ →. ℕ), Partrec f → Partrec' fun v => f v.head
n : ℕ
f : Vector ℕ n →. ℕ
hf : _root_.Partrec f
g : ℕ → Part ℕ := fun n₁ => (↑(decode n₁)).bind fun a => Part.map encode (f a)
⊢ Partrec' f
state_after: no goals

tactic: dsimp only [g]
state_before: this : ∀ (f : ℕ →. ℕ), Partrec f → Partrec' fun v => f v.head
n : ℕ
f : Vector ℕ n →. ℕ
hf : _root_.Partrec f
g : ℕ → Part ℕ := fun n₁ => (↑(decode n₁)).bind fun a => Part.map encode (f a)
i : Vector ℕ n
⊢ g (encode i) = f i
state_after: this : ∀ (f : ℕ →. ℕ), Partrec f → Partrec' fun v => f v.head
n : ℕ
f : Vector ℕ n →. ℕ
hf : _root_.Partrec f
g : ℕ → Part ℕ := fun n₁ => (↑(decode n₁)).bind fun a => Part.map encode (f a)
i : Vector ℕ n
⊢ ((↑(decode (encode i))).bind fun a => Part.map encode (f a)) = f i

tactic: simp [encodek, Part.map_id']
state_before: this : ∀ (f : ℕ →. ℕ), Partrec f → Partrec' fun v => f v.head
n : ℕ
f : Vector ℕ n →. ℕ
hf : _root_.Partrec f
g : ℕ → Part ℕ := fun n₁ => (↑(decode n₁)).bind fun a => Part.map encode (f a)
i : Vector ℕ n
⊢ ((↑(decode (encode i))).bind fun a => Part.map encode (f a)) = f i
state_after: no goals

tactic: obtain ⟨c, rfl⟩ := exists_code.1 hf
state_before: f : ℕ →. ℕ
hf : Partrec f
⊢ Partrec' fun v => f v.head
state_after: case intro
c : Code
hf : Partrec c.eval
⊢ Partrec' fun v => c.eval v.head

tactic: simpa [eval_eq_rfindOpt] using
  rfindOpt <|
    of_prim <|
      Primrec.encode_iff.2 <|
        evaln_prim.comp <|
          (Primrec.vector_head.pair (_root_.Primrec.const c)).pair <|
            Primrec.vector_head.comp Primrec.vector_tail
state_before: case intro
c : Code
hf : Partrec c.eval
⊢ Partrec' fun v => c.eval v.head
state_after: no goals
Theorem: abs_real_inner_div_norm_mul_norm_le_one
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [abs_div, abs_mul, abs_norm, abs_norm]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : F
⊢ |⟪x, y⟫_ℝ / (‖x‖ * ‖y‖)| ≤ 1
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : F
⊢ |⟪x, y⟫_ℝ| / (‖x‖ * ‖y‖) ≤ 1

tactic: exact div_le_one_of_le (abs_real_inner_le_norm x y) (by positivity)
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : F
⊢ |⟪x, y⟫_ℝ| / (‖x‖ * ‖y‖) ≤ 1
state_after: no goals

tactic: positivity
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : F
⊢ 0 ≤ ‖x‖ * ‖y‖
state_after: no goals
Theorem: ENNReal.lintegral_mul_eq_zero_of_lintegral_rpow_eq_zero
File: Mathlib/MeasureTheory/Integral/MeanInequalities.lean

tactic: rw [← @lintegral_zero_fun α _ μ]
state_before: α : Type u_1
inst✝ : MeasurableSpace α
μ : Measure α
p : ℝ
hp0 : 0 ≤ p
f g : α → ℝ≥0∞
hf : AEMeasurable f μ
hf_zero : ∫⁻ (a : α), f a ^ p ∂μ = 0
⊢ ∫⁻ (a : α), (f * g) a ∂μ = 0
state_after: α : Type u_1
inst✝ : MeasurableSpace α
μ : Measure α
p : ℝ
hp0 : 0 ≤ p
f g : α → ℝ≥0∞
hf : AEMeasurable f μ
hf_zero : ∫⁻ (a : α), f a ^ p ∂μ = 0
⊢ ∫⁻ (a : α), (f * g) a ∂μ = lintegral μ 0

tactic: refine lintegral_congr_ae ?_
state_before: α : Type u_1
inst✝ : MeasurableSpace α
μ : Measure α
p : ℝ
hp0 : 0 ≤ p
f g : α → ℝ≥0∞
hf : AEMeasurable f μ
hf_zero : ∫⁻ (a : α), f a ^ p ∂μ = 0
⊢ ∫⁻ (a : α), (f * g) a ∂μ = lintegral μ 0
state_after: α : Type u_1
inst✝ : MeasurableSpace α
μ : Measure α
p : ℝ
hp0 : 0 ≤ p
f g : α → ℝ≥0∞
hf : AEMeasurable f μ
hf_zero : ∫⁻ (a : α), f a ^ p ∂μ = 0
⊢ f * g =ᶠ[ae μ] 0

tactic: suffices h_mul_zero : f * g =ᵐ[μ] 0 * g by rwa [zero_mul] at h_mul_zero
state_before: α : Type u_1
inst✝ : MeasurableSpace α
μ : Measure α
p : ℝ
hp0 : 0 ≤ p
f g : α → ℝ≥0∞
hf : AEMeasurable f μ
hf_zero : ∫⁻ (a : α), f a ^ p ∂μ = 0
⊢ f * g =ᶠ[ae μ] 0
state_after: α : Type u_1
inst✝ : MeasurableSpace α
μ : Measure α
p : ℝ
hp0 : 0 ≤ p
f g : α → ℝ≥0∞
hf : AEMeasurable f μ
hf_zero : ∫⁻ (a : α), f a ^ p ∂μ = 0
⊢ f * g =ᶠ[ae μ] 0 * g

tactic: have hf_eq_zero : f =ᵐ[μ] 0 := ae_eq_zero_of_lintegral_rpow_eq_zero hp0 hf hf_zero
state_before: α : Type u_1
inst✝ : MeasurableSpace α
μ : Measure α
p : ℝ
hp0 : 0 ≤ p
f g : α → ℝ≥0∞
hf : AEMeasurable f μ
hf_zero : ∫⁻ (a : α), f a ^ p ∂μ = 0
⊢ f * g =ᶠ[ae μ] 0 * g
state_after: α : Type u_1
inst✝ : MeasurableSpace α
μ : Measure α
p : ℝ
hp0 : 0 ≤ p
f g : α → ℝ≥0∞
hf : AEMeasurable f μ
hf_zero : ∫⁻ (a : α), f a ^ p ∂μ = 0
hf_eq_zero : f =ᶠ[ae μ] 0
⊢ f * g =ᶠ[ae μ] 0 * g

tactic: exact hf_eq_zero.mul (ae_eq_refl g)
state_before: α : Type u_1
inst✝ : MeasurableSpace α
μ : Measure α
p : ℝ
hp0 : 0 ≤ p
f g : α → ℝ≥0∞
hf : AEMeasurable f μ
hf_zero : ∫⁻ (a : α), f a ^ p ∂μ = 0
hf_eq_zero : f =ᶠ[ae μ] 0
⊢ f * g =ᶠ[ae μ] 0 * g
state_after: no goals

tactic: rwa [zero_mul] at h_mul_zero
state_before: α : Type u_1
inst✝ : MeasurableSpace α
μ : Measure α
p : ℝ
hp0 : 0 ≤ p
f g : α → ℝ≥0∞
hf : AEMeasurable f μ
hf_zero : ∫⁻ (a : α), f a ^ p ∂μ = 0
h_mul_zero : f * g =ᶠ[ae μ] 0 * g
⊢ f * g =ᶠ[ae μ] 0
state_after: no goals
Theorem: Equiv.Perm.cycleType_le_of_mem_cycleFactorsFinset
File: Mathlib/GroupTheory/Perm/Cycle/Type.lean

tactic: have hf' := mem_cycleFactorsFinset_iff.1 hf
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
f g : Perm α
hf : f ∈ g.cycleFactorsFinset
⊢ f.cycleType ≤ g.cycleType
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
f g : Perm α
hf : f ∈ g.cycleFactorsFinset
hf' : f.IsCycle ∧ ∀ a ∈ f.support, f a = g a
⊢ f.cycleType ≤ g.cycleType

tactic: rw [cycleType_def, cycleType_def, hf'.left.cycleFactorsFinset_eq_singleton]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
f g : Perm α
hf : f ∈ g.cycleFactorsFinset
hf' : f.IsCycle ∧ ∀ a ∈ f.support, f a = g a
⊢ f.cycleType ≤ g.cycleType
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
f g : Perm α
hf : f ∈ g.cycleFactorsFinset
hf' : f.IsCycle ∧ ∀ a ∈ f.support, f a = g a
⊢ Multiset.map (Finset.card ∘ support) {f}.val ≤ Multiset.map (Finset.card ∘ support) g.cycleFactorsFinset.val

tactic: refine map_le_map ?_
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
f g : Perm α
hf : f ∈ g.cycleFactorsFinset
hf' : f.IsCycle ∧ ∀ a ∈ f.support, f a = g a
⊢ Multiset.map (Finset.card ∘ support) {f}.val ≤ Multiset.map (Finset.card ∘ support) g.cycleFactorsFinset.val
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
f g : Perm α
hf : f ∈ g.cycleFactorsFinset
hf' : f.IsCycle ∧ ∀ a ∈ f.support, f a = g a
⊢ {f}.val ≤ g.cycleFactorsFinset.val

tactic: simpa only [Finset.singleton_val, singleton_le, Finset.mem_val] using hf
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
f g : Perm α
hf : f ∈ g.cycleFactorsFinset
hf' : f.IsCycle ∧ ∀ a ∈ f.support, f a = g a
⊢ {f}.val ≤ g.cycleFactorsFinset.val
state_after: no goals
Theorem: List.sublists_cons
File: Mathlib/Data/List/Sublists.lean

tactic: rw [sublists_append]
state_before: α : Type u
β : Type v
γ : Type w
a : α
l : List α
⊢ ([a] ++ l).sublists = do
    let x ← l.sublists
    [x, a :: x]
state_after: α : Type u
β : Type v
γ : Type w
a : α
l : List α
⊢ (do
      let x ← l.sublists
      map (fun x_1 => x_1 ++ x) [a].sublists) =
    do
    let x ← l.sublists
    [x, a :: x]

tactic: simp only [sublists_singleton, map_cons, bind_eq_bind, nil_append, cons_append, map_nil]
state_before: α : Type u
β : Type v
γ : Type w
a : α
l : List α
⊢ (do
      let x ← l.sublists
      map (fun x_1 => x_1 ++ x) [a].sublists) =
    do
    let x ← l.sublists
    [x, a :: x]
state_after: no goals
Theorem: sign_finRotate
File: Mathlib/GroupTheory/Perm/Fin.lean

tactic: induction' n with n ih
state_before: n : ℕ
⊢ sign (finRotate (n + 1)) = (-1) ^ n
state_after: case zero

⊢ sign (finRotate (0 + 1)) = (-1) ^ 0

case succ
n : ℕ
ih : sign (finRotate (n + 1)) = (-1) ^ n
⊢ sign (finRotate (n + 1 + 1)) = (-1) ^ (n + 1)

tactic: simp
state_before: case zero

⊢ sign (finRotate (0 + 1)) = (-1) ^ 0
state_after: no goals

tactic: rw [finRotate_succ_eq_decomposeFin]
state_before: case succ
n : ℕ
ih : sign (finRotate (n + 1)) = (-1) ^ n
⊢ sign (finRotate (n + 1 + 1)) = (-1) ^ (n + 1)
state_after: case succ
n : ℕ
ih : sign (finRotate (n + 1)) = (-1) ^ n
⊢ sign (decomposeFin.symm (1, finRotate (n + 1))) = (-1) ^ (n + 1)

tactic: simp [ih, pow_succ]
state_before: case succ
n : ℕ
ih : sign (finRotate (n + 1)) = (-1) ^ n
⊢ sign (decomposeFin.symm (1, finRotate (n + 1))) = (-1) ^ (n + 1)
state_after: no goals
Theorem: Fin.succAbove_last
File: Mathlib/Data/Fin/Basic.lean

tactic: ext
state_before: n m : ℕ
p : Fin (n + 1)
i j : Fin n
⊢ (last n).succAbove = castSucc
state_after: case h.h
n m : ℕ
p : Fin (n + 1)
i j x✝ : Fin n
⊢ ↑((last n).succAbove x✝) = ↑x✝.castSucc

tactic: simp only [succAbove_of_castSucc_lt, castSucc_lt_last]
state_before: case h.h
n m : ℕ
p : Fin (n + 1)
i j x✝ : Fin n
⊢ ↑((last n).succAbove x✝) = ↑x✝.castSucc
state_after: no goals
Theorem: SimpleGraph.set_walk_self_length_zero_eq
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: ext p
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u : V
⊢ {p | p.length = 0} = {Walk.nil}
state_after: case h
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u : V
p : G.Walk u u
⊢ p ∈ {p | p.length = 0} ↔ p ∈ {Walk.nil}

tactic: simp
state_before: case h
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u : V
p : G.Walk u u
⊢ p ∈ {p | p.length = 0} ↔ p ∈ {Walk.nil}
state_after: no goals
Theorem: Ideal.MvPolynomial.quotient_mk_comp_C_isIntegral_of_jacobson'
File: Mathlib/RingTheory/Jacobson.lean

tactic: induction' n with n IH
state_before: n : ℕ
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P : Ideal (MvPolynomial (Fin n) R)
hP : P.IsMaximal
⊢ (algebraMap R (MvPolynomial (Fin n) R ⧸ P)).IsIntegral
state_after: case zero
n : ℕ
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P : Ideal (MvPolynomial (Fin 0) R)
hP : P.IsMaximal
⊢ (algebraMap R (MvPolynomial (Fin 0) R ⧸ P)).IsIntegral

case succ
n✝ : ℕ
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
n : ℕ
IH : ∀ (P : Ideal (MvPolynomial (Fin n) R)), P.IsMaximal → (algebraMap R (MvPolynomial (Fin n) R ⧸ P)).IsIntegral
P : Ideal (MvPolynomial (Fin (n + 1)) R)
hP : P.IsMaximal
⊢ (algebraMap R (MvPolynomial (Fin (n + 1)) R ⧸ P)).IsIntegral

tactic: apply RingHom.isIntegral_of_surjective
state_before: case zero
n : ℕ
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P : Ideal (MvPolynomial (Fin 0) R)
hP : P.IsMaximal
⊢ (algebraMap R (MvPolynomial (Fin 0) R ⧸ P)).IsIntegral
state_after: case zero.hf
n : ℕ
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P : Ideal (MvPolynomial (Fin 0) R)
hP : P.IsMaximal
⊢ Function.Surjective ⇑(algebraMap R (MvPolynomial (Fin 0) R ⧸ P))

tactic: apply Function.Surjective.comp Quotient.mk_surjective
state_before: case zero.hf
n : ℕ
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P : Ideal (MvPolynomial (Fin 0) R)
hP : P.IsMaximal
⊢ Function.Surjective ⇑(algebraMap R (MvPolynomial (Fin 0) R ⧸ P))
state_after: case zero.hf
n : ℕ
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P : Ideal (MvPolynomial (Fin 0) R)
hP : P.IsMaximal
⊢ Function.Surjective ⇑(algebraMap R (MvPolynomial (Fin 0) R))

tactic: exact C_surjective (Fin 0)
state_before: case zero.hf
n : ℕ
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P : Ideal (MvPolynomial (Fin 0) R)
hP : P.IsMaximal
⊢ Function.Surjective ⇑(algebraMap R (MvPolynomial (Fin 0) R))
state_after: no goals

tactic: apply aux_IH IH (finSuccEquiv R n).symm P hP
state_before: case succ
n✝ : ℕ
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
n : ℕ
IH : ∀ (P : Ideal (MvPolynomial (Fin n) R)), P.IsMaximal → (algebraMap R (MvPolynomial (Fin n) R ⧸ P)).IsIntegral
P : Ideal (MvPolynomial (Fin (n + 1)) R)
hP : P.IsMaximal
⊢ (algebraMap R (MvPolynomial (Fin (n + 1)) R ⧸ P)).IsIntegral
state_after: no goals
Theorem: Associates.pow_factors
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: induction' k with n h
state_before: α : Type u_1
inst✝⁴ : CancelCommMonoidWithZero α
inst✝³ : UniqueFactorizationMonoid α
inst✝² : DecidableEq (Associates α)
inst✝¹ : (p : Associates α) → Decidable (Irreducible p)
inst✝ : Nontrivial α
a : Associates α
k : ℕ
⊢ (a ^ k).factors = k • a.factors
state_after: case zero
α : Type u_1
inst✝⁴ : CancelCommMonoidWithZero α
inst✝³ : UniqueFactorizationMonoid α
inst✝² : DecidableEq (Associates α)
inst✝¹ : (p : Associates α) → Decidable (Irreducible p)
inst✝ : Nontrivial α
a : Associates α
⊢ (a ^ 0).factors = 0 • a.factors

case succ
α : Type u_1
inst✝⁴ : CancelCommMonoidWithZero α
inst✝³ : UniqueFactorizationMonoid α
inst✝² : DecidableEq (Associates α)
inst✝¹ : (p : Associates α) → Decidable (Irreducible p)
inst✝ : Nontrivial α
a : Associates α
n : ℕ
h : (a ^ n).factors = n • a.factors
⊢ (a ^ (n + 1)).factors = (n + 1) • a.factors

tactic: rw [zero_nsmul, pow_zero]
state_before: case zero
α : Type u_1
inst✝⁴ : CancelCommMonoidWithZero α
inst✝³ : UniqueFactorizationMonoid α
inst✝² : DecidableEq (Associates α)
inst✝¹ : (p : Associates α) → Decidable (Irreducible p)
inst✝ : Nontrivial α
a : Associates α
⊢ (a ^ 0).factors = 0 • a.factors
state_after: case zero
α : Type u_1
inst✝⁴ : CancelCommMonoidWithZero α
inst✝³ : UniqueFactorizationMonoid α
inst✝² : DecidableEq (Associates α)
inst✝¹ : (p : Associates α) → Decidable (Irreducible p)
inst✝ : Nontrivial α
a : Associates α
⊢ factors 1 = 0

tactic: exact factors_one
state_before: case zero
α : Type u_1
inst✝⁴ : CancelCommMonoidWithZero α
inst✝³ : UniqueFactorizationMonoid α
inst✝² : DecidableEq (Associates α)
inst✝¹ : (p : Associates α) → Decidable (Irreducible p)
inst✝ : Nontrivial α
a : Associates α
⊢ factors 1 = 0
state_after: no goals

tactic: rw [pow_succ, succ_nsmul, factors_mul, h]
state_before: case succ
α : Type u_1
inst✝⁴ : CancelCommMonoidWithZero α
inst✝³ : UniqueFactorizationMonoid α
inst✝² : DecidableEq (Associates α)
inst✝¹ : (p : Associates α) → Decidable (Irreducible p)
inst✝ : Nontrivial α
a : Associates α
n : ℕ
h : (a ^ n).factors = n • a.factors
⊢ (a ^ (n + 1)).factors = (n + 1) • a.factors
state_after: no goals
Theorem: AffineSubspace.mem_perpBisector_iff_dist_eq'
File: Mathlib/Geometry/Euclidean/PerpBisector.lean

tactic: simp only [mem_perpBisector_iff_dist_eq, dist_comm]
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
c c₁ c₂ p₁ p₂ : P
⊢ c ∈ perpBisector p₁ p₂ ↔ dist p₁ c = dist p₂ c
state_after: no goals
Theorem: mem_pairSelfAdjointMatricesSubmodule'
File: Mathlib/LinearAlgebra/Matrix/BilinearForm.lean

tactic: simp only [mem_pairSelfAdjointMatricesSubmodule]
state_before: R : Type u_1
M : Type u_2
inst✝¹⁶ : CommSemiring R
inst✝¹⁵ : AddCommMonoid M
inst✝¹⁴ : Module R M
R₁ : Type u_3
M₁ : Type u_4
inst✝¹³ : CommRing R₁
inst✝¹² : AddCommGroup M₁
inst✝¹¹ : Module R₁ M₁
R₂ : Type u_5
M₂ : Type u_6
inst✝¹⁰ : CommSemiring R₂
inst✝⁹ : AddCommMonoid M₂
inst✝⁸ : Module R₂ M₂
R₃ : Type u_7
M₃ : Type u_8
inst✝⁷ : CommRing R₃
inst✝⁶ : AddCommGroup M₃
inst✝⁵ : Module R₃ M₃
V : Type u_9
K : Type u_10
inst✝⁴ : Field K
inst✝³ : AddCommGroup V
inst✝² : Module K V
B : BilinForm R M
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
n : Type u_11
inst✝¹ : Fintype n
b : Basis n R₃ M₃
J J₃ A A' : Matrix n n R₃
inst✝ : DecidableEq n
⊢ A ∈ pairSelfAdjointMatricesSubmodule J J₃ ↔ J.IsAdjointPair J₃ A A
state_after: no goals
Theorem: Monoid.CoprodI.Word.equivPair_smul_same
File: Mathlib/GroupTheory/CoprodI.lean

tactic: rw [of_smul_def, ← equivPair_symm]
state_before: ι : Type u_1
M : ι → Type u_2
inst✝³ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝² : Monoid N
inst✝¹ : (i : ι) → DecidableEq (M i)
inst✝ : DecidableEq ι
i : ι
m : M i
w : Word M
⊢ (equivPair i) (of m • w) = { head := m * ((equivPair i) w).head, tail := ((equivPair i) w).tail, fstIdx_ne := ⋯ }
state_after: ι : Type u_1
M : ι → Type u_2
inst✝³ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝² : Monoid N
inst✝¹ : (i : ι) → DecidableEq (M i)
inst✝ : DecidableEq ι
i : ι
m : M i
w : Word M
⊢ (equivPair i)
      ((equivPair i).symm
        (let __src := (equivPair i) w;
        { head := m * ((equivPair i) w).head, tail := __src.tail, fstIdx_ne := ⋯ })) =
    { head := m * ((equivPair i) w).head, tail := ((equivPair i) w).tail, fstIdx_ne := ⋯ }

tactic: simp
state_before: ι : Type u_1
M : ι → Type u_2
inst✝³ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝² : Monoid N
inst✝¹ : (i : ι) → DecidableEq (M i)
inst✝ : DecidableEq ι
i : ι
m : M i
w : Word M
⊢ (equivPair i)
      ((equivPair i).symm
        (let __src := (equivPair i) w;
        { head := m * ((equivPair i) w).head, tail := __src.tail, fstIdx_ne := ⋯ })) =
    { head := m * ((equivPair i) w).head, tail := ((equivPair i) w).tail, fstIdx_ne := ⋯ }
state_after: no goals
Theorem: LinearMap.flip_injective_iff₂
File: Mathlib/LinearAlgebra/Dual.lean

tactic: rw [← dualMap_injective_iff]
state_before: K : Type uK
inst✝⁵ : Field K
V₁ : Type uV₁
V₂ : Type uV₂
inst✝⁴ : AddCommGroup V₁
inst✝³ : Module K V₁
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
B : V₁ →ₗ[K] V₂ →ₗ[K] K
inst✝ : FiniteDimensional K V₂
⊢ Injective ⇑B.flip ↔ Surjective ⇑B
state_after: K : Type uK
inst✝⁵ : Field K
V₁ : Type uV₁
V₂ : Type uV₂
inst✝⁴ : AddCommGroup V₁
inst✝³ : Module K V₁
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
B : V₁ →ₗ[K] V₂ →ₗ[K] K
inst✝ : FiniteDimensional K V₂
⊢ Injective ⇑B.flip ↔ Injective ⇑B.dualMap

tactic: exact (evalEquiv K V₂).toEquiv.injective_comp B.dualMap
state_before: K : Type uK
inst✝⁵ : Field K
V₁ : Type uV₁
V₂ : Type uV₂
inst✝⁴ : AddCommGroup V₁
inst✝³ : Module K V₁
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
B : V₁ →ₗ[K] V₂ →ₗ[K] K
inst✝ : FiniteDimensional K V₂
⊢ Injective ⇑B.flip ↔ Injective ⇑B.dualMap
state_after: no goals
Theorem: CategoryTheory.Limits.biproduct.isoCoproduct_inv
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

tactic: simp [biproduct.isoCoproduct]
state_before: J : Type w
K : Type u_1
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
f : J → C
inst✝ : HasBiproduct f
j : Discrete J
⊢ colimit.ι (Discrete.functor f) j ≫ (isoCoproduct f).inv = colimit.ι (Discrete.functor f) j ≫ Sigma.desc (ι f)
state_after: no goals
Theorem: Set.prod_sUnion
File: Mathlib/Data/Set/Lattice.lean

tactic: simp_rw [sUnion_eq_biUnion, biUnion_image, prod_iUnion₂]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
s : Set α
C : Set (Set β)
⊢ s ×ˢ ⋃₀ C = ⋃₀ ((fun t => s ×ˢ t) '' C)
state_after: no goals