1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: NNReal.not_summable_iff_tendsto_nat_atTop
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: constructor
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : ℕ → ℝ≥0
⊢ ¬Summable f ↔ Tendsto (fun n => ∑ i ∈ Finset.range n, f i) atTop atTop
state_after: case mp
α : Type u_1
β : Type u_2
γ : Type u_3
f : ℕ → ℝ≥0
⊢ ¬Summable f → Tendsto (fun n => ∑ i ∈ Finset.range n, f i) atTop atTop

case mpr
α : Type u_1
β : Type u_2
γ : Type u_3
f : ℕ → ℝ≥0
⊢ Tendsto (fun n => ∑ i ∈ Finset.range n, f i) atTop atTop → ¬Summable f

tactic: intro h
state_before: case mp
α : Type u_1
β : Type u_2
γ : Type u_3
f : ℕ → ℝ≥0
⊢ ¬Summable f → Tendsto (fun n => ∑ i ∈ Finset.range n, f i) atTop atTop
state_after: case mp
α : Type u_1
β : Type u_2
γ : Type u_3
f : ℕ → ℝ≥0
h : ¬Summable f
⊢ Tendsto (fun n => ∑ i ∈ Finset.range n, f i) atTop atTop

tactic: refine ((tendsto_of_monotone ?_).resolve_right h).comp ?_
state_before: case mp
α : Type u_1
β : Type u_2
γ : Type u_3
f : ℕ → ℝ≥0
h : ¬Summable f
⊢ Tendsto (fun n => ∑ i ∈ Finset.range n, f i) atTop atTop
state_after: case mp.refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
f : ℕ → ℝ≥0
h : ¬Summable f
⊢ Monotone fun s => ∑ b ∈ s, f b

case mp.refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
f : ℕ → ℝ≥0
h : ¬Summable f
⊢ Tendsto Finset.range atTop atTop

tactic: exacts [Finset.sum_mono_set _, tendsto_finset_range]
state_before: case mp.refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
f : ℕ → ℝ≥0
h : ¬Summable f
⊢ Monotone fun s => ∑ b ∈ s, f b

case mp.refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
f : ℕ → ℝ≥0
h : ¬Summable f
⊢ Tendsto Finset.range atTop atTop
state_after: no goals

tactic: rintro hnat ⟨r, hr⟩
state_before: case mpr
α : Type u_1
β : Type u_2
γ : Type u_3
f : ℕ → ℝ≥0
⊢ Tendsto (fun n => ∑ i ∈ Finset.range n, f i) atTop atTop → ¬Summable f
state_after: case mpr.intro
α : Type u_1
β : Type u_2
γ : Type u_3
f : ℕ → ℝ≥0
hnat : Tendsto (fun n => ∑ i ∈ Finset.range n, f i) atTop atTop
r : ℝ≥0
hr : HasSum f r
⊢ False

tactic: exact not_tendsto_nhds_of_tendsto_atTop hnat _ (hasSum_iff_tendsto_nat.1 hr)
state_before: case mpr.intro
α : Type u_1
β : Type u_2
γ : Type u_3
f : ℕ → ℝ≥0
hnat : Tendsto (fun n => ∑ i ∈ Finset.range n, f i) atTop atTop
r : ℝ≥0
hr : HasSum f r
⊢ False
state_after: no goals
Theorem: LocalizedModule.smul_zero_aux
File: Mathlib/Algebra/Module/LocalizedModule.lean

tactic: erw [smul_def, smul_zero, zero_mk]
state_before: R : Type u
inst✝⁵ : CommSemiring R
S : Submonoid R
M : Type v
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
T : Type u_1
inst✝² : CommSemiring T
inst✝¹ : Algebra R T
inst✝ : IsLocalization S T
x : T
⊢ x • 0 = 0
state_after: no goals
Theorem: MeasureTheory.mem_fundamentalFrontier
File: Mathlib/MeasureTheory/Group/FundamentalDomain.lean

tactic: simp [fundamentalFrontier]
state_before: G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
E : Type u_5
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
x : α
⊢ x ∈ fundamentalFrontier G s ↔ x ∈ s ∧ ∃ g, g ≠ 1 ∧ x ∈ g • s
state_after: no goals
Theorem: Nat.cast_le_one
File: Mathlib/Data/Nat/Cast/Order.lean

tactic: rw [← cast_one, cast_le]
state_before: α : Type u_1
β : Type u_2
inst✝⁴ : AddMonoidWithOne α
inst✝³ : PartialOrder α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : ZeroLEOneClass α
inst✝ : CharZero α
m n : ℕ
⊢ ↑n ≤ 1 ↔ n ≤ 1
state_after: no goals
Theorem: Set.Finite.prod
File: Mathlib/Data/Set/Finite.lean

tactic: have := hs.to_subtype
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
t : Set β
hs : s.Finite
ht : t.Finite
⊢ (s ×ˢ t).Finite
state_after: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
t : Set β
hs : s.Finite
ht : t.Finite
this : Finite ↑s
⊢ (s ×ˢ t).Finite

tactic: have := ht.to_subtype
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
t : Set β
hs : s.Finite
ht : t.Finite
this : Finite ↑s
⊢ (s ×ˢ t).Finite
state_after: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
t : Set β
hs : s.Finite
ht : t.Finite
this✝ : Finite ↑s
this : Finite ↑t
⊢ (s ×ˢ t).Finite

tactic: apply toFinite
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
t : Set β
hs : s.Finite
ht : t.Finite
this✝ : Finite ↑s
this : Finite ↑t
⊢ (s ×ˢ t).Finite
state_after: no goals
Theorem: CategoryTheory.Limits.Concrete.initial_iff_empty_of_preserves_of_reflects
File: Mathlib/CategoryTheory/Limits/Shapes/ConcreteCategory.lean

tactic: rw [← Types.initial_iff_empty, (IsInitial.isInitialIffObj (forget C) X).nonempty_congr]
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : ConcreteCategory C
inst✝¹ : PreservesColimit (Functor.empty C) (forget C)
inst✝ : ReflectsColimit (Functor.empty C) (forget C)
X : C
⊢ Nonempty (IsInitial X) ↔ IsEmpty ((forget C).obj X)
state_after: no goals
Theorem: Matrix.Fin.circulant_ite
File: Mathlib/LinearAlgebra/Matrix/Circulant.lean

tactic: simp [Injective, eq_iff_true_of_subsingleton]
state_before: α✝ : Type u_1
β : Type u_2
m : Type u_3
n : Type u_4
R : Type u_5
α : Type u_6
inst✝¹ : Zero α
inst✝ : One α
⊢ (circulant fun i => if ↑i = 0 then 1 else 0) = 1
state_after: no goals

tactic: rw [← circulant_single_one]
state_before: α✝ : Type u_1
β : Type u_2
m : Type u_3
n✝ : Type u_4
R : Type u_5
α : Type u_6
inst✝¹ : Zero α
inst✝ : One α
n : ℕ
⊢ (circulant fun i => if ↑i = 0 then 1 else 0) = 1
state_after: α✝ : Type u_1
β : Type u_2
m : Type u_3
n✝ : Type u_4
R : Type u_5
α : Type u_6
inst✝¹ : Zero α
inst✝ : One α
n : ℕ
⊢ (circulant fun i => if ↑i = 0 then 1 else 0) = circulant (Pi.single 0 1)

tactic: congr with j
state_before: α✝ : Type u_1
β : Type u_2
m : Type u_3
n✝ : Type u_4
R : Type u_5
α : Type u_6
inst✝¹ : Zero α
inst✝ : One α
n : ℕ
⊢ (circulant fun i => if ↑i = 0 then 1 else 0) = circulant (Pi.single 0 1)
state_after: case a
α✝ : Type u_1
β : Type u_2
m : Type u_3
n✝ : Type u_4
R : Type u_5
α : Type u_6
inst✝¹ : Zero α
inst✝ : One α
n : ℕ
j j✝ : Fin (n + 1)
⊢ circulant (fun i => if ↑i = 0 then 1 else 0) j j✝ = circulant (Pi.single 0 1) j j✝

tactic: simp [Pi.single_apply, Fin.ext_iff]
state_before: case a
α✝ : Type u_1
β : Type u_2
m : Type u_3
n✝ : Type u_4
R : Type u_5
α : Type u_6
inst✝¹ : Zero α
inst✝ : One α
n : ℕ
j j✝ : Fin (n + 1)
⊢ circulant (fun i => if ↑i = 0 then 1 else 0) j j✝ = circulant (Pi.single 0 1) j j✝
state_after: no goals
Theorem: OrderEmbedding.isAtom_of_map_bot_of_image
File: Mathlib/Order/Atoms.lean

tactic: simp only [← bot_covBy_iff] at hb ⊢
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝³ : PartialOrder α
inst✝² : PartialOrder β
inst✝¹ : OrderBot α
inst✝ : OrderBot β
f : β ↪o α
hbot : f ⊥ = ⊥
b : β
hb : IsAtom (f b)
⊢ IsAtom b
state_after: ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝³ : PartialOrder α
inst✝² : PartialOrder β
inst✝¹ : OrderBot α
inst✝ : OrderBot β
f : β ↪o α
hbot : f ⊥ = ⊥
b : β
hb : ⊥ ⋖ f b
⊢ ⊥ ⋖ b

tactic: exact CovBy.of_image f (hbot.symm ▸ hb)
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝³ : PartialOrder α
inst✝² : PartialOrder β
inst✝¹ : OrderBot α
inst✝ : OrderBot β
f : β ↪o α
hbot : f ⊥ = ⊥
b : β
hb : ⊥ ⋖ f b
⊢ ⊥ ⋖ b
state_after: no goals
Theorem: MeasurableEquiv.map_measurableEquiv_injective
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: intro μ₁ μ₂ hμ
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
μ : Measure α
ν : Measure β
e : α ≃ᵐ β
⊢ Injective (Measure.map ⇑e)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
μ : Measure α
ν : Measure β
e : α ≃ᵐ β
μ₁ μ₂ : Measure α
hμ : Measure.map (⇑e) μ₁ = Measure.map (⇑e) μ₂
⊢ μ₁ = μ₂

tactic: apply_fun Measure.map e.symm at hμ
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
μ : Measure α
ν : Measure β
e : α ≃ᵐ β
μ₁ μ₂ : Measure α
hμ : Measure.map (⇑e) μ₁ = Measure.map (⇑e) μ₂
⊢ μ₁ = μ₂
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
μ : Measure α
ν : Measure β
e : α ≃ᵐ β
μ₁ μ₂ : Measure α
hμ : Measure.map (⇑e.symm) (Measure.map (⇑e) μ₁) = Measure.map (⇑e.symm) (Measure.map (⇑e) μ₂)
⊢ μ₁ = μ₂

tactic: simpa [map_symm_map e] using hμ
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
μ : Measure α
ν : Measure β
e : α ≃ᵐ β
μ₁ μ₂ : Measure α
hμ : Measure.map (⇑e.symm) (Measure.map (⇑e) μ₁) = Measure.map (⇑e.symm) (Measure.map (⇑e) μ₂)
⊢ μ₁ = μ₂
state_after: no goals
Theorem: Real.logb_mul_base
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: rw [← inv_logb_mul_base h₁ h₂ c, inv_inv]
state_before: b✝ x y a b : ℝ
h₁ : a ≠ 0
h₂ : b ≠ 0
c : ℝ
⊢ logb (a * b) c = ((logb a c)⁻¹ + (logb b c)⁻¹)⁻¹
state_after: no goals
Theorem: WeierstrassCurve.coeff_preΨ₄
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Degree.lean

tactic: rw [preΨ₄]
state_before: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
⊢ W.preΨ₄.coeff 6 = 2
state_after: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
⊢ (2 * X ^ 6 + C W.b₂ * X ^ 5 + 5 * C W.b₄ * X ^ 4 + 10 * C W.b₆ * X ^ 3 + 10 * C W.b₈ * X ^ 2 +
            C (W.b₂ * W.b₈ - W.b₄ * W.b₆) * X +
          C (W.b₄ * W.b₈ - W.b₆ ^ 2)).coeff
      6 =
    2

tactic: compute_degree!
state_before: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
⊢ (2 * X ^ 6 + C W.b₂ * X ^ 5 + 5 * C W.b₄ * X ^ 4 + 10 * C W.b₆ * X ^ 3 + 10 * C W.b₈ * X ^ 2 +
            C (W.b₂ * W.b₈ - W.b₄ * W.b₆) * X +
          C (W.b₄ * W.b₈ - W.b₆ ^ 2)).coeff
      6 =
    2
state_after: no goals
Theorem: IsClosed.continuous_piecewise_of_specializes
File: Mathlib/Topology/Inseparable.lean

tactic: simpa only [piecewise_compl] using hs.isOpen_compl.continuous_piecewise_of_specializes hg hf hspec
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
inst✝¹ : (i : ι) → TopologicalSpace (π i)
x y z : X
s : Set X
f g : X → Y
inst✝ : DecidablePred fun x => x ∈ s
hs : IsClosed s
hf : Continuous f
hg : Continuous g
hspec : ∀ (x : X), g x ⤳ f x
⊢ Continuous (s.piecewise f g)
state_after: no goals
Theorem: Nat.Partrec'.comp₁
File: Mathlib/Computability/Halting.lean

tactic: simpa using hf.comp' (Partrec'.cons hg Partrec'.nil)
state_before: n : ℕ
f : ℕ →. ℕ
g : Vector ℕ n → ℕ
hf : Partrec' fun v => f v.head
hg : Partrec' ↑g
⊢ Partrec' fun v => f (g v)
state_after: no goals
Theorem: measurable_pi_iff
File: Mathlib/MeasureTheory/MeasurableSpace/Basic.lean

tactic: simp_rw [measurable_iff_comap_le, MeasurableSpace.pi, MeasurableSpace.comap_iSup,
  MeasurableSpace.comap_comp, Function.comp, iSup_le_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
π : δ → Type u_6
inst✝² : MeasurableSpace α
inst✝¹ : (a : δ) → MeasurableSpace (π a)
inst✝ : MeasurableSpace γ
g : α → (a : δ) → π a
⊢ Measurable g ↔ ∀ (a : δ), Measurable fun x => g x a
state_after: no goals
Theorem: SzemerediRegularity.card_aux₂
File: Mathlib/Combinatorics/SimpleGraph/Regularity/Bound.lean

tactic: have : m * 4 ^ P.parts.card ≤ card α / P.parts.card := by
  rw [stepBound, ← Nat.div_div_eq_div_mul]
  exact Nat.div_mul_le_self _ _
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
P : Finpartition univ
u : Finset α
ε : ℝ
hP : P.IsEquipartition
hu : u ∈ P.parts
hucard : ¬u.card = m * 4 ^ P.parts.card + a
⊢ (4 ^ P.parts.card - (a + 1)) * m + (a + 1) * (m + 1) = u.card
state_after: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
P : Finpartition univ
u : Finset α
ε : ℝ
hP : P.IsEquipartition
hu : u ∈ P.parts
hucard : ¬u.card = m * 4 ^ P.parts.card + a
this : m * 4 ^ P.parts.card ≤ Fintype.card α / P.parts.card
⊢ (4 ^ P.parts.card - (a + 1)) * m + (a + 1) * (m + 1) = u.card

tactic: rw [Nat.add_sub_of_le this] at hucard
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
P : Finpartition univ
u : Finset α
ε : ℝ
hP : P.IsEquipartition
hu : u ∈ P.parts
hucard : ¬u.card = m * 4 ^ P.parts.card + a
this : m * 4 ^ P.parts.card ≤ Fintype.card α / P.parts.card
⊢ (4 ^ P.parts.card - (a + 1)) * m + (a + 1) * (m + 1) = u.card
state_after: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
P : Finpartition univ
u : Finset α
ε : ℝ
hP : P.IsEquipartition
hu : u ∈ P.parts
hucard : ¬u.card = Fintype.card α / P.parts.card
this : m * 4 ^ P.parts.card ≤ Fintype.card α / P.parts.card
⊢ (4 ^ P.parts.card - (a + 1)) * m + (a + 1) * (m + 1) = u.card

tactic: rw [(hP.card_parts_eq_average hu).resolve_left hucard, mul_add, mul_one, ← add_assoc, ← add_mul,
  Nat.sub_add_cancel a_add_one_le_four_pow_parts_card, ← add_assoc, mul_comm,
  Nat.add_sub_of_le this, card_univ]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
P : Finpartition univ
u : Finset α
ε : ℝ
hP : P.IsEquipartition
hu : u ∈ P.parts
hucard : ¬u.card = Fintype.card α / P.parts.card
this : m * 4 ^ P.parts.card ≤ Fintype.card α / P.parts.card
⊢ (4 ^ P.parts.card - (a + 1)) * m + (a + 1) * (m + 1) = u.card
state_after: no goals

tactic: rw [stepBound, ← Nat.div_div_eq_div_mul]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
P : Finpartition univ
u : Finset α
ε : ℝ
hP : P.IsEquipartition
hu : u ∈ P.parts
hucard : ¬u.card = m * 4 ^ P.parts.card + a
⊢ m * 4 ^ P.parts.card ≤ Fintype.card α / P.parts.card
state_after: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
P : Finpartition univ
u : Finset α
ε : ℝ
hP : P.IsEquipartition
hu : u ∈ P.parts
hucard : ¬u.card = m * 4 ^ P.parts.card + a
⊢ Fintype.card α / P.parts.card / 4 ^ P.parts.card * 4 ^ P.parts.card ≤ Fintype.card α / P.parts.card

tactic: exact Nat.div_mul_le_self _ _
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
P : Finpartition univ
u : Finset α
ε : ℝ
hP : P.IsEquipartition
hu : u ∈ P.parts
hucard : ¬u.card = m * 4 ^ P.parts.card + a
⊢ Fintype.card α / P.parts.card / 4 ^ P.parts.card * 4 ^ P.parts.card ≤ Fintype.card α / P.parts.card
state_after: no goals
Theorem: div_eq_inv_self
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [div_eq_mul_inv, mul_left_eq_self]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n : ℤ
⊢ a / b = b⁻¹ ↔ a = 1
state_after: no goals
Theorem: String.extract.go₂_append_left
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

tactic: cases t <;> simp [go₂]
state_before: t : List Char
i : Nat
⊢ go₂ ([] ++ t) { byteIdx := i } { byteIdx := utf8Len [] + i } = []
state_after: no goals

tactic: simp only [go₂, utf8Len_cons, Pos.ext_iff, ne_add_csize_add_self, ↓reduceIte, List.append_eq,
  Pos.addChar_eq, List.cons.injEq, true_and]
state_before: c : Char
cs t : List Char
i : Nat
⊢ go₂ (c :: cs ++ t) { byteIdx := i } { byteIdx := utf8Len (c :: cs) + i } = c :: cs
state_after: c : Char
cs t : List Char
i : Nat
⊢ go₂ (cs ++ t) { byteIdx := i + c.utf8Size } { byteIdx := utf8Len cs + c.utf8Size + i } = cs

tactic: apply go₂_append_left
state_before: c : Char
cs t : List Char
i : Nat
⊢ go₂ (cs ++ t) { byteIdx := i + c.utf8Size } { byteIdx := utf8Len cs + c.utf8Size + i } = cs
state_after: case a
c : Char
cs t : List Char
i : Nat
⊢ utf8Len cs + c.utf8Size + i = utf8Len cs + (i + c.utf8Size)

tactic: rw [Nat.add_right_comm, Nat.add_assoc]
state_before: case a
c : Char
cs t : List Char
i : Nat
⊢ utf8Len cs + c.utf8Size + i = utf8Len cs + (i + c.utf8Size)
state_after: no goals
Theorem: continuum_le_cardinal_of_isOpen
File: Mathlib/Topology/Algebra/Module/Cardinality.lean

tactic: simpa [cardinal_eq_of_isOpen 𝕜 hs h's] using continuum_le_cardinal_of_module 𝕜 E
state_before: E : Type u_1
𝕜 : Type u_2
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : CompleteSpace 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : Nontrivial E
inst✝² : TopologicalSpace E
inst✝¹ : ContinuousAdd E
inst✝ : ContinuousSMul 𝕜 E
s : Set E
hs : IsOpen s
h's : s.Nonempty
⊢ 𝔠 ≤ #↑s
state_after: no goals
Theorem: TangentBundle.symmL_model_space
File: Mathlib/Geometry/Manifold/VectorBundle/Tangent.lean

tactic: rw [TangentBundle.trivializationAt_symmL, coordChange_model_space]
state_before: 𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
E' : Type u_3
inst✝¹¹ : NormedAddCommGroup E'
inst✝¹⁰ : NormedSpace 𝕜 E'
H : Type u_4
inst✝⁹ : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
H' : Type u_5
inst✝⁸ : TopologicalSpace H'
I' : ModelWithCorners 𝕜 E' H'
M : Type u_6
inst✝⁷ : TopologicalSpace M
inst✝⁶ : ChartedSpace H M
inst✝⁵ : SmoothManifoldWithCorners I M
M' : Type u_7
inst✝⁴ : TopologicalSpace M'
inst✝³ : ChartedSpace H' M'
inst✝² : SmoothManifoldWithCorners I' M'
F : Type u_8
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
b b' : F
⊢ Trivialization.symmL 𝕜 (trivializationAt F (TangentSpace 𝓘(𝕜, F)) b) b' = 1
state_after: case hb
𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
E' : Type u_3
inst✝¹¹ : NormedAddCommGroup E'
inst✝¹⁰ : NormedSpace 𝕜 E'
H : Type u_4
inst✝⁹ : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
H' : Type u_5
inst✝⁸ : TopologicalSpace H'
I' : ModelWithCorners 𝕜 E' H'
M : Type u_6
inst✝⁷ : TopologicalSpace M
inst✝⁶ : ChartedSpace H M
inst✝⁵ : SmoothManifoldWithCorners I M
M' : Type u_7
inst✝⁴ : TopologicalSpace M'
inst✝³ : ChartedSpace H' M'
inst✝² : SmoothManifoldWithCorners I' M'
F : Type u_8
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
b b' : F
⊢ b' ∈ (trivializationAt F (TangentSpace 𝓘(𝕜, F)) b).baseSet

tactic: apply mem_univ
state_before: case hb
𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
E' : Type u_3
inst✝¹¹ : NormedAddCommGroup E'
inst✝¹⁰ : NormedSpace 𝕜 E'
H : Type u_4
inst✝⁹ : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
H' : Type u_5
inst✝⁸ : TopologicalSpace H'
I' : ModelWithCorners 𝕜 E' H'
M : Type u_6
inst✝⁷ : TopologicalSpace M
inst✝⁶ : ChartedSpace H M
inst✝⁵ : SmoothManifoldWithCorners I M
M' : Type u_7
inst✝⁴ : TopologicalSpace M'
inst✝³ : ChartedSpace H' M'
inst✝² : SmoothManifoldWithCorners I' M'
F : Type u_8
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
b b' : F
⊢ b' ∈ (trivializationAt F (TangentSpace 𝓘(𝕜, F)) b).baseSet
state_after: no goals
Theorem: Nat.pow_mod
File: Mathlib/Data/Nat/Defs.lean

tactic: induction b with
| zero => rfl
| succ b ih => simp [Nat.pow_succ, Nat.mul_mod, ih]
state_before: a✝ b✝ c d m n✝ k : ℕ
p q : ℕ → Prop
a b n : ℕ
⊢ a ^ b % n = (a % n) ^ b % n
state_after: no goals

tactic: rfl
state_before: case zero
a✝ b c d m n✝ k : ℕ
p q : ℕ → Prop
a n : ℕ
⊢ a ^ 0 % n = (a % n) ^ 0 % n
state_after: no goals

tactic: simp [Nat.pow_succ, Nat.mul_mod, ih]
state_before: case succ
a✝ b✝ c d m n✝ k : ℕ
p q : ℕ → Prop
a n b : ℕ
ih : a ^ b % n = (a % n) ^ b % n
⊢ a ^ (b + 1) % n = (a % n) ^ (b + 1) % n
state_after: no goals
Theorem: finrank_eq_one_iff_of_nonzero'
File: Mathlib/LinearAlgebra/FiniteDimensional.lean

tactic: rw [finrank_eq_one_iff_of_nonzero v nz]
state_before: K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
v : V
nz : v ≠ 0
⊢ finrank K V = 1 ↔ ∀ (w : V), ∃ c, c • v = w
state_after: K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
v : V
nz : v ≠ 0
⊢ span K {v} = ⊤ ↔ ∀ (w : V), ∃ c, c • v = w

tactic: apply span_singleton_eq_top_iff
state_before: K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
v : V
nz : v ≠ 0
⊢ span K {v} = ⊤ ↔ ∀ (w : V), ∃ c, c • v = w
state_after: no goals
Theorem: dense_biInter_of_isOpen
File: Mathlib/Topology/Baire/Lemmas.lean

tactic: rw [← sInter_image]
state_before: X : Type u_1
α : Type u_2
ι : Sort u_3
inst✝¹ : TopologicalSpace X
inst✝ : BaireSpace X
S : Set α
f : α → Set X
ho : ∀ s ∈ S, IsOpen (f s)
hS : S.Countable
hd : ∀ s ∈ S, Dense (f s)
⊢ Dense (⋂ s ∈ S, f s)
state_after: X : Type u_1
α : Type u_2
ι : Sort u_3
inst✝¹ : TopologicalSpace X
inst✝ : BaireSpace X
S : Set α
f : α → Set X
ho : ∀ s ∈ S, IsOpen (f s)
hS : S.Countable
hd : ∀ s ∈ S, Dense (f s)
⊢ Dense (⋂₀ (f '' S))

tactic: refine dense_sInter_of_isOpen ?_ (hS.image _) ?_ <;> rwa [forall_mem_image]
state_before: X : Type u_1
α : Type u_2
ι : Sort u_3
inst✝¹ : TopologicalSpace X
inst✝ : BaireSpace X
S : Set α
f : α → Set X
ho : ∀ s ∈ S, IsOpen (f s)
hS : S.Countable
hd : ∀ s ∈ S, Dense (f s)
⊢ Dense (⋂₀ (f '' S))
state_after: no goals
Theorem: bihimp_self
File: Mathlib/Order/SymmDiff.lean

tactic: rw [bihimp, inf_idem, himp_self]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedHeytingAlgebra α
a b c d : α
⊢ a ⇔ a = ⊤
state_after: no goals
Theorem: SemiNormedGrp.ExplicitCoker.map_desc
File: Mathlib/Analysis/Normed/Group/SemiNormedGrp/Kernels.lean

tactic: delta explicitCokernel.map
state_before: A B C D B' D' : SemiNormedGrp
fab : A ⟶ B
fbd : B ⟶ D
fac : A ⟶ C
fcd : C ⟶ D
h : fab ≫ fbd = fac ≫ fcd
fbb' : B ⟶ B'
fdd' : D ⟶ D'
condb : fab ≫ fbb' = 0
condd : fcd ≫ fdd' = 0
g : B' ⟶ D'
h' : fbb' ≫ g = fbd ≫ fdd'
⊢ explicitCokernelDesc condb ≫ g = explicitCokernel.map h ≫ explicitCokernelDesc condd
state_after: A B C D B' D' : SemiNormedGrp
fab : A ⟶ B
fbd : B ⟶ D
fac : A ⟶ C
fcd : C ⟶ D
h : fab ≫ fbd = fac ≫ fcd
fbb' : B ⟶ B'
fdd' : D ⟶ D'
condb : fab ≫ fbb' = 0
condd : fcd ≫ fdd' = 0
g : B' ⟶ D'
h' : fbb' ≫ g = fbd ≫ fdd'
⊢ explicitCokernelDesc condb ≫ g = explicitCokernelDesc ⋯ ≫ explicitCokernelDesc condd

tactic: simp [← cancel_epi (explicitCokernelπ fab), ← Category.assoc, Category.assoc,
  explicitCokernelπ_desc, h']
state_before: A B C D B' D' : SemiNormedGrp
fab : A ⟶ B
fbd : B ⟶ D
fac : A ⟶ C
fcd : C ⟶ D
h : fab ≫ fbd = fac ≫ fcd
fbb' : B ⟶ B'
fdd' : D ⟶ D'
condb : fab ≫ fbb' = 0
condd : fcd ≫ fdd' = 0
g : B' ⟶ D'
h' : fbb' ≫ g = fbd ≫ fdd'
⊢ explicitCokernelDesc condb ≫ g = explicitCokernelDesc ⋯ ≫ explicitCokernelDesc condd
state_after: no goals
Theorem: MeasureTheory.tilted_eq_withDensity_nnreal
File: Mathlib/MeasureTheory/Measure/Tilted.lean

tactic: positivity
state_before: α : Type u_1
mα : MeasurableSpace α
μ✝ : Measure α
f✝ : α → ℝ
μ : Measure α
f : α → ℝ
x : α
⊢ 0 ≤ rexp (f x) / ∫ (x : α), rexp (f x) ∂μ
state_after: no goals

tactic: rw [Measure.tilted]
state_before: α : Type u_1
mα : MeasurableSpace α
μ✝ : Measure α
f✝ : α → ℝ
μ : Measure α
f : α → ℝ
⊢ μ.tilted f = μ.withDensity fun x => ↑⟨rexp (f x) / ∫ (x : α), rexp (f x) ∂μ, ⋯⟩
state_after: α : Type u_1
mα : MeasurableSpace α
μ✝ : Measure α
f✝ : α → ℝ
μ : Measure α
f : α → ℝ
⊢ (μ.withDensity fun x => ENNReal.ofReal (rexp (f x) / ∫ (x : α), rexp (f x) ∂μ)) =
    μ.withDensity fun x => ↑⟨rexp (f x) / ∫ (x : α), rexp (f x) ∂μ, ⋯⟩

tactic: congr with x
state_before: α : Type u_1
mα : MeasurableSpace α
μ✝ : Measure α
f✝ : α → ℝ
μ : Measure α
f : α → ℝ
⊢ (μ.withDensity fun x => ENNReal.ofReal (rexp (f x) / ∫ (x : α), rexp (f x) ∂μ)) =
    μ.withDensity fun x => ↑⟨rexp (f x) / ∫ (x : α), rexp (f x) ∂μ, ⋯⟩
state_after: case e_f.h
α : Type u_1
mα : MeasurableSpace α
μ✝ : Measure α
f✝ : α → ℝ
μ : Measure α
f : α → ℝ
x : α
⊢ ENNReal.ofReal (rexp (f x) / ∫ (x : α), rexp (f x) ∂μ) = ↑⟨rexp (f x) / ∫ (x : α), rexp (f x) ∂μ, ⋯⟩

tactic: rw [ENNReal.ofReal_eq_coe_nnreal]
state_before: case e_f.h
α : Type u_1
mα : MeasurableSpace α
μ✝ : Measure α
f✝ : α → ℝ
μ : Measure α
f : α → ℝ
x : α
⊢ ENNReal.ofReal (rexp (f x) / ∫ (x : α), rexp (f x) ∂μ) = ↑⟨rexp (f x) / ∫ (x : α), rexp (f x) ∂μ, ⋯⟩
state_after: no goals
Theorem: List.toFinset_union
File: Mathlib/Data/Finset/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
l✝ l'✝ : List α
a : α
l l' : List α
⊢ (l ∪ l').toFinset = l.toFinset ∪ l'.toFinset
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
l✝ l'✝ : List α
a : α
l l' : List α
a✝ : α
⊢ a✝ ∈ (l ∪ l').toFinset ↔ a✝ ∈ l.toFinset ∪ l'.toFinset

tactic: simp
state_before: case a
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
l✝ l'✝ : List α
a : α
l l' : List α
a✝ : α
⊢ a✝ ∈ (l ∪ l').toFinset ↔ a✝ ∈ l.toFinset ∪ l'.toFinset
state_after: no goals