1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Polynomial.le_natTrailingDegree_mul
File: Mathlib/Algebra/Polynomial/Degree/TrailingDegree.lean

tactic: have hp : p ≠ 0 := fun hp => h (by rw [hp, zero_mul])
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : p * q ≠ 0
⊢ p.natTrailingDegree + q.natTrailingDegree ≤ (p * q).natTrailingDegree
state_after: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : p * q ≠ 0
hp : p ≠ 0
⊢ p.natTrailingDegree + q.natTrailingDegree ≤ (p * q).natTrailingDegree

tactic: have hq : q ≠ 0 := fun hq => h (by rw [hq, mul_zero])
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : p * q ≠ 0
hp : p ≠ 0
⊢ p.natTrailingDegree + q.natTrailingDegree ≤ (p * q).natTrailingDegree
state_after: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : p * q ≠ 0
hp : p ≠ 0
hq : q ≠ 0
⊢ p.natTrailingDegree + q.natTrailingDegree ≤ (p * q).natTrailingDegree

tactic: have : ∀ (p : R[X]), WithTop.some (natTrailingDegree p) = Nat.cast (natTrailingDegree p) :=
  fun p ↦ rfl
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : p * q ≠ 0
hp : p ≠ 0
hq : q ≠ 0
⊢ p.natTrailingDegree + q.natTrailingDegree ≤ (p * q).natTrailingDegree
state_after: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : p * q ≠ 0
hp : p ≠ 0
hq : q ≠ 0
this : ∀ (p : R[X]), ↑p.natTrailingDegree = ↑p.natTrailingDegree
⊢ p.natTrailingDegree + q.natTrailingDegree ≤ (p * q).natTrailingDegree

tactic: rw [← WithTop.coe_le_coe, WithTop.coe_add, this p, this q, this (p * q),
  ← trailingDegree_eq_natTrailingDegree hp, ← trailingDegree_eq_natTrailingDegree hq,
  ← trailingDegree_eq_natTrailingDegree h]
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : p * q ≠ 0
hp : p ≠ 0
hq : q ≠ 0
this : ∀ (p : R[X]), ↑p.natTrailingDegree = ↑p.natTrailingDegree
⊢ p.natTrailingDegree + q.natTrailingDegree ≤ (p * q).natTrailingDegree
state_after: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : p * q ≠ 0
hp : p ≠ 0
hq : q ≠ 0
this : ∀ (p : R[X]), ↑p.natTrailingDegree = ↑p.natTrailingDegree
⊢ p.trailingDegree + q.trailingDegree ≤ (p * q).trailingDegree

tactic: exact le_trailingDegree_mul
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : p * q ≠ 0
hp : p ≠ 0
hq : q ≠ 0
this : ∀ (p : R[X]), ↑p.natTrailingDegree = ↑p.natTrailingDegree
⊢ p.trailingDegree + q.trailingDegree ≤ (p * q).trailingDegree
state_after: no goals

tactic: rw [hp, zero_mul]
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : p * q ≠ 0
hp : p = 0
⊢ p * q = 0
state_after: no goals

tactic: rw [hq, mul_zero]
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : p * q ≠ 0
hp : p ≠ 0
hq : q = 0
⊢ p * q = 0
state_after: no goals
Theorem: Set.iUnion_Icc_left
File: Mathlib/Order/Interval/Set/Disjoint.lean

tactic: simp only [← Ici_inter_Iic, ← iUnion_inter, iUnion_Ici, univ_inter]
state_before: ι : Sort u
α : Type v
β : Type w
inst✝ : Preorder α
a b✝ c b : α
⊢ ⋃ a, Icc a b = Iic b
state_after: no goals
Theorem: beq_ext
File: Mathlib/Logic/Basic.lean

tactic: have ⟨beq1⟩ := inst1
state_before: α : Type u_1
inst1 inst2 : BEq α
h : ∀ (x y : α), (x == y) = (x == y)
⊢ inst1 = inst2
state_after: α : Type u_1
inst1 inst2 : BEq α
beq1 : α → α → Bool
h : ∀ (x y : α), (x == y) = (x == y)
⊢ { beq := beq1 } = inst2

tactic: have ⟨beq2⟩ := inst2
state_before: α : Type u_1
inst1 inst2 : BEq α
beq1 : α → α → Bool
h : ∀ (x y : α), (x == y) = (x == y)
⊢ { beq := beq1 } = inst2
state_after: α : Type u_1
inst1 inst2 : BEq α
beq1 beq2 : α → α → Bool
h : ∀ (x y : α), (x == y) = (x == y)
⊢ { beq := beq1 } = { beq := beq2 }

tactic: congr
state_before: α : Type u_1
inst1 inst2 : BEq α
beq1 beq2 : α → α → Bool
h : ∀ (x y : α), (x == y) = (x == y)
⊢ { beq := beq1 } = { beq := beq2 }
state_after: case e_beq
α : Type u_1
inst1 inst2 : BEq α
beq1 beq2 : α → α → Bool
h : ∀ (x y : α), (x == y) = (x == y)
⊢ beq1 = beq2

tactic: funext x y
state_before: case e_beq
α : Type u_1
inst1 inst2 : BEq α
beq1 beq2 : α → α → Bool
h : ∀ (x y : α), (x == y) = (x == y)
⊢ beq1 = beq2
state_after: case e_beq.h.h
α : Type u_1
inst1 inst2 : BEq α
beq1 beq2 : α → α → Bool
h : ∀ (x y : α), (x == y) = (x == y)
x y : α
⊢ beq1 x y = beq2 x y

tactic: exact h x y
state_before: case e_beq.h.h
α : Type u_1
inst1 inst2 : BEq α
beq1 beq2 : α → α → Bool
h : ∀ (x y : α), (x == y) = (x == y)
x y : α
⊢ beq1 x y = beq2 x y
state_after: no goals
Theorem: MvPolynomial.totalDegree_finset_sum
File: Mathlib/Algebra/MvPolynomial/Degrees.lean

tactic: induction' s using Finset.cons_induction with a s has hind
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s✝ : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
ι : Type u_3
s : Finset ι
f : ι → MvPolynomial σ R
⊢ (s.sum f).totalDegree ≤ s.sup fun i => (f i).totalDegree
state_after: case empty
R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
ι : Type u_3
f : ι → MvPolynomial σ R
⊢ (∅.sum f).totalDegree ≤ ∅.sup fun i => (f i).totalDegree

case cons
R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s✝ : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
ι : Type u_3
f : ι → MvPolynomial σ R
a : ι
s : Finset ι
has : a ∉ s
hind : (s.sum f).totalDegree ≤ s.sup fun i => (f i).totalDegree
⊢ ((Finset.cons a s has).sum f).totalDegree ≤ (Finset.cons a s has).sup fun i => (f i).totalDegree

tactic: exact zero_le _
state_before: case empty
R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
ι : Type u_3
f : ι → MvPolynomial σ R
⊢ (∅.sum f).totalDegree ≤ ∅.sup fun i => (f i).totalDegree
state_after: no goals

tactic: rw [Finset.sum_cons, Finset.sup_cons, sup_eq_max]
state_before: case cons
R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s✝ : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
ι : Type u_3
f : ι → MvPolynomial σ R
a : ι
s : Finset ι
has : a ∉ s
hind : (s.sum f).totalDegree ≤ s.sup fun i => (f i).totalDegree
⊢ ((Finset.cons a s has).sum f).totalDegree ≤ (Finset.cons a s has).sup fun i => (f i).totalDegree
state_after: case cons
R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s✝ : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
ι : Type u_3
f : ι → MvPolynomial σ R
a : ι
s : Finset ι
has : a ∉ s
hind : (s.sum f).totalDegree ≤ s.sup fun i => (f i).totalDegree
⊢ (f a + ∑ x ∈ s, f x).totalDegree ≤ max (f a).totalDegree (s.sup fun i => (f i).totalDegree)

tactic: exact (MvPolynomial.totalDegree_add _ _).trans (max_le_max le_rfl hind)
state_before: case cons
R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s✝ : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
ι : Type u_3
f : ι → MvPolynomial σ R
a : ι
s : Finset ι
has : a ∉ s
hind : (s.sum f).totalDegree ≤ s.sup fun i => (f i).totalDegree
⊢ (f a + ∑ x ∈ s, f x).totalDegree ≤ max (f a).totalDegree (s.sup fun i => (f i).totalDegree)
state_after: no goals
Theorem: Matrix.mul_smul
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝⁵ : AddCommMonoid α
inst✝⁴ : Mul α
inst✝³ : Fintype n
inst✝² : Monoid R
inst✝¹ : DistribMulAction R α
inst✝ : SMulCommClass R α α
M : Matrix m n α
a : R
N : Matrix n l α
⊢ M * a • N = a • (M * N)
state_after: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝⁵ : AddCommMonoid α
inst✝⁴ : Mul α
inst✝³ : Fintype n
inst✝² : Monoid R
inst✝¹ : DistribMulAction R α
inst✝ : SMulCommClass R α α
M : Matrix m n α
a : R
N : Matrix n l α
i✝ : m
j✝ : l
⊢ (M * a • N) i✝ j✝ = (a • (M * N)) i✝ j✝

tactic: apply dotProduct_smul
state_before: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝⁵ : AddCommMonoid α
inst✝⁴ : Mul α
inst✝³ : Fintype n
inst✝² : Monoid R
inst✝¹ : DistribMulAction R α
inst✝ : SMulCommClass R α α
M : Matrix m n α
a : R
N : Matrix n l α
i✝ : m
j✝ : l
⊢ (M * a • N) i✝ j✝ = (a • (M * N)) i✝ j✝
state_after: no goals
Theorem: ProbabilityTheory.kernel.fst_prod
File: Mathlib/Probability/Kernel/Composition.lean

tactic: rw [prod]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
inst✝¹ : IsSFiniteKernel κ
η : ↥(kernel α γ)
inst✝ : IsMarkovKernel η
⊢ fst (κ ×ₖ η) = κ
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
inst✝¹ : IsSFiniteKernel κ
η : ↥(kernel α γ)
inst✝ : IsMarkovKernel η
⊢ fst (κ ⊗ₖ swapLeft (prodMkLeft β η)) = κ

tactic: simp
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
inst✝¹ : IsSFiniteKernel κ
η : ↥(kernel α γ)
inst✝ : IsMarkovKernel η
⊢ fst (κ ⊗ₖ swapLeft (prodMkLeft β η)) = κ
state_after: no goals
Theorem: SetTheory.PGame.nim_add_fuzzy_zero_iff
File: Mathlib/SetTheory/Game/Nim.lean

tactic: rw [iff_not_comm, Impartial.not_fuzzy_zero_iff, nim_add_equiv_zero_iff]
state_before: o₁ o₂ : Ordinal.{u_1}
⊢ nim o₁ + nim o₂ ‖ 0 ↔ o₁ ≠ o₂
state_after: no goals
Theorem: IsAdjoinRoot.aeval_eq
File: Mathlib/RingTheory/IsAdjoinRoot.lean

tactic: rw [aeval_C, h.algebraMap_apply]
state_before: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRoot S f
p : R[X]
x : R
⊢ (aeval h.root) (C x) = h.map (C x)
state_after: no goals

tactic: rw [AlgHom.map_add, RingHom.map_add, ihp, ihq]
state_before: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRoot S f
p✝ p q : R[X]
ihp : (aeval h.root) p = h.map p
ihq : (aeval h.root) q = h.map q
⊢ (aeval h.root) (p + q) = h.map (p + q)
state_after: no goals

tactic: rw [AlgHom.map_mul, aeval_C, AlgHom.map_pow, aeval_X, RingHom.map_mul, ← h.algebraMap_apply,
  RingHom.map_pow, map_X]
state_before: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRoot S f
p : R[X]
n : ℕ
x : R
x✝ : (aeval h.root) (C x * X ^ n) = h.map (C x * X ^ n)
⊢ (aeval h.root) (C x * X ^ (n + 1)) = h.map (C x * X ^ (n + 1))
state_after: no goals
Theorem: aestronglyMeasurable_add_measure_iff
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

tactic: rw [← sum_cond, aestronglyMeasurable_sum_measure_iff, Bool.forall_bool, and_comm]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝³ : Countable ι
m : MeasurableSpace α
μ ν✝ : Measure α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
f g : α → β
inst✝ : PseudoMetrizableSpace β
ν : Measure α
⊢ AEStronglyMeasurable f (μ + ν) ↔ AEStronglyMeasurable f μ ∧ AEStronglyMeasurable f ν
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝³ : Countable ι
m : MeasurableSpace α
μ ν✝ : Measure α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
f g : α → β
inst✝ : PseudoMetrizableSpace β
ν : Measure α
⊢ AEStronglyMeasurable f (bif true then μ else ν) ∧ AEStronglyMeasurable f (bif false then μ else ν) ↔
    AEStronglyMeasurable f μ ∧ AEStronglyMeasurable f ν

tactic: rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝³ : Countable ι
m : MeasurableSpace α
μ ν✝ : Measure α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
f g : α → β
inst✝ : PseudoMetrizableSpace β
ν : Measure α
⊢ AEStronglyMeasurable f (bif true then μ else ν) ∧ AEStronglyMeasurable f (bif false then μ else ν) ↔
    AEStronglyMeasurable f μ ∧ AEStronglyMeasurable f ν
state_after: no goals
Theorem: Quotient.induction_on_pi
File: Mathlib/Data/Quot.lean

tactic: rw [← (funext fun i ↦ Quotient.out_eq (f i) : (fun i ↦ ⟦(f i).out⟧) = f)]
state_before: α✝ : Sort u_1
β : Sort u_2
ι : Type u_3
α : ι → Sort u_4
s : (i : ι) → Setoid (α i)
p : ((i : ι) → Quotient (s i)) → Prop
f : (i : ι) → Quotient (s i)
h : ∀ (a : (i : ι) → α i), p fun i => ⟦a i⟧
⊢ p f
state_after: α✝ : Sort u_1
β : Sort u_2
ι : Type u_3
α : ι → Sort u_4
s : (i : ι) → Setoid (α i)
p : ((i : ι) → Quotient (s i)) → Prop
f : (i : ι) → Quotient (s i)
h : ∀ (a : (i : ι) → α i), p fun i => ⟦a i⟧
⊢ p fun i => ⟦(f i).out⟧

tactic: apply h
state_before: α✝ : Sort u_1
β : Sort u_2
ι : Type u_3
α : ι → Sort u_4
s : (i : ι) → Setoid (α i)
p : ((i : ι) → Quotient (s i)) → Prop
f : (i : ι) → Quotient (s i)
h : ∀ (a : (i : ι) → α i), p fun i => ⟦a i⟧
⊢ p fun i => ⟦(f i).out⟧
state_after: no goals
Theorem: ComplexShape.ε_zero
File: Mathlib/Algebra/Homology/ComplexShapeSigns.lean

tactic: apply MonoidHom.map_one
state_before: I₁ : Type u_1
I₂ : Type u_2
I₁₂ : Type u_3
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
c₁₂ : ComplexShape I₁₂
inst✝² : TotalComplexShape c₁ c₂ c₁₂
I : Type u_4
inst✝¹ : AddMonoid I
c : ComplexShape I
inst✝ : c.TensorSigns
⊢ c.ε 0 = 1
state_after: no goals
Theorem: Multiset.erase_add_right_pos
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [add_comm, erase_add_left_pos s h, add_comm]
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ t✝ : Multiset α
a✝ b a : α
s t : Multiset α
h : a ∈ t
⊢ (s + t).erase a = s + t.erase a
state_after: no goals
Theorem: Int.coe_negOnePow
File: Mathlib/Algebra/Ring/NegOnePow.lean

tactic: rcases even_or_odd' n with ⟨k, rfl | rfl⟩
state_before: K : Type u_1
n : ℤ
inst✝ : Field K
⊢ ↑↑n.negOnePow = (-1) ^ n
state_after: case intro.inl
K : Type u_1
inst✝ : Field K
k : ℤ
⊢ ↑↑(2 * k).negOnePow = (-1) ^ (2 * k)

case intro.inr
K : Type u_1
inst✝ : Field K
k : ℤ
⊢ ↑↑(2 * k + 1).negOnePow = (-1) ^ (2 * k + 1)

tactic: rw [zpow_mul, zpow_ofNat]
state_before: case intro.inl
K : Type u_1
inst✝ : Field K
k : ℤ
⊢ ↑↑(2 * k).negOnePow = (-1) ^ (2 * k)
state_after: case intro.inl
K : Type u_1
inst✝ : Field K
k : ℤ
⊢ ↑↑(2 * k).negOnePow = ((-1) ^ 2) ^ k

tactic: simp
state_before: case intro.inl
K : Type u_1
inst✝ : Field K
k : ℤ
⊢ ↑↑(2 * k).negOnePow = ((-1) ^ 2) ^ k
state_after: no goals

tactic: rw [zpow_add_one₀ (by norm_num), zpow_mul, zpow_ofNat]
state_before: case intro.inr
K : Type u_1
inst✝ : Field K
k : ℤ
⊢ ↑↑(2 * k + 1).negOnePow = (-1) ^ (2 * k + 1)
state_after: case intro.inr
K : Type u_1
inst✝ : Field K
k : ℤ
⊢ ↑↑(2 * k + 1).negOnePow = ((-1) ^ 2) ^ k * -1

tactic: simp
state_before: case intro.inr
K : Type u_1
inst✝ : Field K
k : ℤ
⊢ ↑↑(2 * k + 1).negOnePow = ((-1) ^ 2) ^ k * -1
state_after: no goals

tactic: norm_num
state_before: K : Type u_1
inst✝ : Field K
k : ℤ
⊢ -1 ≠ 0
state_after: no goals
Theorem: Stream'.WSeq.exists_of_mem_map
File: Mathlib/Data/Seq/WSeq.lean

tactic: let ⟨o, om, oe⟩ := Seq.exists_of_mem_map h
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
b : β
g : Stream' (Option (Option α))
al : g.IsSeq
h : b ∈ map f ⟨g, al⟩
⊢ ∃ a, a ∈ ⟨g, al⟩ ∧ f a = b
state_after: α : Type u
β : Type v
γ : Type w
f : α → β
b : β
g : Stream' (Option (Option α))
al : g.IsSeq
h : b ∈ map f ⟨g, al⟩
o : Option α
om : o ∈ ⟨g, al⟩
oe : Option.map f o = some b
⊢ ∃ a, a ∈ ⟨g, al⟩ ∧ f a = b

tactic: cases' o with a
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
b : β
g : Stream' (Option (Option α))
al : g.IsSeq
h : b ∈ map f ⟨g, al⟩
o : Option α
om : o ∈ ⟨g, al⟩
oe : Option.map f o = some b
⊢ ∃ a, a ∈ ⟨g, al⟩ ∧ f a = b
state_after: case none
α : Type u
β : Type v
γ : Type w
f : α → β
b : β
g : Stream' (Option (Option α))
al : g.IsSeq
h : b ∈ map f ⟨g, al⟩
om : none ∈ ⟨g, al⟩
oe : Option.map f none = some b
⊢ ∃ a, a ∈ ⟨g, al⟩ ∧ f a = b

case some
α : Type u
β : Type v
γ : Type w
f : α → β
b : β
g : Stream' (Option (Option α))
al : g.IsSeq
h : b ∈ map f ⟨g, al⟩
a : α
om : some a ∈ ⟨g, al⟩
oe : Option.map f (some a) = some b
⊢ ∃ a, a ∈ ⟨g, al⟩ ∧ f a = b

tactic: injection oe with h'
state_before: case some
α : Type u
β : Type v
γ : Type w
f : α → β
b : β
g : Stream' (Option (Option α))
al : g.IsSeq
h : b ∈ map f ⟨g, al⟩
a : α
om : some a ∈ ⟨g, al⟩
oe : Option.map f (some a) = some b
⊢ ∃ a, a ∈ ⟨g, al⟩ ∧ f a = b
state_after: case some
α : Type u
β : Type v
γ : Type w
f : α → β
b : β
g : Stream' (Option (Option α))
al : g.IsSeq
h : b ∈ map f ⟨g, al⟩
a : α
om : some a ∈ ⟨g, al⟩
h' : f a = b
⊢ ∃ a, a ∈ ⟨g, al⟩ ∧ f a = b

tactic: exact ⟨a, om, h'⟩
state_before: case some
α : Type u
β : Type v
γ : Type w
f : α → β
b : β
g : Stream' (Option (Option α))
al : g.IsSeq
h : b ∈ map f ⟨g, al⟩
a : α
om : some a ∈ ⟨g, al⟩
h' : f a = b
⊢ ∃ a, a ∈ ⟨g, al⟩ ∧ f a = b
state_after: no goals

tactic: injection oe
state_before: case none
α : Type u
β : Type v
γ : Type w
f : α → β
b : β
g : Stream' (Option (Option α))
al : g.IsSeq
h : b ∈ map f ⟨g, al⟩
om : none ∈ ⟨g, al⟩
oe : Option.map f none = some b
⊢ ∃ a, a ∈ ⟨g, al⟩ ∧ f a = b
state_after: no goals
Theorem: CategoryTheory.Subgroupoid.isWide_iff_objs_eq_univ
File: Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean

tactic: constructor
state_before: C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
⊢ S.IsWide ↔ S.objs = univ
state_after: case mp
C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
⊢ S.IsWide → S.objs = univ

case mpr
C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
⊢ S.objs = univ → S.IsWide

tactic: rintro h
state_before: case mp
C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
⊢ S.IsWide → S.objs = univ
state_after: case mp
C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
h : S.IsWide
⊢ S.objs = univ

tactic: ext x
state_before: case mp
C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
h : S.IsWide
⊢ S.objs = univ
state_after: case mp.h
C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
h : S.IsWide
x : C
⊢ x ∈ S.objs ↔ x ∈ univ

tactic: constructor <;> simp only [top_eq_univ, mem_univ, imp_true_iff, forall_true_left]
state_before: case mp.h
C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
h : S.IsWide
x : C
⊢ x ∈ S.objs ↔ x ∈ univ
state_after: case mp.h.mpr
C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
h : S.IsWide
x : C
⊢ x ∈ S.objs

tactic: apply mem_objs_of_src S (h.wide x)
state_before: case mp.h.mpr
C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
h : S.IsWide
x : C
⊢ x ∈ S.objs
state_after: no goals

tactic: rintro h
state_before: case mpr
C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
⊢ S.objs = univ → S.IsWide
state_after: case mpr
C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
h : S.objs = univ
⊢ S.IsWide

tactic: refine ⟨fun c => ?_⟩
state_before: case mpr
C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
h : S.objs = univ
⊢ S.IsWide
state_after: case mpr
C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
h : S.objs = univ
c : C
⊢ 𝟙 c ∈ S.arrows c c

tactic: obtain ⟨γ, γS⟩ := (le_of_eq h.symm : ⊤ ⊆ S.objs) (Set.mem_univ c)
state_before: case mpr
C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
h : S.objs = univ
c : C
⊢ 𝟙 c ∈ S.arrows c c
state_after: case mpr.intro
C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
h : S.objs = univ
c : C
γ : c ⟶ c
γS : γ ∈ S.arrows c c
⊢ 𝟙 c ∈ S.arrows c c

tactic: exact id_mem_of_src S γS
state_before: case mpr.intro
C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
h : S.objs = univ
c : C
γ : c ⟶ c
γS : γ ∈ S.arrows c c
⊢ 𝟙 c ∈ S.arrows c c
state_after: no goals
Theorem: Multiset.powersetCardAux_zero
File: Mathlib/Data/Multiset/Powerset.lean

tactic: simp [powersetCardAux_eq_map_coe]
state_before: α : Type u_1
l : List α
⊢ powersetCardAux 0 l = [0]
state_after: no goals
Theorem: MeasureTheory.OuterMeasure.mkMetric'.tendsto_pre_nat
File: Mathlib/MeasureTheory/Measure/Hausdorff.lean

tactic: refine (tendsto_pre m s).comp (tendsto_inf.2 ⟨ENNReal.tendsto_inv_nat_nhds_zero, ?_⟩)
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝¹ : EMetricSpace X
inst✝ : EMetricSpace Y
m✝ : Set X → ℝ≥0∞
r : ℝ≥0∞
μ : OuterMeasure X
s✝ : Set X
m : Set X → ℝ≥0∞
s : Set X
⊢ Tendsto (fun n => (pre m (↑n)⁻¹) s) atTop (𝓝 ((mkMetric' m) s))
state_after: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝¹ : EMetricSpace X
inst✝ : EMetricSpace Y
m✝ : Set X → ℝ≥0∞
r : ℝ≥0∞
μ : OuterMeasure X
s✝ : Set X
m : Set X → ℝ≥0∞
s : Set X
⊢ Tendsto (fun n => (↑n)⁻¹) atTop (𝓟 (Ioi 0))

tactic: refine tendsto_principal.2 (eventually_of_forall fun n => ?_)
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝¹ : EMetricSpace X
inst✝ : EMetricSpace Y
m✝ : Set X → ℝ≥0∞
r : ℝ≥0∞
μ : OuterMeasure X
s✝ : Set X
m : Set X → ℝ≥0∞
s : Set X
⊢ Tendsto (fun n => (↑n)⁻¹) atTop (𝓟 (Ioi 0))
state_after: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝¹ : EMetricSpace X
inst✝ : EMetricSpace Y
m✝ : Set X → ℝ≥0∞
r : ℝ≥0∞
μ : OuterMeasure X
s✝ : Set X
m : Set X → ℝ≥0∞
s : Set X
n : ℕ
⊢ (↑n)⁻¹ ∈ Ioi 0

tactic: simp
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝¹ : EMetricSpace X
inst✝ : EMetricSpace Y
m✝ : Set X → ℝ≥0∞
r : ℝ≥0∞
μ : OuterMeasure X
s✝ : Set X
m : Set X → ℝ≥0∞
s : Set X
n : ℕ
⊢ (↑n)⁻¹ ∈ Ioi 0
state_after: no goals
Theorem: HasStrictFDerivAt.comp
File: Mathlib/Analysis/Calculus/FDeriv/Comp.lean

tactic: simpa only [g'.map_sub, f'.coe_comp'] using (g'.isBigO_comp _ _).trans_isLittleO hf
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
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g✝ : E → F
f' f₀' f₁' g'✝ e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
g : F → G
g' : F →L[𝕜] G
hg : HasStrictFDerivAt g g' (f x)
hf : HasStrictFDerivAt f f' x
⊢ (fun x =>
      g' (((fun p => (f p.1, f p.2)) x).1 - ((fun p => (f p.1, f p.2)) x).2) - (g'.comp f') (x.1 - x.2)) =o[𝓝 (x, x)]
    fun p => p.1 - p.2
state_after: no goals