ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CochainComplex.HomComplex.Cochain.comp_assoc_of_second_degree_eq_neg_third_degree
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m n₁ n₂ n₁₂ : ℤ
z₁ : Cochain F G n₁
z₂ : Cochain G K (-n₂)
z₃ : Cochain K L n₂
h₁₂ : n₁ + -n₂ = n₁₂
⊢ n₁₂ + n₂ = n₁
state_after: no goals
tactic: rw [← h₁₂, add_assoc, neg_add_self, add_zero]
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m n₁ n₂ n₁₂ : ℤ
z₁ : Cochain F G n₁
z₂ : Cochain G K (-n₂)
z₃ : Cochain K L n₂
h₁₂ : n₁ + -n₂ = n₁₂
⊢ n₁ + -n₂ + n₂ = n₁
state_after: no goals
tactic: omega
Theorem: DFinsupp.neLocus_eq_support_sub
File: Mathlib/Data/DFinsupp/NeLocus.lean

Proof steps:
state_before: α : Type u_1
N : α → Type u_2
inst✝² : DecidableEq α
inst✝¹ : (a : α) → DecidableEq (N a)
inst✝ : (a : α) → AddGroup (N a)
f f₁ f₂ g g₁ g₂ : Π₀ (a : α), N a
⊢ f.neLocus g = (f - g).support
state_after: no goals
tactic: rw [← @neLocus_add_right α N _ _ _ _ _ (-g), add_right_neg, neLocus_zero_right, sub_eq_add_neg]
Theorem: MeasurableEmbedding.mutuallySingular_map
File: Mathlib/MeasureTheory/Measure/MutuallySingular.lean

Proof steps:
state_before: α : Type u_1
m0 : MeasurableSpace α
μ μ₁ μ₂ ν ν₁ ν₂ : Measure α
β : Type u_2
x✝ : MeasurableSpace β
f : α → β
hf : MeasurableEmbedding f
hμν : μ ⟂ₘ ν
⊢ map f μ ⟂ₘ map f ν
state_after: case refine_1
α : Type u_1
m0 : MeasurableSpace α
μ μ₁ μ₂ ν ν₁ ν₂ : Measure α
β : Type u_2
x✝ : MeasurableSpace β
f : α → β
hf : MeasurableEmbedding f
hμν : μ ⟂ₘ ν
⊢ (map f μ) (f '' hμν.nullSet) = 0

case refine_2
α : Type u_1
m0 : MeasurableSpace α
μ μ₁ μ₂ ν ν₁ ν₂ : Measure α
β : Type u_2
x✝ : MeasurableSpace β
f : α → β
hf : MeasurableEmbedding f
hμν : μ ⟂ₘ ν
⊢ (map f ν) (f '' hμν.nullSet)ᶜ = 0
tactic: refine ⟨f '' hμν.nullSet, hf.measurableSet_image' hμν.measurableSet_nullSet, ?_, ?_⟩
Theorem: norm_iteratedFDerivWithin_eq_norm_iteratedDerivWithin
File: Mathlib/Analysis/Calculus/IteratedDeriv/Defs.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n : ℕ
f : 𝕜 → F
s : Set 𝕜
x : 𝕜
⊢ ‖iteratedFDerivWithin 𝕜 n f s x‖ = ‖iteratedDerivWithin n f s x‖
state_after: no goals
tactic: rw [iteratedDerivWithin_eq_equiv_comp, Function.comp_apply, LinearIsometryEquiv.norm_map]
Theorem: MeasureTheory.Measure.rnDeriv_zero
File: Mathlib/MeasureTheory/Decomposition/Lebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν✝ ν : Measure α
⊢ rnDeriv 0 ν =ᶠ[ae ν] 0
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν✝ ν : Measure α
⊢ 0 ⟂ₘ ν
tactic: rw [rnDeriv_eq_zero]
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν✝ ν : Measure α
⊢ 0 ⟂ₘ ν
state_after: no goals
tactic: exact MutuallySingular.zero_left
Theorem: Real.comap_exp_nhdsWithin_Ioi_zero
File: Mathlib/Analysis/SpecialFunctions/Exp.lean

Proof steps:
state_before: α : Type u_1
x y z : ℝ
l : Filter α
⊢ comap rexp (𝓝[>] 0) = atBot
state_after: no goals
tactic: rw [← map_exp_atBot, comap_map exp_injective]
Theorem: EReal.image_coe_Iic
File: Mathlib/Data/Real/EReal.lean

Proof steps:
state_before: x : ℝ
⊢ Real.toEReal '' Iic x = Ioc ⊥ ↑x
state_after: x : ℝ
⊢ WithBot.some '' (WithTop.some '' Iic x) = Ioc ⊥ ↑x
tactic: refine (image_comp WithBot.some WithTop.some _).trans ?_
state_before: x : ℝ
⊢ WithBot.some '' (WithTop.some '' Iic x) = Ioc ⊥ ↑x
state_after: x : ℝ
⊢ Ioc ⊥ ↑↑x = Ioc ⊥ ↑x
tactic: rw [WithTop.image_coe_Iic, WithBot.image_coe_Iic]
state_before: x : ℝ
⊢ Ioc ⊥ ↑↑x = Ioc ⊥ ↑x
state_after: no goals
tactic: rfl
Theorem: List.mem_rotate
File: Mathlib/Data/List/Rotate.lean

Proof steps:
state_before: α : Type u
x✝ : α
n : ℕ
⊢ x✝ ∈ [].rotate n ↔ x✝ ∈ []
state_after: no goals
tactic: simp
state_before: α : Type u
a : α
l : List α
x✝ : α
⊢ x✝ ∈ (a :: l).rotate 0 ↔ x✝ ∈ a :: l
state_after: no goals
tactic: simp
state_before: α : Type u
a : α
l : List α
x✝ : α
n : ℕ
⊢ x✝ ∈ (a :: l).rotate (n + 1) ↔ x✝ ∈ a :: l
state_after: no goals
tactic: simp [rotate_cons_succ, mem_rotate, or_comm]
Theorem: CochainComplex.mappingCone.inr_triangleδ
File: Mathlib/Algebra/Homology/HomotopyCategory/Pretriangulated.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝⁷ : Category.{u_3, u_1} C
inst✝⁶ : Category.{?u.18744, u_2} D
inst✝⁵ : Preadditive C
inst✝⁴ : HasZeroObject C
inst✝³ : HasBinaryBiproducts C
inst✝² : Preadditive D
inst✝¹ : HasZeroObject D
inst✝ : HasBinaryBiproducts D
K L : CochainComplex C ℤ
φ : K ⟶ L
⊢ inr φ ≫ (triangle φ).mor₃ = 0
state_after: no goals
tactic: aesop_cat
Theorem: uniqueDiffOn_Ici
File: Mathlib/Analysis/Calculus/TangentCone.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type u_3
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
x y : E
s t : Set E
a : ℝ
⊢ (interior (Ici a)).Nonempty
state_after: no goals
tactic: simp only [interior_Ici, nonempty_Ioi]
Theorem: UpperHalfPlane.modular_S_smul
File: Mathlib/Analysis/Complex/UpperHalfPlane/Basic.lean

Proof steps:
state_before: z : ℍ
⊢ ModularGroup.S • z = mk (-↑z)⁻¹ ⋯
state_after: z : ℍ
⊢ mk
      ((↑((algebraMap ℤ ℝ) (↑↑ModularGroup.S 0 0)) * ↑z + ↑((algebraMap ℤ ℝ) (↑↑ModularGroup.S 0 1))) /
        (↑((algebraMap ℤ ℝ) (↑↑ModularGroup.S 1 0)) * ↑z + ↑((algebraMap ℤ ℝ) (↑↑ModularGroup.S 1 1))))
      ⋯ =
    mk (-↑z)⁻¹ ⋯
tactic: rw [specialLinearGroup_apply]
state_before: z : ℍ
⊢ mk
      ((↑((algebraMap ℤ ℝ) (↑↑ModularGroup.S 0 0)) * ↑z + ↑((algebraMap ℤ ℝ) (↑↑ModularGroup.S 0 1))) /
        (↑((algebraMap ℤ ℝ) (↑↑ModularGroup.S 1 0)) * ↑z + ↑((algebraMap ℤ ℝ) (↑↑ModularGroup.S 1 1))))
      ⋯ =
    mk (-↑z)⁻¹ ⋯
state_after: no goals
tactic: simp [ModularGroup.S, neg_div, inv_neg, coeToGL]
Theorem: Real.cos_nat_mul_two_pi_add_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

Proof steps:
state_before: n : ℕ
⊢ cos (↑n * (2 * π) + π) = -1
state_after: no goals
tactic: simpa only [cos_zero] using (cos_periodic.nat_mul n).add_antiperiod_eq cos_antiperiodic
Theorem: Stream'.WSeq.mem_think
File: Mathlib/Data/Seq/WSeq.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
a : α
⊢ a ∈ s.think ↔ a ∈ s
state_after: case mk
α : Type u
β : Type v
γ : Type w
a : α
f : Stream' (Option (Option α))
al : f.IsSeq
⊢ a ∈ think ⟨f, al⟩ ↔ a ∈ ⟨f, al⟩
tactic: cases' s with f al
state_before: case mk
α : Type u
β : Type v
γ : Type w
a : α
f : Stream' (Option (Option α))
al : f.IsSeq
⊢ a ∈ think ⟨f, al⟩ ↔ a ∈ ⟨f, al⟩
state_after: case mk
α : Type u
β : Type v
γ : Type w
a : α
f : Stream' (Option (Option α))
al : f.IsSeq
⊢ some (some a) ∈ some none :: f ↔ some (some a) ∈ f
tactic: change (some (some a) ∈ some none::f) ↔ some (some a) ∈ f
state_before: case mk
α : Type u
β : Type v
γ : Type w
a : α
f : Stream' (Option (Option α))
al : f.IsSeq
⊢ some (some a) ∈ some none :: f ↔ some (some a) ∈ f
state_after: case mk.mp
α : Type u
β : Type v
γ : Type w
a : α
f : Stream' (Option (Option α))
al : f.IsSeq
h : some (some a) ∈ some none :: f
⊢ some (some a) ∈ f

case mk.mpr
α : Type u
β : Type v
γ : Type w
a : α
f : Stream' (Option (Option α))
al : f.IsSeq
h : some (some a) ∈ f
⊢ some (some a) ∈ some none :: f
tactic: constructor <;> intro h
Theorem: Fintype.card_fin_lt_of_le
File: Mathlib/Data/Fintype/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
m n : ℕ
h : m ≤ n
⊢ card { i // ↑i < m } = m
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
m n : ℕ
h : m ≤ n
⊢ card { i // ↑i < m } = card (Fin m)
tactic: conv_rhs => rw [← Fintype.card_fin m]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
m n : ℕ
h : m ≤ n
⊢ card { i // ↑i < m } = card (Fin m)
state_after: case f
α : Type u_1
β : Type u_2
γ : Type u_3
m n : ℕ
h : m ≤ n
⊢ { i // ↑i < m } ≃ Fin m
tactic: apply Fintype.card_congr
state_before: case f
α : Type u_1
β : Type u_2
γ : Type u_3
m n : ℕ
h : m ≤ n
⊢ { i // ↑i < m } ≃ Fin m
state_after: no goals
tactic: exact { toFun := fun ⟨⟨i, _⟩, hi⟩ ↦ ⟨i, hi⟩
          invFun := fun ⟨i, hi⟩ ↦ ⟨⟨i, lt_of_lt_of_le hi h⟩, hi⟩
          left_inv := fun i ↦ rfl
          right_inv := fun i ↦ rfl }
Theorem: ContinuousMap.idealOfSet_closed
File: Mathlib/Topology/ContinuousFunction/Ideals.lean

Proof steps:
state_before: X : Type u_1
R : Type u_2
inst✝⁴ : TopologicalSpace X
inst✝³ : Semiring R
inst✝² : TopologicalSpace R
inst✝¹ : TopologicalSemiring R
inst✝ : T2Space R
s : Set X
⊢ IsClosed ↑(idealOfSet R s)
state_after: X : Type u_1
R : Type u_2
inst✝⁴ : TopologicalSpace X
inst✝³ : Semiring R
inst✝² : TopologicalSpace R
inst✝¹ : TopologicalSemiring R
inst✝ : T2Space R
s : Set X
⊢ IsClosed ↑{ carrier := ⋂ i ∈ sᶜ, {x | x i = 0}, add_mem' := ⋯, zero_mem' := ⋯ }
tactic: simp only [idealOfSet, Submodule.coe_set_mk, Set.setOf_forall]
state_before: X : Type u_1
R : Type u_2
inst✝⁴ : TopologicalSpace X
inst✝³ : Semiring R
inst✝² : TopologicalSpace R
inst✝¹ : TopologicalSemiring R
inst✝ : T2Space R
s : Set X
⊢ IsClosed ↑{ carrier := ⋂ i ∈ sᶜ, {x | x i = 0}, add_mem' := ⋯, zero_mem' := ⋯ }
state_after: no goals
tactic: exact isClosed_iInter fun x => isClosed_iInter fun _ =>
    isClosed_eq (continuous_eval_const x) continuous_const
Theorem: MeasureTheory.rnDeriv_tilted_left
File: Mathlib/MeasureTheory/Measure/Tilted.lean

Proof steps:
state_before: α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f : α → ℝ
ν : Measure α
inst✝¹ : SigmaFinite μ
inst✝ : SigmaFinite ν
hfν : AEMeasurable f ν
⊢ (μ.tilted f).rnDeriv ν =ᶠ[ae ν] fun x => ENNReal.ofReal (rexp (f x) / ∫ (x : α), rexp (f x) ∂μ) * μ.rnDeriv ν x
state_after: α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f : α → ℝ
ν : Measure α
inst✝¹ : SigmaFinite μ
inst✝ : SigmaFinite ν
hfν : AEMeasurable f ν
g : α → ℝ≥0∞ := fun x => ENNReal.ofReal (rexp (f x) / ∫ (x : α), rexp (f x) ∂μ)
⊢ (μ.tilted f).rnDeriv ν =ᶠ[ae ν] fun x => ENNReal.ofReal (rexp (f x) / ∫ (x : α), rexp (f x) ∂μ) * μ.rnDeriv ν x
tactic: let g := fun x ↦ ENNReal.ofReal (exp (f x) / (∫ x, exp (f x) ∂μ))
state_before: α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f : α → ℝ
ν : Measure α
inst✝¹ : SigmaFinite μ
inst✝ : SigmaFinite ν
hfν : AEMeasurable f ν
g : α → ℝ≥0∞ := fun x => ENNReal.ofReal (rexp (f x) / ∫ (x : α), rexp (f x) ∂μ)
⊢ (μ.tilted f).rnDeriv ν =ᶠ[ae ν] fun x => ENNReal.ofReal (rexp (f x) / ∫ (x : α), rexp (f x) ∂μ) * μ.rnDeriv ν x
state_after: case refine_1
α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f : α → ℝ
ν : Measure α
inst✝¹ : SigmaFinite μ
inst✝ : SigmaFinite ν
hfν : AEMeasurable f ν
g : α → ℝ≥0∞ := fun x => ENNReal.ofReal (rexp (f x) / ∫ (x : α), rexp (f x) ∂μ)
⊢ AEMeasurable g ν

case refine_2
α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f : α → ℝ
ν : Measure α
inst✝¹ : SigmaFinite μ
inst✝ : SigmaFinite ν
hfν : AEMeasurable f ν
g : α → ℝ≥0∞ := fun x => ENNReal.ofReal (rexp (f x) / ∫ (x : α), rexp (f x) ∂μ)
⊢ ∀ᵐ (x : α) ∂μ, g x ≠ ⊤
tactic: refine Measure.rnDeriv_withDensity_left (μ := μ) (ν := ν) (f := g) ?_ ?_
Theorem: List.rotate_nil
File: Mathlib/Data/List/Rotate.lean

Proof steps:
state_before: α : Type u
n : ℕ
⊢ [].rotate n = []
state_after: no goals
tactic: simp [rotate]
Theorem: AlgHom.compLeft_apply
File: Mathlib/Algebra/Algebra/Pi.lean

Proof steps:
state_before: R : Type u
A : Type v
B : Type w
I✝ : Type u_1
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : A →ₐ[R] B
I : Type u_2
c : R
⊢ (↑↑{ toFun := fun h => ⇑f ∘ h, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯, map_add' := ⋯ }).toFun
      ((algebraMap R (I → A)) c) =
    (algebraMap R (I → B)) c
state_after: case h
R : Type u
A : Type v
B : Type w
I✝ : Type u_1
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : A →ₐ[R] B
I : Type u_2
c : R
x✝ : I
⊢ (↑↑{ toFun := fun h => ⇑f ∘ h, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯, map_add' := ⋯ }).toFun
      ((algebraMap R (I → A)) c) x✝ =
    (algebraMap R (I → B)) c x✝
tactic: ext
state_before: case h
R : Type u
A : Type v
B : Type w
I✝ : Type u_1
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : A →ₐ[R] B
I : Type u_2
c : R
x✝ : I
⊢ (↑↑{ toFun := fun h => ⇑f ∘ h, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯, map_add' := ⋯ }).toFun
      ((algebraMap R (I → A)) c) x✝ =
    (algebraMap R (I → B)) c x✝
state_after: no goals
tactic: exact f.commutes' c
Theorem: spectrum.subset_closedBall_norm
File: Mathlib/Analysis/Normed/Algebra/Spectrum.lean

Proof steps:
state_before: 𝕜 : Type u_1
A : Type u_2
inst✝⁴ : NormedField 𝕜
inst✝³ : NormedRing A
inst✝² : NormedAlgebra 𝕜 A
inst✝¹ : CompleteSpace A
inst✝ : NormOneClass A
a : A
k : 𝕜
hk : k ∈ σ a
⊢ k ∈ Metric.closedBall 0 ‖a‖
state_after: no goals
tactic: simp [norm_le_norm_of_mem hk]
Theorem: continuousAt_iff_continuous_left'_right'
File: Mathlib/Topology/Order/LeftRight.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : TopologicalSpace β
a : α
f : α → β
⊢ ContinuousAt f a ↔ ContinuousWithinAt f (Iio a) a ∧ ContinuousWithinAt f (Ioi a) a
state_after: no goals
tactic: rw [continuousWithinAt_Ioi_iff_Ici, continuousWithinAt_Iio_iff_Iic,
    continuousAt_iff_continuous_left_right]
Theorem: Nat.sub_one_mul_sum_log_div_pow_eq_sub_sum_digits
File: Mathlib/Data/Nat/Digits.lean

Proof steps:
state_before: n✝ p n : ℕ
⊢ (p - 1) * ∑ i ∈ range (log p n).succ, n / p ^ i.succ = n - (p.digits n).sum
state_after: case inl
n✝ p n : ℕ
h : 1 < p
⊢ (p - 1) * ∑ i ∈ range (log p n).succ, n / p ^ i.succ = n - (p.digits n).sum

case inr.inl
n✝ n : ℕ
⊢ (1 - 1) * ∑ i ∈ range (log 1 n).succ, n / 1 ^ i.succ = n - (digits 1 n).sum

case inr.inr
n✝ p n : ℕ
h : p < 1
⊢ (p - 1) * ∑ i ∈ range (log p n).succ, n / p ^ i.succ = n - (p.digits n).sum
tactic: obtain h | rfl | h : 1 < p ∨ 1 = p ∨ p < 1 := trichotomous 1 p
Theorem: Commute.add_pow_prime_pow_eq
File: Mathlib/Algebra/CharP/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
p : ℕ
x y : R
hp : Nat.Prime p
h : Commute x y
n : ℕ
⊢ (x + y) ^ p ^ n = x ^ p ^ n + y ^ p ^ n + ↑p * ∑ k ∈ Ioo 0 (p ^ n), x ^ k * y ^ (p ^ n - k) * ↑((p ^ n).choose k / p)
state_after: R : Type u_1
inst✝ : Semiring R
p : ℕ
x y : R
hp : Nat.Prime p
h : Commute x y
n : ℕ
⊢ (x + y) ^ p ^ n = x ^ p ^ n + y ^ p ^ n + ∑ k ∈ Ioo 0 (p ^ n), x ^ k * y ^ (p ^ n - k) * ↑((p ^ n).choose k)

R : Type u_1
inst✝ : Semiring R
p : ℕ
x y : R
hp : Nat.Prime p
h : Commute x y
n : ℕ
⊢ x ^ p ^ n + y ^ p ^ n + ∑ k ∈ Ioo 0 (p ^ n), x ^ k * y ^ (p ^ n - k) * ↑((p ^ n).choose k) =
    x ^ p ^ n + y ^ p ^ n + ↑p * ∑ k ∈ Ioo 0 (p ^ n), x ^ k * y ^ (p ^ n - k) * ↑((p ^ n).choose k / p)
tactic: trans x ^ p ^ n + y ^ p ^ n + ∑ k ∈ Ioo 0 (p ^ n), x ^ k * y ^ (p ^ n - k) * (p ^ n).choose k
Theorem: Ideal.mem_inv_pointwise_smul_iff
File: Mathlib/RingTheory/Ideal/Pointwise.lean

Proof steps:
state_before: M : Type u_1
R : Type u_2
inst✝² : Group M
inst✝¹ : CommRing R
inst✝ : MulSemiringAction M R
a : M
S : Ideal R
x : R
⊢ x ∈ a⁻¹ • S ↔ a • x ∈ S
state_after: no goals
tactic: rw [mem_pointwise_smul_iff_inv_smul_mem, inv_inv]
Theorem: Matrix.updateColumn_submatrix_equiv
File: Mathlib/Data/Matrix/RowCol.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
M : Matrix m n α
i : m
j✝ : n
b : n → α
c✝ : m → α
inst✝¹ : DecidableEq o
inst✝ : DecidableEq n
A : Matrix m n α
j : o
c : l → α
e : l ≃ m
f : o ≃ n
⊢ (A.submatrix ⇑e ⇑f).updateColumn j c = (A.updateColumn (f j) fun i => c (e.symm i)).submatrix ⇑e ⇑f
state_after: no goals
tactic: simpa only [← transpose_submatrix, updateRow_transpose] using
    congr_arg transpose (updateRow_submatrix_equiv Aᵀ j c f e)
Theorem: Ordinal.IsNormal.limit_lt
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
f : Ordinal.{u_4} → Ordinal.{u_5}
H : IsNormal f
o : Ordinal.{u_4}
h : o.IsLimit
a : Ordinal.{u_5}
⊢ ¬a < f o ↔ ¬∃ b < o, a < f b
state_after: no goals
tactic: simpa only [exists_prop, not_exists, not_and, not_lt] using H.2 _ h a
Theorem: List.lookupAll_nodup
File: Mathlib/Data/List/Sigma.lean

Proof steps:
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
h : l.NodupKeys
⊢ (lookupAll a l).Nodup
state_after: no goals
tactic: (rw [lookupAll_eq_dlookup a h]; apply Option.toList_nodup)
Theorem: Polynomial.smeval_monomial_mul
File: Mathlib/Algebra/Polynomial/Smeval.lean

Proof steps:
state_before: R : Type u_1
inst✝⁶ : Semiring R
p✝ : R[X]
r : R
p q : R[X]
S : Type u_2
inst✝⁵ : NonAssocSemiring S
inst✝⁴ : Module R S
inst✝³ : IsScalarTower R S S
inst✝² : SMulCommClass R S S
inst✝¹ : Pow S ℕ
inst✝ : NatPowAssoc S
x : S
n : ℕ
⊢ ((monomial n) r * p).smeval x = r • (x ^ n * p.smeval x)
state_after: no goals
tactic: induction p using Polynomial.induction_on' with
  | h_add r s hr hs =>
    simp only [add_comp, hr, hs, smeval_add, add_mul]
    rw [← C_mul_X_pow_eq_monomial, mul_assoc, smeval_C_mul, smeval_X_pow_mul, smeval_add]
  | h_monomial n a =>
    rw [smeval_monomial, monomial_mul_monomial, smeval_monomial, npow_add, mul_smul, mul_smul_comm]
Theorem: Set.Ici_add_Ici_subset
File: Mathlib/Data/Set/Pointwise/Interval.lean

Proof steps:
state_before: α : Type u_1
inst✝³ : Mul α
inst✝² : Preorder α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (Function.swap HMul.hMul) LE.le
a b : α
⊢ Ici a * Ici b ⊆ Ici (a * b)
state_after: case intro.intro.intro.intro
α : Type u_1
inst✝³ : Mul α
inst✝² : Preorder α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (Function.swap HMul.hMul) LE.le
a b y : α
hya : y ∈ Ici a
z : α
hzb : z ∈ Ici b
⊢ (fun x x_1 => x * x_1) y z ∈ Ici (a * b)
tactic: rintro x ⟨y, hya, z, hzb, rfl⟩
state_before: case intro.intro.intro.intro
α : Type u_1
inst✝³ : Mul α
inst✝² : Preorder α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (Function.swap HMul.hMul) LE.le
a b y : α
hya : y ∈ Ici a
z : α
hzb : z ∈ Ici b
⊢ (fun x x_1 => x * x_1) y z ∈ Ici (a * b)
state_after: no goals
tactic: exact mul_le_mul' hya hzb
Theorem: PiTensorProduct.congr_symm_tprod
File: Mathlib/LinearAlgebra/PiTensorProduct.lean

Proof steps:
state_before: ι : Type u_1
ι₂ : Type u_2
ι₃ : Type u_3
R : Type u_4
inst✝¹¹ : CommSemiring R
R₁ : Type u_5
R₂ : Type u_6
s : ι → Type u_7
inst✝¹⁰ : (i : ι) → AddCommMonoid (s i)
inst✝⁹ : (i : ι) → Module R (s i)
M : Type u_8
inst✝⁸ : AddCommMonoid M
inst✝⁷ : Module R M
E : Type u_9
inst✝⁶ : AddCommMonoid E
inst✝⁵ : Module R E
F : Type u_10
inst✝⁴ : AddCommMonoid F
t : ι → Type u_11
t' : ι → Type u_12
inst✝³ : (i : ι) → AddCommMonoid (t i)
inst✝² : (i : ι) → Module R (t i)
inst✝¹ : (i : ι) → AddCommMonoid (t' i)
inst✝ : (i : ι) → Module R (t' i)
g : (i : ι) → t i →ₗ[R] t' i
f✝ : (i : ι) → s i →ₗ[R] t i
f : (i : ι) → s i ≃ₗ[R] t i
p : (i : ι) → t i
⊢ (congr f).symm ((tprod R) p) = ⨂ₜ[R] (i : ι), (f i).symm (p i)
state_after: no goals
tactic: simp only [congr, LinearEquiv.ofLinear_symm_apply, map_tprod, LinearEquiv.coe_coe]
Theorem: Set.Iic_mul_Iio_subset'
File: Mathlib/Data/Set/Pointwise/Interval.lean

Proof steps:
state_before: α : Type u_1
inst✝³ : Mul α
inst✝² : PartialOrder α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (Function.swap HMul.hMul) LT.lt
a b : α
⊢ Iic a * Iio b ⊆ Iio (a * b)
state_after: α : Type u_1
inst✝³ : Mul α
inst✝² : PartialOrder α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (Function.swap HMul.hMul) LT.lt
a b : α
this :
  ∀ (M : Type ?u.9430) (N : Type ?u.9429) (μ : M → N → N) [inst : PartialOrder N]
    [inst_1 : CovariantClass M N μ fun x x_1 => x < x_1], CovariantClass M N μ fun x x_1 => x ≤ x_1
⊢ Iic a * Iio b ⊆ Iio (a * b)
tactic: haveI := covariantClass_le_of_lt
state_before: α : Type u_1
inst✝³ : Mul α
inst✝² : PartialOrder α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (Function.swap HMul.hMul) LT.lt
a b : α
this :
  ∀ (M : Type ?u.9430) (N : Type ?u.9429) (μ : M → N → N) [inst : PartialOrder N]
    [inst_1 : CovariantClass M N μ fun x x_1 => x < x_1], CovariantClass M N μ fun x x_1 => x ≤ x_1
⊢ Iic a * Iio b ⊆ Iio (a * b)
state_after: case intro.intro.intro.intro
α : Type u_1
inst✝³ : Mul α
inst✝² : PartialOrder α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (Function.swap HMul.hMul) LT.lt
a b : α
this :
  ∀ (M : Type ?u.9430) (N : Type ?u.9429) (μ : M → N → N) [inst : PartialOrder N]
    [inst_1 : CovariantClass M N μ fun x x_1 => x < x_1], CovariantClass M N μ fun x x_1 => x ≤ x_1
y : α
hya : y ∈ Iic a
z : α
hzb : z ∈ Iio b
⊢ (fun x x_1 => x * x_1) y z ∈ Iio (a * b)
tactic: rintro x ⟨y, hya, z, hzb, rfl⟩
state_before: case intro.intro.intro.intro
α : Type u_1
inst✝³ : Mul α
inst✝² : PartialOrder α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (Function.swap HMul.hMul) LT.lt
a b : α
this :
  ∀ (M : Type ?u.9430) (N : Type ?u.9429) (μ : M → N → N) [inst : PartialOrder N]
    [inst_1 : CovariantClass M N μ fun x x_1 => x < x_1], CovariantClass M N μ fun x x_1 => x ≤ x_1
y : α
hya : y ∈ Iic a
z : α
hzb : z ∈ Iio b
⊢ (fun x x_1 => x * x_1) y z ∈ Iio (a * b)
state_after: no goals
tactic: exact mul_lt_mul_of_le_of_lt hya hzb
Theorem: collinear_triple_of_mem_affineSpan_pair
File: Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ p₃ p₄ p₅ : P
h₁ : p₁ ∈ affineSpan k {p₄, p₅}
h₂ : p₂ ∈ affineSpan k {p₄, p₅}
h₃ : p₃ ∈ affineSpan k {p₄, p₅}
⊢ Collinear k {p₁, p₂, p₃}
state_after: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ p₃ p₄ p₅ : P
h₁ : p₁ ∈ affineSpan k {p₄, p₅}
h₂ : p₂ ∈ affineSpan k {p₄, p₅}
h₃ : p₃ ∈ affineSpan k {p₄, p₅}
⊢ {p₁, p₂, p₃} ⊆ {p₁, p₂, p₃, p₄}
tactic: refine (collinear_insert_insert_insert_left_of_mem_affineSpan_pair h₁ h₂ h₃).subset ?_
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ p₃ p₄ p₅ : P
h₁ : p₁ ∈ affineSpan k {p₄, p₅}
h₂ : p₂ ∈ affineSpan k {p₄, p₅}
h₃ : p₃ ∈ affineSpan k {p₄, p₅}
⊢ {p₁, p₂, p₃} ⊆ {p₁, p₂, p₃, p₄}
state_after: no goals
tactic: simp [Set.insert_subset_insert]
Theorem: CategoryTheory.isoSheafify_inv
File: Mathlib/CategoryTheory/Sites/Sheafification.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
J : GrothendieckTopology C
A : Type u₂
inst✝² : Category.{v₂, u₂} A
D : Type u_1
inst✝¹ : Category.{u_2, u_1} D
inst✝ : HasWeakSheafify J D
P : Cᵒᵖ ⥤ D
hP : Presheaf.IsSheaf J P
⊢ (isoSheafify J hP).inv = sheafifyLift J (𝟙 P) hP
state_after: case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
J : GrothendieckTopology C
A : Type u₂
inst✝² : Category.{v₂, u₂} A
D : Type u_1
inst✝¹ : Category.{u_2, u_1} D
inst✝ : HasWeakSheafify J D
P : Cᵒᵖ ⥤ D
hP : Presheaf.IsSheaf J P
⊢ toSheafify J P ≫ (isoSheafify J hP).inv = 𝟙 P
tactic: apply sheafifyLift_unique
state_before: case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
J : GrothendieckTopology C
A : Type u₂
inst✝² : Category.{v₂, u₂} A
D : Type u_1
inst✝¹ : Category.{u_2, u_1} D
inst✝ : HasWeakSheafify J D
P : Cᵒᵖ ⥤ D
hP : Presheaf.IsSheaf J P
⊢ toSheafify J P ≫ (isoSheafify J hP).inv = 𝟙 P
state_after: no goals
tactic: simp [Iso.comp_inv_eq]