tasksource/leandojo huggingface dataset:
Theorem: measurable_from_prod_countable
File: Mathlib/MeasureTheory/MeasurableSpace.lean

tactic: have : f ⁻¹' s = ⋃ y, ((fun x => f (x, y)) ⁻¹' s) ×ˢ ({y} : Set β) := by
  ext1 ⟨x, y⟩
  simp [and_assoc, and_left_comm]
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.86341
δ' : Type ?u.86344
ι : Sort uι
s✝ t u : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝¹ : Countable β
inst✝ : MeasurableSingletonClass β
x✝ : MeasurableSpace γ
f : α × β → γ
hf : ∀ (y : β), Measurable fun x => f (x, y)
s : Set γ
hs : MeasurableSet s
⊢ MeasurableSet (f ⁻¹' s)

tactic: rw [this]
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.86341
δ' : Type ?u.86344
ι : Sort uι
s✝ t u : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝¹ : Countable β
inst✝ : MeasurableSingletonClass β
x✝ : MeasurableSpace γ
f : α × β → γ
hf : ∀ (y : β), Measurable fun x => f (x, y)
s : Set γ
hs : MeasurableSet s
this : f ⁻¹' s = ⋃ (y : β), ((fun x => f (x, y)) ⁻¹' s) ×ˢ {y}
⊢ MeasurableSet (f ⁻¹' s)

tactic: exact .iUnion fun y => (hf y hs).prod (.singleton y)
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.86341
δ' : Type ?u.86344
ι : Sort uι
s✝ t u : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝¹ : Countable β
inst✝ : MeasurableSingletonClass β
x✝ : MeasurableSpace γ
f : α × β → γ
hf : ∀ (y : β), Measurable fun x => f (x, y)
s : Set γ
hs : MeasurableSet s
this : f ⁻¹' s = ⋃ (y : β), ((fun x => f (x, y)) ⁻¹' s) ×ˢ {y}
⊢ MeasurableSet (⋃ (y : β), ((fun x => f (x, y)) ⁻¹' s) ×ˢ {y})

tactic: ext1 ⟨x, y⟩
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.86341
δ' : Type ?u.86344
ι : Sort uι
s✝ t u : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝¹ : Countable β
inst✝ : MeasurableSingletonClass β
x✝ : MeasurableSpace γ
f : α × β → γ
hf : ∀ (y : β), Measurable fun x => f (x, y)
s : Set γ
hs : MeasurableSet s
⊢ f ⁻¹' s = ⋃ (y : β), ((fun x => f (x, y)) ⁻¹' s) ×ˢ {y}

tactic: simp [and_assoc, and_left_comm]
state_before: case h.mk
α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.86341
δ' : Type ?u.86344
ι : Sort uι
s✝ t u : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝¹ : Countable β
inst✝ : MeasurableSingletonClass β
x✝ : MeasurableSpace γ
f : α × β → γ
hf : ∀ (y : β), Measurable fun x => f (x, y)
s : Set γ
hs : MeasurableSet s
x : α
y : β
⊢ (x, y) ∈ f ⁻¹' s ↔ (x, y) ∈ ⋃ (y : β), ((fun x => f (x, y)) ⁻¹' s) ×ˢ {y}
Theorem: MvPolynomial.vars_X
File: Mathlib/Data/MvPolynomial/Variables.lean

tactic: rw [X, vars_monomial (one_ne_zero' R), Finsupp.support_single_ne_zero _ (one_ne_zero' ℕ)]
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.151305
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p q : MvPolynomial σ R
inst✝ : Nontrivial R
⊢ vars (X n) = {n}
Theorem: exists_orderOf_eq_prime_pow_iff
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: rw [← hk, pow_orderOf_eq_one]
state_before: G : Type u
A : Type v
x y : G
a b : A
n m : ℕ
inst✝¹ : Monoid G
inst✝ : AddMonoid A
p : ℕ
hp : Fact (Nat.Prime p)
x✝ : ∃ k, orderOf x = p ^ k
k : ℕ
hk : orderOf x = p ^ k
⊢ x ^ p ^ k = 1

tactic: obtain ⟨k, _, hk⟩ := (Nat.dvd_prime_pow hp.elim).mp (orderOf_dvd_of_pow_eq_one hm)
state_before: G : Type u
A : Type v
x y : G
a b : A
n m : ℕ
inst✝¹ : Monoid G
inst✝ : AddMonoid A
p : ℕ
hp : Fact (Nat.Prime p)
x✝ : ∃ m, x ^ p ^ m = 1
w✝ : ℕ
hm : x ^ p ^ w✝ = 1
⊢ ∃ k, orderOf x = p ^ k

tactic: exact ⟨k, hk⟩
state_before: case intro.intro
G : Type u
A : Type v
x y : G
a b : A
n m : ℕ
inst✝¹ : Monoid G
inst✝ : AddMonoid A
p : ℕ
hp : Fact (Nat.Prime p)
x✝ : ∃ m, x ^ p ^ m = 1
w✝ : ℕ
hm : x ^ p ^ w✝ = 1
k : ℕ
left✝ : k ≤ w✝
hk : orderOf x = p ^ k
⊢ ∃ k, orderOf x = p ^ k
Theorem: TypeVec.lastFun_prod
File: Mathlib/Data/TypeVec.lean

tactic: ext i : 1
state_before: n : ℕ
α α' β β' : TypeVec (n + 1)
f : α ⟹ β
f' : α' ⟹ β'
⊢ lastFun (f ⊗' f') = Prod.map (lastFun f) (lastFun f')

tactic: induction i
state_before: case h
n : ℕ
α α' β β' : TypeVec (n + 1)
f : α ⟹ β
f' : α' ⟹ β'
i : last (α ⊗ α')
⊢ lastFun (f ⊗' f') i = Prod.map (lastFun f) (lastFun f') i

tactic: simp [lastFun, *]
state_before: case h.mk
n : ℕ
α α' β β' : TypeVec (n + 1)
f : α ⟹ β
f' : α' ⟹ β'
fst✝ : last α
snd✝ : last α'
⊢ lastFun (f ⊗' f') (fst✝, snd✝) = Prod.map (lastFun f) (lastFun f') (fst✝, snd✝)

tactic: rfl
state_before: case h.mk
n : ℕ
α α' β β' : TypeVec (n + 1)
f : α ⟹ β
f' : α' ⟹ β'
fst✝ : last α
snd✝ : last α'
⊢ (f ⊗' f') Fin2.fz (fst✝, snd✝) = Prod.map (f Fin2.fz) (f' Fin2.fz) (fst✝, snd✝)
Theorem: RatFunc.num_denom_add
File: Mathlib/FieldTheory/RatFunc.lean

tactic: conv_lhs => rw [← num_div_denom x, ← num_div_denom y]
state_before: K : Type u
inst✝ : Field K
x y : RatFunc K
⊢ x + y =
    ↑(algebraMap K[X] (RatFunc K)) (num x * denom y + denom x * num y) /
      ↑(algebraMap K[X] (RatFunc K)) (denom x * denom y)

tactic: rw [div_add_div, RingHom.map_mul, RingHom.map_add, RingHom.map_mul, RingHom.map_mul]
state_before: K : Type u
inst✝ : Field K
x y : RatFunc K
⊢ ↑(algebraMap K[X] (RatFunc K)) (num x) / ↑(algebraMap K[X] (RatFunc K)) (denom x) +
      ↑(algebraMap K[X] (RatFunc K)) (num y) / ↑(algebraMap K[X] (RatFunc K)) (denom y) =
    ↑(algebraMap K[X] (RatFunc K)) (num x * denom y + denom x * num y) /
      ↑(algebraMap K[X] (RatFunc K)) (denom x * denom y)

tactic: exact algebraMap_ne_zero (denom_ne_zero x)
state_before: case hb
K : Type u
inst✝ : Field K
x y : RatFunc K
⊢ ↑(algebraMap K[X] (RatFunc K)) (denom x) ≠ 0

tactic: exact algebraMap_ne_zero (denom_ne_zero y)
state_before: case hd
K : Type u
inst✝ : Field K
x y : RatFunc K
⊢ ↑(algebraMap K[X] (RatFunc K)) (denom y) ≠ 0
Theorem: RingHom.ker_isRadical_iff_reduced_of_surjective
File: Mathlib/RingTheory/Nilpotent.lean

tactic: simp_rw [isReduced_iff, hf.forall, IsNilpotent, ← map_pow, ← RingHom.mem_ker]
state_before: R S✝ : Type u
x y : R
S : Type u_1
F : Type u_2
inst✝² : CommSemiring R
inst✝¹ : CommRing S
inst✝ : RingHomClass F R S
f : F
hf : Function.Surjective ↑f
⊢ Ideal.IsRadical (ker f) ↔ IsReduced S

tactic: rfl
state_before: R S✝ : Type u
x y : R
S : Type u_1
F : Type u_2
inst✝² : CommSemiring R
inst✝¹ : CommRing S
inst✝ : RingHomClass F R S
f : F
hf : Function.Surjective ↑f
⊢ Ideal.IsRadical (ker f) ↔ ∀ (x : R), (∃ n, x ^ n ∈ ker f) → x ∈ ker f
Theorem: Bool.or_self
File: src/lean/Init/SimpLemmas.lean

tactic: cases b <;> rfl
state_before: b : Bool
⊢ (b || b) = b
Theorem: List.form_perm_zpow_apply_mem_imp_mem
File: Mathlib/GroupTheory/Perm/List.lean

tactic: by_cases h : (l.formPerm ^ n) x = x
state_before: α : Type u_1
β : Type ?u.825028
inst✝ : DecidableEq α
l✝ : List α
x✝ : α
l : List α
x : α
hx : x ∈ l
n : ℤ
⊢ ↑(formPerm l ^ n) x ∈ l

tactic: simpa [h] using hx
state_before: case pos
α : Type u_1
β : Type ?u.825028
inst✝ : DecidableEq α
l✝ : List α
x✝ : α
l : List α
x : α
hx : x ∈ l
n : ℤ
h : ↑(formPerm l ^ n) x = x
⊢ ↑(formPerm l ^ n) x ∈ l

tactic: have h : x ∈ { x | (l.formPerm ^ n) x ≠ x } := h
state_before: case neg
α : Type u_1
β : Type ?u.825028
inst✝ : DecidableEq α
l✝ : List α
x✝ : α
l : List α
x : α
hx : x ∈ l
n : ℤ
h : ¬↑(formPerm l ^ n) x = x
⊢ ↑(formPerm l ^ n) x ∈ l

tactic: rw [← set_support_apply_mem] at h
state_before: case neg
α : Type u_1
β : Type ?u.825028
inst✝ : DecidableEq α
l✝ : List α
x✝ : α
l : List α
x : α
hx : x ∈ l
n : ℤ
h✝ : ¬↑(formPerm l ^ n) x = x
h : x ∈ {x | ↑(formPerm l ^ n) x ≠ x}
⊢ ↑(formPerm l ^ n) x ∈ l

tactic: replace h := set_support_zpow_subset _ _ h
state_before: case neg
α : Type u_1
β : Type ?u.825028
inst✝ : DecidableEq α
l✝ : List α
x✝ : α
l : List α
x : α
hx : x ∈ l
n : ℤ
h✝ : ¬↑(formPerm l ^ n) x = x
h : ↑(formPerm l ^ n) x ∈ {x | ↑(formPerm l ^ n) x ≠ x}
⊢ ↑(formPerm l ^ n) x ∈ l

tactic: simpa using support_formPerm_le' _ h
state_before: case neg
α : Type u_1
β : Type ?u.825028
inst✝ : DecidableEq α
l✝ : List α
x✝ : α
l : List α
x : α
hx : x ∈ l
n : ℤ
h✝ : ¬↑(formPerm l ^ n) x = x
h : ↑(formPerm l ^ n) x ∈ {x_1 | ↑(formPerm l) x_1 ≠ x_1}
⊢ ↑(formPerm l ^ n) x ∈ l
Theorem: Functor.Comp.applicative_comp_id
File: Mathlib/Control/Applicative.lean

tactic: rw [id_map]
state_before: F✝ : Type u → Type w
G : Type v → Type u
inst✝⁴ : Applicative F✝
inst✝³ : Applicative G
inst✝² : LawfulApplicative F✝
inst✝¹ : LawfulApplicative G
α β γ : Type v
F : Type u_1 → Type u_2
AF : Applicative F
inst✝ : LawfulApplicative F
α✝ β✝ : Type u_1
f : F (α✝ → β✝)
x : F α✝
⊢ (Seq.seq (id <$> f) fun x_1 => x) = Seq.seq f fun x_1 => x
Theorem: Submodule.span_nat_eq
File: Mathlib/LinearAlgebra/Span.lean

tactic: rw [span_nat_eq_addSubmonoid_closure, s.closure_eq]
state_before: R : Type ?u.34774
R₂ : Type ?u.34777
K : Type ?u.34780
M : Type u_1
M₂ : Type ?u.34786
V : Type ?u.34789
S : Type ?u.34792
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
x : M
p p' : Submodule R M
inst✝² : Semiring R₂
σ₁₂ : R →+* R₂
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R₂ M₂
s✝ t : Set M
s : AddSubmonoid M
⊢ (span ℕ ↑s).toAddSubmonoid = s
Theorem: EReal.closedEmbedding_coe_ennreal
File: Mathlib/Topology/Instances/EReal.lean

tactic: rw [range_coe_ennreal]
state_before: α : Type ?u.6979
inst✝ : TopologicalSpace α
⊢ IsClosed (range ENNReal.toEReal)

tactic: exact isClosed_Ici
state_before: α : Type ?u.6979
inst✝ : TopologicalSpace α
⊢ IsClosed (Ici 0)
Theorem: Set.OrdConnected.convex_of_chain
File: Mathlib/Analysis/Convex/Basic.lean

tactic: refine' convex_iff_segment_subset.mpr fun x hx y hy => _
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.276015
β : Type ?u.276018
inst✝³ : OrderedSemiring 𝕜
inst✝² : OrderedAddCommMonoid E
inst✝¹ : Module 𝕜 E
inst✝ : OrderedSMul 𝕜 E
s : Set E
hs : OrdConnected s
h : IsChain (fun x x_1 => x ≤ x_1) s
⊢ Convex 𝕜 s

tactic: obtain hxy | hyx := h.total hx hy
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.276015
β : Type ?u.276018
inst✝³ : OrderedSemiring 𝕜
inst✝² : OrderedAddCommMonoid E
inst✝¹ : Module 𝕜 E
inst✝ : OrderedSMul 𝕜 E
s : Set E
hs : OrdConnected s
h : IsChain (fun x x_1 => x ≤ x_1) s
x : E
hx : x ∈ s
y : E
hy : y ∈ s
⊢ [x-[𝕜]y] ⊆ s

tactic: exact (segment_subset_Icc hxy).trans (hs.out hx hy)
state_before: case inl
𝕜 : Type u_1
E : Type u_2
F : Type ?u.276015
β : Type ?u.276018
inst✝³ : OrderedSemiring 𝕜
inst✝² : OrderedAddCommMonoid E
inst✝¹ : Module 𝕜 E
inst✝ : OrderedSMul 𝕜 E
s : Set E
hs : OrdConnected s
h : IsChain (fun x x_1 => x ≤ x_1) s
x : E
hx : x ∈ s
y : E
hy : y ∈ s
hxy : x ≤ y
⊢ [x-[𝕜]y] ⊆ s

tactic: rw [segment_symm]
state_before: case inr
𝕜 : Type u_1
E : Type u_2
F : Type ?u.276015
β : Type ?u.276018
inst✝³ : OrderedSemiring 𝕜
inst✝² : OrderedAddCommMonoid E
inst✝¹ : Module 𝕜 E
inst✝ : OrderedSMul 𝕜 E
s : Set E
hs : OrdConnected s
h : IsChain (fun x x_1 => x ≤ x_1) s
x : E
hx : x ∈ s
y : E
hy : y ∈ s
hyx : y ≤ x
⊢ [x-[𝕜]y] ⊆ s

tactic: exact (segment_subset_Icc hyx).trans (hs.out hy hx)
state_before: case inr
𝕜 : Type u_1
E : Type u_2
F : Type ?u.276015
β : Type ?u.276018
inst✝³ : OrderedSemiring 𝕜
inst✝² : OrderedAddCommMonoid E
inst✝¹ : Module 𝕜 E
inst✝ : OrderedSMul 𝕜 E
s : Set E
hs : OrdConnected s
h : IsChain (fun x x_1 => x ≤ x_1) s
x : E
hx : x ∈ s
y : E
hy : y ∈ s
hyx : y ≤ x
⊢ [y-[𝕜]x] ⊆ s
Theorem: PadicInt.valuation_p_pow_mul
File: Mathlib/NumberTheory/Padics/PadicIntegers.lean

tactic: have : ‖(p : ℤ_[p]) ^ n * c‖ = ‖(p : ℤ_[p]) ^ n‖ * ‖c‖ := norm_mul _ _
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
c : ℤ_[p]
hc : c ≠ 0
⊢ valuation (↑p ^ n * c) = ↑n + valuation c

tactic: rwa [norm_eq_pow_val aux, norm_p_pow, norm_eq_pow_val hc, ← zpow_add₀, ← neg_add,
  zpow_inj, neg_inj] at this
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
c : ℤ_[p]
hc : c ≠ 0
this : ‖↑p ^ n * c‖ = ‖↑p ^ n‖ * ‖c‖
aux : ↑p ^ n * c ≠ 0
⊢ valuation (↑p ^ n * c) = ↑n + valuation c

tactic: contrapose! hc
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
c : ℤ_[p]
hc : c ≠ 0
this : ‖↑p ^ n * c‖ = ‖↑p ^ n‖ * ‖c‖
⊢ ↑p ^ n * c ≠ 0

tactic: rw [mul_eq_zero] at hc
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
c : ℤ_[p]
this : ‖↑p ^ n * c‖ = ‖↑p ^ n‖ * ‖c‖
hc : ↑p ^ n * c = 0
⊢ c = 0

tactic: cases' hc with hc hc
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
c : ℤ_[p]
this : ‖↑p ^ n * c‖ = ‖↑p ^ n‖ * ‖c‖
hc : ↑p ^ n = 0 ∨ c = 0
⊢ c = 0

tactic: refine (hp.1.ne_zero ?_).elim
state_before: case inl
p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
c : ℤ_[p]
this : ‖↑p ^ n * c‖ = ‖↑p ^ n‖ * ‖c‖
hc : ↑p ^ n = 0
⊢ c = 0

tactic: exact_mod_cast pow_eq_zero hc
state_before: case inl
p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
c : ℤ_[p]
this : ‖↑p ^ n * c‖ = ‖↑p ^ n‖ * ‖c‖
hc : ↑p ^ n = 0
⊢ p = 0

tactic: exact hc
state_before: case inr
p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
c : ℤ_[p]
this : ‖↑p ^ n * c‖ = ‖↑p ^ n‖ * ‖c‖
hc : c = 0
⊢ c = 0

tactic: exact_mod_cast hp.1.pos
state_before: case h₀
p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
c : ℤ_[p]
hc : c ≠ 0
this : ↑p ^ (-valuation (↑p ^ n * c)) = ↑p ^ (-(↑n + valuation c))
aux : ↑p ^ n * c ≠ 0
⊢ 0 < ↑p

tactic: exact_mod_cast hp.1.ne_one
state_before: case h₁
p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
c : ℤ_[p]
hc : c ≠ 0
this : ↑p ^ (-valuation (↑p ^ n * c)) = ↑p ^ (-(↑n + valuation c))
aux : ↑p ^ n * c ≠ 0
⊢ ↑p ≠ 1

tactic: exact_mod_cast hp.1.ne_zero
state_before: case ha
p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
c : ℤ_[p]
hc : c ≠ 0
this : ↑p ^ (-valuation (↑p ^ n * c)) = ↑p ^ (-↑n) * ↑p ^ (-valuation c)
aux : ↑p ^ n * c ≠ 0
⊢ ↑p ≠ 0
Theorem: CategoryTheory.Limits.coprod.map_codiag
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

tactic: simp
state_before: C : Type u
inst✝² : Category C
X✝ Y✝ X Y : C
f : X ⟶ Y
inst✝¹ : HasBinaryCoproduct X X
inst✝ : HasBinaryCoproduct Y Y
⊢ map f f ≫ codiag Y = codiag X ≫ f
Theorem: MvPolynomial.support_mul_X
File: Mathlib/Data/MvPolynomial/Basic.lean

tactic: simp
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s✝ : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p✝ q : MvPolynomial σ R
s : σ
p : MvPolynomial σ R
⊢ ∀ (y : R), y * 1 = 0 ↔ y = 0
Theorem: List.card_cons_of_not_mem
File: Mathlib/Data/List/Card.lean

tactic: simp [card, h]
state_before: α : Type u_1
β : Sort ?u.22146
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
a : α
as : List α
h : ¬a ∈ as
⊢ card (a :: as) = card as + 1
Theorem: OrderIso.bddBelow_preimage
File: Mathlib/Order/GaloisConnection.lean

tactic: rw [← e.bddBelow_image, e.image_preimage]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
κ : ι → Sort ?u.33292
a a₁ a₂ : α
b b₁ b₂ : β
inst✝¹ : Preorder α
inst✝ : Preorder β
e : α ≃o β
s : Set β
⊢ BddBelow (↑e ⁻¹' s) ↔ BddBelow s
Theorem: norm_prod_le
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: rw [← Multiplicative.ofAdd_le, ofAdd_sum]
state_before: 𝓕 : Type ?u.737054
𝕜 : Type ?u.737057
α : Type ?u.737060
ι : Type u_1
κ : Type ?u.737066
E : Type u_2
F : Type ?u.737072
G : Type ?u.737075
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
s : Finset ι
f : ι → E
⊢ ‖∏ i in s, f i‖ ≤ ∑ i in s, ‖f i‖

tactic: refine' Finset.le_prod_of_submultiplicative (Multiplicative.ofAdd ∘ norm) _ (fun x y => _) _ _
state_before: 𝓕 : Type ?u.737054
𝕜 : Type ?u.737057
α : Type ?u.737060
ι : Type u_1
κ : Type ?u.737066
E : Type u_2
F : Type ?u.737072
G : Type ?u.737075
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
s : Finset ι
f : ι → E
⊢ ↑Multiplicative.ofAdd ‖∏ i in s, f i‖ ≤ ∏ i in s, ↑Multiplicative.ofAdd ‖f i‖

tactic: simp only [comp_apply, norm_one', ofAdd_zero]
state_before: case refine'_1
𝓕 : Type ?u.737054
𝕜 : Type ?u.737057
α : Type ?u.737060
ι : Type u_1
κ : Type ?u.737066
E : Type u_2
F : Type ?u.737072
G : Type ?u.737075
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
s : Finset ι
f : ι → E
⊢ (↑Multiplicative.ofAdd ∘ norm) 1 = 1

tactic: exact norm_mul_le' x y
state_before: case refine'_2
𝓕 : Type ?u.737054
𝕜 : Type ?u.737057
α : Type ?u.737060
ι : Type u_1
κ : Type ?u.737066
E : Type u_2
F : Type ?u.737072
G : Type ?u.737075
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
s : Finset ι
f : ι → E
x y : E
⊢ (↑Multiplicative.ofAdd ∘ norm) (x * y) ≤ (↑Multiplicative.ofAdd ∘ norm) x * (↑Multiplicative.ofAdd ∘ norm) y
Theorem: mulTSupport_eq_empty_iff
File: Mathlib/Topology/Support.lean

tactic: rw [mulTSupport, closure_empty_iff, mulSupport_eq_empty_iff]
state_before: X : Type u_1
α : Type u_2
α' : Type ?u.750
β : Type ?u.753
γ : Type ?u.756
δ : Type ?u.759
M : Type ?u.762
E : Type ?u.765
R : Type ?u.768
inst✝¹ : One α
inst✝ : TopologicalSpace X
f : X → α
⊢ mulTSupport f = ∅ ↔ f = 1
Theorem: Equiv.Perm.sign_prodCongrLeft
File: Mathlib/GroupTheory/Perm/Sign.lean

tactic: refine' (sign_eq_sign_of_equiv _ _ (prodComm β α) _).trans (sign_prodCongrRight σ)
state_before: α : Type u
β : Type v
inst✝³ : DecidableEq α
inst✝² : Fintype α
inst✝¹ : DecidableEq β
inst✝ : Fintype β
σ : α → Perm β
⊢ ↑sign (prodCongrLeft σ) = ∏ k : α, ↑sign (σ k)

tactic: rintro ⟨b, α⟩
state_before: α : Type u
β : Type v
inst✝³ : DecidableEq α
inst✝² : Fintype α
inst✝¹ : DecidableEq β
inst✝ : Fintype β
σ : α → Perm β
⊢ ∀ (x : β × α), ↑(prodComm β α) (↑(prodCongrLeft σ) x) = ↑(prodCongrRight σ) (↑(prodComm β α) x)

tactic: rfl
state_before: case mk
α✝ : Type u
β : Type v
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
inst✝¹ : DecidableEq β
inst✝ : Fintype β
σ : α✝ → Perm β
b : β
α : α✝
⊢ ↑(prodComm β α✝) (↑(prodCongrLeft σ) (b, α)) = ↑(prodCongrRight σ) (↑(prodComm β α✝) (b, α))
Theorem: List.drop_length_cons
File: Mathlib/Data/List/Basic.lean

tactic: induction' l with y l ih generalizing a
state_before: ι : Type ?u.203942
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
h : l ≠ []
a : α
⊢ drop (length l) (a :: l) = [getLast l h]

tactic: cases h rfl
state_before: case nil
ι : Type ?u.203942
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
h✝ : l ≠ []
a✝ : α
h : [] ≠ []
a : α
⊢ drop (length []) [a] = [getLast [] h]

tactic: simp only [drop, length]
state_before: case cons
ι : Type ?u.203942
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l✝ : List α
h✝ : l✝ ≠ []
a✝ y : α
l : List α
ih : ∀ (h : l ≠ []) (a : α), drop (length l) (a :: l) = [getLast l h]
h : y :: l ≠ []
a : α
⊢ drop (length (y :: l)) (a :: y :: l) = [getLast (y :: l) h]

tactic: by_cases h₁ : l = []
state_before: case cons
ι : Type ?u.203942
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l✝ : List α
h✝ : l✝ ≠ []
a✝ y : α
l : List α
ih : ∀ (h : l ≠ []) (a : α), drop (length l) (a :: l) = [getLast l h]
h : y :: l ≠ []
a : α
⊢ drop (Nat.add (length l) 0) (y :: l) = [getLast (y :: l) h]

tactic: rw [getLast_cons h₁]
state_before: case neg
ι : Type ?u.203942
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l✝ : List α
h✝ : l✝ ≠ []
a✝ y : α
l : List α
ih : ∀ (h : l ≠ []) (a : α), drop (length l) (a :: l) = [getLast l h]
h : y :: l ≠ []
a : α
h₁ : ¬l = []
⊢ drop (Nat.add (length l) 0) (y :: l) = [getLast (y :: l) h]

tactic: exact ih h₁ y
state_before: case neg
ι : Type ?u.203942
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l✝ : List α
h✝ : l✝ ≠ []
a✝ y : α
l : List α
ih : ∀ (h : l ≠ []) (a : α), drop (length l) (a :: l) = [getLast l h]
h : y :: l ≠ []
a : α
h₁ : ¬l = []
⊢ drop (Nat.add (length l) 0) (y :: l) = [getLast l h₁]

tactic: simp [h₁]
state_before: case pos
ι : Type ?u.203942
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l✝ : List α
h✝ : l✝ ≠ []
a✝ y : α
l : List α
ih : ∀ (h : l ≠ []) (a : α), drop (length l) (a :: l) = [getLast l h]
h : y :: l ≠ []
a : α
h₁ : l = []
⊢ drop (Nat.add (length l) 0) (y :: l) = [getLast (y :: l) h]
Theorem: pow_dvd_pow_iff
File: Mathlib/Algebra/GroupPower/Ring.lean

tactic: constructor
state_before: R : Type u_1
S : Type ?u.68385
M : Type ?u.68388
inst✝ : CancelCommMonoidWithZero R
x : R
n m : ℕ
h0 : x ≠ 0
h1 : ¬IsUnit x
⊢ x ^ n ∣ x ^ m ↔ n ≤ m

tactic: intro h
state_before: case mp
R : Type u_1
S : Type ?u.68385
M : Type ?u.68388
inst✝ : CancelCommMonoidWithZero R
x : R
n m : ℕ
h0 : x ≠ 0
h1 : ¬IsUnit x
⊢ x ^ n ∣ x ^ m → n ≤ m

tactic: rw [← not_lt]
state_before: case mp
R : Type u_1
S : Type ?u.68385
M : Type ?u.68388
inst✝ : CancelCommMonoidWithZero R
x : R
n m : ℕ
h0 : x ≠ 0
h1 : ¬IsUnit x
h : x ^ n ∣ x ^ m
⊢ n ≤ m

tactic: intro hmn
state_before: case mp
R : Type u_1
S : Type ?u.68385
M : Type ?u.68388
inst✝ : CancelCommMonoidWithZero R
x : R
n m : ℕ
h0 : x ≠ 0
h1 : ¬IsUnit x
h : x ^ n ∣ x ^ m
⊢ ¬m < n

tactic: apply h1
state_before: case mp
R : Type u_1
S : Type ?u.68385
M : Type ?u.68388
inst✝ : CancelCommMonoidWithZero R
x : R
n m : ℕ
h0 : x ≠ 0
h1 : ¬IsUnit x
h : x ^ n ∣ x ^ m
hmn : m < n
⊢ False

tactic: have : x ^ m * x ∣ x ^ m * 1 := by
  rw [← pow_succ', mul_one]
  exact (pow_dvd_pow _ (Nat.succ_le_of_lt hmn)).trans h
state_before: case mp
R : Type u_1
S : Type ?u.68385
M : Type ?u.68388
inst✝ : CancelCommMonoidWithZero R
x : R
n m : ℕ
h0 : x ≠ 0
h1 : ¬IsUnit x
h : x ^ n ∣ x ^ m
hmn : m < n
⊢ IsUnit x

tactic: rwa [mul_dvd_mul_iff_left, ← isUnit_iff_dvd_one] at this
state_before: case mp
R : Type u_1
S : Type ?u.68385
M : Type ?u.68388
inst✝ : CancelCommMonoidWithZero R
x : R
n m : ℕ
h0 : x ≠ 0
h1 : ¬IsUnit x
h : x ^ n ∣ x ^ m
hmn : m < n
this : x ^ m * x ∣ x ^ m * 1
⊢ IsUnit x

tactic: apply pow_ne_zero m h0
state_before: case mp
R : Type u_1
S : Type ?u.68385
M : Type ?u.68388
inst✝ : CancelCommMonoidWithZero R
x : R
n m : ℕ
h0 : x ≠ 0
h1 : ¬IsUnit x
h : x ^ n ∣ x ^ m
hmn : m < n
this : x ^ m * x ∣ x ^ m * 1
⊢ x ^ m ≠ 0

tactic: rw [← pow_succ', mul_one]
state_before: R : Type u_1
S : Type ?u.68385
M : Type ?u.68388
inst✝ : CancelCommMonoidWithZero R
x : R
n m : ℕ
h0 : x ≠ 0
h1 : ¬IsUnit x
h : x ^ n ∣ x ^ m
hmn : m < n
⊢ x ^ m * x ∣ x ^ m * 1

tactic: exact (pow_dvd_pow _ (Nat.succ_le_of_lt hmn)).trans h
state_before: R : Type u_1
S : Type ?u.68385
M : Type ?u.68388
inst✝ : CancelCommMonoidWithZero R
x : R
n m : ℕ
h0 : x ≠ 0
h1 : ¬IsUnit x
h : x ^ n ∣ x ^ m
hmn : m < n
⊢ x ^ (m + 1) ∣ x ^ m

tactic: apply pow_dvd_pow
state_before: case mpr
R : Type u_1
S : Type ?u.68385
M : Type ?u.68388
inst✝ : CancelCommMonoidWithZero R
x : R
n m : ℕ
h0 : x ≠ 0
h1 : ¬IsUnit x
⊢ n ≤ m → x ^ n ∣ x ^ m
Theorem: Finset.card_singleton_inter
File: Mathlib/Data/Finset/Card.lean

tactic: cases' Finset.decidableMem a s with h h
state_before: α : Type u_1
β : Type ?u.3414
s t : Finset α
a b : α
inst✝ : DecidableEq α
⊢ card ({a} ∩ s) ≤ 1

tactic: simp [Finset.singleton_inter_of_not_mem h]
state_before: case isFalse
α : Type u_1
β : Type ?u.3414
s t : Finset α
a b : α
inst✝ : DecidableEq α
h : ¬a ∈ s
⊢ card ({a} ∩ s) ≤ 1

tactic: simp [Finset.singleton_inter_of_mem h]
state_before: case isTrue
α : Type u_1
β : Type ?u.3414
s t : Finset α
a b : α
inst✝ : DecidableEq α
h : a ∈ s
⊢ card ({a} ∩ s) ≤ 1