tasksource/leandojo huggingface dataset:
Theorem: Measurable.map_prod_mk_left
File: Mathlib/MeasureTheory/Constructions/Prod/Basic.lean

tactic: apply measurable_of_measurable_coe
state_before: α : Type u_2
α' : Type ?u.2479556
β : Type u_1
β' : Type ?u.2479562
γ : Type ?u.2479565
E : Type ?u.2479568
inst✝⁶ : MeasurableSpace α
inst✝⁵ : MeasurableSpace α'
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace β'
inst✝² : MeasurableSpace γ
μ μ' : MeasureTheory.Measure α
ν ν' : MeasureTheory.Measure β
τ : MeasureTheory.Measure γ
inst✝¹ : NormedAddCommGroup E
inst✝ : SigmaFinite ν
⊢ Measurable fun x => map (Prod.mk x) ν

tactic: intro s hs
state_before: case h
α : Type u_2
α' : Type ?u.2479556
β : Type u_1
β' : Type ?u.2479562
γ : Type ?u.2479565
E : Type ?u.2479568
inst✝⁶ : MeasurableSpace α
inst✝⁵ : MeasurableSpace α'
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace β'
inst✝² : MeasurableSpace γ
μ μ' : MeasureTheory.Measure α
ν ν' : MeasureTheory.Measure β
τ : MeasureTheory.Measure γ
inst✝¹ : NormedAddCommGroup E
inst✝ : SigmaFinite ν
⊢ ∀ (s : Set (α × β)), MeasurableSet s → Measurable fun b => ↑↑(map (Prod.mk b) ν) s

tactic: simp_rw [map_apply measurable_prod_mk_left hs]
state_before: case h
α : Type u_2
α' : Type ?u.2479556
β : Type u_1
β' : Type ?u.2479562
γ : Type ?u.2479565
E : Type ?u.2479568
inst✝⁶ : MeasurableSpace α
inst✝⁵ : MeasurableSpace α'
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace β'
inst✝² : MeasurableSpace γ
μ μ' : MeasureTheory.Measure α
ν ν' : MeasureTheory.Measure β
τ : MeasureTheory.Measure γ
inst✝¹ : NormedAddCommGroup E
inst✝ : SigmaFinite ν
s : Set (α × β)
hs : MeasurableSet s
⊢ Measurable fun b => ↑↑(map (Prod.mk b) ν) s

tactic: exact measurable_measure_prod_mk_left hs
state_before: case h
α : Type u_2
α' : Type ?u.2479556
β : Type u_1
β' : Type ?u.2479562
γ : Type ?u.2479565
E : Type ?u.2479568
inst✝⁶ : MeasurableSpace α
inst✝⁵ : MeasurableSpace α'
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace β'
inst✝² : MeasurableSpace γ
μ μ' : MeasureTheory.Measure α
ν ν' : MeasureTheory.Measure β
τ : MeasureTheory.Measure γ
inst✝¹ : NormedAddCommGroup E
inst✝ : SigmaFinite ν
s : Set (α × β)
hs : MeasurableSet s
⊢ Measurable fun b => ↑↑ν (Prod.mk b ⁻¹' s)
Theorem: Turing.PartrecToTM2.trStmts₁_self
File: Mathlib/Computability/TMToPartrec.lean

tactic: first |apply Finset.mem_singleton_self|apply Finset.mem_insert_self
state_before: case ret
k✝ : Cont'
⊢ Λ'.ret k✝ ∈ trStmts₁ (Λ'.ret k✝)

tactic: apply Finset.mem_singleton_self
state_before: case ret
k✝ : Cont'
⊢ Λ'.ret k✝ ∈ trStmts₁ (Λ'.ret k✝)

tactic: apply Finset.mem_insert_self
state_before: case pred
q₁✝ q₂✝ : Λ'
q₁_ih✝ : q₁✝ ∈ trStmts₁ q₁✝
q₂_ih✝ : q₂✝ ∈ trStmts₁ q₂✝
⊢ Λ'.pred q₁✝ q₂✝ ∈ trStmts₁ (Λ'.pred q₁✝ q₂✝)
Theorem: Homeomorph.mulLeft_symm
File: Mathlib/Topology/Algebra/Group/Basic.lean

tactic: ext
state_before: α : Type u
β : Type v
G : Type w
H : Type x
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : ContinuousMul G
a : G
⊢ Homeomorph.symm (Homeomorph.mulLeft a) = Homeomorph.mulLeft a⁻¹

tactic: rfl
state_before: case H
α : Type u
β : Type v
G : Type w
H : Type x
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : ContinuousMul G
a x✝ : G
⊢ ↑(Homeomorph.symm (Homeomorph.mulLeft a)) x✝ = ↑(Homeomorph.mulLeft a⁻¹) x✝
Theorem: aemeasurable_restrict_iff_comap_subtype
File: Mathlib/MeasureTheory/Measure/AEMeasurable.lean

tactic: rw [← map_comap_subtype_coe hs, (MeasurableEmbedding.subtype_coe hs).aemeasurable_map_iff]
state_before: ι : Type ?u.3617330
α : Type u_1
β : Type u_2
γ : Type ?u.3617339
δ : Type ?u.3617342
R : Type ?u.3617345
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
f✝ g : α → β
μ✝ ν : MeasureTheory.Measure α
s : Set α
hs : MeasurableSet s
μ : MeasureTheory.Measure α
f : α → β
⊢ AEMeasurable f ↔ AEMeasurable (f ∘ Subtype.val)
Theorem: Polynomial.lifts_iff_ringHom_rangeS
File: Mathlib/Data/Polynomial/Lifts.lean

tactic: simp only [coe_mapRingHom, lifts, Set.mem_range, RingHom.mem_rangeS]
state_before: R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f : R →+* S
p : S[X]
⊢ p ∈ lifts f ↔ p ∈ RingHom.rangeS (mapRingHom f)
Theorem: List.partition_eq_filter_filter
File: Std/Data/List/Lemmas.lean

tactic: simp [partition, aux]
state_before: α : Type u_1
p : α → Bool
l : List α
⊢ partition p l = (filter p l, filter (not ∘ p) l)

tactic: simp [partition.loop, filter]
state_before: α : Type u_1
p : α → Bool
l as✝ bs✝ : List α
⊢ partition.loop p [] (as✝, bs✝) = (reverse as✝ ++ filter p [], reverse bs✝ ++ filter (not ∘ p) [])

tactic: cases pa : p a <;> simp [partition.loop, pa, aux, filter, append_assoc]
state_before: α : Type u_1
p : α → Bool
l✝ as✝ bs✝ : List α
a : α
l : List α
⊢ partition.loop p (a :: l) (as✝, bs✝) = (reverse as✝ ++ filter p (a :: l), reverse bs✝ ++ filter (not ∘ p) (a :: l))
Theorem: inv_mul_cancel_left₀
File: Mathlib/Algebra/GroupWithZero/Basic.lean

tactic: simp [h]
state_before: α : Type ?u.20012
M₀ : Type ?u.20015
G₀ : Type u_1
M₀' : Type ?u.20021
G₀' : Type ?u.20024
F : Type ?u.20027
F' : Type ?u.20030
inst✝ : GroupWithZero G₀
a b✝ c g h✝ x : G₀
h : a ≠ 0
b : G₀
⊢ a⁻¹ * a * b = b
Theorem: Submodule.restrictScalars_eq_top_iff
File: Mathlib/Algebra/Module/Submodule/Lattice.lean

tactic: simp [SetLike.ext_iff]
state_before: R : Type u_1
S : Type u_3
M : Type u_2
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : Module S M
inst✝¹ : SMul S R
inst✝ : IsScalarTower S R M
p✝ q p : Submodule R M
⊢ restrictScalars S p = ⊤ ↔ p = ⊤
Theorem: SimpleGraph.Walk.reverse_transfer
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: simp only [edges_reverse, List.mem_reverse']
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
H : SimpleGraph V
hp : ∀ (e : Sym2 V), e ∈ edges p → e ∈ edgeSet H
⊢ ∀ (e : Sym2 V), e ∈ edges (reverse p) → e ∈ edgeSet H

tactic: exact hp
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
H : SimpleGraph V
hp : ∀ (e : Sym2 V), e ∈ edges p → e ∈ edgeSet H
⊢ ∀ (e : Sym2 V), e ∈ edges p → e ∈ edgeSet H

tactic: induction p with
| nil => simp
| cons _ _ ih => simp only [transfer_append, Walk.transfer, reverse_nil, reverse_cons, ih]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
H : SimpleGraph V
hp : ∀ (e : Sym2 V), e ∈ edges p → e ∈ edgeSet H
⊢ reverse (Walk.transfer p H hp) =
    Walk.transfer (reverse p) H (_ : ∀ (e : Sym2 V), e ∈ edges (reverse p) → e ∈ edgeSet H)

tactic: simp
state_before: case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
H : SimpleGraph V
u✝ : V
hp : ∀ (e : Sym2 V), e ∈ edges nil → e ∈ edgeSet H
⊢ reverse (Walk.transfer nil H hp) =
    Walk.transfer (reverse nil) H (_ : ∀ (e : Sym2 V), e ∈ edges (reverse nil) → e ∈ edgeSet H)

tactic: simp only [transfer_append, Walk.transfer, reverse_nil, reverse_cons, ih]
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
H : SimpleGraph V
u✝ v✝ w✝ : V
h✝ : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih :
  ∀ (hp : ∀ (e : Sym2 V), e ∈ edges p✝ → e ∈ edgeSet H),
    reverse (Walk.transfer p✝ H hp) =
      Walk.transfer (reverse p✝) H (_ : ∀ (e : Sym2 V), e ∈ edges (reverse p✝) → e ∈ edgeSet H)
hp : ∀ (e : Sym2 V), e ∈ edges (cons h✝ p✝) → e ∈ edgeSet H
⊢ reverse (Walk.transfer (cons h✝ p✝) H hp) =
    Walk.transfer (reverse (cons h✝ p✝)) H (_ : ∀ (e : Sym2 V), e ∈ edges (reverse (cons h✝ p✝)) → e ∈ edgeSet H)
Theorem: Dfinsupp.mem_support_toFun
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: cases' f with f s
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
i : ι
⊢ i ∈ support f ↔ ↑f i ≠ 0

tactic: induction' s using Trunc.induction_on with s
state_before: case mk'
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
i : ι
f : (i : ι) → β i
s : Trunc { s // ∀ (i : ι), i ∈ s ∨ f i = 0 }
⊢ i ∈ support { toFun := f, support' := s } ↔ ↑{ toFun := f, support' := s } i ≠ 0

tactic: dsimp only [support, Trunc.lift_mk]
state_before: case mk'.h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
i : ι
f : (i : ι) → β i
s : { s // ∀ (i : ι), i ∈ s ∨ f i = 0 }
⊢ i ∈ support { toFun := f, support' := Trunc.mk s } ↔ ↑{ toFun := f, support' := Trunc.mk s } i ≠ 0

tactic: rw [Finset.mem_filter, Multiset.mem_toFinset, coe_mk']
state_before: case mk'.h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
i : ι
f : (i : ι) → β i
s : { s // ∀ (i : ι), i ∈ s ∨ f i = 0 }
⊢ i ∈ Finset.filter (fun i => ↑{ toFun := f, support' := Trunc.mk s } i ≠ 0) (Multiset.toFinset ↑s) ↔
    ↑{ toFun := f, support' := Trunc.mk s } i ≠ 0

tactic: exact and_iff_right_of_imp (s.prop i).resolve_right
state_before: case mk'.h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
i : ι
f : (i : ι) → β i
s : { s // ∀ (i : ι), i ∈ s ∨ f i = 0 }
⊢ i ∈ ↑s ∧ f i ≠ 0 ↔ f i ≠ 0
Theorem: Submodule.prod_map_snd
File: Mathlib/LinearAlgebra/Prod.lean

tactic: ext x
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.310080
M₆ : Type ?u.310083
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
⊢ map (snd R M M₂) (prod p q) = q

tactic: simp [(⟨0, zero_mem _⟩ : ∃ x, x ∈ p)]
state_before: case h
R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.310080
M₆ : Type ?u.310083
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
x : M₂
⊢ x ∈ map (snd R M M₂) (prod p q) ↔ x ∈ q
Theorem: LucasLehmer.order_ω
File: Mathlib/NumberTheory/LucasLehmer.lean

tactic: apply Nat.eq_prime_pow_of_dvd_least_prime_pow
state_before: p' : ℕ
h : lucasLehmerResidue (p' + 2) = 0
⊢ orderOf (ωUnit (p' + 2)) = 2 ^ (p' + 2)

tactic: exact Nat.prime_two
state_before: case pp
p' : ℕ
h : lucasLehmerResidue (p' + 2) = 0
⊢ Nat.Prime 2

tactic: intro o
state_before: case h₁
p' : ℕ
h : lucasLehmerResidue (p' + 2) = 0
⊢ ¬orderOf (ωUnit (p' + 2)) ∣ 2 ^ (p' + 1)

tactic: have ω_pow := orderOf_dvd_iff_pow_eq_one.1 o
state_before: case h₁
p' : ℕ
h : lucasLehmerResidue (p' + 2) = 0
o : orderOf (ωUnit (p' + 2)) ∣ 2 ^ (p' + 1)
⊢ False

tactic: replace ω_pow :=
  congr_arg (Units.coeHom (X (q (p' + 2))) : Units (X (q (p' + 2))) → X (q (p' + 2))) ω_pow
state_before: case h₁
p' : ℕ
h : lucasLehmerResidue (p' + 2) = 0
o : orderOf (ωUnit (p' + 2)) ∣ 2 ^ (p' + 1)
ω_pow : ωUnit (p' + 2) ^ 2 ^ (p' + 1) = 1
⊢ False

tactic: simp at ω_pow
state_before: case h₁
p' : ℕ
h : lucasLehmerResidue (p' + 2) = 0
o : orderOf (ωUnit (p' + 2)) ∣ 2 ^ (p' + 1)
ω_pow : ↑(Units.coeHom (X (q (p' + 2)))) (ωUnit (p' + 2) ^ 2 ^ (p' + 1)) = ↑(Units.coeHom (X (q (p' + 2)))) 1
⊢ False

tactic: have h : (1 : ZMod (q (p' + 2))) = -1 :=
  congr_arg Prod.fst (ω_pow.symm.trans (ω_pow_eq_neg_one p' h))
state_before: case h₁
p' : ℕ
h : lucasLehmerResidue (p' + 2) = 0
o : orderOf (ωUnit (p' + 2)) ∣ 2 ^ (p' + 1)
ω_pow : ω ^ 2 ^ (p' + 1) = 1
⊢ False

tactic: haveI : Fact (2 < (q (p' + 2) : ℕ)) := ⟨two_lt_q _⟩
state_before: case h₁
p' : ℕ
h✝ : lucasLehmerResidue (p' + 2) = 0
o : orderOf (ωUnit (p' + 2)) ∣ 2 ^ (p' + 1)
ω_pow : ω ^ 2 ^ (p' + 1) = 1
h : 1 = -1
⊢ False

tactic: apply ZMod.neg_one_ne_one h.symm
state_before: case h₁
p' : ℕ
h✝ : lucasLehmerResidue (p' + 2) = 0
o : orderOf (ωUnit (p' + 2)) ∣ 2 ^ (p' + 1)
ω_pow : ω ^ 2 ^ (p' + 1) = 1
h : 1 = -1
this : Fact (2 < ↑(q (p' + 2)))
⊢ False

tactic: apply orderOf_dvd_iff_pow_eq_one.2
state_before: case h₂
p' : ℕ
h : lucasLehmerResidue (p' + 2) = 0
⊢ orderOf (ωUnit (p' + 2)) ∣ 2 ^ (p' + 1 + 1)

tactic: apply Units.ext
state_before: case h₂
p' : ℕ
h : lucasLehmerResidue (p' + 2) = 0
⊢ ωUnit (p' + 2) ^ 2 ^ (p' + 1 + 1) = 1

tactic: push_cast
state_before: case h₂.a
p' : ℕ
h : lucasLehmerResidue (p' + 2) = 0
⊢ ↑(ωUnit (p' + 2) ^ 2 ^ (p' + 1 + 1)) = ↑1

tactic: exact ω_pow_eq_one p' h
state_before: case h₂.a
p' : ℕ
h : lucasLehmerResidue (p' + 2) = 0
⊢ ↑(ωUnit (p' + 2)) ^ 2 ^ (p' + 1 + 1) = 1
Theorem: Submodule.isOrtho_span
File: Mathlib/Analysis/InnerProductSpace/Orthogonal.lean

tactic: simp_rw [span_eq_iSup_of_singleton_spans s, span_eq_iSup_of_singleton_spans t, isOrtho_iSup_left,
  isOrtho_iSup_right, isOrtho_iff_le, span_le, Set.subset_def, SetLike.mem_coe,
  mem_orthogonal_singleton_iff_inner_left, Set.mem_singleton_iff, forall_eq]
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.145468
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
s t : Set E
⊢ span 𝕜 s ⟂ span 𝕜 t ↔ ∀ ⦃u : E⦄, u ∈ s → ∀ ⦃v : E⦄, v ∈ t → inner u v = 0
Theorem: char_dvd_card_solutions_of_fintype_sum_lt
File: Mathlib/FieldTheory/ChevalleyWarning.lean

tactic: simpa using char_dvd_card_solutions_of_sum_lt p h
state_before: K : Type u_3
σ : Type u_2
ι : Type u_1
inst✝⁶ : Fintype K
inst✝⁵ : Field K
inst✝⁴ : Fintype σ
inst✝³ : DecidableEq σ
inst✝² : DecidableEq K
p : ℕ
inst✝¹ : CharP K p
inst✝ : Fintype ι
f : ι → MvPolynomial σ K
h : ∑ i : ι, totalDegree (f i) < Fintype.card σ
⊢ p ∣ Fintype.card { x // ∀ (i : ι), ↑(eval x) (f i) = 0 }
Theorem: Inducing.specializes_iff
File: Mathlib/Topology/Inseparable.lean

tactic: simp only [specializes_iff_mem_closure, hf.closure_eq_preimage_closure_image, image_singleton,
  mem_preimage]
state_before: X : Type u_1
Y : Type u_2
Z : Type ?u.14588
α : Type ?u.14591
ι : Type ?u.14594
π : ι → Type ?u.14599
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x y z : X
s : Set X
f : X → Y
hf : Inducing f
⊢ f x ⤳ f y ↔ x ⤳ y
Theorem: Stream'.Seq1.ret_bind
File: Mathlib/Data/Seq/Seq.lean

tactic: simp [ret, bind, map]
state_before: α : Type u
β : Type v
γ : Type w
a : α
f : α → Seq1 β
⊢ bind (ret a) f = f a

tactic: cases' f a with a s
state_before: α : Type u
β : Type v
γ : Type w
a : α
f : α → Seq1 β
⊢ join (f a, nil) = f a

tactic: apply recOn s <;> intros <;> simp
state_before: case mk
α : Type u
β : Type v
γ : Type w
a✝ : α
f : α → Seq1 β
a : β
s : Seq β
⊢ join ((a, s), nil) = (a, s)
Theorem: Real.rpow_eq_nhds_of_pos
File: Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean

tactic: suffices : ∀ᶠ x : ℝ × ℝ in 𝓝 p, 0 < x.1
state_before: p : ℝ × ℝ
hp_fst : 0 < p.fst
⊢ (fun x => x.fst ^ x.snd) =ᶠ[𝓝 p] fun x => exp (log x.fst * x.snd)

tactic: exact
  this.mono fun x hx => by
    dsimp only
    rw [rpow_def_of_pos hx]
state_before: p : ℝ × ℝ
hp_fst : 0 < p.fst
this : ∀ᶠ (x : ℝ × ℝ) in 𝓝 p, 0 < x.fst
⊢ (fun x => x.fst ^ x.snd) =ᶠ[𝓝 p] fun x => exp (log x.fst * x.snd)

case this
p : ℝ × ℝ
hp_fst : 0 < p.fst
⊢ ∀ᶠ (x : ℝ × ℝ) in 𝓝 p, 0 < x.fst

tactic: exact IsOpen.eventually_mem (isOpen_lt continuous_const continuous_fst) hp_fst
state_before: case this
p : ℝ × ℝ
hp_fst : 0 < p.fst
⊢ ∀ᶠ (x : ℝ × ℝ) in 𝓝 p, 0 < x.fst

tactic: dsimp only
state_before: p : ℝ × ℝ
hp_fst : 0 < p.fst
this : ∀ᶠ (x : ℝ × ℝ) in 𝓝 p, 0 < x.fst
x : ℝ × ℝ
hx : 0 < x.fst
⊢ (fun x => x.fst ^ x.snd) x = (fun x => exp (log x.fst * x.snd)) x

tactic: rw [rpow_def_of_pos hx]
state_before: p : ℝ × ℝ
hp_fst : 0 < p.fst
this : ∀ᶠ (x : ℝ × ℝ) in 𝓝 p, 0 < x.fst
x : ℝ × ℝ
hx : 0 < x.fst
⊢ x.fst ^ x.snd = exp (log x.fst * x.snd)
Theorem: CategoryTheory.Injective.injective_iff_preservesEpimorphisms_preadditiveYoneda_obj
File: Mathlib/CategoryTheory/Preadditive/Yoneda/Injective.lean

tactic: rw [injective_iff_preservesEpimorphisms_yoneda_obj]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : Preadditive C
J : C
⊢ Injective J ↔ Functor.PreservesEpimorphisms (preadditiveYoneda.obj J)

tactic: refine'
  ⟨fun h : (preadditiveYoneda.obj J ⋙  (forget AddCommGroupCat)).PreservesEpimorphisms => _, _⟩
state_before: C : Type u
inst✝¹ : Category C
inst✝ : Preadditive C
J : C
⊢ Functor.PreservesEpimorphisms (yoneda.obj J) ↔ Functor.PreservesEpimorphisms (preadditiveYoneda.obj J)

tactic: exact
  Functor.preservesEpimorphisms_of_preserves_of_reflects (preadditiveYoneda.obj J) (forget _)
state_before: case refine'_1
C : Type u
inst✝¹ : Category C
inst✝ : Preadditive C
J : C
h : Functor.PreservesEpimorphisms (preadditiveYoneda.obj J ⋙ forget AddCommGroupCat)
⊢ Functor.PreservesEpimorphisms (preadditiveYoneda.obj J)

tactic: intro
state_before: case refine'_2
C : Type u
inst✝¹ : Category C
inst✝ : Preadditive C
J : C
⊢ Functor.PreservesEpimorphisms (preadditiveYoneda.obj J) → Functor.PreservesEpimorphisms (yoneda.obj J)

tactic: exact (inferInstance : (preadditiveYoneda.obj J ⋙ forget _).PreservesEpimorphisms)
state_before: case refine'_2
C : Type u
inst✝¹ : Category C
inst✝ : Preadditive C
J : C
a✝ : Functor.PreservesEpimorphisms (preadditiveYoneda.obj J)
⊢ Functor.PreservesEpimorphisms (yoneda.obj J)
Theorem: Equiv.Perm.subtypePerm_pow
File: Mathlib/GroupTheory/Perm/Basic.lean

tactic: induction' n with n ih
state_before: α : Type u
β : Type v
p : α → Prop
f✝ f : Perm α
n : ℕ
hf : ∀ (x : α), p x ↔ p (↑f x)
⊢ subtypePerm f hf ^ n = subtypePerm (f ^ n) (_ : ∀ (x : α), p x ↔ p (↑(f ^ n) x))

tactic: simp
state_before: case zero
α : Type u
β : Type v
p : α → Prop
f✝ f : Perm α
hf : ∀ (x : α), p x ↔ p (↑f x)
⊢ subtypePerm f hf ^ Nat.zero = subtypePerm (f ^ Nat.zero) (_ : ∀ (x : α), p x ↔ p (↑(f ^ Nat.zero) x))

tactic: simp_rw [pow_succ', ih, subtypePerm_mul]
state_before: case succ
α : Type u
β : Type v
p : α → Prop
f✝ f : Perm α
hf : ∀ (x : α), p x ↔ p (↑f x)
n : ℕ
ih : subtypePerm f hf ^ n = subtypePerm (f ^ n) (_ : ∀ (x : α), p x ↔ p (↑(f ^ n) x))
⊢ subtypePerm f hf ^ Nat.succ n = subtypePerm (f ^ Nat.succ n) (_ : ∀ (x : α), p x ↔ p (↑(f ^ Nat.succ n) x))
Theorem: Sym2.card_image_offDiag
File: Mathlib/Data/Sym/Card.lean

tactic: rw [Nat.choose_two_right, mul_tsub, mul_one, ← offDiag_card,
  Nat.div_eq_of_eq_mul_right zero_lt_two (two_mul_card_image_offDiag s).symm]
state_before: α : Type u_1
β : Type ?u.78623
inst✝ : DecidableEq α
s : Finset α
⊢ Finset.card (image Quotient.mk' (offDiag s)) = Nat.choose (Finset.card s) 2
Theorem: Even.neg_zpow
File: Mathlib/Algebra/Parity.lean

tactic: rintro ⟨c, rfl⟩ a
state_before: F : Type ?u.40950
α : Type u_1
β : Type ?u.40956
R : Type ?u.40959
inst✝¹ : DivisionMonoid α
a : α
inst✝ : HasDistribNeg α
n : ℤ
⊢ Even n → ∀ (a : α), (-a) ^ n = a ^ n

tactic: exact zpow_bit0_neg _ _
state_before: case intro
F : Type ?u.40950
α : Type u_1
β : Type ?u.40956
R : Type ?u.40959
inst✝¹ : DivisionMonoid α
a✝ : α
inst✝ : HasDistribNeg α
c : ℤ
a : α
⊢ (-a) ^ (c + c) = a ^ (c + c)
Theorem: Prime.pow_dvd_of_dvd_mul_right
File: Mathlib/Algebra/Associated.lean

tactic: rw [mul_comm] at h'
state_before: α : Type u_1
β : Type ?u.38286
γ : Type ?u.38289
δ : Type ?u.38292
inst✝ : CancelCommMonoidWithZero α
p a b : α
hp : Prime p
n : ℕ
h : ¬p ∣ b
h' : p ^ n ∣ a * b
⊢ p ^ n ∣ a

tactic: exact hp.pow_dvd_of_dvd_mul_left n h h'
state_before: α : Type u_1
β : Type ?u.38286
γ : Type ?u.38289
δ : Type ?u.38292
inst✝ : CancelCommMonoidWithZero α
p a b : α
hp : Prime p
n : ℕ
h : ¬p ∣ b
h' : p ^ n ∣ b * a
⊢ p ^ n ∣ a
Theorem: mul_nonneg_of_three
File: Mathlib/Algebra/Order/Ring/Defs.lean

tactic: iterate 3 rw [mul_nonneg_iff]
state_before: α : Type u
β : Type ?u.180652
inst✝ : LinearOrderedRing α
a✝ b✝ c✝ a b c : α
⊢ 0 ≤ a * b ∨ 0 ≤ b * c ∨ 0 ≤ c * a

tactic: have or_a := le_total 0 a
state_before: α : Type u
β : Type ?u.180652
inst✝ : LinearOrderedRing α
a✝ b✝ c✝ a b c : α
⊢ (0 ≤ a ∧ 0 ≤ b ∨ a ≤ 0 ∧ b ≤ 0) ∨ (0 ≤ b ∧ 0 ≤ c ∨ b ≤ 0 ∧ c ≤ 0) ∨ 0 ≤ c ∧ 0 ≤ a ∨ c ≤ 0 ∧ a ≤ 0

tactic: have or_b := le_total 0 b
state_before: α : Type u
β : Type ?u.180652
inst✝ : LinearOrderedRing α
a✝ b✝ c✝ a b c : α
or_a : 0 ≤ a ∨ a ≤ 0
⊢ (0 ≤ a ∧ 0 ≤ b ∨ a ≤ 0 ∧ b ≤ 0) ∨ (0 ≤ b ∧ 0 ≤ c ∨ b ≤ 0 ∧ c ≤ 0) ∨ 0 ≤ c ∧ 0 ≤ a ∨ c ≤ 0 ∧ a ≤ 0

tactic: have or_c := le_total 0 c
state_before: α : Type u
β : Type ?u.180652
inst✝ : LinearOrderedRing α
a✝ b✝ c✝ a b c : α
or_a : 0 ≤ a ∨ a ≤ 0
or_b : 0 ≤ b ∨ b ≤ 0
⊢ (0 ≤ a ∧ 0 ≤ b ∨ a ≤ 0 ∧ b ≤ 0) ∨ (0 ≤ b ∧ 0 ≤ c ∨ b ≤ 0 ∧ c ≤ 0) ∨ 0 ≤ c ∧ 0 ≤ a ∨ c ≤ 0 ∧ a ≤ 0

tactic: exact Or.elim or_c
  (fun (h0 : 0 ≤ c) =>
    Or.elim or_b
      (fun (h1 : 0 ≤ b) =>
          Or.elim or_a (fun (h2 : 0 ≤ a) => Or.inl (Or.inl ⟨h2, h1⟩))
            (fun (_ : a ≤ 0) => Or.inr (Or.inl (Or.inl ⟨h1, h0⟩))))
      (fun (h1 : b ≤ 0) =>
          Or.elim or_a (fun (h3 : 0 ≤ a) => Or.inr (Or.inr (Or.inl ⟨h0, h3⟩)))
            (fun (h3 : a ≤ 0) => Or.inl (Or.inr ⟨h3, h1⟩))))
  (fun (h0 : c ≤ 0) =>
    Or.elim or_b
      (fun (h4 : 0 ≤ b) =>
          Or.elim or_a (fun (h5 : 0 ≤ a) => Or.inl (Or.inl ⟨h5, h4⟩))
            (fun (h5 : a ≤ 0) => Or.inr (Or.inr (Or.inr ⟨h0, h5⟩))))
      (fun (h4 : b ≤ 0) =>
          Or.elim or_a (fun (_ : 0 ≤ a) => Or.inr (Or.inl (Or.inr ⟨h4, h0⟩)))
            (fun (h6 : a ≤ 0) => Or.inl (Or.inr ⟨h6, h4⟩))))
state_before: α : Type u
β : Type ?u.180652
inst✝ : LinearOrderedRing α
a✝ b✝ c✝ a b c : α
or_a : 0 ≤ a ∨ a ≤ 0
or_b : 0 ≤ b ∨ b ≤ 0
or_c : 0 ≤ c ∨ c ≤ 0
⊢ (0 ≤ a ∧ 0 ≤ b ∨ a ≤ 0 ∧ b ≤ 0) ∨ (0 ≤ b ∧ 0 ≤ c ∨ b ≤ 0 ∧ c ≤ 0) ∨ 0 ≤ c ∧ 0 ≤ a ∨ c ≤ 0 ∧ a ≤ 0

tactic: rw [mul_nonneg_iff]
state_before: α : Type u
β : Type ?u.180652
inst✝ : LinearOrderedRing α
a✝ b✝ c✝ a b c : α
⊢ (0 ≤ a ∧ 0 ≤ b ∨ a ≤ 0 ∧ b ≤ 0) ∨ (0 ≤ b ∧ 0 ≤ c ∨ b ≤ 0 ∧ c ≤ 0) ∨ 0 ≤ c * a
Theorem: Set.ncard_union_add_ncard_inter
File: Mathlib/Data/Set/Ncard.lean

tactic: have hu := hs.union ht
state_before: α : Type u_1
β : Type ?u.119105
s✝ t✝ : Set α
a b x y : α
f : α → β
s t : Set α
hs : autoParam (Set.Finite s) _auto✝
ht : autoParam (Set.Finite t) _auto✝
⊢ ncard (s ∪ t) + ncard (s ∩ t) = ncard s + ncard t

tactic: have hi := hs.subset (inter_subset_left s t)
state_before: α : Type u_1
β : Type ?u.119105
s✝ t✝ : Set α
a b x y : α
f : α → β
s t : Set α
hs : autoParam (Set.Finite s) _auto✝
ht : autoParam (Set.Finite t) _auto✝
hu : Set.Finite (s ∪ t)
⊢ ncard (s ∪ t) + ncard (s ∩ t) = ncard s + ncard t

tactic: rw [ncard_eq_toFinset_card _ hs, ncard_eq_toFinset_card _ ht, ncard_eq_toFinset_card _ hu,
  ncard_eq_toFinset_card _ hi, Finite.toFinset_union, Finite.toFinset_inter]
state_before: α : Type u_1
β : Type ?u.119105
s✝ t✝ : Set α
a b x y : α
f : α → β
s t : Set α
hs : autoParam (Set.Finite s) _auto✝
ht : autoParam (Set.Finite t) _auto✝
hu : Set.Finite (s ∪ t)
hi : Set.Finite (s ∩ t)
⊢ ncard (s ∪ t) + ncard (s ∩ t) = ncard s + ncard t

tactic: exact Finset.card_union_add_card_inter _ _
state_before: α : Type u_1
β : Type ?u.119105
s✝ t✝ : Set α
a b x y : α
f : α → β
s t : Set α
hs : autoParam (Set.Finite s) _auto✝
ht : autoParam (Set.Finite t) _auto✝
hu : Set.Finite (s ∪ t)
hi : Set.Finite (s ∩ t)
⊢ Finset.card (Finite.toFinset ?hs ∪ Finite.toFinset ?ht) + Finset.card (Finite.toFinset ?hs ∩ Finite.toFinset ?ht) =
    Finset.card (Finite.toFinset hs) + Finset.card (Finite.toFinset ht)
Theorem: mem_nhdsWithin_insert
File: Mathlib/Topology/ContinuousOn.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.19402
γ : Type ?u.19405
δ : Type ?u.19408
inst✝ : TopologicalSpace α
a : α
s t : Set α
⊢ t ∈ 𝓝[insert a s] a ↔ a ∈ t ∧ t ∈ 𝓝[s] a
Theorem: CategoryTheory.Mat.id_apply_self
File: Mathlib/CategoryTheory/Preadditive/Mat.lean

tactic: simp [id_apply]
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : Preadditive C
R : Type u
inst✝ : Semiring R
M : Mat R
i : ↑M
⊢ 𝟙 M i i = 1