1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: CategoryTheory.Limits.PullbackCone.mono_fst_of_is_pullback_of_mono
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: refine ⟨fun {W} h k i => IsLimit.hom_ext ht i ?_⟩
state_before: C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
t : PullbackCone f g
ht : IsLimit t
inst✝ : Mono g
⊢ Mono t.fst
state_after: C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
t : PullbackCone f g
ht : IsLimit t
inst✝ : Mono g
W : C
h k : W ⟶ t.pt
i : h ≫ t.fst = k ≫ t.fst
⊢ h ≫ t.snd = k ≫ t.snd

tactic: rw [← cancel_mono g, Category.assoc, Category.assoc, ← condition]
state_before: C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
t : PullbackCone f g
ht : IsLimit t
inst✝ : Mono g
W : C
h k : W ⟶ t.pt
i : h ≫ t.fst = k ≫ t.fst
⊢ h ≫ t.snd = k ≫ t.snd
state_after: C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
t : PullbackCone f g
ht : IsLimit t
inst✝ : Mono g
W : C
h k : W ⟶ t.pt
i : h ≫ t.fst = k ≫ t.fst
⊢ h ≫ t.fst ≫ f = k ≫ t.fst ≫ f

tactic: dsimp at this
state_before: C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
t : PullbackCone f g
ht : IsLimit t
inst✝ : Mono g
W : C
h k : W ⟶ t.pt
i : h ≫ t.fst = k ≫ t.fst
this : (fun x => x ≫ f) (h ≫ t.fst) = (fun x => x ≫ f) (k ≫ t.fst)
⊢ h ≫ t.fst ≫ f = k ≫ t.fst ≫ f
state_after: C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
t : PullbackCone f g
ht : IsLimit t
inst✝ : Mono g
W : C
h k : W ⟶ t.pt
i : h ≫ t.fst = k ≫ t.fst
this : (h ≫ t.fst) ≫ f = (k ≫ t.fst) ≫ f
⊢ h ≫ t.fst ≫ f = k ≫ t.fst ≫ f

tactic: rwa [Category.assoc, Category.assoc] at this
state_before: C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
t : PullbackCone f g
ht : IsLimit t
inst✝ : Mono g
W : C
h k : W ⟶ t.pt
i : h ≫ t.fst = k ≫ t.fst
this : (h ≫ t.fst) ≫ f = (k ≫ t.fst) ≫ f
⊢ h ≫ t.fst ≫ f = k ≫ t.fst ≫ f
state_after: no goals
Theorem: Polynomial.degree_add_le
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

tactic: simpa only [degree, ← support_toFinsupp, toFinsupp_add]
  using AddMonoidAlgebra.sup_support_add_le _ _ _
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝¹ p✝ q✝ : R[X]
ι : Type u_1
p q : R[X]
⊢ (p + q).degree ≤ max p.degree q.degree
state_after: no goals
Theorem: Nat.measurable_ceil
File: Mathlib/MeasureTheory/Function/Floor.lean

tactic: rcases eq_or_ne ⌈n⌉₊ 0 with h | h <;> simp_all [h, Nat.preimage_ceil_of_ne_zero, -ceil_eq_zero]
state_before: α : Type u_1
R : Type u_2
inst✝⁶ : MeasurableSpace α
inst✝⁵ : LinearOrderedSemiring R
inst✝⁴ : FloorSemiring R
inst✝³ : TopologicalSpace R
inst✝² : OrderTopology R
inst✝¹ : MeasurableSpace R
inst✝ : OpensMeasurableSpace R
f : α → R
n : R
⊢ MeasurableSet (ceil ⁻¹' {⌈n⌉₊})
state_after: no goals
Theorem: IsLocalizedModule.mk'_sub
File: Mathlib/Algebra/Module/LocalizedModule.lean

tactic: rw [sub_eq_add_neg, sub_eq_add_neg, mk'_add, mk'_neg]
state_before: R : Type u_1
inst✝¹⁷ : CommSemiring R
S : Submonoid R
M✝ : Type u_2
M'✝ : Type u_3
M'' : Type u_4
inst✝¹⁶ : AddCommMonoid M✝
inst✝¹⁵ : AddCommMonoid M'✝
inst✝¹⁴ : AddCommMonoid M''
A : Type u_5
inst✝¹³ : CommSemiring A
inst✝¹² : Algebra R A
inst✝¹¹ : Module A M'✝
inst✝¹⁰ : IsLocalization S A
inst✝⁹ : Module R M✝
inst✝⁸ : Module R M'✝
inst✝⁷ : Module R M''
inst✝⁶ : IsScalarTower R A M'✝
f✝ : M✝ →ₗ[R] M'✝
g : M✝ →ₗ[R] M''
inst✝⁵ : IsLocalizedModule S f✝
M : Type u_6
M' : Type u_7
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup M'
inst✝² : Module R M
inst✝¹ : Module R M'
f : M →ₗ[R] M'
inst✝ : IsLocalizedModule S f
m₁ m₂ : M
s : ↥S
⊢ mk' f (m₁ - m₂) s = mk' f m₁ s - mk' f m₂ s
state_after: no goals
Theorem: LinearPMap.right_le_sup
File: Mathlib/LinearAlgebra/LinearPMap.lean

tactic: refine ⟨le_sup_right, fun z₁ z₂ hz => ?_⟩
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : ↥f.domain) (y : ↥g.domain), ↑x = ↑y → ↑f x = ↑g y
⊢ g ≤ f.sup g h
state_after: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : ↥f.domain) (y : ↥g.domain), ↑x = ↑y → ↑f x = ↑g y
z₁ : ↥g.domain
z₂ : ↥(f.sup g h).domain
hz : ↑z₁ = ↑z₂
⊢ ↑g z₁ = ↑(f.sup g h) z₂

tactic: rw [← zero_add (g _), ← f.map_zero]
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : ↥f.domain) (y : ↥g.domain), ↑x = ↑y → ↑f x = ↑g y
z₁ : ↥g.domain
z₂ : ↥(f.sup g h).domain
hz : ↑z₁ = ↑z₂
⊢ ↑g z₁ = ↑(f.sup g h) z₂
state_after: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : ↥f.domain) (y : ↥g.domain), ↑x = ↑y → ↑f x = ↑g y
z₁ : ↥g.domain
z₂ : ↥(f.sup g h).domain
hz : ↑z₁ = ↑z₂
⊢ ↑f 0 + ↑g z₁ = ↑(f.sup g h) z₂

tactic: refine (sup_apply h _ _ _ ?_).symm
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : ↥f.domain) (y : ↥g.domain), ↑x = ↑y → ↑f x = ↑g y
z₁ : ↥g.domain
z₂ : ↥(f.sup g h).domain
hz : ↑z₁ = ↑z₂
⊢ ↑f 0 + ↑g z₁ = ↑(f.sup g h) z₂
state_after: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : ↥f.domain) (y : ↥g.domain), ↑x = ↑y → ↑f x = ↑g y
z₁ : ↥g.domain
z₂ : ↥(f.sup g h).domain
hz : ↑z₁ = ↑z₂
⊢ ↑0 + ↑z₁ = ↑z₂

tactic: simpa
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : ↥f.domain) (y : ↥g.domain), ↑x = ↑y → ↑f x = ↑g y
z₁ : ↥g.domain
z₂ : ↥(f.sup g h).domain
hz : ↑z₁ = ↑z₂
⊢ ↑0 + ↑z₁ = ↑z₂
state_after: no goals
Theorem: Cardinal.lift_umax_eq
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [← lift_lift.{v, w, u}, ← lift_lift.{u, w, v}, lift_inj]
state_before: α β : Type u
a : Cardinal.{u}
b : Cardinal.{v}
⊢ lift.{max v w, u} a = lift.{max u w, v} b ↔ lift.{v, u} a = lift.{u, v} b
state_after: no goals
Theorem: Int.gcd_div_gcd_div_gcd
File: Mathlib/Data/Int/GCD.lean

tactic: rw [gcd_div gcd_dvd_left gcd_dvd_right, natAbs_ofNat, Nat.div_self H]
state_before: i j : ℤ
H : 0 < i.gcd j
⊢ (i / ↑(i.gcd j)).gcd (j / ↑(i.gcd j)) = 1
state_after: no goals
Theorem: WittVector.verschiebung_zmod
File: Mathlib/RingTheory/WittVector/Identities.lean

tactic: rw [← frobenius_verschiebung, frobenius_zmodp]
state_before: p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
x : 𝕎 (ZMod p)
⊢ verschiebung x = x * ↑p
state_after: no goals
Theorem: Real.deriv_arccos
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/InverseDeriv.lean

tactic: simp only [deriv_arcsin]
state_before: x : ℝ
⊢ -deriv arcsin x = -(1 / √(1 - x ^ 2))
state_after: no goals
Theorem: Filter.smallSets_comap_eq_comap_image
File: Mathlib/Order/Filter/SmallSets.lean

tactic: refine (gc_map_comap _).u_comm_of_l_comm (gc_map_comap _) bind_smallSets_gc bind_smallSets_gc ?_
state_before: α : Type u_1
β : Type u_2
ι : Sort u_3
l✝ l' la : Filter α
lb l : Filter β
f : α → β
⊢ (comap f l).smallSets = comap (image f) l.smallSets
state_after: α : Type u_1
β : Type u_2
ι : Sort u_3
l✝ l' la : Filter α
lb l : Filter β
f : α → β
⊢ ∀ (x : Filter (Set α)), map f (x.bind 𝓟) = (map (image f) x).bind 𝓟

tactic: simp [Function.comp, map_bind, bind_map]
state_before: α : Type u_1
β : Type u_2
ι : Sort u_3
l✝ l' la : Filter α
lb l : Filter β
f : α → β
⊢ ∀ (x : Filter (Set α)), map f (x.bind 𝓟) = (map (image f) x).bind 𝓟
state_after: no goals
Theorem: List.range_succ
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: simp only [range_eq_range', range'_1_concat, Nat.zero_add]
state_before: n : Nat
⊢ range n.succ = range n ++ [n]
state_after: no goals
Theorem: DirichletCharacter.conductor_one_dvd
File: Mathlib/NumberTheory/DirichletCharacter/Basic.lean

tactic: rw [(isPrimitive_def _).mp isPrimitive_one_level_one]
state_before: R : Type u_1
inst✝ : CommMonoidWithZero R
n✝ : ℕ
χ : DirichletCharacter R n✝
n : ℕ
⊢ conductor 1 ∣ n
state_after: R : Type u_1
inst✝ : CommMonoidWithZero R
n✝ : ℕ
χ : DirichletCharacter R n✝
n : ℕ
⊢ 1 ∣ n

tactic: apply one_dvd _
state_before: R : Type u_1
inst✝ : CommMonoidWithZero R
n✝ : ℕ
χ : DirichletCharacter R n✝
n : ℕ
⊢ 1 ∣ n
state_after: no goals
Theorem: AddCommGroup.modEq_iff_eq_add_zsmul
File: Mathlib/Algebra/ModEq.lean

tactic: simp_rw [ModEq, sub_eq_iff_eq_add']
state_before: α : Type u_1
inst✝ : AddCommGroup α
p a a₁ a₂ b b₁ b₂ c : α
n : ℕ
z : ℤ
⊢ a ≡ b [PMOD p] ↔ ∃ z, b = a + z • p
state_after: no goals
Theorem: Set.inter_nonempty_iff_exists_right
File: Mathlib/Data/Set/Basic.lean

tactic: simp_rw [inter_nonempty, and_comm]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
⊢ (s ∩ t).Nonempty ↔ ∃ x ∈ t, x ∈ s
state_after: no goals
Theorem: Finset.mem_eraseNone
File: Mathlib/Data/Finset/Option.lean

tactic: simp [eraseNone]
state_before: α : Type u_1
β : Type u_2
s : Finset (Option α)
x : α
⊢ x ∈ eraseNone s ↔ some x ∈ s
state_after: no goals
Theorem: Std.Range.numElems_le_iff
File: .lake/packages/batteries/Batteries/Data/Range/Lemmas.lean

tactic: rw [← Nat.lt_succ (n := i), Nat.div_lt_iff_lt_mul hstep, Nat.mul_comm, ← Nat.mul_succ]
state_before: start stop step i : Nat
hstep : 0 < step
⊢ (stop - start + step - 1) / step ≤ i ↔ stop - start + step - 1 < step * i + step
state_after: no goals

tactic: rw [Nat.add_right_comm, Nat.add_assoc, Nat.sub_add_cancel hstep]
state_before: start stop step i : Nat
hstep : 0 < step
⊢ stop - start + step - 1 < step * i + step ↔ stop - start + step - 1 < step * i + 1 + (step - 1)
state_after: no goals

tactic: rw [Nat.add_sub_assoc hstep, Nat.add_lt_add_iff_right, Nat.lt_succ,
  Nat.sub_le_iff_le_add']
state_before: start stop step i : Nat
hstep : 0 < step
⊢ stop - start + step - 1 < step * i + 1 + (step - 1) ↔ stop ≤ start + step * i
state_after: no goals
Theorem: List.dropWhile_idempotent
File: Mathlib/Data/List/DropRight.lean

tactic: simp only [dropWhile_eq_self_iff]
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
⊢ dropWhile p (dropWhile p l) = dropWhile p l
state_after: α : Type u_1
p : α → Bool
l : List α
n : ℕ
⊢ ∀ (hl : 0 < (dropWhile p l).length), ¬p ((dropWhile p l).get ⟨0, hl⟩) = true

tactic: exact fun h => dropWhile_nthLe_zero_not p l h
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
⊢ ∀ (hl : 0 < (dropWhile p l).length), ¬p ((dropWhile p l).get ⟨0, hl⟩) = true
state_after: no goals
Theorem: Asymptotics.SuperpolynomialDecay.trans_eventually_abs_le
File: Mathlib/Analysis/Asymptotics/SuperpolynomialDecay.lean

tactic: rw [superpolynomialDecay_iff_abs_tendsto_zero] at hf ⊢
state_before: α : Type u_1
β : Type u_2
l : Filter α
k f g g' : α → β
inst✝² : TopologicalSpace β
inst✝¹ : LinearOrderedCommRing β
inst✝ : OrderTopology β
hf : SuperpolynomialDecay l k f
hfg : abs ∘ g ≤ᶠ[l] abs ∘ f
⊢ SuperpolynomialDecay l k g
state_after: α : Type u_1
β : Type u_2
l : Filter α
k f g g' : α → β
inst✝² : TopologicalSpace β
inst✝¹ : LinearOrderedCommRing β
inst✝ : OrderTopology β
hf : ∀ (n : ℕ), Tendsto (fun a => |k a ^ n * f a|) l (𝓝 0)
hfg : abs ∘ g ≤ᶠ[l] abs ∘ f
⊢ ∀ (n : ℕ), Tendsto (fun a => |k a ^ n * g a|) l (𝓝 0)

tactic: refine fun z =>
  tendsto_of_tendsto_of_tendsto_of_le_of_le' tendsto_const_nhds (hf z)
    (eventually_of_forall fun x => abs_nonneg _) (hfg.mono fun x hx => ?_)
state_before: α : Type u_1
β : Type u_2
l : Filter α
k f g g' : α → β
inst✝² : TopologicalSpace β
inst✝¹ : LinearOrderedCommRing β
inst✝ : OrderTopology β
hf : ∀ (n : ℕ), Tendsto (fun a => |k a ^ n * f a|) l (𝓝 0)
hfg : abs ∘ g ≤ᶠ[l] abs ∘ f
⊢ ∀ (n : ℕ), Tendsto (fun a => |k a ^ n * g a|) l (𝓝 0)
state_after: α : Type u_1
β : Type u_2
l : Filter α
k f g g' : α → β
inst✝² : TopologicalSpace β
inst✝¹ : LinearOrderedCommRing β
inst✝ : OrderTopology β
hf : ∀ (n : ℕ), Tendsto (fun a => |k a ^ n * f a|) l (𝓝 0)
hfg : abs ∘ g ≤ᶠ[l] abs ∘ f
z : ℕ
x : α
hx : (abs ∘ g) x ≤ (abs ∘ f) x
⊢ |k x ^ z * g x| ≤ |k x ^ z * f x|

tactic: calc
  |k x ^ z * g x| = |k x ^ z| * |g x| := abs_mul (k x ^ z) (g x)
  _ ≤ |k x ^ z| * |f x| := by gcongr _ * ?_; exact hx
  _ = |k x ^ z * f x| := (abs_mul (k x ^ z) (f x)).symm
state_before: α : Type u_1
β : Type u_2
l : Filter α
k f g g' : α → β
inst✝² : TopologicalSpace β
inst✝¹ : LinearOrderedCommRing β
inst✝ : OrderTopology β
hf : ∀ (n : ℕ), Tendsto (fun a => |k a ^ n * f a|) l (𝓝 0)
hfg : abs ∘ g ≤ᶠ[l] abs ∘ f
z : ℕ
x : α
hx : (abs ∘ g) x ≤ (abs ∘ f) x
⊢ |k x ^ z * g x| ≤ |k x ^ z * f x|
state_after: no goals

tactic: gcongr _ * ?_
state_before: α : Type u_1
β : Type u_2
l : Filter α
k f g g' : α → β
inst✝² : TopologicalSpace β
inst✝¹ : LinearOrderedCommRing β
inst✝ : OrderTopology β
hf : ∀ (n : ℕ), Tendsto (fun a => |k a ^ n * f a|) l (𝓝 0)
hfg : abs ∘ g ≤ᶠ[l] abs ∘ f
z : ℕ
x : α
hx : (abs ∘ g) x ≤ (abs ∘ f) x
⊢ |k x ^ z| * |g x| ≤ |k x ^ z| * |f x|
state_after: case h
α : Type u_1
β : Type u_2
l : Filter α
k f g g' : α → β
inst✝² : TopologicalSpace β
inst✝¹ : LinearOrderedCommRing β
inst✝ : OrderTopology β
hf : ∀ (n : ℕ), Tendsto (fun a => |k a ^ n * f a|) l (𝓝 0)
hfg : abs ∘ g ≤ᶠ[l] abs ∘ f
z : ℕ
x : α
hx : (abs ∘ g) x ≤ (abs ∘ f) x
⊢ |g x| ≤ |f x|

tactic: exact hx
state_before: case h
α : Type u_1
β : Type u_2
l : Filter α
k f g g' : α → β
inst✝² : TopologicalSpace β
inst✝¹ : LinearOrderedCommRing β
inst✝ : OrderTopology β
hf : ∀ (n : ℕ), Tendsto (fun a => |k a ^ n * f a|) l (𝓝 0)
hfg : abs ∘ g ≤ᶠ[l] abs ∘ f
z : ℕ
x : α
hx : (abs ∘ g) x ≤ (abs ∘ f) x
⊢ |g x| ≤ |f x|
state_after: no goals
Theorem: Nat.add_modEq_left
File: Mathlib/Data/Nat/ModEq.lean

tactic: rw [ModEq, add_mod_left]
state_before: m n a b c d : ℕ
⊢ n + a ≡ a [MOD n]
state_after: no goals
Theorem: MeasureTheory.VectorMeasure.AbsolutelyContinuous.add
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: intro s hs
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
L : Type u_3
M : Type u_4
N : Type u_5
inst✝⁶ : AddCommMonoid L
inst✝⁵ : TopologicalSpace L
inst✝⁴ : AddCommMonoid M
inst✝³ : TopologicalSpace M
inst✝² : AddCommMonoid N
inst✝¹ : TopologicalSpace N
v : VectorMeasure α M
w✝ : VectorMeasure α N
inst✝ : ContinuousAdd M
v₁ v₂ : VectorMeasure α M
w : VectorMeasure α N
hv₁ : v₁ ≪ᵥ w
hv₂ : v₂ ≪ᵥ w
⊢ v₁ + v₂ ≪ᵥ w
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
L : Type u_3
M : Type u_4
N : Type u_5
inst✝⁶ : AddCommMonoid L
inst✝⁵ : TopologicalSpace L
inst✝⁴ : AddCommMonoid M
inst✝³ : TopologicalSpace M
inst✝² : AddCommMonoid N
inst✝¹ : TopologicalSpace N
v : VectorMeasure α M
w✝ : VectorMeasure α N
inst✝ : ContinuousAdd M
v₁ v₂ : VectorMeasure α M
w : VectorMeasure α N
hv₁ : v₁ ≪ᵥ w
hv₂ : v₂ ≪ᵥ w
s : Set α
hs : ↑w s = 0
⊢ ↑(v₁ + v₂) s = 0

tactic: rw [add_apply, hv₁ hs, hv₂ hs, zero_add]
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
L : Type u_3
M : Type u_4
N : Type u_5
inst✝⁶ : AddCommMonoid L
inst✝⁵ : TopologicalSpace L
inst✝⁴ : AddCommMonoid M
inst✝³ : TopologicalSpace M
inst✝² : AddCommMonoid N
inst✝¹ : TopologicalSpace N
v : VectorMeasure α M
w✝ : VectorMeasure α N
inst✝ : ContinuousAdd M
v₁ v₂ : VectorMeasure α M
w : VectorMeasure α N
hv₁ : v₁ ≪ᵥ w
hv₂ : v₂ ≪ᵥ w
s : Set α
hs : ↑w s = 0
⊢ ↑(v₁ + v₂) s = 0
state_after: no goals
Theorem: Stream'.Seq.append_nil
File: Mathlib/Data/Seq/Seq.lean

tactic: apply coinduction2 s
state_before: α : Type u
β : Type v
γ : Type w
s : Seq α
⊢ s.append nil = s
state_after: case H
α : Type u
β : Type v
γ : Type w
s : Seq α
⊢ ∀ (s : Seq α), BisimO (fun s1 s2 => ∃ s, s1 = s.append nil ∧ s2 = s) (s.append nil).destruct s.destruct

tactic: intro s
state_before: case H
α : Type u
β : Type v
γ : Type w
s : Seq α
⊢ ∀ (s : Seq α), BisimO (fun s1 s2 => ∃ s, s1 = s.append nil ∧ s2 = s) (s.append nil).destruct s.destruct
state_after: case H
α : Type u
β : Type v
γ : Type w
s✝ s : Seq α
⊢ BisimO (fun s1 s2 => ∃ s, s1 = s.append nil ∧ s2 = s) (s.append nil).destruct s.destruct

tactic: apply recOn s _ _
state_before: case H
α : Type u
β : Type v
γ : Type w
s✝ s : Seq α
⊢ BisimO (fun s1 s2 => ∃ s, s1 = s.append nil ∧ s2 = s) (s.append nil).destruct s.destruct
state_after: α : Type u
β : Type v
γ : Type w
s✝ s : Seq α
⊢ BisimO (fun s1 s2 => ∃ s, s1 = s.append nil ∧ s2 = s) (nil.append nil).destruct nil.destruct

α : Type u
β : Type v
γ : Type w
s✝ s : Seq α
⊢ ∀ (x : α) (s : Seq α),
    BisimO (fun s1 s2 => ∃ s, s1 = s.append nil ∧ s2 = s) ((cons x s).append nil).destruct (cons x s).destruct

tactic: trivial
state_before: α : Type u
β : Type v
γ : Type w
s✝ s : Seq α
⊢ BisimO (fun s1 s2 => ∃ s, s1 = s.append nil ∧ s2 = s) (nil.append nil).destruct nil.destruct
state_after: no goals

tactic: intro x s
state_before: α : Type u
β : Type v
γ : Type w
s✝ s : Seq α
⊢ ∀ (x : α) (s : Seq α),
    BisimO (fun s1 s2 => ∃ s, s1 = s.append nil ∧ s2 = s) ((cons x s).append nil).destruct (cons x s).destruct
state_after: α : Type u
β : Type v
γ : Type w
s✝¹ s✝ : Seq α
x : α
s : Seq α
⊢ BisimO (fun s1 s2 => ∃ s, s1 = s.append nil ∧ s2 = s) ((cons x s).append nil).destruct (cons x s).destruct

tactic: rw [cons_append, destruct_cons, destruct_cons]
state_before: α : Type u
β : Type v
γ : Type w
s✝¹ s✝ : Seq α
x : α
s : Seq α
⊢ BisimO (fun s1 s2 => ∃ s, s1 = s.append nil ∧ s2 = s) ((cons x s).append nil).destruct (cons x s).destruct
state_after: α : Type u
β : Type v
γ : Type w
s✝¹ s✝ : Seq α
x : α
s : Seq α
⊢ BisimO (fun s1 s2 => ∃ s, s1 = s.append nil ∧ s2 = s) (some (x, s.append nil)) (some (x, s))

tactic: dsimp
state_before: α : Type u
β : Type v
γ : Type w
s✝¹ s✝ : Seq α
x : α
s : Seq α
⊢ BisimO (fun s1 s2 => ∃ s, s1 = s.append nil ∧ s2 = s) (some (x, s.append nil)) (some (x, s))
state_after: α : Type u
β : Type v
γ : Type w
s✝¹ s✝ : Seq α
x : α
s : Seq α
⊢ x = x ∧ ∃ s_1, s.append nil = s_1.append nil ∧ s = s_1

tactic: exact ⟨rfl, s, rfl, rfl⟩
state_before: α : Type u
β : Type v
γ : Type w
s✝¹ s✝ : Seq α
x : α
s : Seq α
⊢ x = x ∧ ∃ s_1, s.append nil = s_1.append nil ∧ s = s_1
state_after: no goals
Theorem: Nat.four_pow_le_two_mul_add_one_mul_central_binom
File: Mathlib/Data/Nat/Choose/Sum.lean

tactic: norm_num [pow_mul]
state_before: R : Type u_1
n : ℕ
⊢ 4 ^ n = (1 + 1) ^ (2 * n)
state_after: no goals

tactic: set_option simprocs false in simp [add_pow]
state_before: R : Type u_1
n : ℕ
⊢ (1 + 1) ^ (2 * n) = ∑ m ∈ range (2 * n + 1), (2 * n).choose m
state_after: no goals

tactic: simp [add_pow]
state_before: R : Type u_1
n : ℕ
⊢ (1 + 1) ^ (2 * n) = ∑ m ∈ range (2 * n + 1), (2 * n).choose m
state_after: no goals

tactic: gcongr
state_before: R : Type u_1
n : ℕ
⊢ ∑ m ∈ range (2 * n + 1), (2 * n).choose m ≤ ∑ m ∈ range (2 * n + 1), (2 * n).choose (2 * n / 2)
state_after: case h
R : Type u_1
n i✝ : ℕ
a✝ : i✝ ∈ range (2 * n + 1)
⊢ (2 * n).choose i✝ ≤ (2 * n).choose (2 * n / 2)

tactic: apply choose_le_middle
state_before: case h
R : Type u_1
n i✝ : ℕ
a✝ : i✝ ∈ range (2 * n + 1)
⊢ (2 * n).choose i✝ ≤ (2 * n).choose (2 * n / 2)
state_after: no goals

tactic: simp
state_before: R : Type u_1
n : ℕ
⊢ ∑ m ∈ range (2 * n + 1), (2 * n).choose (2 * n / 2) = (2 * n + 1) * (2 * n).choose n
state_after: no goals
Theorem: Finset.filter_lt_le_eq_Ioc
File: Mathlib/Order/Interval/Finset/Basic.lean

tactic: ext
state_before: ι : Type u_1
α : Type u_2
inst✝³ : Preorder α
inst✝² : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
inst✝¹ : Fintype α
inst✝ : DecidablePred fun j => a < j ∧ j ≤ b
⊢ filter (fun j => a < j ∧ j ≤ b) univ = Ioc a b
state_after: case a
ι : Type u_1
α : Type u_2
inst✝³ : Preorder α
inst✝² : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
inst✝¹ : Fintype α
inst✝ : DecidablePred fun j => a < j ∧ j ≤ b
a✝ : α
⊢ a✝ ∈ filter (fun j => a < j ∧ j ≤ b) univ ↔ a✝ ∈ Ioc a b

tactic: simp
state_before: case a
ι : Type u_1
α : Type u_2
inst✝³ : Preorder α
inst✝² : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
inst✝¹ : Fintype α
inst✝ : DecidablePred fun j => a < j ∧ j ≤ b
a✝ : α
⊢ a✝ ∈ filter (fun j => a < j ∧ j ≤ b) univ ↔ a✝ ∈ Ioc a b
state_after: no goals
Theorem: MeasureTheory.ConvolutionExistsAt.integrable_swap
File: Mathlib/Analysis/Convolution.lean

tactic: convert h.comp_sub_left x
state_before: 𝕜 : Type u𝕜
G : Type uG
E : Type uE
E' : Type uE'
E'' : Type uE''
F : Type uF
F' : Type uF'
F'' : Type uF''
P : Type uP
inst✝¹⁴ : NormedAddCommGroup E
inst✝¹³ : NormedAddCommGroup E'
inst✝¹² : NormedAddCommGroup E''
inst✝¹¹ : NormedAddCommGroup F
f f' : G → E
g g' : G → E'
x x' : G
y y' : E
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : NormedSpace 𝕜 E
inst✝⁸ : NormedSpace 𝕜 E'
inst✝⁷ : NormedSpace 𝕜 E''
inst✝⁶ : NormedSpace 𝕜 F
L : E →L[𝕜] E' →L[𝕜] F
inst✝⁵ : MeasurableSpace G
μ ν : Measure G
inst✝⁴ : AddCommGroup G
inst✝³ : MeasurableNeg G
inst✝² : μ.IsAddLeftInvariant
inst✝¹ : MeasurableAdd G
inst✝ : μ.IsNegInvariant
h : ConvolutionExistsAt f g x L μ
⊢ Integrable (fun t => (L (f (x - t))) (g t)) μ
state_after: case h.e'_5.h.h.e'_6.h.e'_1
𝕜 : Type u𝕜
G : Type uG
E : Type uE
E' : Type uE'
E'' : Type uE''
F : Type uF
F' : Type uF'
F'' : Type uF''
P : Type uP
inst✝¹⁴ : NormedAddCommGroup E
inst✝¹³ : NormedAddCommGroup E'
inst✝¹² : NormedAddCommGroup E''
inst✝¹¹ : NormedAddCommGroup F
f f' : G → E
g g' : G → E'
x x' : G
y y' : E
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : NormedSpace 𝕜 E
inst✝⁸ : NormedSpace 𝕜 E'
inst✝⁷ : NormedSpace 𝕜 E''
inst✝⁶ : NormedSpace 𝕜 F
L : E →L[𝕜] E' →L[𝕜] F
inst✝⁵ : MeasurableSpace G
μ ν : Measure G
inst✝⁴ : AddCommGroup G
inst✝³ : MeasurableNeg G
inst✝² : μ.IsAddLeftInvariant
inst✝¹ : MeasurableAdd G
inst✝ : μ.IsNegInvariant
h : ConvolutionExistsAt f g x L μ
x✝ : G
⊢ x✝ = x - (x - x✝)

tactic: simp_rw [sub_sub_self]
state_before: case h.e'_5.h.h.e'_6.h.e'_1
𝕜 : Type u𝕜
G : Type uG
E : Type uE
E' : Type uE'
E'' : Type uE''
F : Type uF
F' : Type uF'
F'' : Type uF''
P : Type uP
inst✝¹⁴ : NormedAddCommGroup E
inst✝¹³ : NormedAddCommGroup E'
inst✝¹² : NormedAddCommGroup E''
inst✝¹¹ : NormedAddCommGroup F
f f' : G → E
g g' : G → E'
x x' : G
y y' : E
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : NormedSpace 𝕜 E
inst✝⁸ : NormedSpace 𝕜 E'
inst✝⁷ : NormedSpace 𝕜 E''
inst✝⁶ : NormedSpace 𝕜 F
L : E →L[𝕜] E' →L[𝕜] F
inst✝⁵ : MeasurableSpace G
μ ν : Measure G
inst✝⁴ : AddCommGroup G
inst✝³ : MeasurableNeg G
inst✝² : μ.IsAddLeftInvariant
inst✝¹ : MeasurableAdd G
inst✝ : μ.IsNegInvariant
h : ConvolutionExistsAt f g x L μ
x✝ : G
⊢ x✝ = x - (x - x✝)
state_after: no goals
Theorem: Filter.generate_eq_generate_inter
File: Mathlib/Order/Filter/Bases.lean

tactic: rw [← FilterBasis.ofSets_sets, FilterBasis.generate, ← (hasBasis_generate s).filter_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
l l' : Filter α
p : ι → Prop
s✝ : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
s : Set (Set α)
⊢ generate s = generate (sInter '' {t | t.Finite ∧ t ⊆ s})
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
l l' : Filter α
p : ι → Prop
s✝ : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
s : Set (Set α)
⊢ ⋯.filter = (FilterBasis.ofSets s).filter

tactic: rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
l l' : Filter α
p : ι → Prop
s✝ : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
s : Set (Set α)
⊢ ⋯.filter = (FilterBasis.ofSets s).filter
state_after: no goals