tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.Measure.haar.prehaar_mem_haarProduct
File: Mathlib/MeasureTheory/Measure/Haar/Basic.lean

tactic: rintro ⟨K, hK⟩ _
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
hU : Set.Nonempty (interior U)
⊢ prehaar (↑K₀) U ∈ haarProduct ↑K₀

tactic: rw [mem_Icc]
state_before: case mk
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
hU : Set.Nonempty (interior U)
K : Set G
hK : IsCompact K
a✝ : { carrier := K, isCompact' := hK } ∈ univ
⊢ prehaar (↑K₀) U { carrier := K, isCompact' := hK } ∈
    (fun K => Icc 0 ↑(index ↑K ↑K₀)) { carrier := K, isCompact' := hK }

tactic: exact ⟨prehaar_nonneg K₀ _, prehaar_le_index K₀ _ hU⟩
state_before: case mk
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
hU : Set.Nonempty (interior U)
K : Set G
hK : IsCompact K
a✝ : { carrier := K, isCompact' := hK } ∈ univ
⊢ 0 ≤ prehaar (↑K₀) U { carrier := K, isCompact' := hK } ∧
    prehaar (↑K₀) U { carrier := K, isCompact' := hK } ≤ ↑(index ↑{ carrier := K, isCompact' := hK } ↑K₀)
Theorem: intervalIntegral.integral_sub
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: simpa only [sub_eq_add_neg] using (integral_add hf hg.neg).trans (congr_arg _ integral_neg)
state_before: ι : Type ?u.12882374
𝕜 : Type ?u.12882377
E : Type u_1
F : Type ?u.12882383
A : Type ?u.12882386
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b : ℝ
f g : ℝ → E
μ : MeasureTheory.Measure ℝ
hf : IntervalIntegrable f μ a b
hg : IntervalIntegrable g μ a b
⊢ (∫ (x : ℝ) in a..b, f x - g x ∂μ) = (∫ (x : ℝ) in a..b, f x ∂μ) - ∫ (x : ℝ) in a..b, g x ∂μ
Theorem: Polynomial.induction_on'
File: Mathlib/Data/Polynomial/Induction.lean

tactic: rw [C_mul_X_pow_eq_monomial]
state_before: R : Type u
S : Type v
T : Type w
ι : Type x
k : Type y
A : Type z
a✝ b : R
m n✝ : ℕ
inst✝ : Semiring R
p✝ q r : R[X]
M : R[X] → Prop
p : R[X]
h_add : ∀ (p q : R[X]), M p → M q → M (p + q)
h_monomial : ∀ (n : ℕ) (a : R), M (↑(monomial n) a)
n : ℕ
a : R
_h : M (↑C a * X ^ n)
⊢ M (↑C a * X ^ (n + 1))

tactic: exact h_monomial _ _
state_before: R : Type u
S : Type v
T : Type w
ι : Type x
k : Type y
A : Type z
a✝ b : R
m n✝ : ℕ
inst✝ : Semiring R
p✝ q r : R[X]
M : R[X] → Prop
p : R[X]
h_add : ∀ (p q : R[X]), M p → M q → M (p + q)
h_monomial : ∀ (n : ℕ) (a : R), M (↑(monomial n) a)
n : ℕ
a : R
_h : M (↑C a * X ^ n)
⊢ M (↑(monomial (n + 1)) a)
Theorem: Nat.not_odd_iff
File: Mathlib/Data/Nat/Parity.lean

tactic: rw [odd_iff, mod_two_ne_one]
state_before: m n : ℕ
⊢ ¬Odd n ↔ n % 2 = 0
Theorem: Real.pi_gt_31415
File: Mathlib/Data/Real/Pi/Bounds.lean

tactic: pi_lower_bound
      [11482 / 8119, 5401 / 2923, 2348 / 1197, 11367 / 5711, 25705 / 12868, 23235 / 11621]
state_before: ⊢ 3.1415 < π
Theorem: TensorProduct.LieModule.lie_tmul_right
File: Mathlib/Algebra/Lie/TensorProduct.lean

tactic: simp only [hasBracketAux, LinearMap.rTensor_tmul, toEndomorphism_apply_apply,
  LinearMap.add_apply, LinearMap.lTensor_tmul]
state_before: R : Type u
inst✝¹⁸ : CommRing R
L : Type v
M : Type w
N : Type w₁
P : Type w₂
Q : Type w₃
inst✝¹⁷ : LieRing L
inst✝¹⁶ : LieAlgebra R L
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
inst✝¹¹ : AddCommGroup N
inst✝¹⁰ : Module R N
inst✝⁹ : LieRingModule L N
inst✝⁸ : LieModule R L N
inst✝⁷ : AddCommGroup P
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L P
inst✝⁴ : LieModule R L P
inst✝³ : AddCommGroup Q
inst✝² : Module R Q
inst✝¹ : LieRingModule L Q
inst✝ : LieModule R L Q
x : L
m : M
n : N
⊢ ↑(hasBracketAux x) (m ⊗ₜ[R] n) = ⁅x, m⁆ ⊗ₜ[R] n + m ⊗ₜ[R] ⁅x, n⁆
Theorem: List.rotate_length_mul
File: Mathlib/Data/List/Rotate.lean

tactic: rw [rotate_eq_rotate', rotate'_length_mul]
state_before: α : Type u
l : List α
n : ℕ
⊢ rotate l (length l * n) = l
Theorem: Setoid.sSup_eq_eqvGen
File: Mathlib/Data/Setoid/Basic.lean

tactic: rw [eqvGen_eq]
state_before: α : Type u_1
β : Type ?u.8031
S : Set (Setoid α)
⊢ sSup S = EqvGen.Setoid fun x y => ∃ r, r ∈ S ∧ Rel r x y

tactic: apply congr_arg sInf
state_before: α : Type u_1
β : Type ?u.8031
S : Set (Setoid α)
⊢ sSup S = sInf {s | ∀ ⦃x y : α⦄, (∃ r, r ∈ S ∧ Rel r x y) → Rel s x y}

tactic: simp only [upperBounds, le_def, and_imp, exists_imp]
state_before: α : Type u_1
β : Type ?u.8031
S : Set (Setoid α)
⊢ upperBounds S = {s | ∀ ⦃x y : α⦄, (∃ r, r ∈ S ∧ Rel r x y) → Rel s x y}

tactic: ext
state_before: α : Type u_1
β : Type ?u.8031
S : Set (Setoid α)
⊢ {x | ∀ ⦃a : Setoid α⦄, a ∈ S → ∀ {x_1 y : α}, Rel a x_1 y → Rel x x_1 y} =
    {s | ∀ ⦃x y : α⦄ (x_1 : Setoid α), x_1 ∈ S → Rel x_1 x y → Rel s x y}

tactic: exact ⟨fun H x y r hr => H hr, fun H r hr x y => H r hr⟩
state_before: case h
α : Type u_1
β : Type ?u.8031
S : Set (Setoid α)
x✝ : Setoid α
⊢ x✝ ∈ {x | ∀ ⦃a : Setoid α⦄, a ∈ S → ∀ {x_1 y : α}, Rel a x_1 y → Rel x x_1 y} ↔
    x✝ ∈ {s | ∀ ⦃x y : α⦄ (x_1 : Setoid α), x_1 ∈ S → Rel x_1 x y → Rel s x y}
Theorem: pow_sub_mul_pow
File: Mathlib/Algebra/GroupPower/Basic.lean

tactic: rw [← pow_add, Nat.sub_add_cancel h]
state_before: α : Type ?u.26055
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝¹ : Monoid M
inst✝ : AddMonoid A
a : M
m n : ℕ
h : m ≤ n
⊢ a ^ (n - m) * a ^ m = a ^ n
Theorem: Nat.mod_two_ne_one
File: Mathlib/Data/Nat/Parity.lean

tactic: cases' mod_two_eq_zero_or_one n with h h <;> simp [h]
state_before: m n : ℕ
⊢ ¬n % 2 = 1 ↔ n % 2 = 0
Theorem: Dfinsupp.eq_mk_support
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: change f = mk f.support fun i => f i.1
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
f : Π₀ (i : ι), β i
⊢ f = mk (support f) fun i => ↑f ↑i

tactic: ext i
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
f : Π₀ (i : ι), β i
⊢ f = mk (support f) fun i => ↑f ↑i

tactic: by_cases h : f i ≠ 0 <;> [skip; rw [not_not] at h] <;> simp [h]
state_before: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
f : Π₀ (i : ι), β i
i : ι
⊢ ↑f i = ↑(mk (support f) fun i => ↑f ↑i) i
Theorem: SimpleGraph.transpose_adjMatrix
File: Mathlib/Combinatorics/SimpleGraph/AdjMatrix.lean

tactic: ext
state_before: V : Type u_2
α : Type u_1
β : Type ?u.27033
G : SimpleGraph V
inst✝² : DecidableRel G.Adj
inst✝¹ : Zero α
inst✝ : One α
⊢ (adjMatrix α G)ᵀ = adjMatrix α G

tactic: simp [adj_comm]
state_before: case a.h
V : Type u_2
α : Type u_1
β : Type ?u.27033
G : SimpleGraph V
inst✝² : DecidableRel G.Adj
inst✝¹ : Zero α
inst✝ : One α
i✝ x✝ : V
⊢ (adjMatrix α G)ᵀ i✝ x✝ = adjMatrix α G i✝ x✝
Theorem: MeasureTheory.SignedMeasure.singularPart_smul
File: Mathlib/MeasureTheory/Decomposition/Lebesgue.lean

tactic: by_cases hr : 0 ≤ r
state_before: α : Type u_1
β : Type ?u.630886
m : MeasurableSpace α
μ✝ ν : Measure α
s✝ t s : SignedMeasure α
μ : Measure α
r : ℝ
⊢ singularPart (r • s) μ = r • singularPart s μ

tactic: lift r to ℝ≥0 using hr
state_before: case pos
α : Type u_1
β : Type ?u.630886
m : MeasurableSpace α
μ✝ ν : Measure α
s✝ t s : SignedMeasure α
μ : Measure α
r : ℝ
hr : 0 ≤ r
⊢ singularPart (r • s) μ = r • singularPart s μ

tactic: exact singularPart_smul_nnreal s μ r
state_before: case pos.intro
α : Type u_1
β : Type ?u.630886
m : MeasurableSpace α
μ✝ ν : Measure α
s✝ t s : SignedMeasure α
μ : Measure α
r : ℝ≥0
⊢ singularPart (↑r • s) μ = ↑r • singularPart s μ

tactic: rw [singularPart, singularPart]
state_before: case neg
α : Type u_1
β : Type ?u.630886
m : MeasurableSpace α
μ✝ ν : Measure α
s✝ t s : SignedMeasure α
μ : Measure α
r : ℝ
hr : ¬0 ≤ r
⊢ singularPart (r • s) μ = r • singularPart s μ

tactic: rw [toSignedMeasure_smul, toSignedMeasure_smul, ← neg_sub, ← smul_sub]
state_before: case neg
α : Type u_1
β : Type ?u.630886
m : MeasurableSpace α
μ✝ ν : Measure α
s✝ t s : SignedMeasure α
μ : Measure α
r : ℝ
hr : ¬0 ≤ r
⊢ toSignedMeasure (Real.toNNReal (-r) • Measure.singularPart (toJordanDecomposition s).negPart μ) -
      toSignedMeasure (Real.toNNReal (-r) • Measure.singularPart (toJordanDecomposition s).posPart μ) =
    r •
      (toSignedMeasure (Measure.singularPart (toJordanDecomposition s).posPart μ) -
        toSignedMeasure (Measure.singularPart (toJordanDecomposition s).negPart μ))

tactic: change -(((-r).toNNReal : ℝ) • (_ : SignedMeasure α)) = _
state_before: case neg
α : Type u_1
β : Type ?u.630886
m : MeasurableSpace α
μ✝ ν : Measure α
s✝ t s : SignedMeasure α
μ : Measure α
r : ℝ
hr : ¬0 ≤ r
⊢ -(Real.toNNReal (-r) •
        (toSignedMeasure (Measure.singularPart (toJordanDecomposition s).posPart μ) -
          toSignedMeasure (Measure.singularPart (toJordanDecomposition s).negPart μ))) =
    r •
      (toSignedMeasure (Measure.singularPart (toJordanDecomposition s).posPart μ) -
        toSignedMeasure (Measure.singularPart (toJordanDecomposition s).negPart μ))

tactic: rw [← neg_smul, Real.coe_toNNReal _ (le_of_lt (neg_pos.mpr (not_le.1 hr))), neg_neg]
state_before: case neg
α : Type u_1
β : Type ?u.630886
m : MeasurableSpace α
μ✝ ν : Measure α
s✝ t s : SignedMeasure α
μ : Measure α
r : ℝ
hr : ¬0 ≤ r
⊢ -(↑(Real.toNNReal (-r)) •
        (toSignedMeasure (Measure.singularPart (toJordanDecomposition s).posPart μ) -
          toSignedMeasure (Measure.singularPart (toJordanDecomposition s).negPart μ))) =
    r •
      (toSignedMeasure (Measure.singularPart (toJordanDecomposition s).posPart μ) -
        toSignedMeasure (Measure.singularPart (toJordanDecomposition s).negPart μ))
Theorem: Subgroup.normalizer_eq_top
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: rwa [h.mem_comm_iff, inv_mul_cancel_left] at hb
state_before: G : Type u_1
G' : Type ?u.384241
inst✝² : Group G
inst✝¹ : Group G'
A : Type ?u.384250
inst✝ : AddGroup A
H K : Subgroup G
h : Normal H
a : G
_ha : a ∈ ⊤
b : G
hb : a * b * a⁻¹ ∈ H
⊢ b ∈ H
Theorem: eq_of_hammingDist_eq_zero
File: Mathlib/InformationTheory/Hamming.lean

tactic: simp_rw [hammingDist, card_eq_zero, filter_eq_empty_iff, Classical.not_not, funext_iff, mem_univ,
  forall_true_left, imp_self]
state_before: α : Type ?u.7802
ι : Type u_1
β : ι → Type u_2
inst✝² : Fintype ι
inst✝¹ : (i : ι) → DecidableEq (β i)
γ : ι → Type ?u.7834
inst✝ : (i : ι) → DecidableEq (γ i)
x y : (i : ι) → β i
⊢ hammingDist x y = 0 → x = y
Theorem: Fin.snoc_castSucc
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: simp only [snoc, coe_castSucc, is_lt, cast_eq, dite_true]
state_before: m n : ℕ
α : Fin (n + 1) → Type u
x : α (last n)
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α (↑castSucc i)
i : Fin n
y : α (↑castSucc i)
z : α (last n)
⊢ snoc p x (↑castSucc i) = p i

tactic: convert cast_eq rfl (p i)
state_before: m n : ℕ
α : Fin (n + 1) → Type u
x : α (last n)
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α (↑castSucc i)
i : Fin n
y : α (↑castSucc i)
z : α (last n)
⊢ p (castLT (↑castSucc i) (_ : ↑i < n)) = p i
Theorem: Finset.image_add_right_Ico
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: rw [← map_add_right_Ico, map_eq_image]
state_before: ι : Type ?u.247963
α : Type u_1
inst✝³ : OrderedCancelAddCommMonoid α
inst✝² : ExistsAddOfLE α
inst✝¹ : LocallyFiniteOrder α
inst✝ : DecidableEq α
a b c : α
⊢ image (fun x => x + c) (Ico a b) = Ico (a + c) (b + c)

tactic: rfl
state_before: ι : Type ?u.247963
α : Type u_1
inst✝³ : OrderedCancelAddCommMonoid α
inst✝² : ExistsAddOfLE α
inst✝¹ : LocallyFiniteOrder α
inst✝ : DecidableEq α
a b c : α
⊢ image (fun x => x + c) (Ico a b) = image (↑(addRightEmbedding c)) (Ico a b)
Theorem: Sigma.lex_iff
File: Mathlib/Data/Sigma/Lex.lean

tactic: constructor
state_before: ι : Type u_1
α : ι → Type u_2
r r₁ r₂ : ι → ι → Prop
s s₁ s₂ : (i : ι) → α i → α i → Prop
a b : (i : ι) × α i
⊢ Lex r s a b ↔ r a.fst b.fst ∨ ∃ h, s b.fst (h ▸ a.snd) b.snd

tactic: rintro (⟨a, b, hij⟩ | ⟨a, b, hab⟩)
state_before: case mp
ι : Type u_1
α : ι → Type u_2
r r₁ r₂ : ι → ι → Prop
s s₁ s₂ : (i : ι) → α i → α i → Prop
a b : (i : ι) × α i
⊢ Lex r s a b → r a.fst b.fst ∨ ∃ h, s b.fst (h ▸ a.snd) b.snd

tactic: exact Or.inl hij
state_before: case mp.left
ι : Type u_1
α : ι → Type u_2
r r₁ r₂ : ι → ι → Prop
s s₁ s₂ : (i : ι) → α i → α i → Prop
i✝ j✝ : ι
a : α i✝
b : α j✝
hij : r i✝ j✝
⊢ r { fst := i✝, snd := a }.fst { fst := j✝, snd := b }.fst ∨
    ∃ h, s { fst := j✝, snd := b }.fst (h ▸ { fst := i✝, snd := a }.snd) { fst := j✝, snd := b }.snd

tactic: exact Or.inr ⟨rfl, hab⟩
state_before: case mp.right
ι : Type u_1
α : ι → Type u_2
r r₁ r₂ : ι → ι → Prop
s s₁ s₂ : (i : ι) → α i → α i → Prop
i✝ : ι
a b : α i✝
hab : s i✝ a b
⊢ r { fst := i✝, snd := a }.fst { fst := i✝, snd := b }.fst ∨
    ∃ h, s { fst := i✝, snd := b }.fst (h ▸ { fst := i✝, snd := a }.snd) { fst := i✝, snd := b }.snd

tactic: obtain ⟨i, a⟩ := a
state_before: case mpr
ι : Type u_1
α : ι → Type u_2
r r₁ r₂ : ι → ι → Prop
s s₁ s₂ : (i : ι) → α i → α i → Prop
a b : (i : ι) × α i
⊢ (r a.fst b.fst ∨ ∃ h, s b.fst (h ▸ a.snd) b.snd) → Lex r s a b

tactic: obtain ⟨j, b⟩ := b
state_before: case mpr.mk
ι : Type u_1
α : ι → Type u_2
r r₁ r₂ : ι → ι → Prop
s s₁ s₂ : (i : ι) → α i → α i → Prop
b : (i : ι) × α i
i : ι
a : α i
⊢ (r { fst := i, snd := a }.fst b.fst ∨ ∃ h, s b.fst (h ▸ { fst := i, snd := a }.snd) b.snd) →
    Lex r s { fst := i, snd := a } b

tactic: dsimp only
state_before: case mpr.mk.mk
ι : Type u_1
α : ι → Type u_2
r r₁ r₂ : ι → ι → Prop
s s₁ s₂ : (i : ι) → α i → α i → Prop
i : ι
a : α i
j : ι
b : α j
⊢ (r { fst := i, snd := a }.fst { fst := j, snd := b }.fst ∨
      ∃ h, s { fst := j, snd := b }.fst (h ▸ { fst := i, snd := a }.snd) { fst := j, snd := b }.snd) →
    Lex r s { fst := i, snd := a } { fst := j, snd := b }

tactic: rintro (h | ⟨rfl, h⟩)
state_before: case mpr.mk.mk
ι : Type u_1
α : ι → Type u_2
r r₁ r₂ : ι → ι → Prop
s s₁ s₂ : (i : ι) → α i → α i → Prop
i : ι
a : α i
j : ι
b : α j
⊢ (r i j ∨ ∃ h, s j (h ▸ a) b) → Lex r s { fst := i, snd := a } { fst := j, snd := b }

tactic: exact Lex.left _ _ h
state_before: case mpr.mk.mk.inl
ι : Type u_1
α : ι → Type u_2
r r₁ r₂ : ι → ι → Prop
s s₁ s₂ : (i : ι) → α i → α i → Prop
i : ι
a : α i
j : ι
b : α j
h : r i j
⊢ Lex r s { fst := i, snd := a } { fst := j, snd := b }

tactic: exact Lex.right _ _ h
state_before: case mpr.mk.mk.inr.intro
ι : Type u_1
α : ι → Type u_2
r r₁ r₂ : ι → ι → Prop
s s₁ s₂ : (i : ι) → α i → α i → Prop
i : ι
a b : α i
h : s i ((_ : i = i) ▸ a) b
⊢ Lex r s { fst := i, snd := a } { fst := i, snd := b }
Theorem: card_pow_eq_one_eq_orderOf_aux
File: Mathlib/GroupTheory/SpecificGroups/Cyclic.lean

tactic: let ⟨i, hi⟩ := b.2
state_before: α : Type u
a✝ : α
inst✝² : Group α
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hn : ∀ (n : ℕ), 0 < n → card (filter (fun a => a ^ n = 1) univ) ≤ n
a : α
b : { x // x ∈ zpowers a }
⊢ ↑b ^ orderOf a = 1

tactic: rw [← hi, ← zpow_ofNat, ← zpow_mul, mul_comm, zpow_mul, zpow_ofNat,
  pow_orderOf_eq_one, one_zpow]
state_before: α : Type u
a✝ : α
inst✝² : Group α
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hn : ∀ (n : ℕ), 0 < n → card (filter (fun a => a ^ n = 1) univ) ≤ n
a : α
b : { x // x ∈ zpowers a }
i : ℤ
hi : (fun x x_1 => x ^ x_1) a i = ↑b
⊢ ↑b ^ orderOf a = 1
Theorem: DirectSum.IsInternal.addSubmonoid_iSup_eq_top
File: Mathlib/Algebra/DirectSum/Basic.lean

tactic: rw [AddSubmonoid.iSup_eq_mrange_dfinsupp_sumAddHom, AddMonoidHom.mrange_top_iff_surjective]
state_before: ι : Type v
dec_ι : DecidableEq ι
β : ι → Type w
inst✝³ : (i : ι) → AddCommMonoid (β i)
γ : Type u₁
inst✝² : AddCommMonoid γ
M : Type u_1
inst✝¹ : DecidableEq ι
inst✝ : AddCommMonoid M
A : ι → AddSubmonoid M
h : IsInternal A
⊢ iSup A = ⊤

tactic: exact Function.Bijective.surjective h
state_before: ι : Type v
dec_ι : DecidableEq ι
β : ι → Type w
inst✝³ : (i : ι) → AddCommMonoid (β i)
γ : Type u₁
inst✝² : AddCommMonoid γ
M : Type u_1
inst✝¹ : DecidableEq ι
inst✝ : AddCommMonoid M
A : ι → AddSubmonoid M
h : IsInternal A
⊢ Function.Surjective ↑(Dfinsupp.sumAddHom fun i => AddSubmonoid.subtype (A i))
Theorem: List.get?_range'
File: Std/Data/List/Lemmas.lean

tactic: simp [Nat.mul_succ, Nat.add_assoc, Nat.add_comm]
state_before: s step m n : Nat
h : m + 1 < n + 1
⊢ some (s + step + step * m) = some (s + step * (m + 1))
Theorem: Multiset.prod_induction_nonempty
File: Mathlib/Algebra/BigOperators/Multiset/Basic.lean

tactic: induction' s using Multiset.induction_on with a s hsa
state_before: ι : Type ?u.82609
α : Type u_1
β : Type ?u.82615
γ : Type ?u.82618
inst✝ : CommMonoid α
s t : Multiset α
a : α
m : Multiset ι
f g : ι → α
p : α → Prop
p_mul : ∀ (a b : α), p a → p b → p (a * b)
hs : s ≠ ∅
p_s : ∀ (a : α), a ∈ s → p a
⊢ p (prod s)

tactic: rw [prod_cons]
state_before: case cons
ι : Type ?u.82609
α : Type u_1
β : Type ?u.82615
γ : Type ?u.82618
inst✝ : CommMonoid α
s✝ t : Multiset α
a✝ : α
m : Multiset ι
f g : ι → α
p : α → Prop
p_mul : ∀ (a b : α), p a → p b → p (a * b)
hs✝ : s✝ ≠ ∅
p_s✝ : ∀ (a : α), a ∈ s✝ → p a
a : α
s : Multiset α
hsa : s ≠ ∅ → (∀ (a : α), a ∈ s → p a) → p (prod s)
hs : a ::ₘ s ≠ ∅
p_s : ∀ (a_1 : α), a_1 ∈ a ::ₘ s → p a_1
⊢ p (prod (a ::ₘ s))

tactic: by_cases hs_empty : s = ∅
state_before: case cons
ι : Type ?u.82609
α : Type u_1
β : Type ?u.82615
γ : Type ?u.82618
inst✝ : CommMonoid α
s✝ t : Multiset α
a✝ : α
m : Multiset ι
f g : ι → α
p : α → Prop
p_mul : ∀ (a b : α), p a → p b → p (a * b)
hs✝ : s✝ ≠ ∅
p_s✝ : ∀ (a : α), a ∈ s✝ → p a
a : α
s : Multiset α
hsa : s ≠ ∅ → (∀ (a : α), a ∈ s → p a) → p (prod s)
hs : a ::ₘ s ≠ ∅
p_s : ∀ (a_1 : α), a_1 ∈ a ::ₘ s → p a_1
⊢ p (a * prod s)

tactic: have hps : ∀ x, x ∈ s → p x := fun x hxs => p_s x (mem_cons_of_mem hxs)
state_before: case neg
ι : Type ?u.82609
α : Type u_1
β : Type ?u.82615
γ : Type ?u.82618
inst✝ : CommMonoid α
s✝ t : Multiset α
a✝ : α
m : Multiset ι
f g : ι → α
p : α → Prop
p_mul : ∀ (a b : α), p a → p b → p (a * b)
hs✝ : s✝ ≠ ∅
p_s✝ : ∀ (a : α), a ∈ s✝ → p a
a : α
s : Multiset α
hsa : s ≠ ∅ → (∀ (a : α), a ∈ s → p a) → p (prod s)
hs : a ::ₘ s ≠ ∅
p_s : ∀ (a_1 : α), a_1 ∈ a ::ₘ s → p a_1
hs_empty : ¬s = ∅
⊢ p (a * prod s)

tactic: exact p_mul a s.prod (p_s a (mem_cons_self a s)) (hsa hs_empty hps)
state_before: case neg
ι : Type ?u.82609
α : Type u_1
β : Type ?u.82615
γ : Type ?u.82618
inst✝ : CommMonoid α
s✝ t : Multiset α
a✝ : α
m : Multiset ι
f g : ι → α
p : α → Prop
p_mul : ∀ (a b : α), p a → p b → p (a * b)
hs✝ : s✝ ≠ ∅
p_s✝ : ∀ (a : α), a ∈ s✝ → p a
a : α
s : Multiset α
hsa : s ≠ ∅ → (∀ (a : α), a ∈ s → p a) → p (prod s)
hs : a ::ₘ s ≠ ∅
p_s : ∀ (a_1 : α), a_1 ∈ a ::ₘ s → p a_1
hs_empty : ¬s = ∅
hps : ∀ (x : α), x ∈ s → p x
⊢ p (a * prod s)

tactic: simp at hs
state_before: case empty
ι : Type ?u.82609
α : Type u_1
β : Type ?u.82615
γ : Type ?u.82618
inst✝ : CommMonoid α
s t : Multiset α
a : α
m : Multiset ι
f g : ι → α
p : α → Prop
p_mul : ∀ (a b : α), p a → p b → p (a * b)
hs✝ : s ≠ ∅
p_s✝ : ∀ (a : α), a ∈ s → p a
hs : 0 ≠ ∅
p_s : ∀ (a : α), a ∈ 0 → p a
⊢ p (prod 0)

tactic: simp [hs_empty, p_s a]
state_before: case pos
ι : Type ?u.82609
α : Type u_1
β : Type ?u.82615
γ : Type ?u.82618
inst✝ : CommMonoid α
s✝ t : Multiset α
a✝ : α
m : Multiset ι
f g : ι → α
p : α → Prop
p_mul : ∀ (a b : α), p a → p b → p (a * b)
hs✝ : s✝ ≠ ∅
p_s✝ : ∀ (a : α), a ∈ s✝ → p a
a : α
s : Multiset α
hsa : s ≠ ∅ → (∀ (a : α), a ∈ s → p a) → p (prod s)
hs : a ::ₘ s ≠ ∅
p_s : ∀ (a_1 : α), a_1 ∈ a ::ₘ s → p a_1
hs_empty : s = ∅
⊢ p (a * prod s)
Theorem: Real.one_le_exp
File: Mathlib/Data/Complex/Exponential.lean

tactic: linarith [add_one_le_exp_of_nonneg hx]
state_before: x✝ y x : ℝ
hx : 0 ≤ x
⊢ 1 ≤ exp x
Theorem: Algebra.iInf_toSubmodule
File: Mathlib/Algebra/Algebra/Subalgebra/Basic.lean

tactic: simp
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
ι : Sort u_1
S : ι → Subalgebra R A
⊢ ↑(↑toSubmodule (⨅ (i : ι), S i)) = ↑(⨅ (i : ι), ↑toSubmodule (S i))
Theorem: Subsemigroup.coe_sSup_of_directed_on
File: Mathlib/GroupTheory/Subsemigroup/Membership.lean

tactic: simp [mem_sSup_of_directed_on hS]
state_before: ι : Sort ?u.4507
M : Type u_1
A : Type ?u.4513
B : Type ?u.4516
inst✝ : Mul M
S : Set (Subsemigroup M)
hS : DirectedOn (fun x x_1 => x ≤ x_1) S
x : M
⊢ x ∈ ↑(sSup S) ↔ x ∈ ⋃ (s : Subsemigroup M) (_ : s ∈ S), ↑s
Theorem: Polynomial.reverse_leadingCoeff
File: Mathlib/Data/Polynomial/Reverse.lean

tactic: rw [leadingCoeff, reverse_natDegree, ← revAt_le f.natTrailingDegree_le_natDegree,
  coeff_reverse, revAt_invol, trailingCoeff]
state_before: R : Type u_1
inst✝ : Semiring R
f✝ f : R[X]
⊢ leadingCoeff (reverse f) = trailingCoeff f
Theorem: PNat.factorMultiset_ofPrime
File: Mathlib/Data/PNat/Factors.lean

tactic: apply factorMultisetEquiv.symm.injective
state_before: p : Nat.Primes
⊢ factorMultiset ↑p = PrimeMultiset.ofPrime p

tactic: change (p : ℕ+).factorMultiset.prod = (PrimeMultiset.ofPrime p).prod
state_before: case a
p : Nat.Primes
⊢ ↑factorMultisetEquiv.symm (factorMultiset ↑p) = ↑factorMultisetEquiv.symm (PrimeMultiset.ofPrime p)

tactic: rw [(p : ℕ+).prod_factorMultiset, PrimeMultiset.prod_ofPrime]
state_before: case a
p : Nat.Primes
⊢ PrimeMultiset.prod (factorMultiset ↑p) = PrimeMultiset.prod (PrimeMultiset.ofPrime p)
Theorem: Int.dvd_of_mul_dvd_mul_left
File: Mathlib/Data/Int/GCD.lean

tactic: rw [mul_assoc] at H1
state_before: i j k : ℤ
k_non_zero : k ≠ 0
H : k * i ∣ k * j
l : ℤ
H1 : k * j = k * i * l
⊢ i ∣ j

tactic: exact ⟨_, mul_left_cancel₀ k_non_zero H1⟩
state_before: i j k : ℤ
k_non_zero : k ≠ 0
H : k * i ∣ k * j
l : ℤ
H1 : k * j = k * (i * l)
⊢ i ∣ j
Theorem: Submonoid.multiset_prod_mem
File: Mathlib/GroupTheory/Submonoid/Membership.lean

tactic: lift m to Multiset S using hm
state_before: M✝ : Type ?u.27146
A : Type ?u.27149
B : Type ?u.27152
inst✝³ : Monoid M✝
inst✝² : SetLike B M✝
inst✝¹ : SubmonoidClass B M✝
S✝ : B
s : Submonoid M✝
M : Type u_1
inst✝ : CommMonoid M
S : Submonoid M
m : Multiset M
hm : ∀ (a : M), a ∈ m → a ∈ S
⊢ Multiset.prod m ∈ S

tactic: rw [← coe_multiset_prod]
state_before: case intro
M✝ : Type ?u.27146
A : Type ?u.27149
B : Type ?u.27152
inst✝³ : Monoid M✝
inst✝² : SetLike B M✝
inst✝¹ : SubmonoidClass B M✝
S✝ : B
s : Submonoid M✝
M : Type u_1
inst✝ : CommMonoid M
S : Submonoid M
m : Multiset { x // x ∈ S }
⊢ Multiset.prod (Multiset.map Subtype.val m) ∈ S

tactic: exact m.prod.coe_prop
state_before: case intro
M✝ : Type ?u.27146
A : Type ?u.27149
B : Type ?u.27152
inst✝³ : Monoid M✝
inst✝² : SetLike B M✝
inst✝¹ : SubmonoidClass B M✝
S✝ : B
s : Submonoid M✝
M : Type u_1
inst✝ : CommMonoid M
S : Submonoid M
m : Multiset { x // x ∈ S }
⊢ ↑(Multiset.prod m) ∈ S
Theorem: CategoryTheory.congrArg_cast_hom_right
File: Mathlib/CategoryTheory/EqToHom.lean

tactic: cases q
state_before: C : Type u₁
inst✝ : Category C
X Y Z : C
p : X ⟶ Y
q : Z = Y
⊢ cast (_ : (X ⟶ Y) = (X ⟶ Z)) p = p ≫ eqToHom (_ : Y = Z)

tactic: simp
state_before: case refl
C : Type u₁
inst✝ : Category C
X Y : C
p : X ⟶ Y
⊢ cast (_ : (X ⟶ Y) = (X ⟶ Y)) p = p ≫ eqToHom (_ : Y = Y)
Theorem: WithSeminorms.image_isVonNBounded_iff_seminorm_bounded
File: Mathlib/Analysis/LocallyConvex/WithSeminorms.lean

tactic: simp_rw [hp.isVonNBounded_iff_seminorm_bounded, Set.ball_image_iff]
state_before: 𝕜 : Type u_2
𝕜₂ : Type ?u.493266
𝕝 : Type ?u.493269
𝕝₂ : Type ?u.493272
E : Type u_3
F : Type ?u.493278
G : Type u_1
ι : Type u_4
ι' : Type ?u.493287
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : Nonempty ι
p : SeminormFamily 𝕜 E ι
inst✝ : TopologicalSpace E
f : G → E
s : Set G
hp : WithSeminorms p
⊢ Bornology.IsVonNBounded 𝕜 (f '' s) ↔ ∀ (i : ι), ∃ r, r > 0 ∧ ∀ (x : G), x ∈ s → ↑(p i) (f x) < r
Theorem: BoundedContinuousFunction.coe_npowRec
File: Mathlib/Topology/ContinuousFunction/Bounded.lean

tactic: rw [npowRec, pow_zero, coe_one]
state_before: F : Type ?u.1196548
α : Type u
β : Type v
γ : Type w
inst✝¹ : TopologicalSpace α
R : Type u_1
inst✝ : SeminormedRing R
f : α →ᵇ R
⊢ ↑(npowRec 0 f) = ↑f ^ 0

tactic: rw [npowRec, pow_succ, coe_mul, coe_npowRec f n]
state_before: F : Type ?u.1196548
α : Type u
β : Type v
γ : Type w
inst✝¹ : TopologicalSpace α
R : Type u_1
inst✝ : SeminormedRing R
f : α →ᵇ R
n : ℕ
⊢ ↑(npowRec (n + 1) f) = ↑f ^ (n + 1)